node-red-contrib-ai-agent 0.0.3 → 0.0.4

package/agent/ai-agent.js

@@ -1,216 +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)
-    var node = this
+    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'
-    
-    // Initialize agent state
-    this.context = {
-      conversation: [],
-      lastInteraction: null
-    }
+    this.agentName = config.name || 'AI Agent';
+    this.systemPrompt = config.systemPrompt || 'You are a helpful AI assistant.';
+    this.responseType = config.responseType || 'text';
     
-    // Default responses
-    this.defaultResponse = 'I understand you said: '
-
     // Handle node cleanup
     node.on('close', function (done) {
-      // Clean up any resources here
-      node.status({})
-      if (done) done()
-    })
-
+      node.status({});
+      if (done) done();
+    });
+    
     // Process incoming messages
     node.on('input', async function (msg, send, done) {
-      // Set status to processing
       node.status({ fill: 'blue', shape: 'dot', text: 'processing...' });
-      
-      // Validate AI configuration
-      const validateAIConfig = () => {
-        if (!msg.aiagent || !msg.aiagent.model || !msg.aiagent.apiKey) {
-          const errorMsg = 'Missing required AI configuration. Ensure an AI Model node is properly connected and configured.';
-          node.status({ fill: 'red', shape: 'ring', text: 'Error: Missing AI config' });
-          node.error(errorMsg, msg);
-          throw new Error(errorMsg);
-        }
-      };
-      
+    
       try {
-        validateAIConfig();
+        // 1. Validate AI configuration
+        const validationError = validateAIConfig(msg.aiagent);
+        if (validationError) {
+          throw new Error(validationError);
+        }
         
-        // Get input from message or use default
+        // 2. Get input
         const input = msg.payload || {};
         const inputText = typeof input === 'string' ? input : JSON.stringify(input);
         
-        // Update conversation context
-        node.context.lastInteraction = new Date();
-        node.context.conversation.push({ 
-          role: 'user', 
-          content: inputText, 
-          timestamp: node.context.lastInteraction 
-        });
+        // 3. Prepare prompt with context
+        const { messages, userMessage } = preparePrompt(node, msg, inputText);
         
-        let response;
+        // 4. Execute the prompt and get response
+        const response = await callAI(node, msg.aiagent, messages);
         
-        try {
-          // Use OpenRouter for AI responses
-          response = await generateAIResponse.call(node, inputText, msg.aiagent);
-        } catch (error) {
-          const errorMsg = error.response?.data?.error?.message || error.message;
-          node.status({fill:"red", shape:"ring", text:"API Error: " + (errorMsg || 'Unknown error').substring(0, 30)});
-          node.error('OpenRouter API Error: ' + errorMsg, msg);
-          if (done) done(error);
-          return;
+        // 5. Update context if using memory
+        if (msg.aimemory && userMessage) {
+          updateContext(msg, userMessage, response);
         }
         
-        // Update context with AI response
-        node.context.conversation.push({ role: 'assistant', content: response, timestamp: new Date() })
-        
-        // Format response based on configuration
-        if (node.responseType === 'object') {
-          msg.payload = {
-            agent: node.agentName,
-            type: 'ai',
-            input: input,
-            response: response,
-            timestamp: new Date().toISOString(),
-            context: {
-              conversationLength: node.context.conversation.length,
-              lastInteraction: node.context.lastInteraction
-            }
+        // 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 })
           }
-        } else {
-          msg.payload = response
-        }
-        
-        // Send the message
-        send(msg)
+        } : response;
         
-        // Update status
-        node.status({ fill: 'green', shape: 'dot', text: 'ready' })
+        send(msg);
+        node.status({ fill: 'green', shape: 'dot', text: 'ready' });
         
-        // Complete processing
-        if (done) {
-          done()
-        }
       } catch (error) {
-        // Handle errors
-        const errorMsg = error.message || 'Unknown error occurred'
-        node.status({ fill: 'red', shape: 'ring', text: 'error' })
-        node.error('Error in AI Agent: ' + errorMsg, msg)
-        if (done) {
-          done(error)
-        }
+        handleError(node, msg, error);
+      } finally {
+        if (done) done();
       }
-    })
-    
-    // Generate AI response using OpenRouter API
-    async function generateAIResponse(input, aiConfig) {
-      const messages = [
-        {
-          role: 'system',
-          content: node.systemPrompt
-        },
-        {
-          role: 'user',
-          content: input
-        }
-      ];
-      
-      node.status({fill:"blue", shape:"dot", text:"Calling " + aiConfig.model + "..."});
-      
-      // Prepare tools array if available
-      const tools = aiConfig.tools ? aiConfig.tools.map(tool => ({
-        type: 'function',
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters || {}
-        }
-      })) : [];
-      
-      // Initial API call
-      const response = await axios.post(
-        'https://openrouter.ai/api/v1/chat/completions',
-        {
-          model: aiConfig.model,
-          messages: messages,
-          temperature: aiConfig.temperature || 0.7,
-          max_tokens: aiConfig.maxTokens || 1000,
-          tools: tools.length > 0 ? tools : undefined,
-          tool_choice: tools.length > 0 ? 'auto' : 'none'
-        },
-        {
-          headers: {
-            'Authorization': `Bearer ${aiConfig.apiKey}`,
-            'Content-Type': 'application/json',
-            'HTTP-Referer': 'https://nodered.org/',
-            'X-Title': 'Node-RED AI Agent'
-          }
-        }
-      );
-      
-      const responseMessage = response.data.choices[0].message;
-      
-      // Check if the model wants to call a tool
-      const toolCalls = responseMessage.tool_calls;
-      if (toolCalls && toolCalls.length > 0) {
-        // Process each tool call
-        for (const toolCall of toolCalls) {
-          const functionName = toolCall.function.name;
-          const functionArgs = JSON.parse(toolCall.function.arguments || '{}');
-          
-          // Find the tool
-          const tool = aiConfig.tools?.find(t => t.name === functionName);
-          if (!tool) {
-            throw new Error(`Tool ${functionName} not found`);
-          }
-          
-          // Execute the tool
-          const toolResponse = await tool.execute(functionArgs);
-          
-          // Add the tool response to the messages
-          messages.push({
-            role: 'tool',
-            content: JSON.stringify(toolResponse),
-            tool_call_id: toolCall.id
-          });
-        }
-        
-        // Make a second request with the tool responses
-        const secondResponse = await axios.post(
-          'https://openrouter.ai/api/v1/chat/completions',
-          {
-            model: aiConfig.model,
-            messages: messages,
-            temperature: aiConfig.temperature || 0.7,
-            max_tokens: aiConfig.maxTokens || 1000,
-            tools: tools,
-            tool_choice: 'none' // Force the model to respond normally
-          },
-          {
-            headers: {
-              'Authorization': `Bearer ${aiConfig.apiKey}`,
-              'Content-Type': 'application/json',
-              'HTTP-Referer': 'https://nodered.org/',
-              'X-Title': 'Node-RED AI Agent'
-            }
-          }
-        );
-        
-        return secondResponse.data.choices[0].message.content.trim();
-      }
-      
-      return responseMessage.content.trim();
-    }
+    });
   }
 
