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

package/README.md

@@ -93,9 +93,15 @@ Configures the AI model and API settings.
 ### AI Orchestrator
 Coordinates multiple AI agents by creating and executing plans. It uses an autonomy loop (observe-think-act-reflect) to achieve complex goals.
 
+**Key Features:**
+- **Non-linear Planning**: Supports task dependencies (tasks wait for their predecessors).
+- **Task Prioritization**: Executes higher priority tasks first within dependency constraints.
+- **Dynamic Plan Revision**: Refines the plan based on task outcomes and agent feedback.
+- **Error Recovery**: Automatically handles task failures with recovery strategies (retry, pivot, or fail).
+
 **Properties:**
 - **Max Iterations**: Maximum cycles for the autonomy loop
-- **Planning Strategy**: Simple (linear) or Advanced
+- **Planning Strategy**: Simple (linear) or Advanced (dependency-aware)
 - **Default Goal**: Optional fallback goal
 - **Name**: Display name for the node
 
@@ -120,10 +126,21 @@ Creates an HTTP request tool that can be used by the AI Agent to make external A
 - **Headers**: JSON object of headers to include in the request
 - **Body**: Content to send in the request body
 
+Example: `https://api.example.com/users/${input.userId}`
+
 **Template Variables:**
 You can use template variables in the URL, headers, and body to reference properties from the input object that the AI provides when calling the tool.
 
-Example: `https://api.example.com/users/${input.userId}`
+### AI Tool Approval
+Creates an approval tool that can be used by the AI Agent to request human intervention. When called, the agent's execution pauses until a human provides a response.
+
+**Properties:**
+- **Name**: Display name for the node
+- **Tool Name**: Name of the tool (used by the AI to identify the tool)
+- **Description**: Description of what the tool does (e.g., "Request approval for payments")
+
+**Output 2 (Approval Request):** Sends a message with `msg.payload` containing the human question and `msg.approvalId` to be used for the response.
+
 
 ## Example: Basic Usage
 
@@ -179,7 +196,7 @@ The AI Orchestrator can manage complex, multi-step tasks:
 4. Connect the orchestrator's second output to a **Debug** node
 5. Configure the orchestrator with a goal (e.g., "Write a blog post and then translate it to Spanish")
 
-The orchestrator will create a plan, dispatch the first task to the agent, reflect on the result, and then dispatch the next task until completion.
+The orchestrator will create a plan (optionally with dependencies and priorities), dispatch the first available task to the agent, reflect on the result, and then dispatch the next task until completion. If a task fails, it can revise the plan to recover.
 
 ## Best Practices
 

package/orchestrator/orchestrator.html

@@ -72,5 +72,11 @@
 
     <h3>Details</h3>
     <p>Connect this node to one or more AI agents. The first output should flow into an agent, and the agent's output should loop back to this node's input.</p>
+    <p>The orchestrator supports advanced planning features in "Advanced" mode:</p>
+    <ul>
+        <li><strong>Dependencies:</strong> Tasks can wait for other tasks to complete (<code>dependsOn</code> array).</li>
+        <li><strong>Priorities:</strong> Tasks with higher <code>priority</code> numbers are executed first.</li>
+        <li><strong>Error Recovery:</strong> If a task fails, the orchestrator reflects on the error and can revise the plan to retry or try an alternative approach.</li>
+    </ul>
     <p>When the goal is achieved or max iterations are reached, the final message is sent to the second output.</p>
 </script>

package/orchestrator/orchestrator.js

