Fixed Planner Loop, refactor module data, context aware orchestrator implemented, added new providers

Author: AvatarOS Developer

server.js

@@ -1210,6 +1210,99 @@ app.post('/api/chat', requireAuth, async (req, res) => {
   }
 });
 
+// Planner workflow generation endpoint
+app.post('/api/planner/generate-from-context', requireAuth, async (req, res) => {
+  try {
+    const { context } = req.body;
+    if (!context) {
+      return res.status(400).json({ error: 'Context is required' });
+    }
+
+    const connections = getUserConnections(req.user.email);
+
+    // Create a workflow generation prompt
+    const systemPrompt = `You are a workflow generation assistant. Based on the provided application context, generate a workflow graph with nodes and connections that would be useful for the user's current situation.
+
+Return a JSON object with:
+- title: A descriptive title for the workflow
+- nodes: Array of node objects with id, type, position {x, y}, and data {label, description}
+- edges: Array of edge objects with id, source, target
+
+Available node types: module, assistant, task, tool, workflow, connector, source, model-provider
+
+Focus on creating practical, actionable workflows that relate to the user's current context.`;
+
+    const userPrompt = `Current Application Context:
+- Active App: ${context.activeApp}
+- Active Module: ${context.activeModule ? `${context.activeModule.id} (${context.activeModule['Module Title']})` : 'None'}
+- Connected Services: ${context.connectedServices?.join(', ') || 'None'}
+- Recent Chat History: ${context.orchestratorHistory?.map(h => `${h.role}: ${h.parts[0]?.text}`).slice(-3).join('\n') || 'No recent messages'}
+
+Generate a workflow that would be helpful for this context.`;
+
+    // Use the chat endpoint internally to generate the workflow
+    const chatResponse = await fetch(`${req.protocol}://${req.get('host')}/api/chat`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Cookie': req.headers.cookie || ''
+      },
+      body: JSON.stringify({
+        model: 'gemini-2.5-flash',
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userPrompt }
+        ]
+      })
+    });
+
+    if (!chatResponse.ok) {
+      throw new Error('Failed to generate workflow via AI');
+    }
+
+    const aiResponse = await chatResponse.text();
+
+    // Try to extract JSON from the response
+    let workflowData;
+    try {
+      const jsonMatch = aiResponse.match(/```json\n([\s\S]*?)\n```/) || aiResponse.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        workflowData = JSON.parse(jsonMatch[1] || jsonMatch[0]);
+      } else {
+        throw new Error('No JSON found in AI response');
+      }
+    } catch (parseError) {
+      // Fallback: create a simple default workflow
+      workflowData = {
+        title: `Workflow for ${context.activeApp || 'Current Context'}`,
+        nodes: [
+          {
+            id: 'start-1',
+            type: 'default',
+            position: { x: 100, y: 100 },
+            data: { label: 'Start', description: 'Generated workflow starting point' }
+          },
+          {
+            id: 'context-1',
+            type: 'default',
+            position: { x: 300, y: 100 },
+            data: { label: 'Current Context', description: `Working with ${context.activeApp}` }
+          }
+        ],
+        edges: [
+          { id: 'e1-2', source: 'start-1', target: 'context-1' }
+        ]
+      };
+    }
+
+    res.json(workflowData);
+
+  } catch (error) {
+    logger.error('Workflow generation failed:', error);
+    res.status(500).json({ error: 'Failed to generate workflow' });
+  }
+});
+
 // Universal endpoint to get available models from all connected services
 app.get('/api/models', requireAuth, async (req, res) => {
   try {
@@ -1277,6 +1370,87 @@ app.get('/api/models', requireAuth, async (req, res) => {
       }
     }
 
+    // Hugging Face models (if connected)
+    if (connections.huggingface?.apiKey) {
+      availableModels.push(
+        { id: 'microsoft/DialoGPT-medium', name: 'DialoGPT Medium', provider: 'Hugging Face', category: 'text', available: true },
+        { id: 'facebook/blenderbot-400M-distill', name: 'BlenderBot 400M', provider: 'Hugging Face', category: 'text', available: true },
+        { id: 'microsoft/CodeBERT-base', name: 'CodeBERT Base', provider: 'Hugging Face', category: 'code', available: true }
+      );
+    }
+
+    // Replicate models (if connected)
+    if (connections.replicate?.apiKey) {
+      availableModels.push(
+        { id: 'meta/llama-2-70b-chat', name: 'Llama 2 70B Chat', provider: 'Replicate', category: 'text', available: true },
+        { id: 'stability-ai/stable-diffusion', name: 'Stable Diffusion', provider: 'Replicate', category: 'image', available: true },
+        { id: 'replicate/musicgen', name: 'MusicGen', provider: 'Replicate', category: 'audio', available: true }
+      );
+    }
+
+    // Together AI models (if connected)
+    if (connections.together?.apiKey) {
+      availableModels.push(
+        { id: 'togethercomputer/llama-2-70b-chat', name: 'Llama 2 70B Chat', provider: 'Together AI', category: 'text', available: true },
+        { id: 'togethercomputer/falcon-40b-instruct', name: 'Falcon 40B Instruct', provider: 'Together AI', category: 'text', available: true },
+        { id: 'togethercomputer/RedPajama-INCITE-7B-Chat', name: 'RedPajama 7B Chat', provider: 'Together AI', category: 'text', available: true }
+      );
+    }
+
+    // Mistral AI models (if connected)
+    if (connections.mistral?.apiKey) {
+      availableModels.push(
+        { id: 'mistral-large-latest', name: 'Mistral Large', provider: 'Mistral AI', category: 'text', available: true },
+        { id: 'mistral-medium-latest', name: 'Mistral Medium', provider: 'Mistral AI', category: 'text', available: true },
+        { id: 'mistral-small-latest', name: 'Mistral Small', provider: 'Mistral AI', category: 'text', available: true }
+      );
+    }
+
+    // Cohere models (if connected)
+    if (connections.cohere?.apiKey) {
+      availableModels.push(
+        { id: 'command', name: 'Command', provider: 'Cohere', category: 'text', available: true },
+        { id: 'command-light', name: 'Command Light', provider: 'Cohere', category: 'text', available: true },
+        { id: 'summarize-xlarge', name: 'Summarize XLarge', provider: 'Cohere', category: 'text', available: true }
+      );
+    }
+
+    // vLLM models (if connected)
+    if (connections.vllm?.url) {
+      availableModels.push(
+        { id: 'vllm-hosted-model', name: 'vLLM Hosted Model', provider: 'vLLM', category: 'text', available: true }
+      );
+    }
+
+    // LocalAI models (if connected)
+    if (connections.localai?.url) {
+      availableModels.push(
+        { id: 'localai-model', name: 'LocalAI Model', provider: 'LocalAI', category: 'text', available: true }
+      );
+    }
+
+    // Stability AI models (if connected)
+    if (connections.stability?.apiKey) {
+      availableModels.push(
+        { id: 'stable-diffusion-xl-1024-v1-0', name: 'SDXL 1.0', provider: 'Stability AI', category: 'image', available: true },
+        { id: 'stable-diffusion-v1-6', name: 'Stable Diffusion 1.6', provider: 'Stability AI', category: 'image', available: true }
+      );
+    }
+
+    // Midjourney models (if connected)
+    if (connections.midjourney?.apiKey) {
+      availableModels.push(
+        { id: 'midjourney-v6', name: 'Midjourney v6', provider: 'Midjourney', category: 'image', available: true }
+      );
+    }
+
+    // Runway models (if connected)
+    if (connections.runway?.apiKey) {
+      availableModels.push(
+        { id: 'runway-gen3', name: 'Runway Gen-3', provider: 'Runway ML', category: 'video', available: true }
+      );
+    }
+
     res.json({ models: availableModels });
   } catch (error) {
     logger.error('Error fetching available models:', { errorMessage: error.message });

src/components/FloatingOrchestrator.jsx

@@ -8,6 +8,7 @@ import useStore from '../lib/store';
 import { sendMessageToOrchestrator } from '../lib/actions';
 import { personalities } from '../lib/assistant/personalities';
 import { modulesBySemester } from '../lib/modules';
+import { extractWorkflowContext } from '../lib/contextExtraction';
 import '../styles/components/floating-orchestrator.css';
 
 const AgentTask = ({ message }) => (
@@ -48,6 +49,7 @@ export default function FloatingOrchestrator() {
 
     const [input, setInput] = useState('');
     const [isMinimized, setIsMinimized] = useState(false);
+    const [autoMinimize, setAutoMinimize] = useState(true);
     const [isDragging, setIsDragging] = useState(false);
     const [isResizing, setIsResizing] = useState(false);
     const [dragStart, setDragStart] = useState({ x: 0, y: 0 });
@@ -178,6 +180,70 @@ User Message: ${message}`;
         sendMessageToOrchestrator(enhancedMessage, { enableThinking, thinkingBudget });
     }, [isContextAware, gatherAppContext, enableThinking, thinkingBudget]);
 
+    // Generate workflow from current application context
+    const generateWorkflowFromContext = useCallback(async () => {
+        try {
+            // Use the new context extraction utility
+            const context = extractWorkflowContext();
+
+            // Add to chat history to show user what's happening
+            useStore.setState(state => {
+                state.orchestratorHistory.push({
+                    role: 'user',
+                    parts: [{ text: '/generate_workflow' }]
+                }, {
+                    role: 'assistant',
+                    parts: [{ text: '🔄 Generating workflow from current application context...' }]
+                });
+            });
+
+            // Call the backend to generate workflow
+            const response = await fetch('/api/planner/generate-from-context', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json'
+                },
+                credentials: 'include',
+                body: JSON.stringify({ context })
+            });
+
+            if (response.ok) {
+                const { nodes, edges, title } = await response.json();
+
+                // Set the generated workflow in the planner
+                const actions = useStore.getState().actions;
+                if (actions?.setPlannerGraph) {
+                    actions.setPlannerGraph({ nodes, edges, title: title || 'AI Generated Workflow' });
+                }
+
+                // Switch to planner view
+                if (actions?.setActiveApp) {
+                    actions.setActiveApp('planner');
+                }
+
+                // Update chat history with success
+                useStore.setState(state => {
+                    state.orchestratorHistory.push({
+                        role: 'assistant',
+                        parts: [{ text: `✅ Generated workflow: "${title || 'AI Generated Workflow'}" with ${nodes.length} nodes and ${edges.length} connections. Switching to Planner view.` }]
+                    });
+                });
+            } else {
+                const error = await response.text();
+                throw new Error(error);
+            }
+        } catch (error) {
+            console.error('Failed to generate workflow:', error);
+            useStore.setState(state => {
+                state.orchestratorHistory.push({
+                    role: 'assistant',
+                    parts: [{ text: `❌ Failed to generate workflow: ${error.message}` }]
+                });
+            });
+        }
+    }, []);
+
     // Function to start a new chat
     const handleNewChat = useCallback(() => {
         if (window.confirm('Start a new chat? This will clear the current conversation.')) {
@@ -203,6 +269,17 @@ User Message: ${message}`;
         }
     }, [history, isLoading, isMinimized]);
 
+    // Auto-minimize after inactivity
+    useEffect(() => {
+        if (!autoMinimize || isMinimized || isDragging) return;
+
+        const timer = setTimeout(() => {
+            setIsMinimized(true);
+        }, 30000); // 30 seconds of inactivity
+
+        return () => clearTimeout(timer);
+    }, [autoMinimize, isMinimized, isDragging, history, input]); // Reset timer on any activity
+
     // Close dropdowns when clicking outside
     useEffect(() => {
         const handleClickOutside = (event) => {
@@ -338,6 +415,14 @@ User Message: ${message}`;
     const handleSubmit = (e) => {
         e.preventDefault();
         if (!input.trim()) return;
+
+        // Handle special commands
+        if (input.startsWith('/generate_workflow')) {
+            generateWorkflowFromContext();
+            setInput('');
+            return;
+        }
+
         sendContextualMessage(input);
         setInput('');
     };