nodestorm-mcp 0.1.0

package/dist/tools/describe.js

@@ -0,0 +1,284 @@
+/**
+ * Node definitions for the describe_nodes tool
+ * These are bundled statically to avoid API calls
+ */
+// Static node definitions
+const NODE_DEFINITIONS = [
+    {
+        type: 'text',
+        description: 'Provide static text content to the workflow',
+        category: 'Data',
+        config_schema: {
+            input: { type: 'string', description: 'The static text content' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'list',
+        description: 'Extract list items using LLM or enter items manually',
+        category: 'Data',
+        config_schema: {
+            mode: { type: 'string', enum: ['extract', 'manual'], description: 'Mode of operation' },
+            input: { type: 'string', description: 'Manual items (one per line) or extraction prompt' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output', 'each'],
+        },
+    },
+    {
+        type: 'table',
+        description: 'Store and manipulate tabular data with rows and columns',
+        category: 'Data',
+        config_schema: {
+            columns: { type: 'array', description: 'Column definitions' },
+            rows: { type: 'array', description: 'Row data' },
+            storage_mode: { type: 'string', enum: ['inline', 'file'], description: 'Where to store data' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output', 'each'],
+        },
+    },
+    {
+        type: 'file',
+        description: 'Read from or write to persistent user files',
+        category: 'Data',
+        config_schema: {
+            operation: { type: 'string', enum: ['read', 'write', 'append'], description: 'File operation' },
+            file_id: { type: 'string', description: 'User file ID' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'search',
+        description: 'Search the web using Google and return results',
+        category: 'Web',
+        config_schema: {
+            input: { type: 'string', description: 'Search query' },
+            maxResults: { type: 'number', description: 'Maximum results (default: 5)' },
+            useLlmCleaning: { type: 'boolean', description: 'Use LLM to clean/summarize results' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'scraper',
+        description: 'Scrape web pages and extract content',
+        category: 'Web',
+        config_schema: {
+            input: { type: 'string', description: 'URL to scrape' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'prompt',
+        description: 'Process text using an LLM with custom prompts',
+        category: 'AI',
+        config_schema: {
+            input: { type: 'string', description: 'Prompt/instructions for the LLM' },
+            modelConfig: {
+                type: 'object',
+                description: 'LLM configuration',
+                properties: {
+                    provider: { type: 'string', enum: ['openai', 'anthropic', 'google'] },
+                    chat_model: { type: 'string', description: 'Model ID' },
+                    systemMessage: { type: 'string', description: 'System prompt' },
+                    temperature: { type: 'number', description: '0-2' },
+                    maxTokens: { type: 'number', description: 'Max response tokens' },
+                },
+            },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'boolean',
+        description: 'Make a yes/no decision using LLM',
+        category: 'AI',
+        config_schema: {
+            input: { type: 'string', description: 'Question to answer (yes/no)' },
+            modelConfig: { type: 'object', description: 'LLM configuration' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['true', 'false'],
+        },
+    },
+    {
+        type: 'json',
+        description: 'Extract structured JSON data using LLM',
+        category: 'AI',
+        config_schema: {
+            input: { type: 'string', description: 'Extraction instructions' },
+            schema: { type: 'object', description: 'JSON schema for output' },
+            modelConfig: { type: 'object', description: 'LLM configuration' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'switch',
+        description: 'Route to different paths based on conditions',
+        category: 'Control',
+        config_schema: {
+            condition_type: { type: 'string', enum: ['llm', 'regex', 'contains', 'equals'] },
+            cases: { type: 'array', description: 'List of case definitions' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['case-*'], // Dynamic based on cases
+        },
+    },
+    {
+        type: 'wait',
+        description: 'Pause execution for a specified time',
+        category: 'Control',
+        config_schema: {
+            delay_type: { type: 'string', enum: ['seconds', 'minutes', 'hours', 'until'] },
+            delay_amount: { type: 'number', description: 'Duration (for seconds/minutes/hours)' },
+            until_time: { type: 'string', description: 'ISO timestamp (for until)' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'aggregate',
+        description: 'Collect results from iteration into a single array',
+        category: 'Control',
+        config_schema: {},
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'http_request',
+        description: 'Make HTTP requests to external APIs',
+        category: 'Actions',
+        config_schema: {
+            url: { type: 'string', description: 'Request URL (required)' },
+            method: { type: 'string', enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] },
+            headers: { type: 'object', description: 'Request headers' },
+            body: { type: 'string', description: 'Request body' },
+            credential_id: { type: 'string', description: 'API credential ID' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'email',
+        description: 'Send email to the authenticated user',
+        category: 'Actions',
+        config_schema: {
+            subject: { type: 'string', description: 'Email subject (required)' },
+            body: { type: 'string', description: 'Email body (required)' },
+            format: { type: 'string', enum: ['plain', 'html'] },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'google_drive',
+        description: 'Manage files and folders in Google Drive',
+        category: 'Integrations',
+        config_schema: {
+            operation: {
+                type: 'string',
+                enum: ['list_files', 'get_metadata', 'download_file', 'upload_file', 'update_file', 'create_folder', 'copy_file', 'move_file', 'delete_file', 'search_files'],
+            },
+            file_id: { type: 'string', description: 'File/folder ID' },
+            folder_id: { type: 'string', description: 'Parent folder ID' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'transcription',
+        description: 'Transcribe audio to text',
+        category: 'Media',
+        config_schema: {
+            audio_source: { type: 'string', enum: ['url', 'content'] },
+            provider: { type: 'string', enum: ['openai', 'google'] },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'image_generation',
+        description: 'Generate images using AI (DALL-E)',
+        category: 'Media',
+        config_schema: {
+            provider: { type: 'string', enum: ['openai'] },
+            operation: { type: 'string', enum: ['generate', 'edit', 'variation'] },
+            prompt: { type: 'string', description: 'Image prompt' },
+            size: { type: 'string', enum: ['256x256', '512x512', '1024x1024', '1024x1792', '1792x1024'] },
+            quality: { type: 'string', enum: ['standard', 'hd'] },
+            style: { type: 'string', enum: ['vivid', 'natural'] },
+            count: { type: 'number', description: 'Number of images (1-4)' },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'keyword_data',
+        description: 'Look up SEO keyword data (search volume, CPC, competition) via Keywords Everywhere API',
+        category: 'Web',
+        config_schema: {
+            input: { type: 'string', description: 'Keywords (one per line) or extraction prompt' },
+            country: { type: 'string', description: "Country code (e.g. 'us')" },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: ['output'],
+        },
+    },
+    {
+        type: 'result',
+        description: 'Render flow output on the canvas. LLM-formats the upstream value into the chosen target (~$0.01, ~4s per render).',
+        category: 'Output',
+        config_schema: {
+            format: { type: 'string', enum: ['html', 'markdown', 'plain'], description: "Output target. Default 'html'." },
+        },
+        handles: {
+            inputs: ['input'],
+            outputs: [],
+        },
+    },
+];
+/**
+ * Get node definitions, optionally filtered by type
+ */
+export function getNodeDefinitions(types) {
+    if (!types || types.length === 0) {
+        return NODE_DEFINITIONS;
+    }
+    return NODE_DEFINITIONS.filter((node) => types.includes(node.type));
+}