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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ai-agent",
-    "version": "0.0.3",
+    "version": "0.0.5",
     "description": "AI Agent for Node-RED",
     "repository": {
         "type": "git",
@@ -15,7 +15,7 @@
     ],
     "main": "ai-agent.js",
     "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1"
+        "test": "mocha \"test/**/*.js\""
     },
     "author": "Milan Lesichkov",
     "maintainers": [
@@ -28,15 +28,25 @@
     "files": [
         "agent/*",
         "model/*",
-        "tool/*"
+        "tool/*",
+        "tool-function/*",
+        "tool-http/*",
+        "memory-file/*",
+        "memory-inmem/*"
     ],
     "dependencies": {
-        "node-red": ">=1.0.0",
-        "axios": "^1.6.0"
+        "axios": "^1.6.0",
+        "node-red": ">=1.0.0"
     },
     "devDependencies": {
+        "chai": "^4.3.0",
         "eslint": "^8.0.0",
-        "prettier": "^3.0.0"
+        "mocha": "^10.0.0",
+        "node-red-node-test-helper": "^0.3.0",
+        "prettier": "^3.0.0",
+        "proxyquire": "^2.1.3",
+        "sinon": "^15.0.0",
+        "sinon-chai": "^3.7.0"
     },
     "engines": {
         "node": ">=14.0.0"
@@ -46,7 +56,11 @@
         "nodes": {
             "ai-agent": "./agent/ai-agent.js",
             "ai-model": "./model/ai-model.js",
-            "ai-tool": "./tool/ai-tool.js"
+            "ai-tool": "./tool/ai-tool.js",
+            "ai-tool-function": "./tool-function/ai-tool-function.js",
+            "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"
         }
     }
 }

package/tool-function/ai-tool-function.html

@@ -0,0 +1,95 @@
+<script type="text/javascript">
+    RED.nodes.registerType('ai-tool-function', {
+        category: 'AI Agent',
+        inputs: 1,
+        outputs: 1,
+        icon: 'function.svg',
+        paletteLabel: 'AI Tool (Function)',
+        label: function() {
+            return this.name || 'AI Tool (Function)';
+        },
+        color: '#a6bbcf',
+        defaults: {
+            name: { value: '' },
+            toolName: { value: '', required: true, validate: RED.validators.regex(/^[a-zA-Z0-9_-]+$/) },
+            description: { value: '', required: true },
+            functionCode: { value: '// Write your function here\n// Available variables: input, context, node\n// Remember to use "new Date()" instead of just "Date()" for date objects\n// Return value will be passed to the next tool or as agent output\nreturn input;' }
+        },
+        oneditprepare: function() {
+            const that = this;
+            this.editor = RED.editor.createEditor({
+                id: 'node-input-functionCode-editor',
+                mode: 'ace/mode/javascript',
+                value: $("#node-input-functionCode").val(),
+                globals: {
+                    input: true,
+                    context: true,
+                    node: true
+                }
+            });
+            
+            // Resize function editor when the window size changes
+            function resizeEditor() {
+                const rows = $('#dialog-form>div:not(.node-text-editor-row)');
+                let height = $('#dialog-form').height();
+                for (let i=0; i<rows.length; i++) {
+                    height -= $(rows[i]).outerHeight(true);
+                }
+                height -= 40;
+                $('.node-text-editor').css('height', height+"px");
+                that.editor.resize();
+            };
+            $('#dialog-form').on("dialogresize", resizeEditor);
+            $('#dialog-form').on("dialogopen", resizeEditor);
+            $('#dialog-form').on("dialogclose", function() {
+                $('#dialog-form').off("dialogresize", resizeEditor);
+            });
+            this.editor.focus();
+        },
+        oneditsave: function() {
+            $("#node-input-functionCode").val(this.editor.getValue());
+            this.editor.destroy();
+            delete this.editor;
+            return true;
+        },
+    });
+</script>
+
+<script type="text/html" data-template-name="ai-tool-function">
+    <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-toolName">Tool Name</label>
+        <input type="text" id="node-input-toolName" placeholder="unique_tool_identifier" style="font-family: monospace;">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-description">Description</label>
+        <textarea id="node-input-description" rows="2" placeholder="What this tool does"></textarea>
+    </div>
+
+    <!-- Function Options -->
+    <div class="form-row node-text-editor-row">
+        <label for="node-input-functionCode">Function Code</label>
+        <div style="height: 300px;" class="node-text-editor" id="node-input-functionCode-editor"></div>
+        <input type="hidden" id="node-input-functionCode">
+    </div>
+</script>
+
+<script type="text/html" data-help-name="ai-tool-function">
+    <p>Configures a function tool that can be used by the AI Agent.</p>
+    <p>Function tools extend the capabilities of the AI Agent by allowing it to execute custom JavaScript code.</p>
+    <h3>Function Tool</h3>
+    <p>Define custom logic in JavaScript that will be executed when the AI Agent calls this tool.</p>
+    <p>Your function has access to:</p>
+    <ul>
+        <li><code>input</code>: The data passed to the tool by the AI Agent</li>
+        <li><code>context</code>: The context object from the AI Agent</li>
+        <li><code>node</code>: The Node-RED node object</li>
+    </ul>
+    <h3>Outputs</h3>
+    <p>Adds the function tool definition to <code>msg.aiagent.tools</code> for use by the AI Agent node.</p>
+</script>

