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

package/orchestrator-agent/orchestrator-agent.html

@@ -0,0 +1,69 @@
+<script type="text/javascript">
+    RED.nodes.registerType('ai-orchestrator-agent', {
+        category: 'AI Agent',
+        color: '#deb887',
+        defaults: {
+            name: { value: '' },
+            systemPrompt: {
+                value: 'You are a helpful AI assistant.',
+                required: true
+            },
+            capabilities: {
+                value: '',
+                required: true
+            }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: 'agent/ai-agent-icon.svg',
+        label: function () {
+            return this.name || 'AI Agent Orchestrator';
+        },
+        paletteLabel: 'Agent Orchestrator',
+        oneditprepare: function () {
+        }
+    });
+</script>
+
+<script type="text/x-red" data-template-name="ai-orchestrator-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 Orchestrator">
+  </div>
+  
+  <div class="form-row">
+    <label for="node-input-capabilities"><i class="fa fa-list"></i> Capabilities</label>
+    <input type="text" id="node-input-capabilities" placeholder="e.g. coding, research, translation">
+    <div class="form-tips" style="margin-top: 5px;">
+        Comma-separated list of skills this agent provides to its Orchestrator.
+    </div>
+  </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" style="width: 100%; height: 80px; resize: vertical; font-family: monospace;"></textarea>
+  </div>
+  
+  <div class="form-tips" style="background: #f8f9fa; border-left: 3px solid #3b78e7; padding: 10px;">
+      <p><b>Pipeline Node:</b> This node tags messages with its identity so a connected Orchestrator can use it.</p>
+      <p><b>Output:</b> Discovery Pipeline (Connect to Orchestrator).</p>
+  </div>
+</script>
+
+<script type="text/x-red" data-help-name="ai-orchestrator-agent">
+  <h3>AI Agent Orchestrator Node</h3>
+  <p>A specialized version of the AI Agent designed for multi-agent workflows.</p>
+  
+  <h4>Features</h4>
+  <ul>
+    <li><b>Discovery Pipeline</b>: Appends its metadata to `msg.agents` for the AI Orchestrator.</li>
+    <li><b>Direct Invocation</b>: Can be called directly by the Orchestrator without wires.</li>
+  </ul>
+  
+  <h4>Usage</h4>
+  <ol>
+    <li>Place the node in front of an AI Orchestrator node.</li>
+    <li>Connect the output of this node to the input of the Orchestrator.</li>
+    <li>Define the agent's specific capabilities in the config.</li>
+  </ol>
+</script>

package/orchestrator-agent/orchestrator-agent.js

@@ -0,0 +1,255 @@
+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
+ */
+function createMessage(role, content) {
+    return {
+        role: role,
+        content: content,
+        timestamp: new Date().toISOString(),
+        type: 'conversation'
+    };
+}
+
+/**
+ * Prepares the prompt with context if memory is available
+ */
+function preparePrompt(node, msg, inputText) {
+    const messages = [{ role: 'system', content: node.systemPrompt }];
+    let userMessage = null;
+
+    if (msg.aimemory) {
+        if (!msg.aimemory.context) {
+            throw new Error('Memory not properly initialized. Ensure a memory node is connected.');
+        }
+        msg.aimemory.context = msg.aimemory.context || [];
+        msg.aimemory.maxItems = msg.aimemory.maxItems || 1000;
+        messages.push(...msg.aimemory.context);
+        userMessage = createMessage('user', inputText);
+    }
+
+    messages.push({ role: 'user', content: inputText });
+
+    return { messages, userMessage };
+}
+
+/**
+ * Updates the conversation context with new messages
+ */
+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
+ */
+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 Orchestrator Error: ' + errorMsg, msg);
+}
+
+/**
+ * Formats tools for the OpenAI/OpenRouter API
+ */
+function formatToolsForAPI(tools) {
+    return tools.map(tool => {
+        const type = tool.type || 'function';
+        const fn = tool.function || {};
+        return {
+            type: type,
+            function: {
+                name: fn.name || 'function',
+                description: fn.description || 'function',
+                parameters: fn.parameters || {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
+            }
+        };
+    });
+}
+
+/**
+ * Calls the AI with proper error handling
+ */
+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';
+
+    try {
+        node.status({ fill: 'blue', shape: 'dot', text: `Calling ${aiConfig.model}...` });
+
+        const requestPayload = {
+            model: aiConfig.model,
+            temperature: aiConfig.temperature,
+            messages: messages,
+        };
+
+        if (hasTools) {
+            requestPayload.tools = formatToolsForAPI(tools);
+            requestPayload.tool_choice = toolChoice;
+        }
+
+        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 Orchestrator-Agent'
+                }
+            }
+        );
+
+        const responseMessage = response.data.choices[0]?.message;
+
+        if (responseMessage?.tool_calls && aiConfig.tools) {
+            return await processToolCalls(node, responseMessage, aiConfig.tools, messages, aiConfig);
+        }
+
+        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
+ */
+async function processToolCalls(node, responseMessage, tools, messages, aiConfig) {
+    const toolCalls = responseMessage.tool_calls || [];
+    let toolResults = [];
+
+    for (const toolCall of toolCalls) {
+        const { id, function: fn } = toolCall;
+        const { name, arguments: args } = fn;
+
+        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;
+        }
+
+        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 })
+            });
+        }
+    }
+
+    const updatedMessages = [...messages, responseMessage, ...toolResults];
+    return await callAI(node, { ...aiConfig, tools: null }, updatedMessages);
+}
+
+module.exports = function (RED) {
+    function AIOrchestratorAgent(config) {
+        RED.nodes.createNode(this, config);
+        this.name = config.name || 'AI Agent Orchestrator';
+        this.systemPrompt = config.systemPrompt || 'You are a helpful AI assistant.';
+        this.capabilities = (config.capabilities || '').split(',').map(s => s.trim()).filter(Boolean);
+
+        // AI Orchestrator direct call API
+        this.executeTask = async function (taskInput, msg) {
+            node.status({ fill: 'blue', shape: 'dot', text: 'executing...' });
+            try {
+                const validationError = validateAIConfig(msg.aiagent);
+                if (validationError) throw new Error(validationError);
+
+                const inputText = typeof taskInput === 'string' ? taskInput : JSON.stringify(taskInput);
+                const { messages, userMessage } = preparePrompt(node, msg, inputText);
+                const response = await callAI(node, msg.aiagent, messages);
+
+                if (msg.aimemory && userMessage) {
+                    updateContext(msg, userMessage, response);
+                }
+
+                node.status({ fill: 'green', shape: 'dot', text: 'ready' });
+                return response;
+            } catch (error) {
+                handleError(node, msg, error);
+                throw error;
+            }
+        };
+
+        const node = this;
+
+        node.on('close', function (done) {
+            node.status({});
+            if (done) done();
+        });
+
+        // Discovery Pipeline Logic
+        node.on('input', function (msg, send, done) {
+            node.status({ fill: 'blue', shape: 'dot', text: 'tagging...' });
+
+            try {
+                // Enforce agents array
+                msg.agents = msg.agents || [];
+
+                // Push metadata for the Orchestrator to see
+                msg.agents.push({
+                    id: node.id,
+                    name: node.name,
+                    capabilities: node.capabilities,
+                    type: 'agent'
+                });
+
+                // Pass through to Output 2 (Pipeline)
+                send([null, msg]);
+                node.status({ fill: 'green', shape: 'dot', text: 'ready' });
+
+            } catch (error) {
+                node.error(error.message, msg);
+                node.status({ fill: 'red', shape: 'ring', text: 'Error' });
+            } finally {
+                if (done) done();
+            }
+        });
+    }
+
+    RED.nodes.registerType('ai-orchestrator-agent', AIOrchestratorAgent);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ai-agent",
-    "version": "0.5.0",
+    "version": "0.5.2",
     "description": "AI Agent for Node-RED",
     "repository": {
         "type": "git",
@@ -28,13 +28,14 @@
     "license": "AGPL-3.0",
     "files": [
         "agent/*",
+        "memory-file/*",
+        "memory-inmem/*",
         "model/*",
+        "orchestrator/*",
+        "orchestrator-agent/*",
         "tool/*",
         "tool-function/*",
-        "tool-http/*",
-        "memory-file/*",
-        "memory-inmem/*",
-        "orchestrator/*"
+        "tool-http/*"
     ],
     "dependencies": {
         "axios": "^1.6.0",
@@ -64,7 +65,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-orchestrator-agent": "./orchestrator-agent/orchestrator-agent.js",
             "ai-tool-approval": "./tool-approval/ai-tool-approval.js"
         }
     }