@@ -48,7 +48,7 @@ module.exports = function (RED) {
                 // Logic based on current status
                 if (msg.orchestration.status === 'planning' || !msg.orchestration.plan) {
                     await createInitialPlan(node, msg);
-                } else {
+                } else if (msg.orchestration.currentTaskId) {
                     await reflectAndRefine(node, msg);
                 }
 
@@ -82,23 +82,33 @@ module.exports = function (RED) {
 
     async function createInitialPlan(node, msg) {
         const goal = msg.orchestration.goal;
-        const prompt = `Goal: ${goal}\n\nDecompose this goal into a series of tasks for AI agents. 
+        const strategy = node.planningStrategy;
+
+        let prompt = `Goal: ${goal}\n\nDecompose this goal into a series of tasks for AI agents. 
 Return a JSON object with a "tasks" array. Each task should have:
-- "id": a short string id
-- "type": the type of task
-- "input": what the agent should do
+- "id": a short string id (e.g., "t1", "t2")
+- "type": the type of task (e.g., "research", "code", "review")
+- "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.`;
+        }
 
-Example:
+        prompt += `\n\nExample:
 {
   "tasks": [
-    {"id": "t1", "type": "research", "input": "Find information about X", "status": "pending"},
-    {"id": "t2", "type": "summary", "input": "Summarize the findings", "status": "pending"}
+    {"id": "t1", "type": "research", "input": "...", "status": "pending", "priority": 10, "dependsOn": []},
+    {"id": "t2", "type": "implementation", "input": "...", "status": "pending", "priority": 5, "dependsOn": ["t1"]}
   ]
 }`;
 
         try {
-            const response = await callAI(msg.aiagent, prompt, "You are an AI Orchestrator that creates plans.");
+            const response = await callAI(msg.aiagent, prompt, "You are an AI Orchestrator that creates non-linear plans with dependencies.");
             const planData = JSON.parse(extractJson(response));
             msg.orchestration.plan = planData;
             msg.orchestration.status = 'executing';
@@ -110,35 +120,48 @@ Example:
     async function reflectAndRefine(node, msg) {
         const currentTaskId = msg.orchestration.currentTaskId;
         const taskResult = msg.payload;
+        const isError = msg.error ? true : false;
 
         // Update history
         msg.orchestration.history.push({
             taskId: currentTaskId,
             result: taskResult,
+            error: msg.error,
             timestamp: new Date().toISOString()
         });
 
         // Update task status in plan
         const task = msg.orchestration.plan.tasks.find(t => t.id === currentTaskId);
         if (task) {
-            task.status = 'completed';
-            task.output = taskResult;
+            if (isError) {
+                task.status = 'failed';
+                task.error = msg.error;
+            } else {
+                task.status = 'completed';
+                task.output = taskResult;
+            }
         }
 
         const prompt = `Current Goal: ${msg.orchestration.goal}
 Current Plan: ${JSON.stringify(msg.orchestration.plan)}
-Last Task Result: ${JSON.stringify(taskResult)}
+Last Task ID: ${currentTaskId}
+Last Task ${isError ? 'Error' : 'Result'}: ${JSON.stringify(isError ? msg.error : taskResult)}
+
+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".
+4. Otherwise, continue execution. You may refine the plan by adding, removing, or modifying tasks.
 
-Evaluate the progress. Should we continue with the current plan, refine it, or is the goal achieved?
 Return a JSON object:
 {
-  "analysis": "string evaluation",
+  "analysis": "detailed evaluation of progress and next steps",
   "status": "executing" | "completed" | "failed",
-  "updatedPlan": { ... same structure as plan ... }
+  "updatedPlan": { "tasks": [...] }
 }`;
 
         try {
-            const response = await callAI(msg.aiagent, prompt, "You are an AI Orchestrator that reflects on progress.");
+            const response = await callAI(msg.aiagent, prompt, "You are an AI Orchestrator that reflects on progress and manages plan revisions.");
             const reflection = JSON.parse(extractJson(response));
 
             msg.orchestration.status = reflection.status;
@@ -146,14 +169,37 @@ Return a JSON object:
                 msg.orchestration.plan = reflection.updatedPlan;
             }
         } catch (error) {
-            node.warn(`Reflection failed, continuing with current plan: ${error.message}`);
-            // Fallback: just move to next task if possible
+            node.warn(`Reflection failed, continuing with current plan state: ${error.message}`);
+            // Fallback: stay in executing status if it was executing, let getNextTask decide
         }
     }
 
     function getNextTask(plan) {
         if (!plan || !plan.tasks) return null;
-        return plan.tasks.find(t => t.status === 'pending');
+
+        // Find tasks that are pending AND all their dependencies are completed
+        const eligibleTasks = plan.tasks.filter(t => {
+            if (t.status !== 'pending') return false;
+
+            if (!t.dependsOn || t.dependsOn.length === 0) return true;
+
+            return t.dependsOn.every(depId => {
+                const depTask = plan.tasks.find(pt => pt.id === depId);
+                return depTask && depTask.status === 'completed';
+            });
+        });
+
+        if (eligibleTasks.length === 0) return null;
+
+        // Sort by priority (descending) then by ID
+        eligibleTasks.sort((a, b) => {
+            const priorityA = a.priority || 5;
+            const priorityB = b.priority || 5;
+            if (priorityB !== priorityA) return priorityB - priorityA;
+            return a.id.localeCompare(b.id);
+        });
+
+        return eligibleTasks[0];
     }
 
     async function callAI(aiConfig, prompt, systemPrompt) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ai-agent",
-    "version": "0.2.0",
+    "version": "0.4.0",
     "description": "AI Agent for Node-RED",
     "repository": {
         "type": "git",
@@ -62,7 +62,8 @@
             "ai-tool-http": "./tool-http/ai-tool-http.js",
             "ai-memory-file": "./memory-file/memory-file.js",
             "ai-memory-inmem": "./memory-inmem/memory-inmem.js",
-            "ai-orchestrator": "./orchestrator/orchestrator.js"
+            "ai-orchestrator": "./orchestrator/orchestrator.js",
+            "ai-tool-approval": "./tool-approval/ai-tool-approval.js"
         }
     }
 }