package/tool-function/ai-tool-function.js

@@ -0,0 +1,104 @@
+module.exports = function(RED) {
+    'use strict';
+
+    function AIToolNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Configuration
+        node.name = config.name || 'function_tool';
+        node.toolName = config.toolName || `function_${Date.now()}`;
+        node.description = config.description || 'JavaScript function tool';
+        
+        // Create a safe function that can be called later
+        try {
+            // Ensure the function code is properly formatted
+            let functionCode = config.functionCode || 'return input;';
+            
+            // Check if the function code already returns a value
+            if (!functionCode.trim().startsWith('return') && !functionCode.includes('return ')) {
+                functionCode = `return (${functionCode});`;
+            }
+            
+            // Create the function with proper error handling
+            node.fn = new Function('input', 'context', 'node', 
+                `try { 
+                    ${functionCode} 
+                } catch(e) { 
+                    return { error: e.message }; 
+                }`
+            );
+        } catch (e) {
+            node.error(`Error creating function: ${e.message}`);
+            node.fn = (input) => ({ error: 'Invalid function' });
+        }
+        
+        // Process incoming messages
+        node.on('input', function(msg, send, done) {
+            try {
+                // Clone the message to avoid modifying the original
+                const newMsg = RED.util.cloneMessage(msg);
+                
+                // Initialize msg.aiagent if it doesn't exist
+                newMsg.aiagent = newMsg.aiagent || {};
+                newMsg.aiagent.tools = newMsg.aiagent.tools || [];
+                
+                // Create tool definition according to OpenAI API format
+                const toolDef = {
+                    type: 'function',
+                    function: {
+                        name: node.toolName,
+                        description: node.description,
+                        parameters: {
+                            type: 'object',
+                            properties: {},
+                            required: []
+                        }
+                    },
+                    // Add execute method for our internal use
+                    execute: (input, context) => executeFunctionTool(node.fn, input, context, node)
+                };
+                
+                // Add tool to the list
+                newMsg.aiagent.tools.push(toolDef);
+                
+                // Update node status
+                node.status({ fill: 'green', shape: 'dot', text: 'Ready' });
+                
+                // Send the modified message
+                send([newMsg, null]);
+                
+                // Complete the async operation
+                if (done) {
+                    done();
+                }
+            } catch (error) {
+                node.status({ fill: 'red', shape: 'ring', text: 'Error' });
+                node.error('Error in AI Tool node: ' + error.message, msg);
+                if (done) done();
+            }
+        });
+        
+        // Handle node cleanup
+        node.on('close', function(done) {
+            node.status({});
+            if (done) done();
+        });
+    }
+    // Helper function to execute JavaScript function tool
+    async function executeFunctionTool(fn, input, context, node) {
+        try {
+            return await fn(input, context, node);
+        } catch (error) {
+            node.error(`Function Tool Error: ${error.message}`, { payload: input });
+            throw error;
+        }
+    }
+    
+    // Register the node type
+    RED.nodes.registerType('ai-tool-function', AIToolNode, {
+        settings: {
+            // Any node settings can go here
+        }
+    });
+};

