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

package/tool/ai-tool.html

@@ -0,0 +1,159 @@
+<script type="text/javascript">
+    RED.nodes.registerType('ai-tool', {
+        category: 'AI Agent',
+        inputs: 1,
+        outputs: 1,
+        icon: 'function.svg',
+        paletteLabel: 'AI Tool',
+        label: function() {
+            return this.name || 'AI Tool';
+        },
+        color: '#a6bbcf',
+        defaults: {
+            name: { value: '' },
+            toolType: { value: 'http', required: true },
+            toolName: { value: '', required: true, validate: RED.validators.regex(/^[a-zA-Z0-9_-]+$/) },
+            description: { value: '', required: true },
+            httpMethod: { value: 'GET' },
+            httpUrl: { value: '' },
+            httpHeaders: { value: '{}', validate: function(v) {
+                try {
+                    JSON.parse(v);
+                    return true;
+                } catch(e) {
+                    return false;
+                }
+            }},
+            httpBody: { value: '' },
+            functionCode: { value: '// Write your function here\n// Available variables: input, context, node\n// Return value will be passed to the next tool or as agent output\nreturn input;' },
+            nodeRedFlow: { value: 'flow' },
+            nodeRedNode: { value: '' },
+            nodeRedProperty: { value: 'payload' }
+        },
+        oneditprepare: function() {
+            // Show/hide fields based on tool type
+            $('#node-input-toolType').on('change', function() {
+                $('.tool-type-options').hide();
+                $(`#${this.value}-options`).show();
+            }).trigger('change');
+
+            // Initialize JSON editor for headers
+            const headersEditor = RED.editor.createEditor({
+                id: 'node-input-http-headers',
+                value: $('#node-input-http-headers').val() || '{}',
+                mode: 'application/json',
+                onComplete: function() {
+                    $('#node-input-http-headers').val(headersEditor.getText());
+                }
+            });
+        },
+        oneditsave: function() {
+            // Validate and format JSON before saving
+            try {
+                if (this.httpHeaders) {
+                    JSON.parse(this.httpHeaders);
+                }
+            } catch (e) {
+                    alert('Invalid JSON in Headers');
+                    return false;
+                }
+            return true;
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="ai-tool">
+    <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-toolType">Tool Type</label>
+        <select id="node-input-toolType" style="width: 70%;">
+            <option value="http">HTTP Request</option>
+            <option value="function">JavaScript Function</option>
+            <option value="node-red">Node-RED Node</option>
+        </select>
+    </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>
+
+    <!-- HTTP Options -->
+    <div id="http-options" class="tool-type-options">
+        <div class="form-row">
+            <label for="node-input-httpMethod">Method</label>
+            <select id="node-input-httpMethod" style="width: 30%;">
+                <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>
+            </select>
+            <input type="text" id="node-input-httpUrl" placeholder="https://example.com/endpoint" style="width: 70%;">
+        </div>
+        
+        <div class="form-row">
+            <label for="node-input-httpHeaders">Headers (JSON)</label>
+            <div id="node-input-http-headers-editor" style="height: 100px; width: 100%;"></div>
+            <input type="hidden" id="node-input-http-headers">
+        </div>
+        
+        <div class="form-row">
+            <label for="node-input-httpBody">Body (for POST/PUT/PATCH)</label>
+            <textarea id="node-input-httpBody" rows="3" placeholder="Request body (leave empty for GET/DELETE)"></textarea>
+        </div>
+    </div>
+
+    <!-- Function Options -->
+    <div id="function-options" class="tool-type-options" style="display: none;">
+        <div class="form-row">
+            <label for="node-input-functionCode">Function Code</label>
+            <div style="height: 200px;">
+                <textarea id="node-input-functionCode" style="width: 100%; height: 100%; font-family: monospace;"></textarea>
+            </div>
+        </div>
+    </div>
+
+    <!-- Node-RED Options -->
+    <div id="node-red-options" class="tool-type-options" style="display: none;">
+        <div class="form-row">
+            <label for="node-input-nodeRedFlow">Flow Context</label>
+            <select id="node-input-nodeRedFlow" style="width: 100%;">
+                <option value="flow">Current Flow</option>
+                <option value="global">Global</option>
+            </select>
+        </div>
+        
+        <div class="form-row">
+            <label for="node-input-nodeRedNode">Node ID</label>
+            <input type="text" id="node-input-nodeRedNode" placeholder="Node ID to call" style="width: 100%;">
+        </div>
+        
+        <div class="form-row">
+            <label for="node-input-nodeRedProperty">Property</label>
+            <input type="text" id="node-input-nodeRedProperty" value="payload" placeholder="Property to set (default: payload)" style="width: 100%;">
+        </div>
+    </div>
+</script>
+
+<script type="text/html" data-help-name="ai-tool">
+    <p>Configures a tool that can be used by the AI Agent.</p>
+    <p>Tools extend the capabilities of the AI Agent by allowing it to interact with external systems, perform calculations, or access Node-RED nodes.</p>
+    <h3>Tool Types</h3>
+    <ul>
+        <li><strong>HTTP Request</strong>: Call external APIs</li>
+        <li><strong>JavaScript Function</strong>: Define custom logic in JavaScript</li>
+        <li><strong>Node-RED Node</strong>: Interact with other nodes in your flow</li>
+    </ul>
+    <h3>Outputs</h3>
+    <p>Adds the tool definition to <code>msg.aiagent.tools</code> for use by the AI Agent node.</p>
+</script>

package/tool/ai-tool.js

@@ -0,0 +1,220 @@
+module.exports = function(RED) {
+    'use strict';
+
+    function AIToolNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // Configuration
+        node.name = config.name || `tool_${config.toolType}`;
+        node.toolType = config.toolType || 'function';
+        node.toolName = config.toolName || `${node.toolType}_${Date.now()}`;
+        node.description = config.description || `${node.toolType} tool`;
+        
+        // Initialize based on tool type
+        if (node.toolType === 'function') {
+            // Create a safe function that can be called later
+            try {
+                node.fn = new Function('input', 'context', 'node', 
+                    `try { ${config.functionCode || 'return input;'} } 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
+                const toolDef = {
+                    name: node.toolName,
+                    description: node.description,
+                    type: node.toolType
+                };
+                
+                // Add tool-specific configuration
+                if (node.toolType === 'http') {
+                    toolDef.config = {
+                        method: config.httpMethod || 'GET',
+                        url: config.httpUrl || '',
+                        headers: tryParseJson(config.httpHeaders) || {},
+                        body: config.httpBody || null
+                    };
+                    toolDef.execute = (input) => executeHttpTool(toolDef.config, input, node);
+                }
+                else if (node.toolType === 'function') {
+                    toolDef.execute = (input, context) => executeFunctionTool(node.fn, input, context, node);
+                }
+                else if (node.toolType === 'node-red') {
+                    toolDef.config = {
+                        flowContext: config.nodeRedFlow || 'flow',
+                        nodeId: config.nodeRedNode || '',
+                        property: config.nodeRedProperty || 'payload'
+                    };
+                    toolDef.execute = (input) => executeNodeRedTool(toolDef.config, input, node, msg._msgid);
+                }
+                
+                // 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 HTTP tool
+    async function executeHttpTool(config, input, node) {
+        const axios = require('axios');
+        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({
+                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 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;
+        }
+    }
+    
+    // Helper function to execute Node-RED node tool
+    async function executeNodeRedTool(config, input, node, msgId) {
+        const { flowContext, nodeId, property } = config;
+        
+        return new Promise((resolve, reject) => {
+            try {
+                // Get the target node
+                const targetNode = RED.nodes.getNode(nodeId);
+                if (!targetNode) {
+                    throw new Error(`Node ${nodeId} not found`);
+                }
+                
+                // Create a new message to send to the target node
+                const msg = {
+                    _msgid: msgId || RED.util.generateId(),
+                    [property]: input,
+                    _toolContext: {
+                        sourceNode: node.id,
+                        timestamp: Date.now()
+                    }
+                };
+                
+                // Set up a one-time listener for the response
+                const responseHandler = (response) => {
+                    // Clean up the listener to prevent memory leaks
+                    RED.events.off('node:' + nodeId, responseHandler);
+                    
+                    // Resolve with the response
+                    resolve(response[property] || response.payload || response);
+                };
+                
+                // Listen for the response
+                RED.events.on('node:' + nodeId, responseHandler);
+                
+                // Send the message to the target node
+                targetNode.receive(msg);
+                
+            } catch (error) {
+                node.error(`Node-RED Tool Error: ${error.message}`, { payload: input });
+                reject(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) => {
+            const value = key.split('.').reduce((obj, k) => (obj || {})[k], data);
+            return value !== undefined ? value : 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', AIToolNode, {
+        settings: {
+            // Any node settings can go here
+        }
+    });
+};

package/.gitpod.yml

@@ -1,10 +0,0 @@
-# This configuration file was automatically generated by Gitpod.
-# Please adjust to your needs (see https://www.gitpod.io/docs/introduction/learn-gitpod/gitpod-yaml)
-# and commit this file to your remote git repository to share the goodness with others.
-
-# Learn more from ready-to-use templates: https://www.gitpod.io/docs/introduction/getting-started/quickstart
-
-tasks:
-  - init: yarn install
-
-

package/ai-agent.html

@@ -1,35 +0,0 @@
-<script type="text/javascript">
-  RED.nodes.registerType('ai-agent', {
-    category: 'storage',
-    color: '#a6bbcf',
-    defaults: {
-      name: { value: '' },
-    },
-    inputs: 1,
-    outputs: 1,
-    icon: 'icon.svg',
-    label: function () {
-      return this.name || 'AI Agent'
-    },
-    oneditprepare: function () {},
-    oneditsave: function () {},
-    oneditresize: function (size) {},
-  })
-</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">
-    </div>
-</script>
-<!-- END: Template -->
-
-<!-- START: Help -->
-<script type="text/x-red" data-help-name="ai-agent">
-  <p>
-    A "batteries included" AI Agent for Node-RED designed to be flexible, portable, and fun to use.
-  </p>
-</script>
-<!-- END: Help -->

package/ai-agent.js

@@ -1,18 +0,0 @@
-module.exports = function (RED) {
-  function AiAgentNode(config) {
-    RED.nodes.createNode(this, config)
-    var node = this
-
-    node.on('close', (done) => {
-      node.done()
-    })
-
-    node.on('input', (msg, send, done) => {
-      send(msg)
-      done()
-    })
-  }
-
-  // Registering the node-red type
-  RED.nodes.registerType('ai-agent', AiAgentNode)
-}