n8n-nodes-confirm8 0.29.0 → 0.30.0

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

@@ -1,51 +1,10 @@
-import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, IDataObject, NodeOperationError } from "n8n-workflow";
-/**
- * =========================
- * Confirm8 Utils (merged)
- * =========================
- */
-export declare const VALID_RESOURCES: readonly ["user", "client", "item", "itemType", "task", "service", "product", "order", "modality", "ticket", "property"];
-export declare const VALID_OPERATIONS: readonly ["getAll", "get", "create", "update", "activate", "deactivate"];
-export type Confirm8Resource = (typeof VALID_RESOURCES)[number];
-export type Confirm8Operation = (typeof VALID_OPERATIONS)[number];
-export declare const RESOURCE_ENDPOINTS: Record<Confirm8Resource, {
-    endpoint: string;
-    relations: string[];
-}>;
-export declare function assertIsoDate(dateStr: string, label: string): void;
-export declare function formatIsoDate(d: Date): string;
-/**
- * Week starts on Monday (pt-BR business default).
- * Returns inclusive start/end in YYYY-MM-DD.
- */
-export declare function getThisWeekRange(now?: Date): {
-    start: string;
-    end: string;
-};
-/** Build query params for relations + filters in Confirm8 format. */
-export declare function buildQueryParams(relations: string[], filters?: IDataObject): string;
-export declare function confirm8Request(this: IExecuteFunctions, i: number, args: {
-    baseUrl: string;
-    bearerToken: string;
-    apiDomain: string;
-    apiKeyToken: string;
-    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-    endpoint: string;
-    query?: string;
-    body?: IDataObject;
-}): Promise<any>;
-export declare function toNodeError(node: any, err: unknown, i: number): NodeOperationError;
-/**
- * =========================
- * Confirm8 OS Tool (merged)
- * =========================
- *
- * CHUMBED:
- * - resource is ALWAYS "order"
- * - operation is ALWAYS "getAll" OR "get" (derived only from presence of recordId)
- * - dates are ALWAYS ISO YYYY-MM-DD (validated / computed here)
- */
-export declare class Confirm8OSTool implements INodeType {
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, IDataObject } from 'n8n-workflow';
+export declare class Confirm8AgentTool implements INodeType {
     description: INodeTypeDescription;
+    /**
+     * 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

@@ -1,288 +1,134 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Confirm8OSTool = exports.RESOURCE_ENDPOINTS = exports.VALID_OPERATIONS = exports.VALID_RESOURCES = void 0;
-exports.assertIsoDate = assertIsoDate;
-exports.formatIsoDate = formatIsoDate;
-exports.getThisWeekRange = getThisWeekRange;
-exports.buildQueryParams = buildQueryParams;
-exports.confirm8Request = confirm8Request;
-exports.toNodeError = toNodeError;
+exports.Confirm8AgentTool = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-/**
- * =========================
- * Confirm8 Utils (merged)
- * =========================
- */
-exports.VALID_RESOURCES = [
-    "user",
-    "client",
-    "item",
-    "itemType",
-    "task",
-    "service",
-    "product",
-    "order",
-    "modality",
-    "ticket",
-    "property",
-];
-exports.VALID_OPERATIONS = [
-    "getAll",
-    "get",
-    "create",
-    "update",
-    "activate",
-    "deactivate",
-];
-exports.RESOURCE_ENDPOINTS = {
-    user: {
-        endpoint: "users",
-        relations: ["clients", "attachments", "permissions", "device", "employee"],
-    },
-    client: {
-        endpoint: "clients",
-        relations: [
-            "address",
-            "contacts",
-            "items",
-            "tickets",
-            "orders",
-            "properties",
-            "attachments",
-        ],
-    },
-    item: {
-        endpoint: "items",
-        relations: ["client", "itemType", "properties", "attachments"],
-    },
-    itemType: { endpoint: "item-types", relations: ["properties"] },
-    task: {
-        endpoint: "tasks",
-        relations: ["itemType", "modality", "services", "products"],
-    },
-    service: { endpoint: "services", relations: ["task"] },
-    product: { endpoint: "products", relations: [] },
-    // IMPORTANT: Confirm8 Work Orders endpoint is 'wos'
-    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", "user", "attachments"],
-    },
-    property: { endpoint: "properties", relations: ["client", "item", "itemType"] },
-};
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
-function assertIsoDate(dateStr, label) {
-    if (!ISO_DATE.test(dateStr)) {
-        throw new Error(`${label} must be in YYYY-MM-DD format. Received: "${dateStr}"`);
-    }
-}
-function formatIsoDate(d) {
-    const y = d.getFullYear();
-    const m = String(d.getMonth() + 1).padStart(2, "0");
-    const day = String(d.getDate()).padStart(2, "0");
-    return `${y}-${m}-${day}`;
-}
-/**
- * Week starts on Monday (pt-BR business default).
- * Returns inclusive start/end in YYYY-MM-DD.
- */
-function getThisWeekRange(now = new Date()) {
-    const d = new Date(now);
-    d.setHours(0, 0, 0, 0);
-    // JS: Sunday=0 ... Saturday=6
-    const day = d.getDay();
-    const diffToMonday = day === 0 ? -6 : 1 - day; // if Sunday -> go back 6 days
-    const startDate = new Date(d);
-    startDate.setDate(d.getDate() + diffToMonday);
-    const endDate = new Date(startDate);
-    endDate.setDate(startDate.getDate() + 6);
-    return { start: formatIsoDate(startDate), end: formatIsoDate(endDate) };
-}
-/** Build query params for relations + filters in Confirm8 format. */
-function buildQueryParams(relations, filters) {
-    const queryParams = [];
-    if (relations?.length) {
-        for (const rel of relations)
-            queryParams.push(`relations=${encodeURIComponent(rel)}`);
-    }
-    if (filters && Object.keys(filters).length) {
-        for (const field of Object.keys(filters)) {
-            const operators = filters[field];
-            for (const op of Object.keys(operators)) {
-                const value = operators[op];
-                queryParams.push(`filters[${encodeURIComponent(field)}][${encodeURIComponent(op)}]=${encodeURIComponent(String(value))}`);
-            }
-        }
-    }
-    return queryParams.length ? `?${queryParams.join("&")}` : "";
-}
-function confirm8Request(i, args) {
-    const { baseUrl, bearerToken, apiDomain, apiKeyToken, method, endpoint, query, body, } = args;
-    const uri = `${baseUrl}${endpoint}${query ?? ""}`;
-    const options = {
-        method,
-        uri,
-        headers: {
-            Authorization: `Bearer ${bearerToken}`,
-            "X-API-DOMAIN": apiDomain,
-            "X-APIKEY-TOKEN": apiKeyToken,
-            "Content-Type": "application/json",
-        },
-        json: true,
-    };
-    if (body && method !== "GET" && method !== "DELETE") {
-        options.body = body;
-    }
-    return this.helpers.request(options);
-}
-function toNodeError(node, err, i) {
-    if (err instanceof n8n_workflow_1.NodeOperationError)
-        return err;
-    const message = err instanceof Error ? err.message : String(err);
-    return new n8n_workflow_1.NodeOperationError(node, message, { itemIndex: i });
-}
-/**
- * =========================
- * Confirm8 OS Tool (merged)
- * =========================
- *
- * CHUMBED:
- * - resource is ALWAYS "order"
- * - operation is ALWAYS "getAll" OR "get" (derived only from presence of recordId)
- * - dates are ALWAYS ISO YYYY-MM-DD (validated / computed here)
- */
-class Confirm8OSTool {
+class Confirm8AgentTool {
     constructor() {
         this.description = {
-            displayName: "Confirm8 OS (Chumbed AI Tool)",
-            name: "confirm8OsTool",
-            group: ["transform"],
+            displayName: 'Confirm8 AI Tool',
+            name: 'confirm8AgentTool',
+            icon: 'file:tool.svg',
+            group: ['transform'],
             version: 1,
-            description: "Work Orders (OS) tool for Confirm8. CHUMBED: resource/order is fixed; operation is derived internally (getAll vs get). Dates are always ISO YYYY-MM-DD.",
-            defaults: { name: "Confirm8 OS" },
-            inputs: ["main"],
-            outputs: ["main"],
+            description: 'Autonomous AI Agent tool for Confirm8 API - AI decides everything',
+            defaults: {
+                name: 'Confirm8 AI Tool',
+            },
+            // CRITICAL: Makes this node usable as an AI Agent Tool
+            usableAsTool: true,
+            inputs: ['main'],
+            outputs: ['main'],
             properties: [
+                // ONLY API Configuration - AI decides the rest
                 {
-                    displayName: "Base URL",
-                    name: "baseUrl",
-                    type: "string",
-                    default: "",
-                    placeholder: "https://api.confirm8.com",
+                    displayName: 'Base URL',
+                    name: 'baseUrl',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'https://api.confirm8.com',
                     required: true,
+                    description: 'Base URL of Confirm8 API',
                 },
                 {
-                    displayName: "Bearer Token",
-                    name: "bearerToken",
-                    type: "string",
+                    displayName: 'Bearer Token',
+                    name: 'bearerToken',
+                    type: 'string',
                     typeOptions: { password: true },
-                    default: "",
+                    default: '',
                     required: true,
+                    description: 'Authentication token',
                 },
                 {
-                    displayName: "API Domain",
-                    name: "apiDomain",
-                    type: "string",
-                    default: "",
+                    displayName: 'X-API-DOMAIN',
+                    name: 'apiDomain',
+                    type: 'string',
+                    default: '',
                     required: true,
                 },
                 {
-                    displayName: "API Key Token",
-                    name: "apiKeyToken",
-                    type: "string",
+                    displayName: 'X-APIKEY-TOKEN',
+                    name: 'apiKeyToken',
+                    type: 'string',
                     typeOptions: { password: true },
-                    default: "",
+                    default: '',
                     required: true,
                 },
+            ],
+        };
+    }
+    /**
+     * Complete tool description for AI Agent
+     * The AI will use this to understand ALL available operations
+     */
+    getToolDescription() {
+        return {
+            name: 'confirm8_api',
+            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: "Session ID",
-                    name: "sessionId",
-                    type: "string",
-                    default: "",
-                },
-                {
-                    displayName: "User Query (Optional)",
-                    name: "chatinput",
-                    type: "string",
-                    default: "",
-                },
-                // If filled, tool performs GET by ID; otherwise, GET ALL (list)
-                {
-                    displayName: "OS ID (recordId)",
-                    name: "recordId",
-                    type: "string",
-                    default: "",
-                    description: "If provided, fetches a single OS (get). If empty, lists OS (getAll).",
-                },
-                // Listing options (only relevant when recordId is empty)
-                {
-                    displayName: "Date Range",
-                    name: "dateRange",
-                    type: "options",
-                    default: "thisWeek",
-                    displayOptions: { show: { recordId: [""] } },
-                    options: [
-                        { name: "This week (Mon..Sun)", value: "thisWeek" },
-                        { name: "Custom", value: "custom" },
-                    ],
-                },
-                {
-                    displayName: "Start Date (YYYY-MM-DD)",
-                    name: "startDate",
-                    type: "string",
-                    default: "",
-                    displayOptions: { show: { dateRange: ["custom"], recordId: [""] } },
-                },
-                {
-                    displayName: "End Date (YYYY-MM-DD)",
-                    name: "endDate",
-                    type: "string",
-                    default: "",
-                    displayOptions: { show: { dateRange: ["custom"], recordId: [""] } },
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'string',
+                    required: true,
+                    description: 'Resource type: user, client, item, itemType, task, service, product, order, modality, ticket, or property',
                 },
                 {
-                    displayName: "Date Field",
-                    name: "dateField",
-                    type: "options",
-                    default: "created_at",
-                    displayOptions: { show: { recordId: [""] } },
-                    options: [
-                        { name: "created_at (recommended)", value: "created_at" },
-                        { name: "date", value: "date" },
-                        { name: "data", value: "data" },
-                    ],
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'string',
+                    required: true,
+                    description: 'Operation: getAll, get, create, update, activate, deactivate, or special operations (getByUsername, getTickets, getTasks, etc.)',
                 },
                 {
-                    displayName: "Per Page",
-                    name: "perPage",
-                    type: "number",
-                    default: 50,
-                    displayOptions: { show: { recordId: [""] } },
-                    typeOptions: { minValue: 1, maxValue: 200 },
+                    displayName: 'Record ID',
+                    name: 'recordId',
+                    type: 'string',
+                    required: false,
+                    description: 'ID of the record (required for get, update, activate, deactivate, and some special operations)',
                 },
                 {
-                    displayName: "Page",
-                    name: "page",
-                    type: "number",
-                    default: 1,
-                    displayOptions: { show: { recordId: [""] } },
-                    typeOptions: { minValue: 1 },
+                    displayName: 'Data',
+                    name: 'data',
+                    type: 'json',
+                    required: false,
+                    description: 'JSON data for create/update operations or additional parameters. Example: {"name":"John","email":"john@example.com"}',
                 },
             ],
         };
@@ -292,106 +138,210 @@ class Confirm8OSTool {
         const returnData = [];
         for (let i = 0; i < items.length; i++) {
             try {
-                const baseUrl = this.getNodeParameter("baseUrl", i);
-                const bearerToken = this.getNodeParameter("bearerToken", i);
-                const apiDomain = this.getNodeParameter("apiDomain", i);
-                const apiKeyToken = this.getNodeParameter("apiKeyToken", i);
-                const sessionId = this.getNodeParameter("sessionId", i, "");
-                const chatinput = this.getNodeParameter("chatinput", i, "");
-                const recordId = this.getNodeParameter("recordId", i, "").trim();
-                // CHUMBED RESOURCE
-                const resource = "order";
-                const config = exports.RESOURCE_ENDPOINTS[resource];
-                // Decide operation internally
-                const operation = recordId ? "get" : "getAll";
-                if (operation === "get") {
-                    const endpoint = `/v3/${config.endpoint}/${encodeURIComponent(recordId)}`;
-                    const query = config.relations?.length
-                        ? `?${config.relations
-                            .map((r) => `relations=${encodeURIComponent(r)}`)
-                            .join("&")}`
-                        : "";
-                    const data = await confirm8Request.call(this, i, {
-                        baseUrl,
-                        bearerToken,
-                        apiDomain,
-                        apiKeyToken,
-                        method: "GET",
-                        endpoint,
-                        query,
-                    });
-                    returnData.push({
-                        json: {
-                            success: true,
-                            fixed: { resource, operation },
-                            request: { sessionId, chatinput, recordId, endpoint },
-                            data,
-                        },
-                        pairedItem: { item: i },
-                    });
-                    continue;
-                }
-                // operation === getAll
-                const dateRange = this.getNodeParameter("dateRange", i);
-                const dateField = this.getNodeParameter("dateField", i);
-                let start;
-                let end;
-                if (dateRange === "custom") {
-                    start = this.getNodeParameter("startDate", i) || "";
-                    end = this.getNodeParameter("endDate", i) || "";
-                    if (!start || !end) {
-                        throw new Error("When Date Range is Custom, startDate and endDate are required.");
+                // 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 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 if provided
+                let data = {};
+                try {
+                    const dataParam = this.getNodeParameter('data', i, '');
+                    if (dataParam) {
+                        if (typeof dataParam === 'string') {
+                            data = JSON.parse(dataParam);
+                        }
+                        else if (typeof dataParam === 'object') {
+                            data = dataParam;
+                        }
                     }
-                    assertIsoDate(start, "startDate");
-                    assertIsoDate(end, "endDate");
                 }
-                else {
-                    const r = getThisWeekRange(new Date());
-                    start = r.start;
-                    end = r.end;
+                catch (e) {
+                    // Data is optional
                 }
-                const endpoint = `/v3/${config.endpoint}`;
-                const filters = { [dateField]: { gte: start, lte: end } };
-                const page = this.getNodeParameter("page", i);
-                const perPage = this.getNodeParameter("perPage", i);
-                const query = buildQueryParams(config.relations, filters);
-                const pagination = `&page=${encodeURIComponent(String(page))}&per_page=${encodeURIComponent(String(perPage))}`;
-                const finalQuery = query
-                    ? `${query}${pagination}`
-                    : `?page=${page}&per_page=${perPage}`;
-                const data = await confirm8Request.call(this, i, {
-                    baseUrl,
-                    bearerToken,
-                    apiDomain,
-                    apiKeyToken,
-                    method: "GET",
-                    endpoint,
-                    query: finalQuery,
-                });
+                // 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 baseEndpoint = resourceMap[resource] || resource;
+                let endpoint = '';
+                let method = 'GET';
+                let body = {};
+                // Build request based on operation
+                switch (operation) {
+                    case 'getAll':
+                        endpoint = `/${baseEndpoint}`;
+                        method = 'GET';
+                        break;
+                    case 'get':
+                        if (!recordId) {
+                            throw new Error('recordId is required for get operation');
+                        }
+                        endpoint = `/${baseEndpoint}/${recordId}`;
+                        method = 'GET';
+                        break;
+                    case 'create':
+                        endpoint = `/${baseEndpoint}`;
+                        method = 'POST';
+                        body = data;
+                        break;
+                    case 'update':
+                        if (!recordId) {
+                            throw new Error('recordId is required for update operation');
+                        }
+                        endpoint = `/${baseEndpoint}/${recordId}`;
+                        method = 'PUT';
+                        body = data;
+                        break;
+                    case 'activate':
+                        if (!recordId) {
+                            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';
+                        }
+                        break;
+                    case 'deactivate':
+                        if (!recordId) {
+                            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');
+                        }
+                        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,
+                    headers: {
+                        'Authorization': `Bearer ${bearerToken}`,
+                        'X-API-DOMAIN': apiDomain,
+                        'X-APIKEY-TOKEN': apiKeyToken,
+                        'Content-Type': 'application/json',
+                    },
+                    json: true,
+                };
+                if (method !== 'GET' && method !== 'DELETE' && Object.keys(body).length > 0) {
+                    options.body = body;
+                }
+                const responseData = await this.helpers.request(options);
                 returnData.push({
                     json: {
                         success: true,
-                        fixed: { resource, operation },
-                        request: {
-                            sessionId,
-                            chatinput,
-                            endpoint,
-                            dateField,
-                            startDate: start,
-                            endDate: end,
-                            page,
-                            perPage,
-                        },
-                        data,
+                        operation,
+                        resource,
+                        endpoint,
+                        data: responseData,
                     },
                     pairedItem: { item: i },
                 });
             }
-            catch (err) {
-                throw toNodeError(this.getNode(), err, i);
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            success: false,
+                            error: error || 'Unknown error',
+                            resource: this.getNodeParameter('resource', i, ''),
+                            operation: this.getNodeParameter('operation', i, ''),
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
             }
         }
         return [returnData];
     }
 }
-exports.Confirm8OSTool = Confirm8OSTool;
+exports.Confirm8AgentTool = Confirm8AgentTool;

package/package.json

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