package/tool-http/ai-tool-http-icon.svg

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="100" height="100" viewBox="0 0 100 100" xmlns="http://www.w3.org/2000/svg">
+    <rect x="10" y="10" width="80" height="80" rx="10" fill="#a6bbcf" stroke="#7a9cbc" stroke-width="2"/>
+    <path d="M30,30 L70,30 L70,50 L30,50 Z" fill="white" stroke="#5a7a99" stroke-width="2"/>
+    <path d="M40,60 L60,60 L60,70 L40,70 Z" fill="white" stroke="#5a7a99" stroke-width="2"/>
+    <path d="M30,35 L40,35" stroke="#5a7a99" stroke-width="2"/>
+    <path d="M30,45 L50,45" stroke="#5a7a99" stroke-width="2"/>
+</svg>

package/tool-http/ai-tool-http.html

@@ -0,0 +1,174 @@
+<!-- AI Tool HTTP Node -->
+<script type="text/javascript">
+    RED.nodes.registerType('ai-tool-http', {
+        category: 'AI Agent',
+        color: '#a6bbcf',
+        defaults: {
+            name: { value: "" },
+            toolName: { value: "", required: true },
+            description: { value: "HTTP request tool" },
+            httpMethod: { value: "GET" },
+            httpUrl: { value: "", required: true },
+            httpHeaders: { value: "{}" },
+            httpBody: { value: "" }
+        },
+        inputs: 1,
+        outputs: 2,
+        outputLabels: ["success", "error"],
+        icon: "font-awesome/fa-globe",
+        label: function() {
+            return this.name || "HTTP Tool";
+        },
+        paletteLabel: "AI HTTP Tool",
+        oneditprepare: function() {
+            // Initialize the ACE editor for JSON headers
+            const headersEditor = RED.editor.createEditor({
+                id: 'node-input-headers-editor',
+                mode: 'ace/mode/json',
+                value: this.httpHeaders || '{}'
+            });
+            
+            // Initialize the ACE editor for the body
+            const bodyEditor = RED.editor.createEditor({
+                id: 'node-input-body-editor',
+                mode: 'ace/mode/text',
+                value: this.httpBody || ''
+            });
+            
+            // Handle resizing
+            function resizeEditors() {
+                const rows = $('#dialog-form>div:not(.node-text-editor-row)');
+                let height = $('#dialog-form').height();
+                
+                for (let i=0; i<rows.length; i++) {
+                    height -= $(rows[i]).outerHeight(true);
+                }
+                
+                const editorRow = $('#dialog-form>div.node-text-editor-row');
+                height -= (parseInt(editorRow.css("marginTop"))+parseInt(editorRow.css("marginBottom")));
+                
+                // Split the height between the two editors
+                const headersHeight = Math.floor(height/2);
+                const bodyHeight = height - headersHeight - 30; // 30px for the label between them
+                
+                $('#node-input-headers-editor').css("height", headersHeight + "px");
+                headersEditor.resize();
+                
+                $('#node-input-body-editor').css("height", bodyHeight + "px");
+                bodyEditor.resize();
+            }
+            
+            $('#dialog-form').css("min-width", "500px").css("min-height", "400px");
+            
+            // Do the resize after a delay to allow the dialog to be fully rendered
+            setTimeout(resizeEditors, 10);
+            
+            // Handle form submission
+            $('#node-input-dialog-ok').on('click', () => {
+                this.httpHeaders = headersEditor.getValue();
+                this.httpBody = bodyEditor.getValue();
+            });
+            
+            // Handle editor cleanup
+            this.editor = {
+                destroy: function() {
+                    headersEditor.destroy();
+                    bodyEditor.destroy();
+                }
+            };
+        },
+        oneditsave: function() {
+            // The values are already saved in oneditprepare
+        },
+        oneditcancel: function() {
+            // Clean up the editors
+            if (this.editor) {
+                this.editor.destroy();
+            }
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="ai-tool-http">
+    <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-toolName"><i class="fa fa-wrench"></i> Tool Name</label>
+        <input type="text" id="node-input-toolName" placeholder="http_request">
+    </div>
+    <div class="form-row">
+        <label for="node-input-description"><i class="fa fa-info-circle"></i> Description</label>
+        <input type="text" id="node-input-description" placeholder="HTTP request tool">
+    </div>
+    <div class="form-row">
+        <label for="node-input-httpMethod"><i class="fa fa-exchange"></i> Method</label>
+        <select id="node-input-httpMethod">
+            <option value="GET">GET</option>
+            <option value="POST">POST</option>
+            <option value="PUT">PUT</option>
+            <option value="DELETE">DELETE</option>
+            <option value="PATCH">PATCH</option>
+            <option value="HEAD">HEAD</option>
+            <option value="OPTIONS">OPTIONS</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-httpUrl"><i class="fa fa-globe"></i> URL</label>
+        <input type="text" id="node-input-httpUrl" placeholder="https://api.example.com/endpoint">
+    </div>
+    <div class="form-row">
+        <label for="node-input-headers-editor"><i class="fa fa-list"></i> Headers (JSON)</label>
+        <div style="height: 150px; min-height: 150px;" class="node-text-editor" id="node-input-headers-editor"></div>
+        <input type="hidden" id="node-input-httpHeaders">
+    </div>
+    <div class="form-row">
+        <label for="node-input-body-editor"><i class="fa fa-file-text-o"></i> Body</label>
+        <div style="height: 150px; min-height: 150px;" class="node-text-editor" id="node-input-body-editor"></div>
+        <input type="hidden" id="node-input-httpBody">
+    </div>
+    <div class="form-tips">
+        <p>Use <code>${input.property}</code> syntax to reference input properties in URL, headers, and body.</p>
+        <p>Example: <code>https://api.example.com/users/${input.userId}</code></p>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="ai-tool-http">
+    <p>Creates an HTTP request tool for AI Agent.</p>
+    
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt>payload <span class="property-type">any</span></dt>
+        <dd>The input message payload.</dd>
+    </dl>
+    
+    <h3>Outputs</h3>
+    <ol class="node-ports">
+        <li>Standard output
+            <dl class="message-properties">
+                <dt>payload <span class="property-type">object</span></dt>
+                <dd>The original payload.</dd>
+                <dt>aiagent.tools <span class="property-type">array</span></dt>
+                <dd>Array containing the HTTP tool definition.</dd>
+            </dl>
+        </li>
+        <li>Error output
+            <dl class="message-properties">
+                <dt>error <span class="property-type">object</span></dt>
+                <dd>Error information if the node fails.</dd>
+            </dl>
+        </li>
+    </ol>
+    
+    <h3>Details</h3>
+    <p>This node creates an HTTP request tool that can be used by the AI Agent node to make HTTP requests.</p>
+    <p>The tool can be configured with a method, URL, headers, and body.</p>
+    <p>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.</p>
+    <p>Example: <code>https://api.example.com/users/${input.userId}</code></p>
+    
+    <h3>References</h3>
+    <ul>
+        <li><a href="https://github.com/lesichkovm/node-red-contrib-ai-agent" target="_blank">GitHub</a> - the nodes github repository</li>
+    </ul>
+</script>

package/tool-http/ai-tool-http.js

@@ -0,0 +1,176 @@
+module.exports = function(RED) {
+    'use strict';
+
+    function AIToolHttpNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Configuration
+        node.name = config.name || 'http_tool';
+        node.toolName = config.toolName || `http_${Date.now()}`;
+        node.description = config.description || 'HTTP request tool';
+        node.httpMethod = config.httpMethod || 'GET';
+        node.httpUrl = config.httpUrl || '';
+        node.httpHeaders = config.httpHeaders || '{}';
+        node.httpBody = config.httpBody || '';
+        
+        // Process incoming messages
+        node.on('input', function(msg, send, done) {
+            try {
+                // Clone the message to avoid modifying the original
+                const newMsg = RED.util.cloneMessage(msg);
+                
+                // Initialize msg.aiagent if it doesn't exist
+                newMsg.aiagent = newMsg.aiagent || {};
+                newMsg.aiagent.tools = newMsg.aiagent.tools || [];
+                
+                // Create tool definition according to OpenAI API format
+                const toolDef = {
+                    type: 'function',
+                    function: {
+                        name: node.toolName,
+                        description: node.description,
+                        parameters: {
+                            type: 'object',
+                            properties: {},
+                            required: []
+                        }
+                    },
+                    // Add execute method for our internal use
+                    execute: (input, context) => executeHttpTool({
+                        method: node.httpMethod,
+                        url: node.httpUrl,
+                        headers: tryParseJson(node.httpHeaders),
+                        body: node.httpBody
+                    }, input, node)
+                };
+                
+                // Add tool to the list
+                newMsg.aiagent.tools.push(toolDef);
+                
+                // Update node status
+                node.status({ fill: 'green', shape: 'dot', text: 'Ready' });
+                
+                // Send the modified message
+                send([newMsg, null]);
+                
+                // Complete the async operation
+                if (done) {
+                    done();
+                }
+            } catch (error) {
+                node.status({ fill: 'red', shape: 'ring', text: 'Error' });
+                node.error('Error in AI Tool HTTP node: ' + error.message, msg);
+                if (done) done();
+            }
+        });
+        
+        // Handle node cleanup
+        node.on('close', function(done) {
+            node.status({});
+            if (done) done();
+        });
+    }
+    
+    // Helper function to execute HTTP tool
+    async function executeHttpTool(config, input, node) {
+        // Import axios here so it can be more easily mocked in tests
+        const axios = require('axios');
+        return executeHttpRequest(axios, config, input, node);
+    }
+    
+    // Separate function for better testability
+    async function executeHttpRequest(axios, config, input, node) {
+        const { method, url, headers, body: bodyTemplate } = config;
+        
+        try {
+            // Process template strings in URL and headers
+            const processedUrl = processTemplate(url, input);
+            const processedHeaders = Object.fromEntries(
+                Object.entries(headers).map(([key, value]) => [
+                    processTemplate(key, input),
+                    typeof value === 'string' ? processTemplate(value, input) : value
+                ])
+            );
+            
+            // Process request body if it's a template
+            let requestBody = bodyTemplate;
+            if (typeof bodyTemplate === 'string') {
+                try {
+                    // First try to parse as JSON to handle JSON templates
+                    requestBody = JSON.parse(processTemplate(bodyTemplate, input));
+                } catch (e) {
+                    // If not valid JSON, use as plain string
+                    requestBody = processTemplate(bodyTemplate, input);
+                }
+            }
+            
+            // Make the HTTP request
+            const response = await axios.request({
+                method,
+                url: processedUrl,
+                headers: processedHeaders,
+                data: method !== 'GET' && method !== 'HEAD' ? requestBody : undefined,
+                validateStatus: () => true // Always resolve, never reject
+            });
+            
+            return {
+                status: response.status,
+                headers: response.headers,
+                data: response.data
+            };
+            
+        } catch (error) {
+            node.error(`HTTP Tool Error: ${error.message}`, { payload: input });
+            throw error;
+        }
+    }
+    
+    // Helper function to process template strings with input data
+    function processTemplate(template, data) {
+        if (typeof template !== 'string') return template;
+        
+        return template.replace(/\$\{([^}]+)\}/g, (match, key) => {
+            try {
+                // Handle nested properties using path notation
+                const value = key.split('.').reduce((obj, k) => {
+                    if (obj === null || obj === undefined) return undefined;
+                    return obj[k];
+                }, data);
+                
+                // Convert undefined/null to empty string to avoid 'undefined' in output
+                if (value === undefined || value === null) return match;
+                
+                // Handle different types of values
+                if (typeof value === 'object') {
+                    try {
+                        return JSON.stringify(value);
+                    } catch (e) {
+                        return String(value);
+                    }
+                }
+                
+                return String(value);
+            } catch (e) {
+                // If any error occurs during processing, return the original template
+                return match;
+            }
+        });
+    }
+    
+    // Helper function to safely parse JSON
+    function tryParseJson(jsonString) {
+        try {
+            return JSON.parse(jsonString);
+        } catch (e) {
+            return {};
+        }
+    }
+    
+    // Register the node type
+    RED.nodes.registerType('ai-tool-http', AIToolHttpNode, {
+        settings: {
+            // Any node settings can go here
+        }
+    });
+};