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

package/README.md

@@ -19,6 +19,7 @@ Your feedback and contributions are highly appreciated!
 ## Features
 
 - **AI Agent Node**: Process messages with AI, maintaining conversation context
+- **AI Agent Orchestrator Node**: Participates in orchestrated flows via Chain Discovery
 - **Memory Nodes**: 
   - **In-Memory**: Store conversation context in memory (volatile)
   - **File-based**: Persist conversation context to disk
@@ -61,6 +62,14 @@ Processes messages using the configured AI model and maintains conversation cont
 - **System Prompt**: Initial instructions for the AI
 - **Response Type**: Format of the response (text or JSON object)
 
+### AI Agent Orchestrator
+A specialized version of the AI Agent designed for multi-agent workflows. It "tags" messages in a pipeline so the **AI Orchestrator** can discover it.
+
+**Properties:**
+- **Name**: Display name for the node
+- **Capabilities**: Comma-separated list of skills (e.g., `coding, research`)
+- **System Prompt**: Instructions for this specific expert
+
 ### Memory (In-Memory)
 A configuration node that initializes the conversation context in memory. The agent node uses this configuration to manage the conversation context.
 
@@ -91,13 +100,13 @@ Configures the AI model and API settings.
 - **Name**: Display name for the node
 
 ### AI Orchestrator
-Coordinates multiple AI agents by creating and executing plans. It uses an autonomy loop (observe-think-act-reflect) to achieve complex goals.
+Coordinates multiple AI agents by creating and executing plans. It uses **Chain Discovery** to identify available agents from its input message.
 
 **Key Features:**
+- **Chain Discovery**: Implicitly discovers agents wired in a pipeline before it.
+- **Zero-Wire Execution**: Calls discovered agents directly via code (no messy routing wires).
 - **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).
+- **Error Recovery**: Automatically handles task failures with recovery strategies.
 
 **Properties:**
 - **Max Iterations**: Maximum cycles for the autonomy loop
@@ -186,17 +195,16 @@ For more complex scenarios, you can chain multiple agents to process messages in
 
 Each agent will maintain its own conversation context based on its memory configuration.
 
-## Example: Autonomous Orchestration
+## Example: Autonomous Orchestration (Chain Discovery)
 
-The AI Orchestrator can manage complex, multi-step tasks:
+The AI Orchestrator can manage complex, multi-step tasks by utilizing specialized agents in a pipeline:
 
-1. Add an **AI Orchestrator** node
-2. Connect its first output to an **AI Agent**
-3. Connect the agent's output back to the **AI Orchestrator** input
-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")
+1. Add an **AI Orchestrator** node.
+2. Add one or more **AI Agent Orchestrator** nodes (e.g., "Coder", "Researcher").
+3. Connect them in a line: `[Inject Goal] --> [Coder] --> [Researcher] --> [Orchestrator] --> [Debug]`.
+4. The Orchestrator will automatically discover the "Coder" and "Researcher" via the message pipeline and call them as needed to achieve the goal.
 
-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.
+This linear architecture keeps your flows clean while allowing for powerful, multi-agent collaboration.
 
 ## Best Practices
 

package/agent/ai-agent.html

