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

package/tool/ai-tool.html

@@ -1,159 +0,0 @@
-<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

@@ -1,220 +0,0 @@
-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
-        }
-    });
-};