n8n-nodes-confirm8 0.31.0 → 0.45.0

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

@@ -1,10 +1,9 @@
-import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, IDataObject } from 'n8n-workflow';
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
 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
+     * Parse natural date queries into filter JSON
      */
-    getToolDescription(): IDataObject;
+    private parseDateQuery;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

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

@@ -10,11 +10,10 @@ 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: 'AI tool for Confirm8. IMPORTANT: For "OS/ordem de serviço" use resource="order". For dates use filters with start_date/end_date. Example: {"start_date":{"gte":"2025-11-23"},"end_date":{"lte":"2025-11-25"}}',
             defaults: {
                 name: 'Confirm8 AI Tool',
             },
-            // IMPORTANT: Makes this node usable as an AI Agent Tool
             usableAsTool: true,
             inputs: ['main'],
             outputs: ['main'],
@@ -27,7 +26,6 @@ class Confirm8AgentTool {
                     default: '',
                     placeholder: 'https://api.confirm8.com',
                     required: true,
-                    description: 'Base URL of Confirm8 API',
                 },
                 {
                     displayName: 'Bearer Token',
@@ -36,7 +34,6 @@ class Confirm8AgentTool {
                     typeOptions: { password: true },
                     default: '',
                     required: true,
-                    description: 'Authentication token',
                 },
                 {
                     displayName: 'X-API-DOMAIN',
@@ -53,247 +50,379 @@ class Confirm8AgentTool {
                     default: '',
                     required: true,
                 },
-                // Operation Configuration
+                // Tool parameters
                 {
                     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' },
+                        { name: 'User', value: 'user', description: 'Users/Employees/Funcionários' },
+                        { name: 'Client', value: 'client', description: 'Clients/Customers/Clientes' },
+                        { name: 'Item', value: 'item', description: 'Items/Itens' },
+                        { name: 'Item Type', value: 'itemType', description: 'Item Types/Tipos' },
+                        { name: 'Task', value: 'task', description: 'Tasks/Tarefas/Checklists' },
+                        { name: 'Service', value: 'service', description: 'Services/Serviços' },
+                        { name: 'Product', value: 'product', description: 'Products/Produtos' },
+                        { name: 'Order (OS)', value: 'order', description: 'Work Orders/OS/Ordens de Serviço/WOS' },
+                        { name: 'Modality', value: 'modality', description: 'Modalities/Modalidades' },
+                        { name: 'Ticket', value: 'ticket', description: 'Tickets/Chamados' },
+                        { name: 'Property', value: 'property', description: 'Properties/Propriedades' },
                     ],
                     default: 'user',
-                    description: 'Type of resource to interact with',
+                    description: 'CRITICAL: For "OS" or "ordem de serviço" ALWAYS use "order"',
                 },
                 {
                     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'
-                        },
+                        { name: 'Get All (List)', value: 'getAll', description: 'List/Listar/Buscar todos/Mostrar todos' },
+                        { name: 'Get (Single)', value: 'get', description: 'Get one/Buscar um/Obter' },
+                        { name: 'Create', value: 'create', description: 'Create/Criar/Adicionar' },
+                        { name: 'Update', value: 'update', description: 'Update/Atualizar/Modificar' },
+                        { name: 'Activate', value: 'activate', description: 'Activate/Ativar' },
+                        { name: 'Deactivate', value: 'deactivate', description: 'Deactivate/Desativar' },
                     ],
                     default: 'getAll',
-                    description: 'Operation to perform',
+                    description: 'CRITICAL: To list/search use "getAll"',
                 },
                 {
                     displayName: 'Record ID',
                     name: 'recordId',
                     type: 'string',
                     default: '',
-                    displayOptions: {
-                        show: {
-                            operation: ['get', 'update', 'activate', 'deactivate'],
-                        },
-                    },
-                    description: 'ID of the record to fetch or modify',
+                    description: 'Record ID (only for get/update/activate/deactivate)',
                 },
                 {
-                    displayName: 'Data (JSON)',
-                    name: 'dataJson',
-                    type: 'json',
-                    default: '{}',
-                    displayOptions: {
-                        show: {
-                            operation: ['create', 'update'],
-                        },
-                    },
-                    description: 'Data to send in the request body as JSON',
+                    displayName: 'Data',
+                    name: 'data',
+                    type: 'string',
+                    default: '',
+                    description: 'JSON data (only for create/update)',
+                },
+                {
+                    displayName: 'Filters',
+                    name: 'filters',
+                    type: 'string',
+                    default: '',
+                    description: 'Filters as JSON. For dates: {"start_date":{"gte":"YYYY-MM-DD"},"end_date":{"lte":"YYYY-MM-DD"}}. For status: {"status":{"eq":"complete"}}',
                 },
             ],
         };
     }
     /**
-     * Tool description for AI Agent
-     * This helps the AI understand when and how to use this tool
+     * Parse natural date queries into filter JSON
      */
