@deepidealab/n8n-nodes-tracira 0.6.0 → 0.8.0

package/dist/nodes/Tracira/Tracira.node.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tracira = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
+const getProjects_1 = require("./listSearch/getProjects");
+const getTasks_1 = require("./listSearch/getTasks");
 const baseUrl = 'https://www.tracira.com/api';
 const logResourceDisplay = {
     resource: ['log'],
@@ -19,7 +21,7 @@ const getDisplay = {
 };
 const getAllDisplay = {
     resource: ['log'],
-    operation: ['getAll'],
+    operation: ['search'],
 };
 const setDecisionDisplay = {
     resource: ['log'],
@@ -29,6 +31,10 @@ const flagDisplay = {
     resource: ['log'],
     operation: ['flag'],
 };
+const uploadDisplay = {
+    resource: ['log'],
+    operation: ['upload'],
+};
 const apiCallDisplay = {
     resource: ['api'],
     operation: ['call'],
@@ -36,15 +42,15 @@ const apiCallDisplay = {
 function stripEmpty(data) {
     return Object.fromEntries(Object.entries(data).filter(([, value]) => value !== '' && value !== undefined && value !== null));
 }
-function normalizeApiPath(path) {
+function normalizeApiPath(path, node) {
     if (!path.trim())
         return '/';
     if (path.startsWith('http://') || path.startsWith('https://')) {
-        throw new n8n_workflow_1.ApplicationError('Use a path relative to https://www.tracira.com/api, for example /logs');
+        throw new n8n_workflow_1.NodeOperationError(node, 'Use a path relative to https://www.tracira.com/api, for example /logs');
     }
     return path.startsWith('/') ? path : `/${path}`;
 }
-function parseJsonObject(text, fieldName) {
+function parseJsonObject(text, fieldName, node) {
     if (!text.trim())
         return {};
     let parsed;
@@ -52,10 +58,10 @@ function parseJsonObject(text, fieldName) {
         parsed = JSON.parse(text);
     }
     catch {
-        throw new n8n_workflow_1.ApplicationError(`${fieldName} must be valid JSON`);
+        throw new n8n_workflow_1.NodeOperationError(node, `${fieldName} must be valid JSON`);
     }
     if (parsed === null || Array.isArray(parsed) || typeof parsed !== 'object') {
-        throw new n8n_workflow_1.ApplicationError(`${fieldName} must be a JSON object`);
+        throw new n8n_workflow_1.NodeOperationError(node, `${fieldName} must be a JSON object`);
     }
     return parsed;
 }
@@ -82,7 +88,7 @@ class Tracira {
         this.description = {
             displayName: 'Tracira',
             name: 'tracira',
-            icon: 'file:tracira.svg',
+            icon: { light: 'file:tracira.svg', dark: 'file:tracira.dark.svg' },
             group: ['transform'],
             version: 1,
             subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
@@ -106,8 +112,8 @@ class Tracira {
             defaults: {
                 name: 'Tracira',
             },
-            inputs: ['main'],
-            outputs: ['main'],
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
             credentials: [
                 {
                     name: 'traciraApi',
@@ -142,34 +148,40 @@ class Tracira {
                     },
                     options: [
                         {
-                            name: 'Flag',
+                            name: 'Create a Log',
+                            value: 'log',
+                            action: 'Create a log',
+                            description: 'Send an AI output to Tracira and create a log for evaluation. Returns a verdict, confidence score, and explanation based on your configured rules.',
+                        },
+                        {
+                            name: 'Flag a Log',
                             value: 'flag',
-                            action: 'Flag a log for review',
+                            action: 'Flag a log',
                             description: 'Flag an evaluated log for human review, e.g. when an end-user reports an issue',
                         },
                         {
-                            name: 'Get',
+                            name: 'Get a Log',
                             value: 'get',
                             action: 'Get a log',
-                            description: 'Fetch a single log by ID',
+                            description: 'Fetch a single log by ID, including verdict, explanation, and human decision',
                         },
                         {
-                            name: 'Get Many',
-                            value: 'getAll',
-                            action: 'Get many logs',
-                            description: 'List logs from Tracira',
+                            name: 'Search Logs',
+                            value: 'search',
+                            action: 'Search logs',
+                            description: 'Return a filtered list of logs from Tracira. Filter by status, project, task name, or date range.',
                         },
                         {
-                            name: 'Log',
-                            value: 'log',
-                            action: 'Log an AI output',
-                            description: 'Send an AI output to Tracira for evaluation',
+                            name: 'Set a Decision',
+                            value: 'setDecision',
+                            action: 'Set a decision',
+                            description: 'Approve, reject, or send a flagged log back to the AI with a comment',
                         },
                         {
-                            name: 'Set Decision',
-                            value: 'setDecision',
-                            action: 'Set a decision for a log',
-                            description: 'Approve or reject a flagged log',
+                            name: 'Upload a File',
+                            value: 'upload',
+                            action: 'Upload a file',
+                            description: 'Upload a large file directly to Tracira storage, then attach it to a log by key',
                         },
                     ],
                     default: 'log',
@@ -225,20 +237,20 @@ class Tracira {
                     },
                     options: [
                         {
-                            name: 'Approved',
+                            name: 'Approve',
                             value: 'approved',
                         },
                         {
-                            name: 'Changed',
-                            value: 'changed',
-                            description: 'Send the log back to the AI with a comment to regenerate',
+                            name: 'Reject',
+                            value: 'rejected',
                         },
                         {
-                            name: 'Rejected',
-                            value: 'rejected',
+                            name: 'Send Back for Changes',
+                            value: 'changed',
+                            description: 'Send the log back to the AI with a comment to regenerate',
                         },
                     ],
-                    description: 'The human review decision to record',
+                    description: 'Approve or reject the flagged log, or send it back to the AI with a comment',
                 },
                 {
                     displayName: 'Comment',
@@ -255,7 +267,7 @@ class Tracira {
                             decision: ['changed'],
                         },
                     },
-                    description: 'The instruction sent back to the AI describing what to change. Required when Decision is Changed. The AI should regenerate the output and resubmit it with the Log operation, setting Revision Of to this log ID.',
+                    description: 'The instruction sent back to the AI describing what to change. Required when Decision is Send Back for Changes. The AI should regenerate the output and resubmit it with the Create a Log operation, setting Revision Of to this log ID.',
                 },
                 {
                     displayName: 'Log ID',
@@ -282,18 +294,66 @@ class Tracira {
                     description: 'Optional reason for flagging, stored as the log explanation, for example the message your end-user submitted when reporting the issue',
                 },
                 {
-                    displayName: 'Project',
-                    name: 'projectName',
+                    displayName: 'Input Binary Field',
+                    name: 'binaryPropertyName',
                     type: 'string',
                     required: true,
+                    default: 'data',
+                    displayOptions: {
+                        show: uploadDisplay,
+                    },
+                    hint: 'The name of the input field containing the binary file to upload',
+                    description: 'Name of the input binary field holding the file (PDF, image, or audio) to upload. The file goes straight to storage, bypassing the request size limit. Up to 32 MB.',
+                },
+                {
+                    displayName: 'File Name',
+                    name: 'uploadFileName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: uploadDisplay,
+                    },
+                    description: 'Optional file name. Overrides the binary field name; its extension is used to detect the file type.',
+                },
+                {
+                    displayName: 'Content Type',
+                    name: 'uploadContentType',
+                    type: 'string',
                     default: '',
+                    displayOptions: {
+                        show: uploadDisplay,
+                    },
+                    description: 'Optional. Override the MIME type (e.g. application/pdf, image/png). Only needed when the file name has no recognizable extension.',
+                },
+                {
+                    displayName: 'Project Name',
+                    name: 'projectName',
+                    type: 'resourceLocator',
+                    required: true,
+                    default: { mode: 'list', value: '' },
                     displayOptions: {
                         show: logOperationDisplay,
                     },
-                    description: 'The Tracira project name for this log',
+                    description: 'Select an existing project or enter a new name — it will be auto-created in Tracira on first use',
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            typeOptions: {
+                                searchListMethod: 'getProjects',
+                                searchable: true,
+                            },
+                        },
+                        {
+                            displayName: 'Name',
+                            name: 'name',
+                            type: 'string',
+                        },
+                    ],
                 },
                 {
-                    displayName: 'Output',
+                    displayName: 'AI Output',
                     name: 'output',
                     type: 'string',
                     typeOptions: {
@@ -304,10 +364,10 @@ class Tracira {
                     displayOptions: {
                         show: logOperationDisplay,
                     },
-                    description: 'The AI-generated output to evaluate in Tracira',
+                    description: 'The AI-generated output to evaluate against your Tracira rules',
                 },
                 {
-                    displayName: 'Input',
+                    displayName: 'Text Prompt',
                     name: 'input',
                     type: 'string',
                     typeOptions: {
@@ -317,27 +377,133 @@ class Tracira {
                     displayOptions: {
                         show: logOperationDisplay,
                     },
-                    description: 'Optional prompt or input text that produced the output',
+                    description: 'Optional text sent to your AI model alongside any attachments',
+                },
+                {
+                    displayName: 'Attachments',
+                    name: 'attachments',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    placeholder: 'Add Attachment',
+                    default: {},
+                    displayOptions: {
+                        show: logOperationDisplay,
+                    },
+                    description: 'Files to attach to the log (the source the AI worked from). Tracira auto-detects whether each attachment is an image, audio file, or document.',
+                    options: [
+                        {
+                            name: 'attachment',
+                            displayName: 'Attachment',
+                            values: [
+                                {
+                                    displayName: 'Attachment Key',
+                                    name: 'key',
+                                    type: 'string',
+                                    default: '',
+                                    displayOptions: {
+                                        show: {
+                                            source: ['uploaded'],
+                                        },
+                                    },
+                                    description: 'The key returned by an Upload a File operation. Use this for large files (over 3 MB) that cannot be sent inline.',
+                                },
+                                {
+                                    displayName: 'File Name',
+                                    name: 'filename',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Optional original file name shown to reviewers',
+                                },
+                                {
+                                    displayName: 'Input Binary Field',
+                                    name: 'binaryProperty',
+                                    type: 'string',
+                                    default: 'data',
+                                    displayOptions: {
+                                        show: {
+                                            source: ['upload'],
+                                        },
+                                    },
+                                    hint: 'The name of the input field containing the binary file to attach',
+                                    description: 'The file is sent inline with this request. The whole request is limited to 4.5 MB, so keep inline files under ~3 MB. For larger files, use the Upload a File operation first, then attach with source "Tracira Upload".',
+                                },
+                                {
+                                    displayName: 'Source',
+                                    name: 'source',
+                                    type: 'options',
+                                    default: 'upload',
+                                    options: [
+                                        {
+                                            name: 'From URL',
+                                            value: 'url',
+                                            description: 'HTTPS URL to a publicly accessible file',
+                                        },
+                                        {
+                                            name: 'Tracira Upload',
+                                            value: 'uploaded',
+                                            description: 'A key returned by the Upload a File operation — use for files over ~3 MB',
+                                        },
+                                        {
+                                            name: 'Upload File',
+                                            value: 'upload',
+                                            description: 'Send a binary file inline with this request (keep under ~3 MB)',
+                                        },
+                                    ],
+                                    description: 'Where the file comes from',
+                                },
+                                {
+                                    displayName: 'URL',
+                                    name: 'url',
+                                    type: 'string',
+                                    default: '',
+                                    displayOptions: {
+                                        show: {
+                                            source: ['url'],
+                                        },
+                                    },
+                                    description: 'HTTPS URL to a publicly accessible image, audio file, or PDF',
+                                },
+                            ],
+                        },
+                    ],
                 },
                 {
-                    displayName: 'Task',
+                    displayName: 'Task Name',
                     name: 'taskName',
-                    type: 'string',
-                    default: '',
+                    type: 'resourceLocator',
+                    default: { mode: 'list', value: '' },
                     displayOptions: {
                         show: logOperationDisplay,
                     },
-                    description: 'Optional Tracira task name',
+                    description: 'Optional. Select an existing task or enter a new name (e.g. "Tone Validator", "Reply Generator").',
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            typeOptions: {
+                                searchListMethod: 'getTasks',
+                                searchable: true,
+                            },
+                        },
+                        {
+                            displayName: 'Name',
+                            name: 'name',
+                            type: 'string',
+                        },
+                    ],
                 },
                 {
-                    displayName: 'Model',
+                    displayName: 'AI Model',
                     name: 'modelName',
                     type: 'string',
                     default: '',
                     displayOptions: {
                         show: logOperationDisplay,
                     },
-                    description: 'Optional AI model name to record with the log',
+                    description: 'Optional. The name of the AI model that produced this output, exactly as you use it — e.g. "gpt-4o", "claude-sonnet-4-5".',
                 },
                 {
                     displayName: 'Wait for Verdict',
@@ -466,24 +632,56 @@ class Tracira {
                     description: 'Filter logs by status',
                 },
                 {
-                    displayName: 'Project',
+                    displayName: 'Project Name',
                     name: 'projectFilter',
-                    type: 'string',
-                    default: '',
+                    type: 'resourceLocator',
+                    default: { mode: 'list', value: '' },
                     displayOptions: {
                         show: getAllDisplay,
                     },
-                    description: 'Filter logs to a specific project name',
+                    description: 'Optional. Filter logs to a specific project name.',
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            typeOptions: {
+                                searchListMethod: 'getProjects',
+                                searchable: true,
+                            },
+                        },
+                        {
+                            displayName: 'Name',
+                            name: 'name',
+                            type: 'string',
+                        },
+                    ],
                 },
                 {
-                    displayName: 'Task',
+                    displayName: 'Task Name',
                     name: 'taskFilter',
-                    type: 'string',
-                    default: '',
+                    type: 'resourceLocator',
+                    default: { mode: 'list', value: '' },
                     displayOptions: {
                         show: getAllDisplay,
                     },
-                    description: 'Filter logs to a specific task name',
+                    description: 'Optional. Filter logs to a specific task name within a project.',
+                    modes: [
+                        {
+                            displayName: 'From List',
+                            name: 'list',
+                            type: 'list',
+                            typeOptions: {
+                                searchListMethod: 'getTasks',
+                                searchable: true,
+                            },
+                        },
+                        {
+                            displayName: 'Name',
+                            name: 'name',
+                            type: 'string',
+                        },
+                    ],
                 },
                 {
                     displayName: 'Search Query',
@@ -496,7 +694,7 @@ class Tracira {
                     description: 'Search across project, task, model, and context IDs',
                 },
                 {
-                    displayName: 'From',
+                    displayName: 'From Date',
                     name: 'from',
                     type: 'dateTime',
                     default: '',
@@ -506,7 +704,7 @@ class Tracira {
                     description: 'Only include logs at or after this date',
                 },
                 {
-                    displayName: 'To',
+                    displayName: 'To Date',
                     name: 'to',
                     type: 'dateTime',
                     default: '',
@@ -642,8 +840,15 @@ class Tracira {
                 },
             ],
         };
+        this.methods = {
+            listSearch: {
+                getProjects: getProjects_1.getProjects,
+                getTasks: getTasks_1.getTasks,
+            },
+        };
     }
     async execute() {
+        var _a, _b;
         const items = this.getInputData();
         const returnData = [];
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
@@ -664,15 +869,45 @@ class Tracira {
                             });
                         }
                     }
+                    const attachmentsParam = this.getNodeParameter('attachments', itemIndex, {});
+                    const attachmentRows = (_a = attachmentsParam.attachment) !== null && _a !== void 0 ? _a : [];
+                    const attachments = [];
+                    for (const row of attachmentRows) {
+                        if (row.source === 'upload') {
+                            const binaryProperty = row.binaryProperty || 'data';
+                            const binary = this.helpers.assertBinaryData(itemIndex, binaryProperty);
+                            const buffer = await this.helpers.getBinaryDataBuffer(itemIndex, binaryProperty);
+                            attachments.push(stripEmpty({
+                                source: 'upload',
+                                data: buffer.toString('base64'),
+                                filename: row.filename || binary.fileName || 'file',
+                            }));
+                            continue;
+                        }
+                        const entry = stripEmpty({
+                            source: row.source,
+                            key: row.key,
+                            url: row.url,
+                            filename: row.filename,
+                        });
+                        if (entry.key !== undefined || entry.url !== undefined) {
+                            attachments.push(entry);
+                        }
+                    }
                     requestOptions = {
                         method: 'POST',
                         url: `${baseUrl}/logs`,
                         body: stripEmpty({
-                            project: this.getNodeParameter('projectName', itemIndex),
+                            project: this.getNodeParameter('projectName', itemIndex, '', {
+                                extractValue: true,
+                            }),
                             output: this.getNodeParameter('output', itemIndex),
                             input: this.getNodeParameter('input', itemIndex, ''),
-                            task: this.getNodeParameter('taskName', itemIndex, ''),
+                            task: this.getNodeParameter('taskName', itemIndex, '', {
+                                extractValue: true,
+                            }),
                             model: this.getNodeParameter('modelName', itemIndex, ''),
+                            attachments: attachments.length ? attachments : undefined,
                             actorId: options.actorId,
                             callbackUrl: options.callbackUrl,
                             callbackEvents: options.callbackEvents,
@@ -696,15 +931,19 @@ class Tracira {
                         url: `${baseUrl}/logs/${encodeURIComponent(logId)}`,
                     };
                 }
-                else if (resource === 'log' && operation === 'getAll') {
+                else if (resource === 'log' && operation === 'search') {
                     const filters = this.getNodeParameter('filters', itemIndex, {});
                     requestOptions = {
                         method: 'GET',
                         url: `${baseUrl}/logs`,
                         qs: stripEmpty({
                             status: this.getNodeParameter('status', itemIndex, ''),
-                            project: this.getNodeParameter('projectFilter', itemIndex, ''),
-                            task: this.getNodeParameter('taskFilter', itemIndex, ''),
+                            project: this.getNodeParameter('projectFilter', itemIndex, '', {
+                                extractValue: true,
+                            }),
+                            task: this.getNodeParameter('taskFilter', itemIndex, '', {
+                                extractValue: true,
+                            }),
                             q: this.getNodeParameter('query', itemIndex, ''),
                             from: this.getNodeParameter('from', itemIndex, ''),
                             to: this.getNodeParameter('to', itemIndex, ''),
@@ -723,7 +962,7 @@ class Tracira {
                         ? this.getNodeParameter('comment', itemIndex, '')
                         : '';
                     if (decision === 'changed' && !comment.trim()) {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Comment is required when Decision is Changed', { itemIndex });
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Comment is required when Decision is Send Back for Changes', { itemIndex });
                     }
                     requestOptions = {
                         method: 'PATCH',
@@ -746,13 +985,48 @@ class Tracira {
                         }),
                     };
                 }
+                else if (resource === 'log' && operation === 'upload') {
+                    const binaryPropertyName = this.getNodeParameter('binaryPropertyName', itemIndex, 'data');
+                    const fileNameOverride = this.getNodeParameter('uploadFileName', itemIndex, '');
+                    const contentTypeOverride = this.getNodeParameter('uploadContentType', itemIndex, '');
+                    const binary = this.helpers.assertBinaryData(itemIndex, binaryPropertyName);
+                    const buffer = await this.helpers.getBinaryDataBuffer(itemIndex, binaryPropertyName);
+                    const filename = fileNameOverride || binary.fileName || 'file';
+                    const presign = (await this.helpers.httpRequestWithAuthentication.call(this, 'traciraApi', {
+                        method: 'POST',
+                        url: `${baseUrl}/uploads`,
+                        body: stripEmpty({
+                            filename,
+                            contentType: contentTypeOverride || binary.mimeType,
+                            sizeBytes: buffer.length,
+                        }),
+                    }));
+                    const uploadUrl = presign.uploadUrl;
+                    const key = presign.key;
+                    const contentType = (_b = presign.contentType) !== null && _b !== void 0 ? _b : (contentTypeOverride || binary.mimeType);
+                    if (!uploadUrl || !key) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Tracira did not return an upload URL', { itemIndex });
+                    }
+                    await this.helpers.httpRequest({
+                        method: 'PUT',
+                        url: uploadUrl,
+                        body: buffer,
+                        headers: { 'Content-Type': contentType },
+                        json: false,
+                    });
+                    returnData.push({
+                        json: { key, contentType },
+                        pairedItem: itemIndex,
+                    });
+                    continue;
+                }
                 else if (resource === 'api' && operation === 'call') {
-                    const headers = parseJsonObject(this.getNodeParameter('apiHeadersJson', itemIndex, '{}'), 'Headers JSON');
-                    const qs = parseJsonObject(this.getNodeParameter('apiQueryJson', itemIndex, '{}'), 'Query String JSON');
+                    const headers = parseJsonObject(this.getNodeParameter('apiHeadersJson', itemIndex, '{}'), 'Headers JSON', this.getNode());
+                    const qs = parseJsonObject(this.getNodeParameter('apiQueryJson', itemIndex, '{}'), 'Query String JSON', this.getNode());
                     const body = parseOptionalJsonBody(this.getNodeParameter('apiBody', itemIndex, ''));
                     requestOptions = {
                         method: this.getNodeParameter('apiMethod', itemIndex),
-                        url: `${baseUrl}${normalizeApiPath(this.getNodeParameter('apiPath', itemIndex))}`,
+                        url: `${baseUrl}${normalizeApiPath(this.getNodeParameter('apiPath', itemIndex), this.getNode())}`,
                         headers,
                         qs,
                         body,
@@ -765,7 +1039,7 @@ class Tracira {
                     });
                 }
                 const response = await this.helpers.httpRequestWithAuthentication.call(this, 'traciraApi', requestOptions);
-                if (resource === 'log' && operation === 'getAll' && Array.isArray(response === null || response === void 0 ? void 0 : response.executions)) {
+                if (resource === 'log' && operation === 'search' && Array.isArray(response === null || response === void 0 ? void 0 : response.executions)) {
                     for (const log of response.executions) {
                         returnData.push({
                             json: log,