node-red-contrib-ai-agent 0.5.11 → 0.5.13

package/orchestrator/orchestrator.html

@@ -6,7 +6,11 @@
             name: { value: "" },
             maxIterations: { value: 5, validate: RED.validators.number() },
             planningStrategy: { value: "simple" },
-            defaultGoal: { value: "" }
+            defaultGoal: { value: "" },
+            maxHistory: { value: 50, validate: RED.validators.number() },
+            providerBaseUrl: { value: "https://openrouter.ai/api/v1" },
+            timeoutMs: { value: 30000, validate: RED.validators.number() },
+            debug: { value: false }
         },
         inputs: 1,
         outputs: 1,
@@ -39,6 +43,22 @@
         <label for="node-input-defaultGoal"><i class="fa fa-bullseye"></i> Default Goal</label>
         <textarea id="node-input-defaultGoal" style="width: 100%" rows="3" placeholder="Optional default goal for the orchestrator"></textarea>
     </div>
+    <div class="form-row">
+        <label for="node-input-maxHistory"><i class="fa fa-history"></i> Max History</label>
+        <input type="number" id="node-input-maxHistory" placeholder="50">
+    </div>
+    <div class="form-row">
+        <label for="node-input-providerBaseUrl"><i class="fa fa-globe"></i> Provider Base URL</label>
+        <input type="text" id="node-input-providerBaseUrl" placeholder="https://openrouter.ai/api/v1">
+    </div>
+    <div class="form-row">
+        <label for="node-input-timeoutMs"><i class="fa fa-clock-o"></i> Timeout (ms)</label>
+        <input type="number" id="node-input-timeoutMs" placeholder="30000">
+    </div>
+    <div class="form-row">
+        <label for="node-input-debug"><i class="fa fa-bug"></i> Debug</label>
+        <input type="checkbox" id="node-input-debug" style="width:auto">
+    </div>
 </script>
 
 <script type="text/html" data-content-help-name="ai-orchestrator">

package/orchestrator/orchestrator.js