-    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.',
-            properties: [
-                {
-                    displayName: 'Resource',
-                    name: 'resource',
-                    type: 'options',
-                    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',
-                },
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    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',
-                },
-                {
-                    displayName: 'Record ID',
-                    name: 'recordId',
-                    type: 'string',
-                    required: false,
-                    description: 'ID of the record (required for get, update, activate, deactivate)',
-                },
-                {
-                    displayName: 'Data',
-                    name: 'dataJson',
-                    type: 'json',
-                    required: false,
-                    description: 'JSON data for create/update operations. Example: {"name":"John","email":"john@example.com"}',
-                },
-            ],
+    parseDateQuery(query) {
+        const now = new Date();
+        const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        query = query.toLowerCase().trim();
+        // Helper to format date as YYYY-MM-DD
+        const formatDate = (date) => {
+            return date.toISOString().split('T')[0];
         };
+        // Today
+        if (query.includes('hoje') || query.includes('today')) {
+            const endOfDay = new Date(today);
+            endOfDay.setHours(23, 59, 59, 999);
+            return {
+                start_date: { gte: formatDate(today) },
+                end_date: { lte: formatDate(endOfDay) }
+            };
+        }
+        // This week / semana atual
+        if (query.includes('semana') || query.includes('week')) {
+            const dayOfWeek = today.getDay();
+            const diff = dayOfWeek === 0 ? -6 : 1 - dayOfWeek; // Monday is start
+            const weekStart = new Date(today);
+            weekStart.setDate(today.getDate() + diff);
+            const weekEnd = new Date(weekStart);
+            weekEnd.setDate(weekStart.getDate() + 6);
+            return {
+                start_date: { gte: formatDate(weekStart) },
+                end_date: { lte: formatDate(weekEnd) }
+            };
+        }
+        // This month / mês atual
+        if (query.includes('mês') || query.includes('mes') || query.includes('month')) {
+            const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+            const monthEnd = new Date(now.getFullYear(), now.getMonth() + 1, 0);
+            return {
+                start_date: { gte: formatDate(monthStart) },
+                end_date: { lte: formatDate(monthEnd) }
+            };
+        }
+        // Last N days
+        const lastDaysMatch = query.match(/últimos?\s+(\d+)\s+dias?|last\s+(\d+)\s+days?/);
+        if (lastDaysMatch) {
+            const days = parseInt(lastDaysMatch[1] || lastDaysMatch[2]);
+            const startDate = new Date(today);
+            startDate.setDate(today.getDate() - days);
+            return {
+                start_date: { gte: formatDate(startDate) },
+                end_date: { lte: formatDate(today) }
+            };
+        }
+        // Next N days
+        const nextDaysMatch = query.match(/próximos?\s+(\d+)\s+dias?|next\s+(\d+)\s+days?/);
+        if (nextDaysMatch) {
+            const days = parseInt(nextDaysMatch[1] || nextDaysMatch[2]);
+            const endDate = new Date(today);
+            endDate.setDate(today.getDate() + days);
+            return {
+                start_date: { gte: formatDate(today) },
+                end_date: { lte: formatDate(endDate) }
+            };
+        }
+        return null;
     }
     async execute() {
         const items = this.getInputData();
         const returnData = [];
         for (let i = 0; i < items.length; i++) {
             try {
-                // Get API configuration
                 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
-                const resource = this.getNodeParameter('resource', i);
-                const operation = this.getNodeParameter('operation', i);
+                let resource = this.getNodeParameter('resource', i, '');
+                let operation = this.getNodeParameter('operation', i, '');
                 const recordId = this.getNodeParameter('recordId', i, '');
-                // Parse data JSON
-                let dataJson = {};
-                try {
-                    const dataJsonStr = this.getNodeParameter('dataJson', i, '{}');
-                    if (dataJsonStr && dataJsonStr.trim() !== '{}') {
-                        dataJson = JSON.parse(dataJsonStr);
+                // Parse data
+                let data = {};
+                const dataParam = this.getNodeParameter('data', i, '');
+                if (dataParam) {
+                    try {
+                        data = JSON.parse(dataParam);
+                    }
+                    catch (e) {
+                        // Ignore
                     }
                 }
-                catch (e) {
-                    // Data is optional
+                // Parse filters
+                let filters = {};
+                const filtersParam = this.getNodeParameter('filters', i, '');
+                if (filtersParam) {
+                    try {
+                        // Try to parse as JSON first
+                        filters = JSON.parse(filtersParam);
+                    }
+                    catch (e) {
+                        // If not JSON, try to parse as natural language date query
+                        const parsedDate = this.parseDateQuery(filtersParam);
+                        if (parsedDate) {
+                            filters = parsedDate;
+                        }
+                    }
                 }
-                // Map resource to endpoint
+                // Aggressive normalization - EXPAND THIS
                 const resourceMap = {
-                    user: 'users',
-                    client: 'clients',
-                    item: 'items',
-                    task: 'tasks',
-                    service: 'services',
-                    product: 'products',
-                    order: 'wos',
-                    ticket: 'tickets',
-                    property: 'properties',
+                    // Standard
+                    'users': 'user', 'usuarios': 'user', 'usuários': 'user', 'employees': 'user', 'funcionários': 'user', 'funcionarios': 'user',
+                    'clients': 'client', 'clientes': 'client', 'customers': 'client',
+                    'items': 'item', 'itens': 'item',
+                    'itemtypes': 'itemType', 'tipos': 'itemType',
+                    'tasks': 'task', 'tarefas': 'task',
+                    'services': 'service', 'serviços': 'service', 'servicos': 'service',
+                    'products': 'product', 'produtos': 'product',
+                    'modalities': 'modality', 'modalidades': 'modality',
+                    'tickets': 'ticket', 'chamados': 'ticket',
+                    'properties': 'property', 'propriedades': 'property',
+                    // CRITICAL: OS mappings
+                    'os': 'order',
+                    'o.s': 'order',
+                    'o.s.': 'order',
+                    'orders': 'order',
+                    'ordens': 'order',
+                    'ordem': 'order',
+                    'ordem de serviço': 'order',
+                    'ordem de servico': 'order',
+                    'ordens de serviço': 'order',
+                    'ordens de servico': 'order',
+                    'wos': 'order',
+                    'work order': 'order',
+                    'work orders': 'order',
+                    'pedidos': 'order',
+                    'pedido': 'order',
+                };
+                const operationMap = {
+                    // List/Get All
+                    'list': 'getAll',
+                    'listar': 'getAll',
+                    'mostrar': 'getAll',
+                    'buscar': 'getAll',
+                    'busque': 'getAll',
+                    'buscar todos': 'getAll',
+                    'buscar todas': 'getAll',
+                    'buscar todo': 'getAll',
+                    'buscar toda': 'getAll',
+                    'get all': 'getAll',
+                    'show all': 'getAll',
+                    'list all': 'getAll',
+                    'todos': 'getAll',
+                    'todas': 'getAll',
+                    'obter todos': 'getAll',
+                    'obter todas': 'getAll',
+                    'pegar todos': 'getAll',
+                    'pegar todas': 'getAll',
+                    // Get Single
+                    'obter': 'get',
+                    'pegar': 'get',
+                    'ver': 'get',
+                    'visualizar': 'get',
+                    // Create
+                    'criar': 'create',
+                    'adicionar': 'create',
+                    'add': 'create',
+                    'novo': 'create',
+                    'nova': 'create',
+                    'new': 'create',
+                    // Update
+                    'atualizar': 'update',
+                    'modificar': 'update',
+                    'modify': 'update',
+                    'editar': 'update',
+                    'edit': 'update',
+                    // Activate/Deactivate
+                    'ativar': 'activate',
+                    'enable': 'activate',
+                    'habilitar': 'activate',
+                    'desativar': 'deactivate',
+                    'disable': 'deactivate',
+                    'desabilitar': 'deactivate',
+                };
+                // Normalize - clean and map
+                const cleanResource = resource.toLowerCase().trim().replace(/\s+/g, ' ');
+                const cleanOperation = operation.toLowerCase().trim().replace(/\s+/g, ' ');
+                resource = resourceMap[cleanResource] || resource;
+                operation = operationMap[cleanOperation] || operation;
+                // If still not valid, throw clear error
+                const validResources = ['user', 'client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality', 'ticket', 'property'];
+                const validOperations = ['getAll', 'get', 'create', 'update', 'activate', 'deactivate'];
+                if (!validResources.includes(resource)) {
+                    throw new Error(`Invalid resource: "${resource}". Must be one of: ${validResources.join(', ')}. ` +
+                        `For OS/Ordem de Serviço use "order".`);
+                }
+                if (!validOperations.includes(operation)) {
+                    throw new Error(`Invalid operation: "${operation}". Must be one of: ${validOperations.join(', ')}. ` +
+                        `To list/search use "getAll".`);
+                }
+                // Resource config with relations
+                const resourceConfig = {
+                    user: {
+                        endpoint: 'users',
+                        relations: ['clients', 'attachments', 'permissions', 'device', 'employee']
+                    },
+                    client: {
+                        endpoint: 'clients',
+                        relations: ['wos', 'items', 'employees', 'headquarter', 'files', 'userGroup', 'properties']
+                    },
+                    item: {
+                        endpoint: 'items',
+                        relations: ['client', 'item_type', 'properties', 'parent', 'children', 'collects', 'wos']
+                    },
+                    itemType: {
+                        endpoint: 'itemTypes',
+                        relations: ['properties']
+                    },
+                    task: {
+                        endpoint: 'tasks',
+                        relations: ['itemType', 'activities', 'wos', 'modalities']
+                    },
+                    service: {
+                        endpoint: 'services',
+                        relations: ['task']
+                    },
+                    product: {
+                        endpoint: 'products',
+                        relations: []
+                    },
+                    order: {
+                        endpoint: 'wos',
+                        relations: ['client', 'modalities', 'tasks', 'pivot_tasks', 'products', 'users', 'items', 'tickets', 'services', 'collects', 'attachments']
+                    },
+                    modality: {
+                        endpoint: 'modalities',
+                        relations: ['tasks']
+                    },
+                    ticket: {
+                        endpoint: 'tickets',
+                        relations: ['client', 'subject_category', 'category', 'status', 'attachments', 'item', 'owner', 'priority', 'users', 'orders', 'properties']
+                    },
+                    property: {
+                        endpoint: 'properties',
+                        relations: []
+                    },
                 };
-                const endpoint = resourceMap[resource] || resource;
-                let url = '';
+                const config = resourceConfig[resource];
+                const baseEndpoint = config.endpoint;
+                let endpoint = '';
                 let method = 'GET';
                 let body = {};
-                // Build request based on operation
+                // Build endpoint
                 switch (operation) {
                     case 'getAll':
-                        url = `${baseUrl}/${endpoint}`;
-                        method = 'GET';
+                        endpoint = `/v3/${baseEndpoint}`;
                         break;
                     case 'get':
-                        if (!recordId) {
-                            throw new Error('Record ID is required for Get operation');
-                        }
-                        url = `${baseUrl}/${endpoint}/${recordId}`;
-                        method = 'GET';
+                        if (!recordId)
+                            throw new Error('recordId required');
+                        endpoint = `/v3/${baseEndpoint}/${recordId}`;
                         break;
                     case 'create':
-                        url = `${baseUrl}/${endpoint}`;
+                        endpoint = `/v3/${baseEndpoint}`;
                         method = 'POST';
-                        body = dataJson;
+                        body = data;
                         break;
                     case 'update':
-                        if (!recordId) {
-                            throw new Error('Record ID is required for Update operation');
-                        }
-                        url = `${baseUrl}/${endpoint}/${recordId}`;
+                        if (!recordId)
+                            throw new Error('recordId required');
+                        endpoint = `/v3/${baseEndpoint}/${recordId}`;
                         method = 'PUT';
-                        body = dataJson;
+                        body = data;
                         break;
                     case 'activate':
-                        if (!recordId) {
-                            throw new Error('Record ID is required for Activate operation');
-                        }
-                        url = `${baseUrl}/${endpoint}/${recordId}/active`;
-                        method = resource === 'client' || resource === 'item' || resource === 'task' ||
-                            resource === 'service' || resource === 'product' || resource === 'order' ? 'PUT' : 'PATCH';
+                        if (!recordId)
+                            throw new Error('recordId required');
+                        endpoint = `/v3/${baseEndpoint}/${recordId}/active`;
+                        method = ['client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality'].includes(resource)
+                            ? 'PUT' : 'PATCH';
                         break;
                     case 'deactivate':
-                        if (!recordId) {
-                            throw new Error('Record ID is required for Deactivate operation');
-                        }
-                        url = `${baseUrl}/${endpoint}/${recordId}/inactive`;
-                        method = resource === 'client' || resource === 'item' || resource === 'task' ||
-                            resource === 'service' || resource === 'product' || resource === 'order' ? 'PUT' : 'PATCH';
+                        if (!recordId)
+                            throw new Error('recordId required');
+                        endpoint = `/v3/${baseEndpoint}/${recordId}/inactive`;
+                        method = ['client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality'].includes(resource)
+                            ? 'PUT' : 'PATCH';
                         break;
-                    default:
-                        throw new Error(`Unknown operation: ${operation}`);
                 }
-                // Make HTTP request
+                // Build query string
+                const queryParams = [];
+                // Add relations (only GET)
+                if (method === 'GET' && config.relations.length > 0) {
+                    config.relations.forEach(relation => {
+                        queryParams.push(`relations=${relation}`);
+                    });
+                }
+                // Add filters
+                if (Object.keys(filters).length > 0) {
+                    Object.keys(filters).forEach(field => {
+                        const operators = filters[field];
+                        Object.keys(operators).forEach(operator => {
+                            const value = operators[operator];
+                            queryParams.push(`filters[${field}][${operator}]=${encodeURIComponent(String(value))}`);
+                        });
+                    });
+                }
+                // Full URL
+                let fullUrl = `${baseUrl}${endpoint}`;
+                if (queryParams.length > 0) {
+                    fullUrl += '?' + queryParams.join('&');
+                }
+                // Make request
                 const options = {
                     method,
-                    uri: url,
+                    uri: fullUrl,
                     headers: {
                         'Authorization': `Bearer ${bearerToken}`,
                         'X-API-DOMAIN': apiDomain,
@@ -309,8 +438,19 @@ class Confirm8AgentTool {
                 returnData.push({
                     json: {
                         success: true,
+                        normalized: {
+                            originalResource: this.getNodeParameter('resource', i, ''),
+                            originalOperation: this.getNodeParameter('operation', i, ''),
+                            normalizedResource: resource,
+                            normalizedOperation: operation,
+                        },
                         operation,
                         resource,
+                        endpoint,
+                        fullUrl,
+                        relations: config.relations,
+                        filters: filters,
+                        method,
                         data: responseData,
                     },
                     pairedItem: { item: i },
@@ -321,7 +461,7 @@ class Confirm8AgentTool {
                     returnData.push({
                         json: {
                             success: false,
-                            error: error || 'Unknown error',
+                            error: error.message || 'Unknown error',
                         },
                         pairedItem: { item: i },
                     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-confirm8",
-  "version": "0.31.0",
+  "version": "0.45.0",
   "description": "Simple n8n node for Confirm8 API - no credentials needed",
   "license": "MIT",
   "author": "Bill Hebert",
@@ -21,8 +21,7 @@
   },
   "n8n": {
     "nodes": [
-      "dist/nodes/Confirm8/ApiConfirm8.node.js",
-      "dist/nodes/Confirm8Tool/Confirm8AgentTool.node.js"
+      "dist/nodes/Confirm8/ApiConfirm8.node.js"
     ]
   },
   "peerDependencies": {