node-red-contrib-ai-agent 0.4.0 → 0.5.0

package/orchestrator/orchestrator.js

@@ -1,5 +1,13 @@
 const axios = require('axios');
 
+/**
+ * AI Orchestrator Node - Manages multi-agent task execution with planning and reflection
+ * @param {Object} config - Node configuration object
+ * @param {string} config.name - Node name
+ * @param {number} config.maxIterations - Maximum number of planning/execution iterations
+ * @param {string} config.planningStrategy - Strategy for plan creation ('simple' or 'advanced')
+ * @param {string} config.defaultGoal - Default goal if none provided in message
+ */
 module.exports = function (RED) {
     function AiOrchestratorNode(config) {
         RED.nodes.createNode(this, config);
@@ -12,16 +20,21 @@ module.exports = function (RED) {
 
         node.on('input', async function (msg, send, done) {
             send = send || function () { node.send.apply(node, arguments) };
-            node.status({ fill: 'blue', shape: 'dot', text: 'thinking...' });
 
             try {
                 // Initialize orchestration state if not present
                 if (!msg.orchestration) {
+                    node.status({ fill: 'blue', shape: 'dot', text: 'initializing team...' });
+
+                    // Pipeline Discovery: Extract agents from upstream chain
+                    const availableAgents = msg.agents || [];
+
                     msg.orchestration = {
                         planId: 'plan-' + Date.now(),
                         iterations: 0,
                         goal: msg.payload || node.defaultGoal,
                         status: 'planning',
+                        availableAgents: availableAgents,
                         history: [],
                         plan: null
                     };
@@ -35,7 +48,7 @@ module.exports = function (RED) {
                     msg.orchestration.status = 'failed';
                     msg.orchestration.error = 'Max iterations reached';
                     node.status({ fill: 'red', shape: 'dot', text: 'max iterations' });
-                    send([null, msg]); // Output 2 for final result
+                    send(msg);
                     if (done) done();
                     return;
                 }
@@ -45,32 +58,61 @@ module.exports = function (RED) {
                     throw new Error('AI Model configuration missing or API key not found.');
                 }
 
-                // Logic based on current status
-                if (msg.orchestration.status === 'planning' || !msg.orchestration.plan) {
-                    await createInitialPlan(node, msg);
-                } else if (msg.orchestration.currentTaskId) {
-                    await reflectAndRefine(node, msg);
-                }
+                // Inner loop for Zero-Wire execution
+                while (msg.orchestration.status !== 'completed' && msg.orchestration.status !== 'failed') {
 
-                // Dispatch or Finalize
-                if (msg.orchestration.status === 'completed' || msg.orchestration.status === 'failed') {
-                    node.status({ fill: 'green', shape: 'dot', text: msg.orchestration.status });
-                    send([null, msg]); // Output 2
-                } else {
+                    // 1. Planning Phase
+                    if (msg.orchestration.status === 'planning' || !msg.orchestration.plan) {
+                        node.status({ fill: 'blue', shape: 'dot', text: 'planning...' });
+                        await createInitialPlan(node, msg);
+                    }
+
+                    // 2. Find Next Task
                     const nextTask = getNextTask(msg.orchestration.plan);
-                    if (nextTask) {
-                        msg.payload = nextTask.input;
-                        msg.topic = nextTask.type;
-                        msg.orchestration.currentTaskId = nextTask.id;
-                        node.status({ fill: 'blue', shape: 'ring', text: `dispatching: ${nextTask.id}` });
-                        send([msg, null]); // Output 1
-                    } else {
+                    if (!nextTask) {
                         msg.orchestration.status = 'completed';
-                        node.status({ fill: 'green', shape: 'dot', text: 'completed' });
-                        send([null, msg]); // Output 2
+                        break;
+                    }
+
+                    // 3. Execution Phase (Direct Call)
+                    msg.orchestration.currentTaskId = nextTask.id;
+                    const agentInfo = msg.orchestration.availableAgents.find(a =>
+                        a.capabilities.some(cap => cap.toLowerCase() === nextTask.type.toLowerCase())
+                    );
+
+                    if (!agentInfo) {
+                        node.warn(`No registered agent found for capability: ${nextTask.type}`);
+                        throw new Error(`Capability not provided by any wired agent: ${nextTask.type}`);
+                    }
+
+                    const agentNode = RED.nodes.getNode(agentInfo.id);
+                    if (!agentNode || typeof agentNode.executeTask !== 'function') {
+                        throw new Error(`Agent node ${agentInfo.name} [${agentInfo.id}] is not an AI Agent Orchestrator or is missing executeTask API.`);
+                    }
+
+                    node.status({ fill: 'blue', shape: 'ring', text: `agent: ${agentInfo.name}` });
+                    try {
+                        const result = await agentNode.executeTask(nextTask.input, msg);
+                        msg.payload = result;
+                        msg.error = null;
+                    } catch (err) {
+                        // Strip 'AI API Error: ' prefix if present to match test expectations
+                        let errorMessage = err.message;
+                        if (errorMessage.startsWith('AI API Error: ')) {
+                            errorMessage = errorMessage.substring('AI API Error: '.length);
+                        }
+                        msg.error = errorMessage;
                     }
+
+                    // 4. Reflection Phase
+                    node.status({ fill: 'blue', shape: 'dot', text: 'reflecting...' });
+                    await reflectAndRefine(node, msg);
                 }
 
+                // Final Output
+                node.status({ fill: 'green', shape: 'dot', text: msg.orchestration.status });
+                send(msg);
+
                 if (done) done();
             } catch (error) {
                 node.status({ fill: 'red', shape: 'ring', text: 'error' });
@@ -80,20 +122,27 @@ module.exports = function (RED) {
         });
     }
 
+    /**
+     * Creates an initial execution plan using AI
+     * @param {Object} node - The orchestrator node instance
+     * @param {Object} msg - The message object containing orchestration state
+     * @throws {Error} If planning fails
+     */
     async function createInitialPlan(node, msg) {
         const goal = msg.orchestration.goal;
         const strategy = node.planningStrategy;
+        const agents = msg.orchestration.availableAgents || [];
+        const agentManifest = agents.map(a => `- ${a.name}: [${a.capabilities.join(', ')}]`).join('\n');
 
-        let prompt = `Goal: ${goal}\n\nDecompose this goal into a series of tasks for AI agents. 
+        let prompt = `Goal: ${goal}\n\nAvailable Agents and their Capabilities:\n${agentManifest}\n\nDecompose this goal into a series of tasks. You MUST ONLY use capabilities provided by the available agents listed above. 
 Return a JSON object with a "tasks" array. Each task should have:
 - "id": a short string id (e.g., "t1", "t2")
-- "type": the type of task (e.g., "research", "code", "review")
+- "type": the name of the REQUIRED capability from the list above
 - "input": detailed instruction for the agent
 - "status": "pending"
 - "priority": a number (1-10, default 5)
 - "dependsOn": an array of IDs of tasks that must be completed BEFORE this task can start (empty array if none)
-
-Note: You can use "human_approval" as a task type if you need a human to verify something before proceeding.`;
+`;
 
         if (strategy === 'advanced') {
             prompt += `\n\nThink about parallel execution. Group related tasks and identify bottlenecks. Ensure dependencies are logical.`;
@@ -117,6 +166,11 @@ Note: You can use "human_approval" as a task type if you need a human to verify
         }
     }
 
+    /**
+     * Reflects on task execution results and refines the plan
+     * @param {Object} node - The orchestrator node instance
+     * @param {Object} msg - The message object containing orchestration state and task results
+     */
     async function reflectAndRefine(node, msg) {
         const currentTaskId = msg.orchestration.currentTaskId;
         const taskResult = msg.payload;
@@ -174,6 +228,11 @@ Return a JSON object:
         }
     }
 
+    /**
+     * Gets the next executable task from the plan based on dependencies and priority
+     * @param {Object} plan - The execution plan containing tasks
+     * @returns {Object|null} The next task to execute or null if no eligible tasks
+     */
     function getNextTask(plan) {
         if (!plan || !plan.tasks) return null;
 
@@ -202,6 +261,14 @@ Return a JSON object:
         return eligibleTasks[0];
     }
 
+    /**
+     * Makes an API call to the AI model
+     * @param {Object} aiConfig - AI configuration containing model and API key
+     * @param {string} prompt - The user prompt to send
+     * @param {string} systemPrompt - The system prompt for context
+     * @returns {Promise<string>} The AI response content
+     * @throws {Error} If API call fails
+     */
     async function callAI(aiConfig, prompt, systemPrompt) {
         const response = await axios.post(
             'https://openrouter.ai/api/v1/chat/completions',
@@ -223,6 +290,11 @@ Return a JSON object:
         return response.data.choices[0]?.message?.content || '';
     }
 
+    /**
+     * Extracts JSON from a text response
+     * @param {string} text - The text containing JSON
+     * @returns {string} The extracted JSON string
+     */
     function extractJson(text) {
         const match = text.match(/\{[\s\S]*\}/);
         return match ? match[0] : text;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ai-agent",
-    "version": "0.4.0",
+    "version": "0.5.0",
     "description": "AI Agent for Node-RED",
     "repository": {
         "type": "git",
@@ -15,7 +15,8 @@
     ],
     "main": "ai-agent.js",
     "scripts": {
-        "test": "mocha \"test/**/*.js\""
+        "test": "mocha \"test/**/*.js\"",
+        "update-models": "python scripts/update_models.py"
     },
     "author": "Milan Lesichkov",
     "maintainers": [
@@ -63,6 +64,7 @@
             "ai-memory-file": "./memory-file/memory-file.js",
             "ai-memory-inmem": "./memory-inmem/memory-inmem.js",
             "ai-orchestrator": "./orchestrator/orchestrator.js",
+            "ai-agent-orchestrator": "./agent-orchestrator/agent-orchestrator.js",
             "ai-tool-approval": "./tool-approval/ai-tool-approval.js"
         }
     }