n8n-nodes-richpanel 1.1.1 → 1.1.3

package/dist/nodes/Richpanel/RichpanelTool.tool.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RichpanelTool = void 0;
+const tools_1 = require("@langchain/core/tools");
+const zod_1 = require("zod");
 class RichpanelTool {
     constructor() {
         this.description = {
@@ -103,203 +105,206 @@ class RichpanelTool {
     }
     async supplyData() {
         const operations = this.getNodeParameter('operations', 0, []);
-        const toolDefinitions = [];
+        const credentials = await this.getCredentials('richpanelApi');
+        const apiKey = credentials.apiKey;
+        const tools = [];
+        // Helper function to make API requests
+        const makeApiRequest = async (method, endpoint, body) => {
+            const options = {
+                method,
+                url: `https://api.richpanel.com/v1${endpoint}`,
+                headers: {
+                    'x-richpanel-key': apiKey,
+                    'Content-Type': 'application/json',
+                    Accept: 'application/json',
+                },
+                body: body ? JSON.stringify(body) : undefined,
+                json: true,
+            };
+            try {
+                const response = await this.helpers.httpRequest(options);
+                return response;
+            }
+            catch (error) {
+                throw new Error(`Richpanel API error: ${error.message}`);
+            }
+        };
         // Create Conversation Tool
         if (operations.includes('createConversation')) {
-            toolDefinitions.push({
+            const createConversationTool = new tools_1.DynamicStructuredTool({
                 name: 'richpanel_create_conversation',
                 description: 'Create a new support conversation/ticket in Richpanel. Use this when a customer needs help, reports an issue, or has a question that needs tracking.',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        messageBody: {
-                            type: 'string',
-                            description: 'The customer message content or issue description',
-                        },
-                        customerEmail: {
-                            type: 'string',
-                            description: 'Customer email address',
-                        },
-                        subject: {
-                            type: 'string',
-                            description: 'Subject line for the conversation/ticket',
-                        },
-                        priority: {
-                            type: 'string',
-                            enum: ['HIGH', 'LOW'],
-                            description: 'Priority level (HIGH for urgent issues, LOW for general questions)',
-                        },
-                    },
-                    required: ['messageBody', 'customerEmail'],
+                schema: zod_1.z.object({
+                    messageBody: zod_1.z.string().describe('The customer message content or issue description'),
+                    customerEmail: zod_1.z.string().email().describe('Customer email address'),
+                    subject: zod_1.z.string().optional().describe('Subject line for the conversation/ticket'),
+                    priority: zod_1.z
+                        .enum(['HIGH', 'LOW'])
+                        .optional()
+                        .describe('Priority level (HIGH for urgent issues, LOW for general questions)'),
+                }),
+                func: async (input) => {
+                    const { messageBody, customerEmail, subject, priority } = input;
+                    const body = {
+                        message_body: messageBody,
+                        customer_email: customerEmail,
+                    };
+                    if (subject)
+                        body.subject = subject;
+                    if (priority)
+                        body.priority = priority;
+                    const result = await makeApiRequest('POST', '/conversations', body);
+                    return JSON.stringify(result);
                 },
             });
+            tools.push(createConversationTool);
         }
         // Get Conversation Tool
         if (operations.includes('getConversation')) {
-            toolDefinitions.push({
+            const getConversationTool = new tools_1.DynamicStructuredTool({
                 name: 'richpanel_get_conversation',
                 description: 'Retrieve details about an existing conversation/ticket by ID. Use this to check ticket status, see assigned agent, read conversation history, or verify if an issue is resolved.',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        conversationId: {
-                            type: 'string',
-                            description: 'The unique ID of the conversation/ticket',
-                        },
-                    },
-                    required: ['conversationId'],
+                schema: zod_1.z.object({
+                    conversationId: zod_1.z.string().describe('The unique ID of the conversation/ticket'),
+                }),
+                func: async (input) => {
+                    const { conversationId } = input;
+                    const result = await makeApiRequest('GET', `/conversations/${conversationId}`);
+                    return JSON.stringify(result);
                 },
             });
+            tools.push(getConversationTool);
         }
         // Update Conversation Tool
         if (operations.includes('updateConversation')) {
-            toolDefinitions.push({
+            const updateConversationTool = new tools_1.DynamicStructuredTool({
                 name: 'richpanel_update_conversation',
                 description: 'Update conversation properties like status or priority. Use this to close resolved tickets, change priority levels, or update conversation state.',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        conversationId: {
-                            type: 'string',
-                            description: 'The unique ID of the conversation to update',
-                        },
-                        status: {
-                            type: 'string',
-                            enum: ['OPEN', 'CLOSED'],
-                            description: 'New status (CLOSED when issue is resolved, OPEN otherwise)',
-                        },
-                        priority: {
-                            type: 'string',
-                            enum: ['HIGH', 'LOW'],
-                            description: 'New priority level',
-                        },
-                    },
-                    required: ['conversationId'],
+                schema: zod_1.z.object({
+                    conversationId: zod_1.z.string().describe('The unique ID of the conversation to update'),
+                    status: zod_1.z
+                        .enum(['OPEN', 'CLOSED'])
+                        .optional()
+                        .describe('New status (CLOSED when issue is resolved, OPEN otherwise)'),
+                    priority: zod_1.z.enum(['HIGH', 'LOW']).optional().describe('New priority level'),
+                }),
+                func: async (input) => {
+                    const { conversationId, status, priority } = input;
+                    const body = {};
+                    if (status)
+                        body.status = status;
+                    if (priority)
+                        body.priority = priority;
+                    const result = await makeApiRequest('PUT', `/conversations/${conversationId}`, body);
+                    return JSON.stringify(result);
                 },
             });
+            tools.push(updateConversationTool);
         }
         // Get Customer Tool
         if (operations.includes('getCustomer')) {
-            toolDefinitions.push({
+            const getCustomerTool = new tools_1.DynamicStructuredTool({
                 name: 'richpanel_get_customer',
                 description: 'Retrieve customer information by email or phone number. Use this to look up customer details, see order history, check customer status, or verify customer information.',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        identifier: {
-                            type: 'string',
-                            description: 'Customer email address or phone number',
-                        },
-                        type: {
-                            type: 'string',
-                            enum: ['email', 'phone'],
-                            description: 'Type of identifier (email or phone)',
-                            default: 'email',
-                        },
-                    },
-                    required: ['identifier'],
+                schema: zod_1.z.object({
+                    identifier: zod_1.z.string().describe('Customer email address or phone number'),
+                    type: zod_1.z
+                        .enum(['email', 'phone'])
+                        .default('email')
+                        .describe('Type of identifier (email or phone)'),
+                }),
+                func: async (input) => {
+                    const { identifier, type } = input;
+                    const endpoint = type === 'email' ? `/customers/${identifier}` : `/customers/phone/${identifier}`;
+                    const result = await makeApiRequest('GET', endpoint);
+                    return JSON.stringify(result);
                 },
             });
+            tools.push(getCustomerTool);
         }
         // Create/Update Customer Tool
         if (operations.includes('upsertCustomer')) {
-            toolDefinitions.push({
+            const upsertCustomerTool = new tools_1.DynamicStructuredTool({
                 name: 'richpanel_create_update_customer',
                 description: 'Create a new customer or update existing customer information. Use this when a customer provides updated details or to add a new customer to the system.',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        email: {
-                            type: 'string',
-                            description: 'Customer email address (required)',
-                        },
-                        firstName: {
-                            type: 'string',
-                            description: 'Customer first name',
-                        },
-                        lastName: {
-                            type: 'string',
-                            description: 'Customer last name',
-                        },
-                        phone: {
-                            type: 'string',
-                            description: 'Customer phone number',
-                        },
-                        city: {
-                            type: 'string',
-                            description: 'Customer city',
-                        },
-                        country: {
-                            type: 'string',
-                            description: 'Customer country',
-                        },
-                    },
-                    required: ['email'],
+                schema: zod_1.z.object({
+                    email: zod_1.z.string().email().describe('Customer email address (required)'),
+                    firstName: zod_1.z.string().optional().describe('Customer first name'),
+                    lastName: zod_1.z.string().optional().describe('Customer last name'),
+                    phone: zod_1.z.string().optional().describe('Customer phone number'),
+                    city: zod_1.z.string().optional().describe('Customer city'),
+                    country: zod_1.z.string().optional().describe('Customer country'),
+                }),
+                func: async (input) => {
+                    const { email, firstName, lastName, phone, city, country } = input;
+                    const body = { email };
+                    if (firstName)
+                        body.first_name = firstName;
+                    if (lastName)
+                        body.last_name = lastName;
+                    if (phone)
+                        body.phone = phone;
+                    if (city)
+                        body.city = city;
+                    if (country)
+                        body.country = country;
+                    const result = await makeApiRequest('POST', '/customers', body);
+                    return JSON.stringify(result);
                 },
             });
+            tools.push(upsertCustomerTool);
         }
         // Get Order Tool
         if (operations.includes('getOrder')) {
-            toolDefinitions.push({
+            const getOrderTool = new tools_1.DynamicStructuredTool({
                 name: 'richpanel_get_order',
                 description: 'Retrieve order information by order ID. Use this when a customer asks about order status, shipping, tracking, or order details.',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        orderId: {
-                            type: 'string',
-                            description: 'The unique order ID/number',
-                        },
-                    },
-                    required: ['orderId'],
+                schema: zod_1.z.object({
+                    orderId: zod_1.z.string().describe('The unique order ID/number'),
+                }),
+                func: async (input) => {
+                    const { orderId } = input;
+                    const result = await makeApiRequest('GET', `/orders/${orderId}`);
+                    return JSON.stringify(result);
                 },
             });
+            tools.push(getOrderTool);
         }
         // Add Tags Tool
         if (operations.includes('addTags')) {
-            toolDefinitions.push({
+            const addTagsTool = new tools_1.DynamicStructuredTool({
                 name: 'richpanel_add_tags',
                 description: 'Add tags to a conversation for categorization and organization. Use this to tag tickets by issue type, urgency, department, or any other category.',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        conversationId: {
-                            type: 'string',
-                            description: 'The conversation ID to add tags to',
-                        },
-                        tags: {
-                            type: 'array',
-                            items: {
-                                type: 'string',
-                            },
-                            description: 'Array of tag names (e.g., ["billing", "urgent", "refund"])',
-                        },
-                    },
-                    required: ['conversationId', 'tags'],
+                schema: zod_1.z.object({
+                    conversationId: zod_1.z.string().describe('The conversation ID to add tags to'),
+                    tags: zod_1.z
+                        .array(zod_1.z.string())
+                        .describe('Array of tag names (e.g., ["billing", "urgent", "refund"])'),
+                }),
+                func: async (input) => {
+                    const { conversationId, tags } = input;
+                    const body = { tags };
+                    const result = await makeApiRequest('POST', `/conversations/${conversationId}/tags`, body);
+                    return JSON.stringify(result);
                 },
             });
+            tools.push(addTagsTool);
         }
         // List Users Tool
         if (operations.includes('listUsers')) {
-            toolDefinitions.push({
+            const listUsersTool = new tools_1.DynamicStructuredTool({
                 name: 'richpanel_list_users',
                 description: 'Get a list of all support agents/users in Richpanel. Use this when a customer asks to speak with an agent, or to find available support staff.',
-                schema: {
-                    type: 'object',
-                    properties: {},
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    const result = await makeApiRequest('GET', '/users');
+                    return JSON.stringify(result);
                 },
             });
+            tools.push(listUsersTool);
         }
-        // Return tool definitions for AI agent
         return {
-            response: toolDefinitions.map((tool) => ({
-                type: 'function',
-                function: {
-                    name: tool.name,
-                    description: tool.description,
-                    parameters: tool.schema,
-                },
-            })),
+            response: tools,
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-richpanel",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "n8n community node for Richpanel customer support platform - manage conversations, customers, orders, and subscriptions",
   "keywords": [
     "n8n",
@@ -53,13 +53,15 @@
     ]
   },
   "devDependencies": {
+    "@langchain/core": "^0.3.80",
     "@typescript-eslint/parser": "^5.59.0",
     "eslint": "^8.40.0",
     "eslint-plugin-n8n-nodes-base": "^1.12.0",
     "gulp": "^4.0.2",
     "n8n-workflow": "^1.0.0",
     "prettier": "^2.8.8",
-    "typescript": "^5.0.4"
+    "typescript": "^5.0.4",
+    "zod": "^4.3.2"
   },
   "peerDependencies": {
     "n8n-workflow": "*"