-  // Registering the node-red type
-  RED.nodes.registerType('ai-agent', AiAgentNode)
-}
+  // Register the node type
+  RED.nodes.registerType('ai-agent', AiAgentNode);
+};

package/memory-file/memory-file.html

@@ -0,0 +1,63 @@
+<script type="text/javascript">
+    RED.nodes.registerType('ai-memory-file', {
+        category: 'AI Agent',
+        paletteLabel: 'AI Memory (File)',
+        color: '#a6bbcf',
+        defaults: {
+            name: { value: "" },
+            filename: { 
+                value: "ai-memories.json",
+                required: true,
+                validate: function(v) {
+                    return v.length > 0;
+                }
+            }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "file.png",
+        label: function() {
+            return this.name || "AI Memory (File)";
+        },
+        labelStyle: function() {
+            return this.name ? "node_label_italic" : "";
+        },
+        oneditprepare: function() {
+            // Initialize any UI components here
+        },
+        oneditsave: function() {
+            // Handle save if needed
+        },
+        oneditcancel: function() {
+            // Cleanup if needed
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="ai-memory-file">
+    <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="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-filename"><i class="fa fa-file"></i> Filename</label>
+        <input type="text" id="node-input-filename" placeholder="ai-memories.json">
+    </div>
+    <div class="form-tips">
+        <p>Memories will be stored in Node-RED's user directory.</p>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="ai-memory-file">
+    <p>Stores AI memories in a JSON file.</p>
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span>object|string</span></dt>
+        <dd>The message to store or retrieve from memory.</dd>
+    </dl>
+    <h3>Outputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span>object|string</span></dt>
+        <dd>The processed message with memory operations applied.</dd>
+    </dl>
+</script>

package/memory-file/memory-file.js

@@ -0,0 +1,62 @@
+module.exports = function(RED) {
+    'use strict';
+
+    function MemoryFileNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Configuration
+        node.name = config.name || 'AI Memory (File)';
+        node.filename = config.filename || 'ai-memories.json';
+        
+        // Initialize empty memories array
+        node.memories = [];
+        
+        // Load existing memories from file if they exist
+        const fs = require('fs');
+        const path = require('path');
+        const filePath = path.join(RED.settings.userDir, node.filename);
+        
+        try {
+            if (fs.existsSync(filePath)) {
+                const data = fs.readFileSync(filePath, 'utf8');
+                node.memories = JSON.parse(data);
+                node.status({fill:"green",shape:"dot",text:"Ready"});
+            } else {
+                node.status({fill:"blue",shape:"ring",text:"New file will be created"});
+            }
+        } catch (err) {
+            node.error("Error loading memory file: " + err.message);
+            node.status({fill:"red",shape:"ring",text:"Error loading"});
+        }
+
+        // Handle incoming messages
+        node.on('input', function(msg) {
+            try {
+                // For now, just pass through the message
+                // We'll add memory operations in the next iteration
+                node.send(msg);
+                
+                // Update status
+                node.status({fill:"green",shape:"dot",text:node.memories.length + " memories"});
+            } catch (err) {
+                node.error("Error in memory node: " + err.message, msg);
+                node.status({fill:"red",shape:"ring",text:"Error"});
+            }
+        });
+
+        // Cleanup on node removal
+        node.on('close', function() {
+            // Save memories to file
+            try {
+                fs.writeFileSync(filePath, JSON.stringify(node.memories, null, 2));
+            } catch (err) {
+                node.error("Error saving memory file: " + err.message);
+            }
+            node.status({});
+        });
+    }
+
+    // Register the node type
+    RED.nodes.registerType("ai-memory-file", MemoryFileNode);
+};