@@ -1,96 +1,96 @@
-<script type="text/javascript">
-  RED.nodes.registerType('ai-agent', {
-    category: 'AI Agent',
-    color: '#a6bbcf',
-    defaults: {
-      name: { value: '' },
-      systemPrompt: { 
-        value: 'You are a helpful AI assistant.',
-        required: true
-      },
-      responseType: { 
-        value: 'text', 
-        required: true,
-        validate: function(val) {
-          return ['text', 'object'].includes(val);
-        }
-      }
-    },
-    inputs: 1,
-    outputs: 1,
-    icon: 'agent/ai-agent-icon.svg',
-    label: function() {
-      return this.name || 'AI Agent';
-    },
-    paletteLabel: 'AI Agent',
-    oneditprepare: function() {
-      // Always show OpenRouter help since we only support OpenRouter now
-      $('#openrouter-help').show();
-    }
-  });
-</script>
-
-<!-- START: Template -->
-<script type="text/x-red" data-template-name="ai-agent">
-  <div class="form-row">
-    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
-    <input type="text" id="node-input-name" placeholder="AI Agent">
-  </div>
-  
-  <div class="form-row">
-    <label for="node-input-systemPrompt"><i class="fa fa-comment"></i> System Prompt</label>
-    <textarea type="text" id="node-input-systemPrompt" placeholder="You are a helpful AI assistant." style="width: 100%; height: 80px; resize: vertical; font-family: monospace;"></textarea>
-  </div>
-  
-  <div class="form-row">
-    <label><i class="fa fa-robot"></i> AI Agent</label>
-    <div class="form-tips" style="width: 70%;">
-      <p>This node uses OpenRouter for AI responses. Connect an <b>AI Model</b> node to configure the model and API key.</p>
-    </div>
-  </div>
-  
-  <div class="form-row">
-    <label for="node-input-responseType"><i class="fa fa-reply"></i> Response Format</label>
-    <select id="node-input-responseType" style="width: 100%;">
-      <option value="text">Text Only</option>
-      <option value="object">Structured Object</option>
-    </select>
-  </div>
-  
-  <div id="openrouter-help" class="form-tips" style="display: none; margin-top: 15px; padding: 10px; background: #f8f9fa; border-radius: 4px; border-left: 3px solid #3b78e7;">
-    <p><i class="fa fa-info-circle"></i> <strong>Note:</strong> When using OpenRouter, connect an AI Model node to provide the model and API key configuration.</p>
-    <p>The AI Model node will add an <code>aiagent</code> property to the message with the required configuration.</p>
-  </div>
-</script>
-<!-- END: Template -->
-
-<!-- START: Help -->
-<script type="text/x-red" data-help-name="ai-agent">
-  <h3>AI Agent Node</h3>
-  <p>An intelligent agent that processes and responds to messages with configurable behavior.</p>
-  
-  <h4>Features</h4>
-  <ul>
-    <li>Multiple agent types (Assistant, Chatbot)</li>
-    <li>Configurable response formats</li>
-    <li>Conversation context tracking</li>
-    <li>Error handling and status reporting</li>
-  </ul>
-  
-  <h4>Usage</h4>
-  <ol>
-    <li>Connect the node to a message source (e.g., HTTP input, inject node)</li>
-    <li>Configure the agent type and response format</li>
-    <li>Process the response in your flow</li>
-  </ol>
-  
-  <h4>Output Formats</h4>
-  <p><b>Text Only:</b> Simple string response</p>
-  <p><b>Structured Object:</b> Detailed response including metadata and context</p>
-  
-  <h4>Examples</h4>
-  <p><b>Input:</b> "Hello"</p>
-  <p><b>Assistant Output:</b> "Hello! How can I assist you today?"</p>
-  <p><b>Chatbot Output:</b> "Hi there! What would you like to chat about?"</p>
-</script>
+<script type="text/javascript">
+  RED.nodes.registerType('ai-agent', {
+    category: 'AI Agent',
+    color: '#a6bbcf',
+    defaults: {
+      name: { value: '' },
+      systemPrompt: { 
+        value: 'You are a helpful AI assistant.',
+        required: true
+      },
+      responseType: { 
+        value: 'text', 
+        required: true,
+        validate: function(val) {
+          return ['text', 'object'].includes(val);
+        }
+      }
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'agent/ai-agent-icon.svg',
+    label: function() {
+      return this.name || 'AI Agent';
+    },
+    paletteLabel: 'AI Agent',
+    oneditprepare: function() {
+      // Always show OpenRouter help since we only support OpenRouter now
+      $('#openrouter-help').show();
+    }
+  });
+</script>
+
+<!-- START: Template -->
+<script type="text/x-red" data-template-name="ai-agent">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+    <input type="text" id="node-input-name" placeholder="AI Agent">
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-systemPrompt"><i class="fa fa-comment"></i> System Prompt</label>
+    <textarea type="text" id="node-input-systemPrompt" placeholder="You are a helpful AI assistant." style="width: 100%; height: 80px; resize: vertical; font-family: monospace;"></textarea>
+  </div>
+  
+  <div class="form-row">
+    <label><i class="fa fa-robot"></i> AI Agent</label>
+    <div class="form-tips" style="width: 70%;">
+      <p>This node uses OpenRouter for AI responses. Connect an <b>AI Model</b> node to configure the model and API key.</p>
+    </div>
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-responseType"><i class="fa fa-reply"></i> Response Format</label>
+    <select id="node-input-responseType" style="width: 100%;">
+      <option value="text">Text Only</option>
+      <option value="object">Structured Object</option>
+    </select>
+  </div>
+  
+  <div id="openrouter-help" class="form-tips" style="display: none; margin-top: 15px; padding: 10px; background: #f8f9fa; border-radius: 4px; border-left: 3px solid #3b78e7;">
+    <p><i class="fa fa-info-circle"></i> <strong>Note:</strong> When using OpenRouter, connect an AI Model node to provide the model and API key configuration.</p>
+    <p>The AI Model node will add an <code>aiagent</code> property to the message with the required configuration.</p>
+  </div>
+</script>
+<!-- END: Template -->
+
+<!-- START: Help -->
+<script type="text/x-red" data-help-name="ai-agent">
+  <h3>AI Agent Node</h3>
+  <p>An intelligent agent that processes and responds to messages with configurable behavior.</p>
+  
+  <h4>Features</h4>
+  <ul>
+    <li>Multiple agent types (Assistant, Chatbot)</li>
+    <li>Configurable response formats</li>
+    <li>Conversation context tracking</li>
+    <li>Error handling and status reporting</li>
+  </ul>
+  
+  <h4>Usage</h4>
+  <ol>
+    <li>Connect the node to a message source (e.g., HTTP input, inject node)</li>
+    <li>Configure the agent type and response format</li>
+    <li>Process the response in your flow</li>
+  </ol>
+  
+  <h4>Output Formats</h4>
+  <p><b>Text Only:</b> Simple string response</p>
+  <p><b>Structured Object:</b> Detailed response including metadata and context</p>
+  
+  <h4>Examples</h4>
+  <p><b>Input:</b> "Hello"</p>
+  <p><b>Assistant Output:</b> "Hello! How can I assist you today?"</p>
+  <p><b>Chatbot Output:</b> "Hi there! What would you like to chat about?"</p>
+</script>
 <!-- END: Help -->

package/agent/ai-agent.js

@@ -1,326 +1,326 @@
-const axios = require('axios');
-
-/**
- * Helper functions for AI Agent Node
- */
-
-// Validate AI configuration
-function validateAIConfig(aiagent) {
-  if (!aiagent) return 'AI configuration missing. Ensure an AI Model node is connected.';
-  if (!aiagent.model) return 'AI model not specified. Please configure the AI Model node with a valid model.';
-  if (!aiagent.apiKey) return 'API key not found. Please configure the AI Model node with a valid API key.';
-  return null; // No errors
-}
-
-/**
- * Creates and returns a message object
- * @param {string} role - The role of the message (e.g., 'user', 'assistant', 'system')
- * @param {string} content - The content of the message
- * @returns {Object} - The message object
- */
-function createMessage(role, content) {
-  return {
-    role: role,
-    content: content,
-    timestamp: new Date().toISOString(),
-    type: 'conversation'
-  };
-}
-
-/**
- * Prepares the prompt with context if memory is available
- * @param {Object} node - The AI Agent node
- * @param {Object} msg - The input message
- * @param {string} inputText - The input text
- * @returns {Object} - The prepared prompt object
- */
-function preparePrompt(node, msg, inputText) {
-  const messages = [{ role: 'system', content: node.systemPrompt }];
-  let userMessage = null;
-  
-  // Add context if using memory
-  if (msg.aimemory) {
-    if (!msg.aimemory.context) {
-      throw new Error('Memory not properly initialized. Ensure a memory node is connected.');
-    }
-    
-    // Ensure memory has required structure
-    msg.aimemory.context = msg.aimemory.context || [];
-    msg.aimemory.maxItems = msg.aimemory.maxItems || 1000;
-    
-    // Add conversation context
-    messages.push(...msg.aimemory.context);
-    
-    // Create and store user message for later context update
-    userMessage = createMessage('user', inputText);
-  }
-  
-  // Add current user input
-  messages.push({ role: 'user', content: inputText });
-  
-  return { messages, userMessage };
-}
-
-/**
- * Updates the conversation context with new messages
- * @param {Object} msg - The input message
- * @param {Object} userMessage - The user message
- * @param {string} assistantResponse - The assistant response
- */
-function updateContext(msg, userMessage, assistantResponse) {
-  if (!msg.aimemory?.context) return;
-  
-  const assistantMessage = createMessage('assistant', assistantResponse);
-  const newContext = [...msg.aimemory.context, userMessage, assistantMessage];
-  const maxItems = msg.aimemory.maxItems || 1000;
-  
-  msg.aimemory.context = newContext.slice(-maxItems);
-}
-
-/**
- * Handles errors consistently
- * @param {Object} node - The AI Agent node
- * @param {Object} msg - The input message
- * @param {Error} error - The error object
- */
-function handleError(node, msg, error) {
-  const errorMsg = error.response?.data?.error?.message || error.message || 'Unknown error';
-  node.status({ fill: 'red', shape: 'ring', text: 'Error' });
-  node.error('AI Agent Error: ' + errorMsg, msg);
-}
-
-/**
- * Formats tools for the OpenAI/OpenRouter API
- * @param {Array} tools - Array of tool definitions
- * @returns {Array} - Formatted tools for the API
- */
-function formatToolsForAPI(tools) {
-  return tools.map(tool => {
-    const type = tool.type || 'function';
-    const fn = tool.function || {};
-    const name = fn.name || 'function';
-    const description = fn.description || 'function';
-    const parameters = fn.parameters || {};
-      return {
-        type: type,
-        function: {
-          name: name,
-          description: description,
-          parameters: parameters || {
-            type: 'object',
-            properties: {},
-            required: []
-          }
-        }
-      };
-    });
-}
-
-/**
- * Calls the AI with proper error handling
- * @param {Object} node - The AI Agent node
- * @param {Object} aiConfig - The AI configuration object
- * @param {Array} messages - The messages to send to the AI
- * @returns {Promise<string>} - The AI response
- */
-async function callAI(node, aiConfig, messages) {
-  const hasTools = aiConfig.tools && Array.isArray(aiConfig.tools) && aiConfig.tools.length > 0;
-  const tools = hasTools ? aiConfig.tools : [];
-  const toolChoice = hasTools ? 'auto' : 'none';
-
-  node.warn(`Calling ${aiConfig.model} with ${tools.length} tools and ${toolChoice} tool choice`);
-  
-  try {
-    node.status({ fill: 'blue', shape: 'dot', text: `Calling ${aiConfig.model}...` });
-    
-    // Prepare request payload
-    const requestPayload = {
-      model: aiConfig.model,
-      temperature: aiConfig.temperature,
-      // max_tokens: aiConfig.maxTokens,
-      messages: messages,
-    };
-    
-    // Add tools if available
-    if (hasTools) {
-      node.warn('Adding tools: ' + JSON.stringify(tools, null, 2));
-      requestPayload.tools = formatToolsForAPI(tools);
-      requestPayload.tool_choice = toolChoice;
-    }
-
-    node.warn(JSON.stringify(requestPayload, null, 2));
-    
-    const response = await axios.post(
-      'https://openrouter.ai/api/v1/chat/completions',
-      requestPayload,
-      {
-        headers: {
-          'Authorization': `Bearer ${aiConfig.apiKey}`,
-          'Content-Type': 'application/json',
-          'HTTP-Referer': 'https://nodered.org/',
-          'X-Title': 'Node-RED AI Agent'
-        }
-      }
-    );
-    
-    // Check if the response contains tool calls
-    const responseMessage = response.data.choices[0]?.message;
-
-    node.warn(JSON.stringify(responseMessage, null, 2));
-
-    if (responseMessage?.tool_calls && aiConfig.tools) {
-      // Process tool calls
-      if (node.warn) node.warn('Processing tool calls');
-      return await processToolCalls(node, responseMessage, aiConfig.tools, messages, aiConfig);
-    }
-
-    node.warn('Processing response');
-    return responseMessage?.content?.trim() || '';
-    
-  } catch (error) {
-    const errorMsg = error.response?.data?.error?.message || error.message;
-    throw new Error(`AI API Error: ${errorMsg}`);
-  }
-}
-
-/**
- * Helper function to process tool calls from AI response
- * @param {Object} node - The Node-RED node instance
- * @param {Object} responseMessage - The AI response message containing tool calls
- * @param {Array} tools - Array of available tools
- * @param {Array} messages - Conversation messages
- * @returns {Promise<string>} - Result of tool executions
- */
-async function processToolCalls(node, responseMessage, tools, messages, aiConfig) {
-  try {
-    const toolCalls = responseMessage.tool_calls || [];
-    let toolResults = [];
-    if (node && node.warn) {
-      node.warn('Processing tool calls: ' + JSON.stringify(toolCalls, null, 2));
-    }
-    
-    // Process each tool call
-    for (const toolCall of toolCalls) {
-      const { id, function: fn } = toolCall;
-      const { name, arguments: args } = fn;
-      
-      // Find the matching tool
-      const tool = tools.find(t => t.function?.name === name);
-      if (!tool) {
-        toolResults.push({
-          tool_call_id: id,
-          role: 'tool',
-          name,
-          content: JSON.stringify({ error: `Tool '${name}' not found` })
-        });
-        continue;
-      }
-      
-      // Execute the tool
-      try {
-        const parsedArgs = typeof args === 'string' ? JSON.parse(args) : args;
-        const result = await tool.execute(parsedArgs);
-        
-        toolResults.push({
-          tool_call_id: id,
-          role: 'tool',
-          name,
-          content: typeof result === 'string' ? result : JSON.stringify(result)
-        });
-      } catch (error) {
-        toolResults.push({
-          tool_call_id: id,
-          role: 'tool',
-          name,
-          content: JSON.stringify({ error: error.message })
-        });
-      }
-    }
-    
-    // Add tool results to the messages array
-    const updatedMessages = [...messages, responseMessage, ...toolResults];
-    
-    // Make a new API call to let the AI process the tool results
-    const aiResponse = await callAI(node, { ...aiConfig, tools: null }, updatedMessages);
-    
-    // Return the final AI response
-    return aiResponse;
-  } catch (error) {
-    return `Error processing tool calls: ${error.message}`;
-  }
-}
-
-module.exports = function (RED) {
-  /**
-   * AI Agent Node
-   * @param {Object} config - The node configuration object
-   */
-  function AiAgentNode(config) {
-    RED.nodes.createNode(this, config);
-    const node = this;
-    
-    // Configuration
-    this.agentName = config.name || 'AI Agent';
-    this.systemPrompt = config.systemPrompt || 'You are a helpful AI assistant.';
-    this.responseType = config.responseType || 'text';
-    
-    // Handle node cleanup
-    node.on('close', function (done) {
-      node.status({});
-      if (done) done();
-    });
-    
-    // Process incoming messages
-    node.on('input', async function (msg, send, done) {
-      node.status({ fill: 'blue', shape: 'dot', text: 'processing...' });
-    
-      try {
-        // 1. Validate AI configuration
-        const validationError = validateAIConfig(msg.aiagent);
-        if (validationError) {
-          throw new Error(validationError);
-        }
-        
-        // 2. Get input
-        const input = msg.payload || {};
-        const inputText = typeof input === 'string' ? input : JSON.stringify(input);
-        
-        // 3. Prepare prompt with context
-        const { messages, userMessage } = preparePrompt(node, msg, inputText);
-        
-        // 4. Execute the prompt and get response
-        const response = await callAI(node, msg.aiagent, messages);
-        
-        // 5. Update context if using memory
-        if (msg.aimemory && userMessage) {
-          updateContext(msg, userMessage, response);
-        }
-        
-        // 6. Format and send response
-        msg.payload = node.responseType === 'object' ? {
-          agent: node.agentName,
-          type: 'ai',
-          input: input,
-          response: response,
-          timestamp: new Date().toISOString(),
-          context: {
-            conversationLength: msg.aimemory?.context?.length || 0,
-            lastInteraction: new Date().toISOString(),
-            ...(msg.aimemory && { aimemory: msg.aimemory })
-          }
-        } : response;
-        
-        send(msg);
-        node.status({ fill: 'green', shape: 'dot', text: 'ready' });
-        
-      } catch (error) {
-        handleError(node, msg, error);
-      } finally {
-        if (done) done();
-      }
-    });
-  }
-
-  // Register the node type
-  RED.nodes.registerType('ai-agent', AiAgentNode);
-};
+const axios = require('axios');
+
+/**
+ * Helper functions for AI Agent Node
+ */
+
+// Validate AI configuration
+function validateAIConfig(aiagent) {
+  if (!aiagent) return 'AI configuration missing. Ensure an AI Model node is connected.';
+  if (!aiagent.model) return 'AI model not specified. Please configure the AI Model node with a valid model.';
+  if (!aiagent.apiKey) return 'API key not found. Please configure the AI Model node with a valid API key.';
+  return null; // No errors
+}
+
+/**
+ * Creates and returns a message object
+ * @param {string} role - The role of the message (e.g., 'user', 'assistant', 'system')
+ * @param {string} content - The content of the message
+ * @returns {Object} - The message object
+ */
+function createMessage(role, content) {
+  return {
+    role: role,
+    content: content,
+    timestamp: new Date().toISOString(),
+    type: 'conversation'
+  };
+}
+
+/**
+ * Prepares the prompt with context if memory is available
+ * @param {Object} node - The AI Agent node
+ * @param {Object} msg - The input message
+ * @param {string} inputText - The input text
+ * @returns {Object} - The prepared prompt object
+ */
+function preparePrompt(node, msg, inputText) {
+  const messages = [{ role: 'system', content: node.systemPrompt }];
+  let userMessage = null;
+  
+  // Add context if using memory
+  if (msg.aimemory) {
+    if (!msg.aimemory.context) {
+      throw new Error('Memory not properly initialized. Ensure a memory node is connected.');
+    }
+    
+    // Ensure memory has required structure
+    msg.aimemory.context = msg.aimemory.context || [];
+    msg.aimemory.maxItems = msg.aimemory.maxItems || 1000;
+    
+    // Add conversation context
+    messages.push(...msg.aimemory.context);
+    
+    // Create and store user message for later context update
+    userMessage = createMessage('user', inputText);
+  }
+  
+  // Add current user input
+  messages.push({ role: 'user', content: inputText });
+  
+  return { messages, userMessage };
+}
+
+/**
+ * Updates the conversation context with new messages
+ * @param {Object} msg - The input message
+ * @param {Object} userMessage - The user message
+ * @param {string} assistantResponse - The assistant response
+ */
+function updateContext(msg, userMessage, assistantResponse) {
+  if (!msg.aimemory?.context) return;
+  
+  const assistantMessage = createMessage('assistant', assistantResponse);
+  const newContext = [...msg.aimemory.context, userMessage, assistantMessage];
+  const maxItems = msg.aimemory.maxItems || 1000;
+  
+  msg.aimemory.context = newContext.slice(-maxItems);
+}
+
+/**
+ * Handles errors consistently
+ * @param {Object} node - The AI Agent node
+ * @param {Object} msg - The input message
+ * @param {Error} error - The error object
+ */
+function handleError(node, msg, error) {
+  const errorMsg = error.response?.data?.error?.message || error.message || 'Unknown error';
+  node.status({ fill: 'red', shape: 'ring', text: 'Error' });
+  node.error('AI Agent Error: ' + errorMsg, msg);
+}
+
+/**
+ * Formats tools for the OpenAI/OpenRouter API
+ * @param {Array} tools - Array of tool definitions
+ * @returns {Array} - Formatted tools for the API
+ */
+function formatToolsForAPI(tools) {
+  return tools.map(tool => {
+    const type = tool.type || 'function';
+    const fn = tool.function || {};
+    const name = fn.name || 'function';
+    const description = fn.description || 'function';
+    const parameters = fn.parameters || {};
+      return {
+        type: type,
+        function: {
+          name: name,
+          description: description,
+          parameters: parameters || {
+            type: 'object',
+            properties: {},
+            required: []
+          }
+        }
+      };
+    });
+}
+
+/**
+ * Calls the AI with proper error handling
+ * @param {Object} node - The AI Agent node
+ * @param {Object} aiConfig - The AI configuration object
+ * @param {Array} messages - The messages to send to the AI
+ * @returns {Promise<string>} - The AI response
+ */
+async function callAI(node, aiConfig, messages) {
+  const hasTools = aiConfig.tools && Array.isArray(aiConfig.tools) && aiConfig.tools.length > 0;
+  const tools = hasTools ? aiConfig.tools : [];
+  const toolChoice = hasTools ? 'auto' : 'none';
+
+  node.warn(`Calling ${aiConfig.model} with ${tools.length} tools and ${toolChoice} tool choice`);
+  
+  try {
+    node.status({ fill: 'blue', shape: 'dot', text: `Calling ${aiConfig.model}...` });
+    
+    // Prepare request payload
+    const requestPayload = {
+      model: aiConfig.model,
+      temperature: aiConfig.temperature,
+      // max_tokens: aiConfig.maxTokens,
+      messages: messages,
+    };
+    
+    // Add tools if available
+    if (hasTools) {
+      node.warn('Adding tools: ' + JSON.stringify(tools, null, 2));
+      requestPayload.tools = formatToolsForAPI(tools);
+      requestPayload.tool_choice = toolChoice;
+    }
+
+    node.warn(JSON.stringify(requestPayload, null, 2));
+    
+    const response = await axios.post(
+      'https://openrouter.ai/api/v1/chat/completions',
+      requestPayload,
+      {
+        headers: {
+          'Authorization': `Bearer ${aiConfig.apiKey}`,
+          'Content-Type': 'application/json',
+          'HTTP-Referer': 'https://nodered.org/',
+          'X-Title': 'Node-RED AI Agent'
+        }
+      }
+    );
+    
+    // Check if the response contains tool calls
+    const responseMessage = response.data.choices[0]?.message;
+
+    node.warn(JSON.stringify(responseMessage, null, 2));
+
+    if (responseMessage?.tool_calls && aiConfig.tools) {
+      // Process tool calls
+      if (node.warn) node.warn('Processing tool calls');
+      return await processToolCalls(node, responseMessage, aiConfig.tools, messages, aiConfig);
+    }
+
+    node.warn('Processing response');
+    return responseMessage?.content?.trim() || '';
+    
+  } catch (error) {
+    const errorMsg = error.response?.data?.error?.message || error.message;
+    throw new Error(`AI API Error: ${errorMsg}`);
+  }
+}
+
+/**
+ * Helper function to process tool calls from AI response
+ * @param {Object} node - The Node-RED node instance
+ * @param {Object} responseMessage - The AI response message containing tool calls
+ * @param {Array} tools - Array of available tools
+ * @param {Array} messages - Conversation messages
+ * @returns {Promise<string>} - Result of tool executions
+ */
+async function processToolCalls(node, responseMessage, tools, messages, aiConfig) {
+  try {
+    const toolCalls = responseMessage.tool_calls || [];
+    let toolResults = [];
+    if (node && node.warn) {
+      node.warn('Processing tool calls: ' + JSON.stringify(toolCalls, null, 2));
+    }
+    
+    // Process each tool call
+    for (const toolCall of toolCalls) {
+      const { id, function: fn } = toolCall;
+      const { name, arguments: args } = fn;
+      
+      // Find the matching tool
+      const tool = tools.find(t => t.function?.name === name);
+      if (!tool) {
+        toolResults.push({
+          tool_call_id: id,
+          role: 'tool',
+          name,
+          content: JSON.stringify({ error: `Tool '${name}' not found` })
+        });
+        continue;
+      }
+      
+      // Execute the tool
+      try {
+        const parsedArgs = typeof args === 'string' ? JSON.parse(args) : args;
+        const result = await tool.execute(parsedArgs);
+        
+        toolResults.push({
+          tool_call_id: id,
+          role: 'tool',
+          name,
+          content: typeof result === 'string' ? result : JSON.stringify(result)
+        });
+      } catch (error) {
+        toolResults.push({
+          tool_call_id: id,
+          role: 'tool',
+          name,
+          content: JSON.stringify({ error: error.message })
+        });
+      }
+    }
+    
+    // Add tool results to the messages array
+    const updatedMessages = [...messages, responseMessage, ...toolResults];
+    
+    // Make a new API call to let the AI process the tool results
+    const aiResponse = await callAI(node, { ...aiConfig, tools: null }, updatedMessages);
+    
+    // Return the final AI response
+    return aiResponse;
+  } catch (error) {
+    return `Error processing tool calls: ${error.message}`;
+  }
+}
+
+module.exports = function (RED) {
+  /**
+   * AI Agent Node
+   * @param {Object} config - The node configuration object
+   */
+  function AiAgentNode(config) {
+    RED.nodes.createNode(this, config);
+    const node = this;
+    
+    // Configuration
+    this.agentName = config.name || 'AI Agent';
+    this.systemPrompt = config.systemPrompt || 'You are a helpful AI assistant.';
+    this.responseType = config.responseType || 'text';
+    
+    // Handle node cleanup
+    node.on('close', function (done) {
+      node.status({});
+      if (done) done();
+    });
+    
+    // Process incoming messages
+    node.on('input', async function (msg, send, done) {
+      node.status({ fill: 'blue', shape: 'dot', text: 'processing...' });
+    
+      try {
+        // 1. Validate AI configuration
+        const validationError = validateAIConfig(msg.aiagent);
+        if (validationError) {
+          throw new Error(validationError);
+        }
+        
+        // 2. Get input
+        const input = msg.payload || {};
+        const inputText = typeof input === 'string' ? input : JSON.stringify(input);
+        
+        // 3. Prepare prompt with context
+        const { messages, userMessage } = preparePrompt(node, msg, inputText);
+        
+        // 4. Execute the prompt and get response
+        const response = await callAI(node, msg.aiagent, messages);
+        
+        // 5. Update context if using memory
+        if (msg.aimemory && userMessage) {
+          updateContext(msg, userMessage, response);
+        }
+        
+        // 6. Format and send response
+        msg.payload = node.responseType === 'object' ? {
+          agent: node.agentName,
+          type: 'ai',
+          input: input,
+          response: response,
+          timestamp: new Date().toISOString(),
+          context: {
+            conversationLength: msg.aimemory?.context?.length || 0,
+            lastInteraction: new Date().toISOString(),
+            ...(msg.aimemory && { aimemory: msg.aimemory })
+          }
+        } : response;
+        
+        send(msg);
+        node.status({ fill: 'green', shape: 'dot', text: 'ready' });
+        
+      } catch (error) {
+        handleError(node, msg, error);
+      } finally {
+        if (done) done();
+      }
+    });
+  }
+
+  // Register the node type
+  RED.nodes.registerType('ai-agent', AiAgentNode);
+};

package/orchestrator/orchestrator.html

@@ -9,8 +9,8 @@
             defaultGoal: { value: "" }
         },
         inputs: 1,
-        outputs: 2,
-        outputLabels: ["Task Dispatch", "Final Result"],
+        outputs: 1,
+        outputLabels: ["Final Result"],
         icon: "font-awesome/fa-sitemap",
         label: function () {
             return this.name || "ai orchestrator";

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.1",
+    "version": "0.5.0",
     "description": "AI Agent for Node-RED",
     "repository": {
         "type": "git",
@@ -64,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"
         }
     }