n8n-nodes-cribops 0.1.20 → 0.2.0

package/dist/nodes/Cribops/Cribops.node.js

@@ -1,19 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cribops = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
 const CribopsHttp_1 = require("../../utils/CribopsHttp");
 class Cribops {
     description = {
-        displayName: 'Cribops',
+        displayName: 'Cribops Webhook',
         name: 'cribops',
         icon: 'file:cribops.svg',
-        group: ['communication'],
+        group: ['transform'],
         version: 1,
         subtitle: '={{$parameter["operation"]}}',
-        description: 'Interact with Cribops AI agents',
+        description: 'Report errors, performance, and send callbacks to Cribops',
         defaults: {
-            name: 'Cribops',
+            name: 'Cribops Webhook',
         },
         inputs: ["main" /* NodeConnectionType.Main */],
         outputs: ["main" /* NodeConnectionType.Main */],
@@ -37,620 +36,470 @@ class Cribops {
                 noDataExpression: true,
                 options: [
                     {
-                        name: 'Get Agent',
-                        value: 'getAgent',
-                        description: 'Get information about a specific agent',
-                        action: 'Get information about a specific agent',
+                        name: 'Report Error',
+                        value: 'reportError',
+                        description: 'Report workflow error to Cribops for monitoring',
+                        action: 'Report workflow error to cribops',
                     },
                     {
-                        name: 'List Agents',
-                        value: 'listAgents',
-                        description: 'List all available agents',
-                        action: 'List all available agents',
+                        name: 'Report Performance',
+                        value: 'reportPerformance',
+                        description: 'Send performance metrics for this webhook processing',
+                        action: 'Send performance metrics',
                     },
                     {
-                        name: 'Poll Queue',
-                        value: 'pollQueue',
-                        description: 'Poll messages from the queue',
-                        action: 'Poll messages from the queue',
+                        name: 'Send Callback',
+                        value: 'sendCallback',
+                        description: 'Send completion callback for long-running workflows',
+                        action: 'Send completion callback',
                     },
                     {
-                        name: 'Reply to Conversation',
-                        value: 'replyToConversation',
-                        description: 'Reply to an existing conversation',
-                        action: 'Reply to an existing conversation',
+                        name: 'Send Progress',
+                        value: 'sendProgress',
+                        description: 'Send progress update for long-running workflows',
+                        action: 'Send progress update',
                     },
                     {
-                        name: 'Send Message',
-                        value: 'sendMessage',
-                        description: 'Send a message to a Cribops agent',
-                        action: 'Send a message to a cribops agent',
-                    },
-                    {
-                        name: 'Send Typing Indicator',
-                        value: 'sendTypingIndicator',
-                        description: 'Send typing indicator to a conversation',
-                        action: 'Send typing indicator to a conversation',
+                        name: 'Send Workflow for Analysis',
+                        value: 'analyzeWorkflow',
+                        description: 'Send workflow definition to get optimization recommendations',
+                        action: 'Send workflow for analysis',
                     },
                 ],
-                default: 'sendMessage',
+                default: 'reportError',
             },
+            // Common webhook ID parameter
             {
-                displayName: 'Agent',
-                name: 'agentId',
-                type: 'resourceLocator',
-                default: { mode: 'list', value: '' },
+                displayName: 'Webhook ID',
+                name: 'webhookId',
+                type: 'string',
                 required: true,
                 displayOptions: {
                     show: {
-                        operation: ['sendMessage', 'replyToConversation', 'getAgent', 'sendTypingIndicator'],
+                        operation: ['reportError', 'reportPerformance', 'sendCallback', 'sendProgress'],
                     },
                 },
-                modes: [
-                    {
-                        displayName: 'From List',
-                        name: 'list',
-                        type: 'list',
-                        placeholder: 'Select an agent...',
-                        typeOptions: {
-                            searchListMethod: 'searchAgents',
-                            searchable: true,
-                        },
+                default: '={{$json["cribops"]["webhook_id"]}}',
+                description: 'The Cribops webhook ID to report on',
+            },
+            // Report Error Operation
+            {
+                displayName: 'Error Details',
+                name: 'errorDetails',
+                type: 'collection',
+                placeholder: 'Add Error Detail',
+                default: {},
+                displayOptions: {
+                    show: {
+                        operation: ['reportError'],
                     },
+                },
+                options: [
                     {
-                        displayName: 'By ID',
-                        name: 'id',
+                        displayName: 'Error Message',
+                        name: 'message',
                         type: 'string',
-                        placeholder: 'agent_123',
-                        validation: [
+                        default: '',
+                    },
+                    {
+                        displayName: 'Error Type',
+                        name: 'type',
+                        type: 'options',
+                        options: [
+                            {
+                                name: 'Connection Error',
+                                value: 'connection_error',
+                            },
+                            {
+                                name: 'Authentication Failed',
+                                value: 'auth_failed',
+                            },
+                            {
+                                name: 'Rate Limited',
+                                value: 'rate_limited',
+                            },
                             {
-                                type: 'regex',
-                                properties: {
-                                    regex: '^[a-zA-Z0-9_-]+$',
-                                    errorMessage: 'Agent ID must contain only letters, numbers, hyphens, and underscores',
-                                },
+                                name: 'Timeout',
+                                value: 'timeout',
+                            },
+                            {
+                                name: 'Invalid Data',
+                                value: 'invalid_data',
+                            },
+                            {
+                                name: 'Server Error',
+                                value: 'server_error',
+                            },
+                            {
+                                name: 'Other',
+                                value: 'other',
                             },
                         ],
+                        default: 'other',
+                        description: 'Type of error encountered',
+                    },
+                    {
+                        displayName: 'Stack Trace',
+                        name: 'stackTrace',
+                        type: 'string',
+                        typeOptions: {
+                            rows: 5,
+                        },
+                        default: '',
+                        description: 'Error stack trace for debugging',
+                    },
+                    {
+                        displayName: 'Node Name',
+                        name: 'nodeName',
+                        type: 'string',
+                        default: '',
+                        description: 'Name of the node that failed',
+                    },
+                    {
+                        displayName: 'Retry Recommended',
+                        name: 'retryRecommended',
+                        type: 'boolean',
+                        default: true,
+                        description: 'Whether retrying might succeed',
                     },
                 ],
             },
+            // Report Performance Operation
             {
-                displayName: 'Conversation ID',
-                name: 'conversationId',
-                type: 'string',
-                required: true,
-                default: '',
-                placeholder: 'conversation_123',
+                displayName: 'Performance Metrics',
+                name: 'performanceMetrics',
+                type: 'collection',
+                placeholder: 'Add Metric',
+                default: {},
                 displayOptions: {
                     show: {
-                        operation: ['replyToConversation'],
+                        operation: ['reportPerformance'],
                     },
                 },
-                description: 'ID of the conversation to reply to',
+                options: [
+                    {
+                        displayName: 'Processing Time (Ms)',
+                        name: 'processingTime',
+                        type: 'number',
+                        default: 0,
+                        description: 'Total time to process the webhook in milliseconds',
+                    },
+                    {
+                        displayName: 'Memory Usage (MB)',
+                        name: 'memoryUsage',
+                        type: 'number',
+                        default: 0,
+                        description: 'Peak memory usage during processing',
+                    },
+                    {
+                        displayName: 'Items Processed',
+                        name: 'itemsProcessed',
+                        type: 'number',
+                        default: 1,
+                        description: 'Number of items processed',
+                    },
+                    {
+                        displayName: 'External API Calls',
+                        name: 'apiCalls',
+                        type: 'number',
+                        default: 0,
+                        description: 'Number of external API calls made',
+                    },
+                    {
+                        displayName: 'Success',
+                        name: 'success',
+                        type: 'boolean',
+                        default: true,
+                        description: 'Whether the processing was successful',
+                    },
+                ],
             },
+            // Send Callback Operation
             {
-                displayName: 'Conversation ID',
-                name: 'conversationId',
-                type: 'string',
-                required: true,
-                default: '',
-                placeholder: 'conversation_123',
+                displayName: 'Callback Type',
+                name: 'callbackType',
+                type: 'options',
                 displayOptions: {
                     show: {
-                        operation: ['sendTypingIndicator'],
+                        operation: ['sendCallback'],
                     },
                 },
-                description: 'ID of the conversation to send typing indicator to',
+                options: [
+                    {
+                        name: 'Success',
+                        value: 'success',
+                    },
+                    {
+                        name: 'Failure',
+                        value: 'failure',
+                    },
+                    {
+                        name: 'Partial Success',
+                        value: 'partial',
+                    },
+                ],
+                default: 'success',
+                description: 'Type of callback to send',
             },
             {
-                displayName: 'Typing',
-                name: 'typing',
-                type: 'boolean',
-                required: true,
-                default: true,
+                displayName: 'Callback Data',
+                name: 'callbackData',
+                type: 'json',
                 displayOptions: {
                     show: {
-                        operation: ['sendTypingIndicator'],
+                        operation: ['sendCallback'],
                     },
                 },
-                description: 'Whether to show typing indicator (true) or stop typing (false)',
+                default: '{}',
+                description: 'Data to include in the callback',
             },
             {
-                displayName: 'Tenant ID',
-                name: 'tenantId',
+                displayName: 'Summary',
+                name: 'summary',
                 type: 'string',
-                required: true,
-                default: '',
-                placeholder: 'my-tenant',
                 displayOptions: {
                     show: {
-                        operation: ['pollQueue'],
+                        operation: ['sendCallback'],
                     },
                 },
-                description: 'The tenant ID for your Cribops organization',
+                default: '',
+                description: 'Brief summary of the processing result',
             },
+            // Send Progress Operation
             {
-                displayName: 'Batch Size',
-                name: 'batchSize',
+                displayName: 'Progress',
+                name: 'progress',
                 type: 'number',
-                default: 10,
+                typeOptions: {
+                    minValue: 0,
+                    maxValue: 100,
+                },
                 displayOptions: {
                     show: {
-                        operation: ['pollQueue'],
+                        operation: ['sendProgress'],
                     },
                 },
-                description: 'Number of messages to retrieve (max 100)',
+                default: 0,
+                description: 'Progress percentage (0-100)',
             },
             {
-                displayName: 'Queue Name',
-                name: 'queueName',
+                displayName: 'Progress Message',
+                name: 'progressMessage',
                 type: 'string',
-                default: '',
-                placeholder: 'e.g., stripe_events',
                 displayOptions: {
                     show: {
-                        operation: ['pollQueue'],
+                        operation: ['sendProgress'],
                     },
                 },
-                description: 'Specific queue to poll (optional). Leave empty to poll all queues.',
+                default: '',
+                description: 'Current status message',
             },
             {
-                displayName: 'Message',
-                name: 'message',
-                type: 'string',
-                required: true,
-                default: '',
-                placeholder: 'Hello, how can you help me?',
+                displayName: 'Items Completed',
+                name: 'itemsCompleted',
+                type: 'number',
                 displayOptions: {
                     show: {
-                        operation: ['sendMessage', 'replyToConversation'],
+                        operation: ['sendProgress'],
                     },
                 },
-                description: 'The message to send',
+                default: 0,
+                description: 'Number of items completed',
             },
             {
-                displayName: 'Conversation ID',
-                name: 'conversationId',
-                type: 'string',
-                default: '',
-                placeholder: 'conversation_123',
+                displayName: 'Total Items',
+                name: 'totalItems',
+                type: 'number',
                 displayOptions: {
                     show: {
-                        operation: ['sendMessage'],
+                        operation: ['sendProgress'],
                     },
                 },
-                description: 'ID of the conversation (leave empty to start a new conversation)',
+                default: 0,
+                description: 'Total number of items to process',
             },
+            // Analyze Workflow Operation
             {
-                displayName: 'User ID',
-                name: 'userId',
-                type: 'string',
-                default: '',
-                placeholder: 'user_123',
+                displayName: 'Include Workflow Definition',
+                name: 'includeDefinition',
+                type: 'boolean',
                 displayOptions: {
                     show: {
-                        operation: ['sendMessage'],
+                        operation: ['analyzeWorkflow'],
                     },
                 },
-                description: 'ID of the user sending the message',
+                default: true,
+                description: 'Whether to include the full workflow definition',
             },
             {
-                displayName: 'File Attachment',
-                name: 'fileAttachment',
-                type: 'fixedCollection',
+                displayName: 'Workflow Metrics',
+                name: 'workflowMetrics',
+                type: 'collection',
+                placeholder: 'Add Metric',
                 default: {},
-                placeholder: 'Add file attachment',
                 displayOptions: {
                     show: {
-                        operation: ['sendMessage'],
+                        operation: ['analyzeWorkflow'],
                     },
                 },
-                typeOptions: {
-                    multipleValues: false,
-                },
                 options: [
                     {
-                        name: 'file',
-                        displayName: 'File',
-                        values: [
-                            {
-                                displayName: 'File URL',
-                                name: 'url',
-                                type: 'string',
-                                default: '',
-                                placeholder: 'https://example.com/file.pdf',
-                                description: 'URL of the file to attach',
-                            },
-                            {
-                                displayName: 'File Name',
-                                name: 'name',
-                                type: 'string',
-                                default: '',
-                                placeholder: 'document.pdf',
-                                description: 'Name of the file (optional)',
-                            },
-                            {
-                                displayName: 'File Type',
-                                name: 'type',
-                                type: 'string',
-                                default: '',
-                                placeholder: 'application/pdf',
-                                description: 'MIME type of the file (optional)',
-                            },
-                        ],
+                        displayName: 'Average Execution Time',
+                        name: 'avgExecutionTime',
+                        type: 'number',
+                        default: 0,
+                        description: 'Average execution time in milliseconds',
                     },
-                ],
-            },
-            {
-                displayName: 'Additional Fields',
-                name: 'additionalFields',
-                type: 'collection',
-                placeholder: 'Add Field',
-                default: {},
-                options: [
                     {
-                        displayName: 'Metadata',
-                        name: 'metadata',
-                        type: 'fixedCollection',
-                        placeholder: 'Add Metadata',
-                        default: {},
-                        typeOptions: {
-                            multipleValues: true,
-                        },
-                        options: [
-                            {
-                                name: 'metadataValues',
-                                displayName: 'Metadata',
-                                values: [
-                                    {
-                                        displayName: 'Key',
-                                        name: 'key',
-                                        type: 'string',
-                                        default: '',
-                                        description: 'Metadata key',
-                                    },
-                                    {
-                                        displayName: 'Value',
-                                        name: 'value',
-                                        type: 'string',
-                                        default: '',
-                                        description: 'Metadata value',
-                                    },
-                                ],
-                            },
-                        ],
+                        displayName: 'Daily Executions',
+                        name: 'dailyExecutions',
+                        type: 'number',
+                        default: 0,
+                        description: 'Average number of executions per day',
+                    },
+                    {
+                        displayName: 'Failure Rate',
+                        name: 'failureRate',
+                        type: 'number',
+                        default: 0,
+                        description: 'Percentage of failed executions',
                     },
                     {
-                        displayName: 'Timeout',
-                        name: 'timeout',
+                        displayName: 'Node Count',
+                        name: 'nodeCount',
                         type: 'number',
-                        default: 30000,
-                        description: 'Request timeout in milliseconds',
+                        default: 0,
+                        description: 'Number of nodes in the workflow',
                     },
                 ],
             },
         ],
     };
-    methods = {
-        listSearch: {
-            searchAgents: async function (filter) {
-                const credentials = await this.getCredentials('cribopsApi');
-                const cribopsHttp = new CribopsHttp_1.CribopsHttp({
-                    baseUrl: credentials.baseUrl,
-                    apiToken: credentials.apiToken,
-                });
-                try {
-                    const agents = await cribopsHttp.getAgents();
-                    const results = agents
-                        .filter((agent) => !filter || agent.name.toLowerCase().includes(filter.toLowerCase()))
-                        .map((agent) => ({
-                        name: `${agent.name} (${agent.id})`,
-                        value: agent.id,
-                    }));
-                    return {
-                        results,
-                    };
-                }
-                catch (error) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load agents: ${error}`, {
-                        description: 'Make sure your API credentials are correct and the Cribops API is accessible',
-                    });
-                }
-            },
-        },
-    };
     async execute() {
         const items = this.getInputData();
-        const results = [];
+        const returnData = [];
         const credentials = await this.getCredentials('cribopsApi');
         const cribopsHttp = new CribopsHttp_1.CribopsHttp({
             baseUrl: credentials.baseUrl,
             apiToken: credentials.apiToken,
         });
+        const operation = this.getNodeParameter('operation', 0);
         for (let i = 0; i < items.length; i++) {
-            const operation = this.getNodeParameter('operation', i);
             try {
                 let responseData;
-                switch (operation) {
-                    case 'replyToConversation':
-                        responseData = await replyToConversation(this, cribopsHttp, i);
-                        break;
-                    case 'sendMessage':
-                        responseData = await sendMessage(this, cribopsHttp, i);
-                        break;
-                    case 'sendTypingIndicator':
-                        responseData = await sendTypingIndicator(this, cribopsHttp, i);
-                        break;
-                    case 'getAgent':
-                        responseData = await getAgent(this, cribopsHttp, i);
-                        break;
-                    case 'listAgents':
-                        responseData = await listAgents(this, cribopsHttp, i);
-                        break;
-                    case 'pollQueue':
-                        responseData = await pollQueue(this, cribopsHttp, i);
-                        break;
-                    default:
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, { itemIndex: i });
+                if (operation === 'reportError') {
+                    const webhookId = this.getNodeParameter('webhookId', i);
+                    const errorDetails = this.getNodeParameter('errorDetails', i);
+                    const errorData = {
+                        webhook_id: webhookId,
+                        error: {
+                            message: String(errorDetails.message || 'Unknown error'),
+                            type: String(errorDetails.type || 'other'),
+                            stack_trace: errorDetails.stackTrace ? String(errorDetails.stackTrace) : undefined,
+                            node_name: errorDetails.nodeName ? String(errorDetails.nodeName) : undefined,
+                            retry_recommended: errorDetails.retryRecommended !== false,
+                            timestamp: new Date().toISOString(),
+                            workflow_id: this.getWorkflow().id,
+                            workflow_name: this.getWorkflow().name,
+                        },
+                    };
+                    responseData = await cribopsHttp.reportError(errorData);
                 }
-                results.push({
+                else if (operation === 'reportPerformance') {
+                    const webhookId = this.getNodeParameter('webhookId', i);
+                    const metrics = this.getNodeParameter('performanceMetrics', i);
+                    const performanceData = {
+                        webhook_id: webhookId,
+                        metrics: {
+                            processing_time_ms: Number(metrics.processingTime || 0),
+                            memory_usage_mb: metrics.memoryUsage ? Number(metrics.memoryUsage) : undefined,
+                            items_processed: Number(metrics.itemsProcessed || 1),
+                            api_calls: metrics.apiCalls ? Number(metrics.apiCalls) : undefined,
+                            success: metrics.success !== false,
+                            timestamp: new Date().toISOString(),
+                            workflow_id: this.getWorkflow().id,
+                            workflow_name: this.getWorkflow().name,
+                        },
+                    };
+                    responseData = await cribopsHttp.reportPerformance(performanceData);
+                }
+                else if (operation === 'sendCallback') {
+                    const webhookId = this.getNodeParameter('webhookId', i);
+                    const callbackType = this.getNodeParameter('callbackType', i);
+                    const callbackData = this.getNodeParameter('callbackData', i);
+                    const summary = this.getNodeParameter('summary', i);
+                    const callback = {
+                        webhook_id: webhookId,
+                        type: callbackType,
+                        data: JSON.parse(callbackData),
+                        summary: summary || undefined,
+                        timestamp: new Date().toISOString(),
+                        workflow_id: this.getWorkflow().id,
+                        workflow_name: this.getWorkflow().name,
+                    };
+                    responseData = await cribopsHttp.sendCallback(callback);
+                }
+                else if (operation === 'sendProgress') {
+                    const webhookId = this.getNodeParameter('webhookId', i);
+                    const progress = this.getNodeParameter('progress', i);
+                    const progressMessage = this.getNodeParameter('progressMessage', i);
+                    const itemsCompleted = this.getNodeParameter('itemsCompleted', i);
+                    const totalItems = this.getNodeParameter('totalItems', i);
+                    const progressData = {
+                        webhook_id: webhookId,
+                        progress: {
+                            percentage: progress,
+                            message: progressMessage,
+                            items_completed: itemsCompleted,
+                            total_items: totalItems,
+                            timestamp: new Date().toISOString(),
+                        },
+                    };
+                    responseData = await cribopsHttp.sendProgress(progressData);
+                }
+                else if (operation === 'analyzeWorkflow') {
+                    const includeDefinition = this.getNodeParameter('includeDefinition', i);
+                    const metrics = this.getNodeParameter('workflowMetrics', i);
+                    const workflowInfo = this.getWorkflow();
+                    const analysisData = {
+                        workflow_id: workflowInfo.id,
+                        workflow_name: workflowInfo.name,
+                        metrics: {
+                            avg_execution_time_ms: Number(metrics.avgExecutionTime || 0),
+                            daily_executions: Number(metrics.dailyExecutions || 0),
+                            failure_rate: Number(metrics.failureRate || 0),
+                            node_count: Number(metrics.nodeCount || 0),
+                        },
+                    };
+                    if (includeDefinition) {
+                        // Get workflow data from the workflow static data if available
+                        // This is a placeholder - in production you might need to get this differently
+                        analysisData.workflow_definition = {
+                            nodes: [],
+                            connections: {},
+                        };
+                    }
+                    responseData = await cribopsHttp.analyzeWorkflow(analysisData);
+                }
+                returnData.push({
                     json: responseData,
                     pairedItem: { item: i },
                 });
             }
             catch (error) {
                 if (this.continueOnFail()) {
-                    results.push({
+                    returnData.push({
                         json: {
-                            error: error.message,
+                            error: error instanceof Error ? error.message : String(error),
                         },
                         pairedItem: { item: i },
                     });
+                    continue;
                 }
-                else {
-                    throw error;
-                }
+                throw error;
             }
         }
-        return [results];
+        return [returnData];
     }
 }
 exports.Cribops = Cribops;
-// Simple UUID v4 generator
-function generateUUID() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = Math.random() * 16 | 0;
-        const v = c === 'x' ? r : (r & 0x3 | 0x8);
-        return v.toString(16);
-    });
-}
-async function replyToConversation(executeFunctions, cribopsHttp, itemIndex) {
-    const agentId = executeFunctions.getNodeParameter('agentId', itemIndex, '', { extractValue: true });
-    const conversationId = executeFunctions.getNodeParameter('conversationId', itemIndex);
-    const message = executeFunctions.getNodeParameter('message', itemIndex);
-    // Get the response webhook URL from the input data
-    const inputData = executeFunctions.getInputData()[itemIndex];
-    let responseWebhook = inputData.json.response_webhook;
-    // If not found directly, check if it's in the original trigger data (passed through by typing indicator)
-    if (!responseWebhook && inputData.json._originalTriggerData) {
-        const originalTriggerData = inputData.json._originalTriggerData;
-        responseWebhook = originalTriggerData.response_webhook;
-    }
-    // If still not found, try to find it in the workflow execution data from the CribopsTrigger node
-    if (!responseWebhook) {
-        try {
-            const workflowData = executeFunctions.getWorkflowDataProxy(itemIndex);
-            const cribopsTriggerData = workflowData.$('Cribops Trigger');
-            if (cribopsTriggerData && cribopsTriggerData.item && cribopsTriggerData.item.json) {
-                responseWebhook = cribopsTriggerData.item.json.response_webhook;
-            }
-        }
-        catch (error) {
-            // Ignore errors if Cribops Trigger node is not found
-        }
-    }
-    // Log the raw values to debug expression evaluation
-    console.log('Debug - agentId:', agentId);
-    console.log('Debug - conversationId:', conversationId);
-    console.log('Debug - message:', message);
-    console.log('Debug - responseWebhook:', responseWebhook);
-    // Check if expressions were not evaluated (contain literal expression syntax)
-    if (conversationId.includes('{{') || conversationId.includes('}}')) {
-        throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `Conversation ID contains unevaluated expression: ${conversationId}. Please ensure the expression is properly formatted.`, { itemIndex });
-    }
-    if (!conversationId || conversationId.trim() === '') {
-        throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), 'Conversation ID is required but was empty', { itemIndex });
-    }
-    if (!responseWebhook) {
-        console.log('Warning: response_webhook not found in input data:', JSON.stringify(inputData.json, null, 2));
-        // Fallback: try to use the agent webhook endpoint
-        console.log('Falling back to agent webhook endpoint');
-        const fallbackMessageData = {
-            id: generateUUID(),
-            content: message,
-            conversationId: conversationId,
-            agentId: agentId,
-            type: 'agent_response',
-            timestamp: new Date().toISOString(),
-        };
-        return await cribopsHttp.sendMessage(agentId, fallbackMessageData);
-    }
-    // Try to get user_id and organization_id from trigger data
-    let userId = inputData.json.user_id || '';
-    let organizationId = inputData.json.organization_id || '';
-    // If not found, try to get from workflow data
-    if ((!userId || !organizationId) && responseWebhook) {
-        try {
-            const workflowData = executeFunctions.getWorkflowDataProxy(itemIndex);
-            const cribopsTriggerData = workflowData.$('Cribops Trigger');
-            if (cribopsTriggerData && cribopsTriggerData.item && cribopsTriggerData.item.json) {
-                userId = userId || cribopsTriggerData.item.json.user_id || '';
-                organizationId = organizationId || cribopsTriggerData.item.json.organization_id || '';
-            }
-        }
-        catch (error) {
-            // Ignore errors
-        }
-    }
-    const messageData = {
-        conversation_id: conversationId,
-        content: message,
-        message_id: generateUUID(),
-        timestamp: new Date().toISOString(),
-        // Include additional fields that might be needed
-        user_id: userId,
-        organization_id: organizationId,
-    };
-    try {
-        console.log('Debug - Response webhook URL:', responseWebhook);
-        console.log('Debug - Request body:', JSON.stringify(messageData, null, 2));
-        // Send to the response webhook URL
-        // Note: The standard workflow uses form parameters, not JSON
-        const formData = new URLSearchParams();
-        Object.keys(messageData).forEach(key => {
-            formData.append(key, String(messageData[key]));
-        });
-        const requestOptions = {
-            method: 'POST',
-            url: responseWebhook,
-            headers: {
-                'Authorization': `Bearer ${cribopsHttp['config'].apiToken}`,
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: formData.toString(),
-            json: false,
-        };
-        const response = await executeFunctions.helpers.httpRequest(requestOptions);
-        return response;
-    }
-    catch (error) {
-        // Enhanced error logging for 422 errors
-        if (error.response?.status === 422) {
-            console.error('422 Error Details:');
-            console.error('Response body:', JSON.stringify(error.response.body, null, 2));
-            console.error('Request that failed:', {
-                agentId: agentId,
-                body: messageData,
-                conversationId: conversationId
-            });
-            const errorDetails = error.response.body?.errors || error.response.body?.message || 'Unknown validation error';
-            throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `Validation error (422): ${JSON.stringify(errorDetails)}. ConversationId: "${conversationId}"`, { itemIndex, description: `Full error: ${JSON.stringify(error.response.body)}` });
-        }
-        throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `Failed to reply to conversation: ${error instanceof Error ? error.message : String(error)}`, { itemIndex });
-    }
-}
-async function sendMessage(executeFunctions, cribopsHttp, itemIndex) {
-    const agentId = executeFunctions.getNodeParameter('agentId', itemIndex, '', { extractValue: true });
-    const message = executeFunctions.getNodeParameter('message', itemIndex);
-    const conversationId = executeFunctions.getNodeParameter('conversationId', itemIndex, '');
-    const userId = executeFunctions.getNodeParameter('userId', itemIndex, '');
-    const fileAttachment = executeFunctions.getNodeParameter('fileAttachment', itemIndex, {});
-    const additionalFields = executeFunctions.getNodeParameter('additionalFields', itemIndex, {});
-    const messageData = {
-        id: generateUUID(),
-        content: message,
-        conversationId: conversationId || `conversation_${Date.now()}`,
-        userId: userId || undefined,
-        type: 'user_message',
-        timestamp: new Date().toISOString(),
-    };
-    // Add file attachment if provided
-    if (fileAttachment.file) {
-        const file = fileAttachment.file;
-        if (file.url) {
-            messageData.fileUrl = file.url;
-            messageData.fileName = file.name || 'file';
-            messageData.fileType = file.type || 'application/octet-stream';
-        }
-    }
-    // Add metadata if provided
-    if (additionalFields.metadata) {
-        const metadata = additionalFields.metadata;
-        const metadataValues = metadata.metadataValues;
-        if (metadataValues && metadataValues.length > 0) {
-            messageData.metadata = {};
-            metadataValues.forEach((item) => {
-                messageData.metadata[item.key] = item.value;
-            });
-        }
-    }
-    return await cribopsHttp.sendMessage(agentId, messageData);
-}
-async function getAgent(executeFunctions, cribopsHttp, itemIndex) {
-    const agentId = executeFunctions.getNodeParameter('agentId', itemIndex, '', { extractValue: true });
-    return await cribopsHttp.getAgent(agentId);
-}
-async function listAgents(executeFunctions, cribopsHttp, itemIndex) {
-    const agents = await cribopsHttp.getAgents();
-    return { agents, count: agents.length };
-}
-async function pollQueue(executeFunctions, cribopsHttp, itemIndex) {
-    const tenantId = executeFunctions.getNodeParameter('tenantId', itemIndex);
-    const batchSize = executeFunctions.getNodeParameter('batchSize', itemIndex, 10);
-    const queueName = executeFunctions.getNodeParameter('queueName', itemIndex, '') || undefined;
-    const messages = await cribopsHttp.pollQueue(tenantId, batchSize, queueName);
-    // Process each message to parse the data if it's JSON
-    const processedMessages = messages.map(message => {
-        let parsedData = message.data.data;
-        try {
-            parsedData = JSON.parse(message.data.data);
-        }
-        catch (e) {
-            // Keep as string if not valid JSON
-        }
-        return {
-            id: message.id,
-            correlation_id: message.correlation_id,
-            queue_name: message.queue_name,
-            data: parsedData,
-            headers: message.data.headers,
-            params: message.data.params,
-            inserted_at: message.inserted_at,
-            // Extract useful fields from headers
-            tenant_id: message.data.headers['x-cribops-tenant-id'] || tenantId,
-            path: message.data.headers['x-cribops-path'],
-        };
-    });
-    // Auto-acknowledge messages after processing
-    if (messages.length > 0) {
-        const messageIds = messages.map(msg => msg.id);
-        try {
-            await cribopsHttp.acknowledgeMessages(tenantId, messageIds);
-        }
-        catch (ackError) {
-            // Log error but don't fail the operation
-            console.error('Failed to acknowledge messages:', ackError);
-        }
-    }
-    return { messages: processedMessages, count: processedMessages.length };
-}
-async function sendTypingIndicator(executeFunctions, cribopsHttp, itemIndex) {
-    const agentId = executeFunctions.getNodeParameter('agentId', itemIndex, '', { extractValue: true });
-    const conversationId = executeFunctions.getNodeParameter('conversationId', itemIndex);
-    const typing = executeFunctions.getNodeParameter('typing', itemIndex);
-    // Check if we have a response_webhook in the input data to extract the correct base URL
-    const inputData = executeFunctions.getInputData()[itemIndex];
-    const responseWebhook = inputData.json.response_webhook;
-    let typingResult;
-    if (responseWebhook) {
-        // Extract base URL from response webhook
-        const webhookUrl = new URL(responseWebhook);
-        const baseUrl = `${webhookUrl.protocol}//${webhookUrl.host}`;
-        // Create a temporary HTTP client with the correct base URL
-        const dynamicCribopsHttp = new CribopsHttp_1.CribopsHttp({
-            baseUrl: baseUrl,
-            apiToken: cribopsHttp['config'].apiToken,
-        });
-        typingResult = await dynamicCribopsHttp.sendTypingIndicator(agentId, conversationId, typing);
-    }
-    else {
-        // Fallback to the configured base URL
-        typingResult = await cribopsHttp.sendTypingIndicator(agentId, conversationId, typing);
-    }
-    // Preserve the original trigger data for subsequent nodes
-    return {
-        ...typingResult,
-        // Pass through the original trigger data so replyToConversation can access it
-        _originalTriggerData: inputData.json
-    };
-}