n8n-nodes-confirm8 0.15.0 → 0.16.0

package/dist/nodes/Confirm8Tool/Confirm8AgentTool.node.d.ts

@@ -2,8 +2,8 @@ import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription,
 export declare class Confirm8AgentTool implements INodeType {
     description: INodeTypeDescription;
     /**
-     * Tool description for AI Agent
-     * This helps the AI understand when and how to use this tool
+     * Complete tool description for AI Agent
+     * The AI will use this to understand ALL available operations
      */
     getToolDescription(): IDataObject;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;

package/dist/nodes/Confirm8Tool/Confirm8AgentTool.node.js

@@ -10,16 +10,16 @@ class Confirm8AgentTool {
             icon: 'file:tool.svg',
             group: ['transform'],
             version: 1,
-            description: 'AI Agent tool for Confirm8 API - Use to fetch, create, update data from Confirm8',
+            description: 'Autonomous AI Agent tool for Confirm8 API - AI decides everything',
             defaults: {
                 name: 'Confirm8 AI Tool',
             },
-            // IMPORTANT: Makes this node usable as an AI Agent Tool
+            // CRITICAL: Makes this node usable as an AI Agent Tool
             usableAsTool: true,
             inputs: ['main'],
             outputs: ['main'],
             properties: [
-                // API Configuration
+                // ONLY API Configuration - AI decides the rest
                 {
                     displayName: 'Base URL',
                     name: 'baseUrl',
@@ -53,153 +53,82 @@ class Confirm8AgentTool {
                     default: '',
                     required: true,
                 },
-                // Operation Configuration
-                {
-                    displayName: 'Resource',
-                    name: 'resource',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        { name: 'User', value: 'user', description: 'Operations with users/employees' },
-                        { name: 'Client', value: 'client', description: 'Operations with clients/customers' },
-                        { name: 'Item', value: 'item', description: 'Operations with items' },
-                        { name: 'Task', value: 'task', description: 'Operations with tasks/checklists' },
-                        { name: 'Service', value: 'service', description: 'Operations with services' },
-                        { name: 'Product', value: 'product', description: 'Operations with products' },
-                        { name: 'Order', value: 'order', description: 'Operations with work orders' },
-                        { name: 'Ticket', value: 'ticket', description: 'Operations with tickets' },
-                        { name: 'Property', value: 'property', description: 'Operations with properties' },
-                    ],
-                    default: 'user',
-                    description: 'Type of resource to interact with',
-                },
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Get',
-                            value: 'get',
-                            description: 'Fetch a single record by ID'
-                        },
-                        {
-                            name: 'Get All',
-                            value: 'getAll',
-                            description: 'Fetch all records or list records'
-                        },
-                        {
-                            name: 'Create',
-                            value: 'create',
-                            description: 'Create a new record'
-                        },
-                        {
-                            name: 'Update',
-                            value: 'update',
-                            description: 'Update an existing record'
-                        },
-                        {
-                            name: 'Activate',
-                            value: 'activate',
-                            description: 'Activate/enable a record'
-                        },
-                        {
-                            name: 'Deactivate',
-                            value: 'deactivate',
-                            description: 'Deactivate/disable a record'
-                        },
-                    ],
-                    default: 'getAll',
-                    description: 'Operation to perform',
-                },
-                {
-                    displayName: 'Record ID',
-                    name: 'recordId',
-                    type: 'string',
-                    default: '',
-                    displayOptions: {
-                        show: {
-                            operation: ['get', 'update', 'activate', 'deactivate'],
-                        },
-                    },
-                    description: 'ID of the record to fetch or modify',
-                },
-                {
-                    displayName: 'Data (JSON)',
-                    name: 'dataJson',
-                    type: 'json',
-                    default: '{}',
-                    displayOptions: {
-                        show: {
-                            operation: ['create', 'update'],
-                        },
-                    },
-                    description: 'Data to send in the request body as JSON',
-                },
             ],
         };
     }
     /**
-     * Tool description for AI Agent
-     * This helps the AI understand when and how to use this tool
+     * Complete tool description for AI Agent
+     * The AI will use this to understand ALL available operations
      */
     getToolDescription() {
         return {
             name: 'confirm8_api',
-            description: 'Use this tool to interact with the Confirm8 API. ' +
-                'It can fetch, create, update, activate, or deactivate records in the Confirm8 system. ' +
-                'Available resources: users, clients, items, tasks, services, products, orders, tickets, properties. ' +
-                'Use "Get All" to list records, "Get" to fetch a specific record by ID, ' +
-                '"Create" to add new records, "Update" to modify existing records, ' +
-                '"Activate/Deactivate" to enable or disable records.',
+            description: 'Complete Confirm8 API access tool. Use this to interact with the Confirm8 system. ' +
+                'You can fetch, create, update, activate, or deactivate any resource. ' +
+                '\n\n**Available Resources:**\n' +
+                '- user (users/employees)\n' +
+                '- client (clients/customers)\n' +
+                '- item (items/products inventory)\n' +
+                '- itemType (item type categories)\n' +
+                '- task (tasks/checklists)\n' +
+                '- service (services)\n' +
+                '- product (products/insumos)\n' +
+                '- order (work orders/WOS)\n' +
+                '- modality (order modalities)\n' +
+                '- ticket (tickets/occurrences)\n' +
+                '- property (properties)\n' +
+                '\n**Available Operations:**\n' +
+                '- getAll: List all records (no ID needed)\n' +
+                '- get: Get single record (requires recordId)\n' +
+                '- create: Create new record (requires data)\n' +
+                '- update: Update existing record (requires recordId and data)\n' +
+                '- activate: Activate/enable record (requires recordId)\n' +
+                '- deactivate: Deactivate/disable record (requires recordId)\n' +
+                '\n**Special User Operations:**\n' +
+                '- getByUsername: Get user by username (requires username in data)\n' +
+                '- getTickets: Get user tickets (requires recordId)\n' +
+                '- getTasks: Get user tasks (requires recordId)\n' +
+                '- getPermissions: Get user permissions (requires recordId)\n' +
+                '- linkTasks: Link tasks to user (requires data with userId and taskIds)\n' +
+                '- deleteLinkedTasks: Delete all linked tasks\n' +
+                '- deleteLinkedTasksByUser: Delete tasks by user (requires employeeId in data)\n' +
+                '- uploadPhoto: Upload user photo (requires recordId and photo data)\n' +
+                '- uploadSignature: Upload user signature (requires recordId and signature data)\n' +
+                '\n**Examples:**\n' +
+                '- List all users: resource="user", operation="getAll"\n' +
+                '- Get client 123: resource="client", operation="get", recordId="123"\n' +
+                '- Create product: resource="product", operation="create", data={"name":"Product X","price":99.99}\n' +
+                '- Update task: resource="task", operation="update", recordId="456", data={"status":"completed"}\n' +
+                '- Activate user: resource="user", operation="activate", recordId="789"\n' +
+                '- Get user tickets: resource="user", operation="getTickets", recordId="123"',
             properties: [
                 {
                     displayName: 'Resource',
                     name: 'resource',
-                    type: 'options',
+                    type: 'string',
                     required: true,
-                    options: [
-                        { name: 'User', value: 'user' },
-                        { name: 'Client', value: 'client' },
-                        { name: 'Item', value: 'item' },
-                        { name: 'Task', value: 'task' },
-                        { name: 'Service', value: 'service' },
-                        { name: 'Product', value: 'product' },
-                        { name: 'Order', value: 'order' },
-                        { name: 'Ticket', value: 'ticket' },
-                        { name: 'Property', value: 'property' },
-                    ],
-                    description: 'Type of resource: user, client, item, task, service, product, order, ticket, or property',
+                    description: 'Resource type: user, client, item, itemType, task, service, product, order, modality, ticket, or property',
                 },
                 {
                     displayName: 'Operation',
                     name: 'operation',
-                    type: 'options',
+                    type: 'string',
                     required: true,
-                    options: [
-                        { name: 'Get', value: 'get' },
-                        { name: 'Get All', value: 'getAll' },
-                        { name: 'Create', value: 'create' },
-                        { name: 'Update', value: 'update' },
-                        { name: 'Activate', value: 'activate' },
-                        { name: 'Deactivate', value: 'deactivate' },
-                    ],
-                    description: 'Operation: get (single), getAll (list), create, update, activate, deactivate',
+                    description: 'Operation: getAll, get, create, update, activate, deactivate, or special operations (getByUsername, getTickets, getTasks, etc.)',
                 },
                 {
                     displayName: 'Record ID',
                     name: 'recordId',
                     type: 'string',
                     required: false,
-                    description: 'ID of the record (required for get, update, activate, deactivate)',
+                    description: 'ID of the record (required for get, update, activate, deactivate, and some special operations)',
                 },
                 {
                     displayName: 'Data',
-                    name: 'dataJson',
+                    name: 'data',
                     type: 'json',
                     required: false,
-                    description: 'JSON data for create/update operations. Example: {"name":"John","email":"john@example.com"}',
+                    description: 'JSON data for create/update operations or additional parameters. Example: {"name":"John","email":"john@example.com"}',
                 },
             ],
         };
@@ -209,88 +138,167 @@ class Confirm8AgentTool {
         const returnData = [];
         for (let i = 0; i < items.length; i++) {
             try {
-                // Get API configuration
+                // Get API configuration (only thing configured in the UI)
                 const baseUrl = this.getNodeParameter('baseUrl', i);
                 const bearerToken = this.getNodeParameter('bearerToken', i);
                 const apiDomain = this.getNodeParameter('apiDomain', i);
                 const apiKeyToken = this.getNodeParameter('apiKeyToken', i);
-                // Get operation parameters
+                // Get operation parameters from the TOOL CALL (provided by AI)
                 const resource = this.getNodeParameter('resource', i);
                 const operation = this.getNodeParameter('operation', i);
                 const recordId = this.getNodeParameter('recordId', i, '');
-                // Parse data JSON
-                let dataJson = {};
+                // Parse data if provided
+                let data = {};
                 try {
-                    const dataJsonStr = this.getNodeParameter('dataJson', i, '{}');
-                    if (dataJsonStr && dataJsonStr.trim() !== '{}') {
-                        dataJson = JSON.parse(dataJsonStr);
+                    const dataParam = this.getNodeParameter('data', i, '');
+                    if (dataParam) {
+                        if (typeof dataParam === 'string') {
+                            data = JSON.parse(dataParam);
+                        }
+                        else if (typeof dataParam === 'object') {
+                            data = dataParam;
+                        }
                     }
                 }
                 catch (e) {
                     // Data is optional
                 }
-                // Map resource to endpoint
+                // Map resource to API endpoint
                 const resourceMap = {
                     user: 'users',
                     client: 'clients',
                     item: 'items',
+                    itemType: 'itemTypes',
                     task: 'tasks',
                     service: 'services',
                     product: 'products',
                     order: 'wos',
+                    modality: 'modalities',
                     ticket: 'tickets',
                     property: 'properties',
                 };
-                const endpoint = resourceMap[resource] || resource;
-                let url = '';
+                const baseEndpoint = resourceMap[resource] || resource;
+                let endpoint = '';
                 let method = 'GET';
                 let body = {};
                 // Build request based on operation
                 switch (operation) {
                     case 'getAll':
-                        url = `${baseUrl}/${endpoint}`;
+                        endpoint = `/${baseEndpoint}`;
                         method = 'GET';
                         break;
                     case 'get':
                         if (!recordId) {
-                            throw new Error('Record ID is required for Get operation');
+                            throw new Error('recordId is required for get operation');
                         }
-                        url = `${baseUrl}/${endpoint}/${recordId}`;
+                        endpoint = `/${baseEndpoint}/${recordId}`;
                         method = 'GET';
                         break;
                     case 'create':
-                        url = `${baseUrl}/${endpoint}`;
+                        endpoint = `/${baseEndpoint}`;
                         method = 'POST';
-                        body = dataJson;
+                        body = data;
                         break;
                     case 'update':
                         if (!recordId) {
-                            throw new Error('Record ID is required for Update operation');
+                            throw new Error('recordId is required for update operation');
                         }
-                        url = `${baseUrl}/${endpoint}/${recordId}`;
+                        endpoint = `/${baseEndpoint}/${recordId}`;
                         method = 'PUT';
-                        body = dataJson;
+                        body = data;
                         break;
                     case 'activate':
                         if (!recordId) {
-                            throw new Error('Record ID is required for Activate operation');
+                            throw new Error('recordId is required for activate operation');
+                        }
+                        endpoint = `/${baseEndpoint}/${recordId}/active`;
+                        // Different resources use different methods
+                        if (['client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality'].includes(resource)) {
+                            method = 'PUT';
+                        }
+                        else {
+                            method = 'PATCH';
                         }
-                        url = `${baseUrl}/${endpoint}/${recordId}/active`;
-                        method = resource === 'client' || resource === 'item' || resource === 'task' ||
-                            resource === 'service' || resource === 'product' || resource === 'order' ? 'PUT' : 'PATCH';
                         break;
                     case 'deactivate':
                         if (!recordId) {
-                            throw new Error('Record ID is required for Deactivate operation');
+                            throw new Error('recordId is required for deactivate operation');
+                        }
+                        endpoint = `/${baseEndpoint}/${recordId}/inactive`;
+                        // Different resources use different methods
+                        if (['client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality'].includes(resource)) {
+                            method = 'PUT';
+                        }
+                        else {
+                            method = 'PATCH';
+                        }
+                        break;
+                    // Special User Operations
+                    case 'getByUsername':
+                        if (!data.username) {
+                            throw new Error('username is required in data for getByUsername operation');
+                        }
+                        endpoint = `/users/${data.username}/user`;
+                        method = 'GET';
+                        break;
+                    case 'getTickets':
+                        if (!recordId) {
+                            throw new Error('recordId is required for getTickets operation');
+                        }
+                        endpoint = `/users/${recordId}/tickets`;
+                        method = 'GET';
+                        break;
+                    case 'getTasks':
+                        if (!recordId) {
+                            throw new Error('recordId is required for getTasks operation');
+                        }
+                        endpoint = `/users/${recordId}/tasks`;
+                        method = 'GET';
+                        break;
+                    case 'getPermissions':
+                        if (!recordId) {
+                            throw new Error('recordId is required for getPermissions operation');
+                        }
+                        endpoint = `/users/${recordId}/permissions`;
+                        method = 'GET';
+                        break;
+                    case 'linkTasks':
+                        endpoint = '/users/tasks';
+                        method = 'POST';
+                        body = data;
+                        break;
+                    case 'deleteLinkedTasks':
+                        endpoint = '/users/tasks';
+                        method = 'DELETE';
+                        break;
+                    case 'deleteLinkedTasksByUser':
+                        if (!data.employeeId) {
+                            throw new Error('employeeId is required in data for deleteLinkedTasksByUser operation');
+                        }
+                        endpoint = `/users/tasks/${data.employeeId}`;
+                        method = 'DELETE';
+                        break;
+                    case 'uploadPhoto':
+                        if (!recordId) {
+                            throw new Error('recordId is required for uploadPhoto operation');
+                        }
+                        endpoint = `/users/${recordId}/photos`;
+                        method = 'PATCH';
+                        body = data;
+                        break;
+                    case 'uploadSignature':
+                        if (!recordId) {
+                            throw new Error('recordId is required for uploadSignature operation');
                         }
-                        url = `${baseUrl}/${endpoint}/${recordId}/inactive`;
-                        method = resource === 'client' || resource === 'item' || resource === 'task' ||
-                            resource === 'service' || resource === 'product' || resource === 'order' ? 'PUT' : 'PATCH';
+                        endpoint = `/users/${recordId}/signatures`;
+                        method = 'PATCH';
+                        body = data;
                         break;
                     default:
                         throw new Error(`Unknown operation: ${operation}`);
                 }
                 // Make HTTP request
+                const url = `${baseUrl}${endpoint}`;
                 const options = {
                     method,
                     uri: url,
@@ -311,6 +319,7 @@ class Confirm8AgentTool {
                         success: true,
                         operation,
                         resource,
+                        endpoint,
                         data: responseData,
                     },
                     pairedItem: { item: i },
@@ -322,6 +331,8 @@ class Confirm8AgentTool {
                         json: {
                             success: false,
                             error: error || 'Unknown error',
+                            resource: this.getNodeParameter('resource', i, ''),
+                            operation: this.getNodeParameter('operation', i, ''),
                         },
                         pairedItem: { item: i },
                     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-confirm8",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Simple n8n node for Confirm8 API - no credentials needed",
   "license": "MIT",
   "author": "Bill Hebert",