n8n-nodes-confirm8 0.29.0 → 0.31.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;
+    /**
+     * Tool description for AI Agent
+     * This helps the AI understand when and how to use this tool
+     */
+    getToolDescription(): IDataObject;
     execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
 }

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

@@ -1,288 +1,205 @@
 "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: 'AI Agent tool for Confirm8 API - Use to fetch, create, update data from Confirm8',
+            defaults: {
+                name: 'Confirm8 AI Tool',
+            },
+            // IMPORTANT: Makes this node usable as an AI Agent Tool
+            usableAsTool: true,
+            inputs: ['main'],
+            outputs: ['main'],
             properties: [
+                // API Configuration
                 {
-                    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,
                 },
+                // Operation Configuration
                 {
-                    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).",
+                    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',
                 },
-                // Listing options (only relevant when recordId is empty)
                 {
-                    displayName: "Date Range",
-                    name: "dateRange",
-                    type: "options",
-                    default: "thisWeek",
-                    displayOptions: { show: { recordId: [""] } },
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
                     options: [
-                        { name: "This week (Mon..Sun)", value: "thisWeek" },
-                        { name: "Custom", value: "custom" },
+                        {
+                            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: "Start Date (YYYY-MM-DD)",
-                    name: "startDate",
-                    type: "string",
-                    default: "",
-                    displayOptions: { show: { dateRange: ["custom"], recordId: [""] } },
+                    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
+     */
+    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: "End Date (YYYY-MM-DD)",
-                    name: "endDate",
-                    type: "string",
-                    default: "",
-                    displayOptions: { show: { dateRange: ["custom"], recordId: [""] } },
+                    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: "Date Field",
-                    name: "dateField",
-                    type: "options",
-                    default: "created_at",
-                    displayOptions: { show: { recordId: [""] } },
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    required: true,
                     options: [
-                        { name: "created_at (recommended)", value: "created_at" },
-                        { name: "date", value: "date" },
-                        { name: "data", value: "data" },
+                        { 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: "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)',
                 },
                 {
-                    displayName: "Page",
-                    name: "page",
-                    type: "number",
-                    default: 1,
-                    displayOptions: { show: { recordId: [""] } },
-                    typeOptions: { minValue: 1 },
+                    displayName: 'Data',
+                    name: 'dataJson',
+                    type: 'json',
+                    required: false,
+                    description: 'JSON data for create/update operations. Example: {"name":"John","email":"john@example.com"}',
                 },
             ],
         };
@@ -292,106 +209,128 @@ 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
+                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);
+                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);
                     }
-                    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 endpoint
+                const resourceMap = {
+                    user: 'users',
+                    client: 'clients',
+                    item: 'items',
+                    task: 'tasks',
+                    service: 'services',
+                    product: 'products',
+                    order: 'wos',
+                    ticket: 'tickets',
+                    property: 'properties',
+                };
+                const endpoint = resourceMap[resource] || resource;
+                let url = '';
+                let method = 'GET';
+                let body = {};
+                // Build request based on operation
+                switch (operation) {
+                    case 'getAll':
+                        url = `${baseUrl}/${endpoint}`;
+                        method = 'GET';
+                        break;
+                    case 'get':
+                        if (!recordId) {
+                            throw new Error('Record ID is required for Get operation');
+                        }
+                        url = `${baseUrl}/${endpoint}/${recordId}`;
+                        method = 'GET';
+                        break;
+                    case 'create':
+                        url = `${baseUrl}/${endpoint}`;
+                        method = 'POST';
+                        body = dataJson;
+                        break;
+                    case 'update':
+                        if (!recordId) {
+                            throw new Error('Record ID is required for Update operation');
+                        }
+                        url = `${baseUrl}/${endpoint}/${recordId}`;
+                        method = 'PUT';
+                        body = dataJson;
+                        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';
+                        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';
+                        break;
+                    default:
+                        throw new Error(`Unknown operation: ${operation}`);
+                }
+                // Make HTTP request
+                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,
+                        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',
+                        },
+                        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.31.0",
   "description": "Simple n8n node for Confirm8 API - no credentials needed",
   "license": "MIT",
   "author": "Bill Hebert",