n8n-nodes-cribops 0.1.5

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

@@ -0,0 +1,568 @@
+"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',
+        name: 'cribops',
+        icon: 'file:cribops.svg',
+        group: ['communication'],
+        version: 1,
+        subtitle: '={{$parameter["operation"]}}',
+        description: 'Interact with Cribops AI agents',
+        defaults: {
+            name: 'Cribops',
+        },
+        inputs: ["main" /* NodeConnectionType.Main */],
+        outputs: ["main" /* NodeConnectionType.Main */],
+        credentials: [
+            {
+                name: 'cribopsApi',
+                required: true,
+            },
+        ],
+        requestDefaults: {
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        },
+        properties: [
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                options: [
+                    {
+                        name: 'Get Agent',
+                        value: 'getAgent',
+                        description: 'Get information about a specific agent',
+                        action: 'Get information about a specific agent',
+                    },
+                    {
+                        name: 'List Agents',
+                        value: 'listAgents',
+                        description: 'List all available agents',
+                        action: 'List all available agents',
+                    },
+                    {
+                        name: 'Reply to Conversation',
+                        value: 'replyToConversation',
+                        description: 'Reply to an existing conversation',
+                        action: 'Reply to an existing conversation',
+                    },
+                    {
+                        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',
+                    },
+                ],
+                default: 'sendMessage',
+            },
+            {
+                displayName: 'Agent',
+                name: 'agentId',
+                type: 'resourceLocator',
+                default: { mode: 'list', value: '' },
+                required: true,
+                displayOptions: {
+                    show: {
+                        operation: ['sendMessage', 'replyToConversation', 'getAgent', 'sendTypingIndicator'],
+                    },
+                },
+                modes: [
+                    {
+                        displayName: 'From List',
+                        name: 'list',
+                        type: 'list',
+                        placeholder: 'Select an agent...',
+                        typeOptions: {
+                            searchListMethod: 'searchAgents',
+                            searchable: true,
+                        },
+                    },
+                    {
+                        displayName: 'By ID',
+                        name: 'id',
+                        type: 'string',
+                        placeholder: 'agent_123',
+                        validation: [
+                            {
+                                type: 'regex',
+                                properties: {
+                                    regex: '^[a-zA-Z0-9_-]+$',
+                                    errorMessage: 'Agent ID must contain only letters, numbers, hyphens, and underscores',
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+            {
+                displayName: 'Conversation ID',
+                name: 'conversationId',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: 'conversation_123',
+                displayOptions: {
+                    show: {
+                        operation: ['replyToConversation'],
+                    },
+                },
+                description: 'ID of the conversation to reply to',
+            },
+            {
+                displayName: 'Conversation ID',
+                name: 'conversationId',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: 'conversation_123',
+                displayOptions: {
+                    show: {
+                        operation: ['sendTypingIndicator'],
+                    },
+                },
+                description: 'ID of the conversation to send typing indicator to',
+            },
+            {
+                displayName: 'Typing',
+                name: 'typing',
+                type: 'boolean',
+                required: true,
+                default: true,
+                displayOptions: {
+                    show: {
+                        operation: ['sendTypingIndicator'],
+                    },
+                },
+                description: 'Whether to show typing indicator (true) or stop typing (false)',
+            },
+            {
+                displayName: 'Message',
+                name: 'message',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: 'Hello, how can you help me?',
+                displayOptions: {
+                    show: {
+                        operation: ['sendMessage', 'replyToConversation'],
+                    },
+                },
+                description: 'The message to send',
+            },
+            {
+                displayName: 'Conversation ID',
+                name: 'conversationId',
+                type: 'string',
+                default: '',
+                placeholder: 'conversation_123',
+                displayOptions: {
+                    show: {
+                        operation: ['sendMessage'],
+                    },
+                },
+                description: 'ID of the conversation (leave empty to start a new conversation)',
+            },
+            {
+                displayName: 'User ID',
+                name: 'userId',
+                type: 'string',
+                default: '',
+                placeholder: 'user_123',
+                displayOptions: {
+                    show: {
+                        operation: ['sendMessage'],
+                    },
+                },
+                description: 'ID of the user sending the message',
+            },
+            {
+                displayName: 'File Attachment',
+                name: 'fileAttachment',
+                type: 'fixedCollection',
+                default: {},
+                placeholder: 'Add file attachment',
+                displayOptions: {
+                    show: {
+                        operation: ['sendMessage'],
+                    },
+                },
+                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: '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: 'Timeout',
+                        name: 'timeout',
+                        type: 'number',
+                        default: 30000,
+                        description: 'Request timeout in milliseconds',
+                    },
+                ],
+            },
+        ],
+    };
+    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 credentials = await this.getCredentials('cribopsApi');
+        const cribopsHttp = new CribopsHttp_1.CribopsHttp({
+            baseUrl: credentials.baseUrl,
+            apiToken: credentials.apiToken,
+        });
+        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;
+                    default:
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, { itemIndex: i });
+                }
+                results.push({
+                    json: responseData,
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    results.push({
+                        json: {
+                            error: error.message,
+                        },
+                        pairedItem: { item: i },
+                    });
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return [results];
+    }
+}
+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 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
+    };
+}

package/dist/nodes/Cribops/cribops.svg

@@ -0,0 +1,7 @@
+<svg width="60" height="60" viewBox="0 0 60 60" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect width="60" height="60" rx="12" fill="#4F46E5"/>
+  <path d="M15 20C15 17.7909 16.7909 16 19 16H41C43.2091 16 45 17.7909 45 20V32C45 34.2091 43.2091 36 41 36H26L18 42V36H19C16.7909 36 15 34.2091 15 32V20Z" fill="white"/>
+  <circle cx="24" cy="26" r="2" fill="#4F46E5"/>
+  <circle cx="30" cy="26" r="2" fill="#4F46E5"/>
+  <circle cx="36" cy="26" r="2" fill="#4F46E5"/>
+</svg>

package/dist/nodes/CribopsTrigger/CribopsTrigger.node.d.ts

@@ -0,0 +1,18 @@
+import { INodeType, INodeTypeDescription, ITriggerFunctions, ITriggerResponse, IWebhookFunctions, IWebhookResponseData, IHookFunctions, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+export declare class CribopsTrigger implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getAgents(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    trigger(this: ITriggerFunctions): Promise<ITriggerResponse>;
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}