@@ -14,9 +14,18 @@ module.exports = function (RED) {
         const node = this;
 
         this.name = config.name || 'AI Orchestrator';
-        this.maxIterations = parseInt(config.maxIterations) || 5;
-        this.planningStrategy = config.planningStrategy || 'simple';
+        this.maxIterations = normalizePositiveInt(config.maxIterations, 5, 1, 100);
+        this.planningStrategy = (config.planningStrategy || 'simple');
         this.defaultGoal = config.defaultGoal || '';
+        this.maxHistory = normalizePositiveInt(config.maxHistory, 50, 1, 1000);
+        this.providerBaseUrl = String(config.providerBaseUrl || 'https://openrouter.ai/api/v1');
+        this.timeoutMs = normalizePositiveInt(config.timeoutMs, 30000, 1000, 300000);
+        this.debug = !!config.debug;
+
+        const configErrors = validateNodeConfig(node);
+        if (configErrors.length > 0) {
+            node.error(configErrors.join('; '));
+        }
 
         node.on('input', async function (msg, send, done) {
             send = send || function () { node.send.apply(node, arguments) };
@@ -38,88 +47,116 @@ module.exports = function (RED) {
                         history: [],
                         plan: null
                     };
-                } else {
-                    msg.orchestration.iterations++;
                 }
 
-                // Check for max iterations
-                if (msg.orchestration.iterations >= node.maxIterations) {
-                    node.warn('Max iterations reached');
-                    msg.orchestration.status = 'failed';
-                    msg.orchestration.error = 'Max iterations reached';
-                    node.status({ fill: 'red', shape: 'dot', text: 'max iterations' });
-                    send(msg);
+                const messageErrors = validateMessage(msg, node);
+                if (messageErrors.length > 0) {
+                    throw new Error(messageErrors.join('; '));
+                }
+
+                if (msg.orchestration._running) {
                     if (done) done();
                     return;
                 }
 
-                // AI Configuration check
-                if (!msg.aiagent || !msg.aiagent.apiKey) {
-                    throw new Error('AI Model configuration missing or API key not found.');
-                }
+                msg.orchestration._running = true;
+                setImmediate(() => processNextStep(RED, node, msg, send, done));
+            } catch (error) {
+                node.status({ fill: 'red', shape: 'ring', text: 'error' });
+                node.error(error.message, msg);
+                if (done) done(error);
+            }
+        });
+    }
+
+    async function processNextStep(RED, node, msg, send, done) {
+        try {
+            if (!msg.orchestration) {
+                msg.orchestration = { status: 'failed', error: 'Orchestration state missing' };
+            }
 
-                // Inner loop for Zero-Wire execution
-                while (msg.orchestration.status !== 'completed' && msg.orchestration.status !== 'failed') {
+            if (msg.orchestration.status === 'completed' || msg.orchestration.status === 'failed') {
+                finalizeOrchestration(node, msg, send, done);
+                return;
+            }
 
-                    // 1. Planning Phase
-                    if (msg.orchestration.status === 'planning' || !msg.orchestration.plan) {
-                        node.status({ fill: 'blue', shape: 'dot', text: 'planning...' });
-                        await createInitialPlan(node, msg);
-                    }
+            if (msg.orchestration.iterations >= node.maxIterations) {
+                msg.orchestration.status = 'failed';
+                msg.orchestration.error = 'Max iterations reached';
+                node.status({ fill: 'red', shape: 'dot', text: 'max iterations' });
+                finalizeOrchestration(node, msg, send, done);
+                return;
+            }
 
-                    // 2. Find Next Task
-                    const nextTask = getNextTask(msg.orchestration.plan);
-                    if (!nextTask) {
-                        msg.orchestration.status = 'completed';
-                        break;
-                    }
+            if (msg.orchestration.status === 'planning' || !msg.orchestration.plan) {
+                node.status({ fill: 'blue', shape: 'dot', text: 'planning...' });
+                await createInitialPlan(node, msg);
 
-                    // 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())
-                    );
+                const planErrors = validatePlan(msg.orchestration.plan, msg.orchestration.availableAgents || []);
+                if (planErrors.length > 0) {
+                    msg.orchestration.status = 'failed';
+                    msg.orchestration.error = planErrors.join('; ');
+                    node.status({ fill: 'red', shape: 'ring', text: 'plan invalid' });
+                    finalizeOrchestration(node, msg, send, done);
+                    return;
+                }
 
-                    if (!agentInfo) {
-                        node.warn(`No registered agent found for capability: ${nextTask.type}`);
-                        throw new Error(`Capability not provided by any wired agent: ${nextTask.type}`);
-                    }
+                setImmediate(() => processNextStep(RED, node, msg, send, done));
+                return;
+            }
 
-                    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 Orchestrator Agent or is missing executeTask API.`);
-                    }
+            const nextTask = getNextTask(msg.orchestration.plan);
+            if (!nextTask) {
+                msg.orchestration.status = 'completed';
+                finalizeOrchestration(node, msg, send, done);
+                return;
+            }
 
+            msg.orchestration.currentTaskId = nextTask.id;
+            const agentInfo = selectAgentForTask(msg.orchestration, nextTask);
+
+            if (!agentInfo) {
+                msg.error = `Capability not provided by any wired agent: ${nextTask.type}`;
+                msg.payload = null;
+            } else {
+                const agentNode = RED.nodes.getNode(agentInfo.id);
+                if (!agentNode || typeof agentNode.executeTask !== 'function') {
+                    msg.error = `Agent node ${agentInfo.name} [${agentInfo.id}] is not an AI Orchestrator Agent or is missing executeTask API.`;
+                    msg.payload = null;
+                } else {
                     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;
+                        let errorMessage = err && err.message ? err.message : String(err);
                         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);
+            node.status({ fill: 'blue', shape: 'dot', text: 'reflecting...' });
+            await reflectAndRefine(node, msg);
+            msg.orchestration.iterations++;
 
-                if (done) done();
-            } catch (error) {
-                node.status({ fill: 'red', shape: 'ring', text: 'error' });
-                node.error(error.message, msg);
-                if (done) done(error);
-            }
-        });
+            setImmediate(() => processNextStep(RED, node, msg, send, done));
+        } catch (error) {
+            msg.orchestration.status = 'failed';
+            msg.orchestration.error = error && error.message ? error.message : String(error);
+            node.status({ fill: 'red', shape: 'ring', text: 'error' });
+            finalizeOrchestration(node, msg, send, done, error);
+        }
+    }
+
+    function finalizeOrchestration(node, msg, send, done, error) {
+        msg.orchestration._running = false;
+        node.status({ fill: msg.orchestration.status === 'completed' ? 'green' : 'red', shape: 'dot', text: msg.orchestration.status });
+        send(msg);
+        if (done) done(error);
     }
 
     /**
@@ -133,6 +170,10 @@ module.exports = function (RED) {
         const strategy = node.planningStrategy;
         const agents = msg.orchestration.availableAgents || [];
         const agentManifest = agents.map(a => `- ${a.name}: [${a.capabilities.join(', ')}]`).join('\n');
+        const allowedCapabilities = Array.from(new Set(
+            agents.flatMap(a => Array.isArray(a.capabilities) ? a.capabilities : []).map(String)
+        ));
+        const allowedCapabilitiesJson = JSON.stringify(allowedCapabilities);
 
         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:
@@ -154,6 +195,11 @@ Return a JSON object with a "tasks" array. Each task should have:
 - Do NOT include trailing commas
 - All string values must be valid JSON strings (escape newlines as \\n if needed)
 
+CAPABILITY RULES:
+- The "type" field MUST be one of these EXACT strings (case-sensitive): ${allowedCapabilitiesJson}
+- Do NOT invent new capabilities.
+- If the goal seems to require a missing capability, still produce a plan using ONLY the allowed capabilities, and include a task whose input explains the limitation.
+
 Example:
 {
   "tasks": [
@@ -163,9 +209,9 @@ Example:
 }`;
 
         try {
-            node.warn("Prompt: " + prompt);
-            const response = await callAI(msg.aiagent, prompt, "You are an AI Orchestrator that creates non-linear plans with dependencies.");
-            node.warn("Response: " + response);
+            debugLog(node, 'Planning Prompt', prompt);
+            const response = await callAI(node, msg.aiagent, prompt, "You are an AI Orchestrator that creates non-linear plans with dependencies.");
+            debugLog(node, 'Planning Response', response);
             const planData = parseJsonResponse(response);
             msg.orchestration.plan = planData;
             msg.orchestration.status = 'executing';
@@ -181,8 +227,8 @@ Example:
      */
     async function reflectAndRefine(node, msg) {
         const currentTaskId = msg.orchestration.currentTaskId;
+        const isError = !!msg.error;
         const taskResult = msg.payload;
-        const isError = msg.error ? true : false;
 
         // Update history
         msg.orchestration.history.push({
@@ -192,6 +238,10 @@ Example:
             timestamp: new Date().toISOString()
         });
 
+        if (Array.isArray(msg.orchestration.history) && msg.orchestration.history.length > node.maxHistory) {
+            msg.orchestration.history = msg.orchestration.history.slice(-node.maxHistory);
+        }
+
         // Update task status in plan
         const task = msg.orchestration.plan.tasks.find(t => t.id === currentTaskId);
         if (task) {
@@ -204,17 +254,38 @@ Example:
             }
         }
 
+        const hasHumanApprovalCapability = (msg.orchestration.availableAgents || []).some(a =>
+            Array.isArray(a.capabilities) && a.capabilities.some(c => String(c).toLowerCase() === 'human_approval')
+        );
+
+        const allowedCapabilities = Array.from(new Set(
+            (msg.orchestration.availableAgents || [])
+                .flatMap(a => Array.isArray(a.capabilities) ? a.capabilities : [])
+                .map(String)
+        ));
+        const allowedCapabilitiesJson = JSON.stringify(allowedCapabilities);
+
+        const humanApprovalInstruction = hasHumanApprovalCapability
+            ? '3. If you need more information or approval from a human, add a task with type "human_approval".'
+            : '3. Do NOT request human approval tasks ("human_approval" is not available).';
+
         const prompt = `Current Goal: ${msg.orchestration.goal}
 Current Plan: ${JSON.stringify(msg.orchestration.plan)}
 Last Task ID: ${currentTaskId}
 Last Task ${isError ? 'Error' : 'Result'}: ${JSON.stringify(isError ? msg.error : taskResult)}
 
+Available Capabilities (EXACT strings): ${allowedCapabilitiesJson}
+
 Evaluate the progress. 
 1. If the last task failed, propose a recovery strategy (retry, alternative task, or fail the goal).
 2. If the goal is achieved, set status to "completed".
-3. If you need more information or approval from a human, add a task with type "human_approval".
+${humanApprovalInstruction}
 4. Otherwise, continue execution. You may refine the plan by adding, removing, or modifying tasks.
 
+PLAN UPDATE RULES:
+- In updatedPlan.tasks, every task.type MUST be one of the EXACT capability strings listed above.
+- Do NOT invent or rename capabilities.
+
 Return a JSON object:
 {
   "analysis": "detailed evaluation of progress and next steps",
@@ -223,7 +294,7 @@ Return a JSON object:
 }`;
 
         try {
-            const response = await callAI(msg.aiagent, prompt, "You are an AI Orchestrator that reflects on progress and manages plan revisions.");
+            const response = await callAI(node, msg.aiagent, prompt, "You are an AI Orchestrator that reflects on progress and manages plan revisions.");
             const reflection = parseJsonResponse(response);
 
             msg.orchestration.status = reflection.status;
@@ -269,6 +340,35 @@ Return a JSON object:
         return eligibleTasks[0];
     }
 
+    function selectAgentForTask(orchestration, task) {
+        if (!orchestration || !task || !task.type) return null;
+        const availableAgents = orchestration.availableAgents || [];
+        const taskType = String(task.type).toLowerCase();
+
+        const matchingAgents = availableAgents.filter(a =>
+            Array.isArray(a.capabilities) && a.capabilities.some(cap => String(cap).toLowerCase() === taskType)
+        );
+
+        if (matchingAgents.length === 0) return null;
+        if (matchingAgents.length === 1) return matchingAgents[0];
+
+        orchestration.agentUsage = orchestration.agentUsage || {};
+        orchestration.agentLastUsedAt = orchestration.agentLastUsedAt || {};
+
+        // Prefer least recently used among matching agents to avoid always picking the first.
+        matchingAgents.sort((a, b) => {
+            const aLast = orchestration.agentLastUsedAt[a.id] || 0;
+            const bLast = orchestration.agentLastUsedAt[b.id] || 0;
+            if (aLast !== bLast) return aLast - bLast;
+            return String(a.id).localeCompare(String(b.id));
+        });
+
+        const selected = matchingAgents[0];
+        orchestration.agentUsage[selected.id] = (orchestration.agentUsage[selected.id] || 0) + 1;
+        orchestration.agentLastUsedAt[selected.id] = Date.now();
+        return selected;
+    }
+
     /**
      * Makes an API call to the AI model
      * @param {Object} aiConfig - AI configuration containing model and API key
@@ -277,9 +377,9 @@ Return a JSON object:
      * @returns {Promise<string>} The AI response content
      * @throws {Error} If API call fails
      */
-    async function callAI(aiConfig, prompt, systemPrompt) {
+    async function callAI(node, aiConfig, prompt, systemPrompt) {
         const response = await axios.post(
-            'https://openrouter.ai/api/v1/chat/completions',
+            buildChatCompletionsUrl(node, aiConfig),
             {
                 model: aiConfig.model,
                 messages: [
@@ -291,13 +391,28 @@ Return a JSON object:
             {
                 headers: {
                     'Authorization': `Bearer ${aiConfig.apiKey}`,
-                    'Content-Type': 'application/json'
-                }
+                    'Content-Type': 'application/json',
+                    'HTTP-Referer': 'https://nodered.org/',
+                    'X-Title': 'Node-RED AI Orchestrator'
+                },
+                timeout: getTimeoutMs(node, aiConfig)
             }
         );
         return response.data.choices[0]?.message?.content || '';
     }
 
+    function buildChatCompletionsUrl(node, aiConfig) {
+        const baseUrl = (aiConfig && aiConfig.baseUrl) ? String(aiConfig.baseUrl) : String(node.providerBaseUrl);
+        return baseUrl.replace(/\/+$/, '') + '/chat/completions';
+    }
+
+    function getTimeoutMs(node, aiConfig) {
+        if (aiConfig && aiConfig.timeoutMs !== undefined) {
+            return normalizePositiveInt(aiConfig.timeoutMs, node.timeoutMs, 1000, 300000);
+        }
+        return node.timeoutMs;
+    }
+
     /**
      * Extracts JSON from a text response
      * @param {string} text - The text containing JSON
@@ -410,5 +525,154 @@ Return a JSON object:
         return out.trim();
     }
 
+    function debugLog(node, label, payload) {
+        if (!node || !node.debug || typeof node.warn !== 'function') return;
+        try {
+            const serialized = typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2);
+            node.warn(`[AI Orchestrator] ${label}: ${serialized}`);
+        } catch (_err) {
+            node.warn(`[AI Orchestrator] ${label}: [unserializable payload]`);
+        }
+    }
+
+    function normalizePositiveInt(value, fallback, min, max) {
+        const n = parseInt(value);
+        if (!Number.isFinite(n)) return fallback;
+        if (n < min) return min;
+        if (n > max) return max;
+        return n;
+    }
+
+    function validateNodeConfig(node) {
+        const errors = [];
+        if (!['simple', 'advanced'].includes(String(node.planningStrategy))) {
+            errors.push('planningStrategy must be "simple" or "advanced"');
+        }
+        if (!String(node.providerBaseUrl || '').trim()) {
+            errors.push('providerBaseUrl must be a non-empty string');
+        }
+        return errors;
+    }
+
+    function validateMessage(msg, node) {
+        const errors = [];
+        if (!msg || typeof msg !== 'object') {
+            errors.push('msg must be an object');
+            return errors;
+        }
+        if (!msg.aiagent) {
+            errors.push('AI Model configuration missing (msg.aiagent)');
+            return errors;
+        }
+        if (!msg.aiagent.apiKey || !String(msg.aiagent.apiKey).trim()) {
+            errors.push('AI Model API key not found (msg.aiagent.apiKey)');
+        }
+        if (!msg.aiagent.model || !String(msg.aiagent.model).trim()) {
+            errors.push('AI Model not found (msg.aiagent.model)');
+        }
+        if (msg.orchestration && (!msg.orchestration.goal || !String(msg.orchestration.goal).trim())) {
+            errors.push('Orchestration goal is empty');
+        }
+        return errors;
+    }
+
+    function validatePlan(plan, availableAgents) {
+        const errors = [];
+        if (!plan || typeof plan !== 'object') {
+            errors.push('Plan is missing');
+            return errors;
+        }
+        if (!Array.isArray(plan.tasks)) {
+            errors.push('Plan.tasks must be an array');
+            return errors;
+        }
+
+        const allowedCapabilities = new Set(
+            (availableAgents || [])
+                .flatMap(a => Array.isArray(a.capabilities) ? a.capabilities : [])
+                .map(c => String(c))
+        );
+
+        const idSet = new Set();
+        for (const task of plan.tasks) {
+            if (!task || typeof task !== 'object') {
+                errors.push('Task must be an object');
+                continue;
+            }
+            if (!task.id || !String(task.id).trim()) {
+                errors.push('Task.id is required');
+            } else {
+                const id = String(task.id);
+                if (idSet.has(id)) errors.push(`Duplicate task id: ${id}`);
+                idSet.add(id);
+            }
+            if (!task.type || !String(task.type).trim()) {
+                errors.push(`Task ${String(task.id || '?')} is missing type`);
+            } else if (allowedCapabilities.size > 0 && !allowedCapabilities.has(String(task.type))) {
+                errors.push(`Task ${String(task.id || '?')} has unsupported type: ${String(task.type)}`);
+            }
+            if (!task.status) {
+                task.status = 'pending';
+            }
+            if (!['pending', 'completed', 'failed'].includes(String(task.status))) {
+                errors.push(`Task ${String(task.id || '?')} has invalid status: ${String(task.status)}`);
+            }
+            if (!Array.isArray(task.dependsOn)) {
+                task.dependsOn = task.dependsOn ? [task.dependsOn] : [];
+            }
+        }
+
+        for (const task of plan.tasks) {
+            for (const depId of (task.dependsOn || [])) {
+                const dep = String(depId);
+                if (!idSet.has(dep)) {
+                    errors.push(`Task ${String(task.id || '?')} depends on non-existent task ${dep}`);
+                }
+            }
+        }
+
+        const cycle = findDependencyCycle(plan.tasks);
+        if (cycle) {
+            errors.push(`Circular dependencies detected: ${cycle.join(' -> ')}`);
+        }
+
+        return errors;
+    }
+
+    function findDependencyCycle(tasks) {
+        const graph = new Map();
+        for (const t of tasks || []) {
+            if (!t || !t.id) continue;
+            graph.set(String(t.id), (t.dependsOn || []).map(String));
+        }
+
+        const visiting = new Set();
+        const visited = new Set();
+
+        function dfs(nodeId, path) {
+            if (visiting.has(nodeId)) {
+                const idx = path.indexOf(nodeId);
+                return idx >= 0 ? path.slice(idx).concat([nodeId]) : path.concat([nodeId]);
+            }
+            if (visited.has(nodeId)) return null;
+
+            visiting.add(nodeId);
+            visited.add(nodeId);
+            const deps = graph.get(nodeId) || [];
+            for (const dep of deps) {
+                const result = dfs(dep, path.concat([nodeId]));
+                if (result) return result;
+            }
+            visiting.delete(nodeId);
+            return null;
+        }
+
+        for (const nodeId of graph.keys()) {
+            const result = dfs(nodeId, []);
+            if (result) return result;
+        }
+        return null;
+    }
+
     RED.nodes.registerType('ai-orchestrator', AiOrchestratorNode);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ai-agent",
-    "version": "0.5.11",
+    "version": "0.5.13",
     "description": "AI Agent for Node-RED",
     "repository": {
         "type": "git",