@deepidealab/n8n-nodes-tracira 0.7.0 → 0.8.1

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'],
@@ -40,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;
@@ -56,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;
 }
@@ -86,11 +88,12 @@ 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"]}}',
             description: 'Log and inspect Tracira AI log data',
+            usableAsTool: true,
             codex: {
                 categories: ['AI'],
                 resources: {
@@ -110,8 +113,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',
@@ -146,37 +149,37 @@ 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: 'Log',
-                            value: 'log',
-                            action: 'Log an AI output',
-                            description: 'Send an AI output to Tracira for evaluation',
+                            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: 'Set Decision',
+                            name: 'Set a Decision',
                             value: 'setDecision',
-                            action: 'Set a decision for a log',
-                            description: 'Approve or reject a flagged log',
+                            action: 'Set a decision',
+                            description: 'Approve, reject, or send a flagged log back to the AI with a comment',
                         },
                         {
-                            name: 'Upload File',
+                            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',
@@ -235,20 +238,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',
@@ -265,7 +268,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',
@@ -314,18 +317,44 @@ class Tracira {
                     description: 'Optional file name. Overrides the binary field name; its extension is used to detect the file type.',
                 },
                 {
-                    displayName: 'Project',
-                    name: 'projectName',
+                    displayName: 'Content Type',
+                    name: 'uploadContentType',
                     type: 'string',
-                    required: true,
                     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: {
@@ -336,10 +365,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: {
@@ -349,7 +378,7 @@ 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',
@@ -363,23 +392,12 @@ class Tracira {
                     displayOptions: {
                         show: logOperationDisplay,
                     },
-                    description: 'Files to attach to the log (the source the AI worked from)',
+                    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: 'Source',
-                                    name: 'source',
-                                    type: 'options',
-                                    default: 'uploaded',
-                                    options: [
-                                        { name: 'Uploaded File (Key)', value: 'uploaded' },
-                                        { name: 'URL', value: 'url' },
-                                    ],
-                                    description: 'Where the file comes from',
-                                },
                                 {
                                     displayName: 'Attachment Key',
                                     name: 'key',
@@ -390,50 +408,103 @@ class Tracira {
                                             source: ['uploaded'],
                                         },
                                     },
-                                    description: 'The key returned by an Upload File operation. Use this for large files (over 3 MB) that cannot be sent inline.',
+                                    description: 'The key returned by an Upload a File operation. Use this for large files (over 3 MB) that cannot be sent inline.',
                                 },
                                 {
-                                    displayName: 'URL',
-                                    name: 'url',
+                                    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: ['url'],
+                                            source: ['upload'],
                                         },
                                     },
-                                    description: 'HTTPS URL to a publicly accessible image, audio file, or PDF',
+                                    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: 'File Name',
-                                    name: 'filename',
+                                    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: '',
-                                    description: 'Optional original file name shown to reviewers',
+                                    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',
@@ -562,24 +633,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',
@@ -592,7 +695,7 @@ class Tracira {
                     description: 'Search across project, task, model, and context IDs',
                 },
                 {
-                    displayName: 'From',
+                    displayName: 'From Date',
                     name: 'from',
                     type: 'dateTime',
                     default: '',
@@ -602,7 +705,7 @@ class Tracira {
                     description: 'Only include logs at or after this date',
                 },
                 {
-                    displayName: 'To',
+                    displayName: 'To Date',
                     name: 'to',
                     type: 'dateTime',
                     default: '',
@@ -738,6 +841,12 @@ class Tracira {
                 },
             ],
         };
+        this.methods = {
+            listSearch: {
+                getProjects: getProjects_1.getProjects,
+                getTasks: getTasks_1.getTasks,
+            },
+        };
     }
     async execute() {
         var _a, _b;
@@ -763,22 +872,41 @@ class Tracira {
                     }
                     const attachmentsParam = this.getNodeParameter('attachments', itemIndex, {});
                     const attachmentRows = (_a = attachmentsParam.attachment) !== null && _a !== void 0 ? _a : [];
-                    const attachments = attachmentRows
-                        .map((row) => stripEmpty({
-                        source: row.source,
-                        key: row.key,
-                        url: row.url,
-                        filename: row.filename,
-                    }))
-                        .filter((row) => row.key !== undefined || row.url !== undefined);
+                    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,
@@ -804,15 +932,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, ''),
@@ -831,7 +963,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',
@@ -857,6 +989,7 @@ 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';
@@ -865,13 +998,13 @@ class Tracira {
                         url: `${baseUrl}/uploads`,
                         body: stripEmpty({
                             filename,
-                            contentType: binary.mimeType,
+                            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 : binary.mimeType;
+                    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 });
                     }
@@ -889,12 +1022,12 @@ class Tracira {
                     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,
@@ -907,7 +1040,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,