n8n-nodes-vercel-ai-sdk-universal-temp 0.2.71 → 0.2.72

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "n8n-nodes-vercel-ai-sdk-universal-temp",
-	"version": "0.2.71",
+	"version": "0.2.72",
 	"description": "Universal AI SDK n8n nodes integration",
 	"keywords": [
 		"n8n-community-node-package"
@@ -15,7 +15,7 @@
 	},
 	"main": "index.js",
 	"scripts": {
-		"build": "tsc && gulp build:icons",
+		"build": "bun run clean && tsc && gulp build:icons",
 		"dev": "build && tsc --watch",
 		"format": "prettier nodes credentials --write",
 		"lint": "eslint nodes credentials package.json",
@@ -23,13 +23,15 @@
 		"test": "bun test",
 		"test:watch": "jest --watch",
 		"test:coverage": "jest --coverage",
-		"prepublishOnly": "bun run build"
+		"prepublishOnly": "bun run build",
+		"clean": "rm -rf dist"
 	},
 	"files": [
 		"dist"
 	],
 	"n8n": {
 		"n8nNodesApiVersion": 1,
+		"strict": true,
 		"credentials": [
 			"dist/credentials/GoogleGenerativeAIApi.credentials.js",
 			"dist/credentials/DeepSeekApi.credentials.js",

package/dist/credentials/UniversalAi.credentials.d.ts

@@ -1,7 +0,0 @@
-import type { ICredentialType, INodeProperties } from 'n8n-workflow';
-export declare class UniversalAiApi implements ICredentialType {
-    name: string;
-    displayName: string;
-    documentationUrl: string;
-    properties: INodeProperties[];
-}

package/dist/credentials/UniversalAi.credentials.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniversalAiApi = void 0;
-class UniversalAiApi {
-    constructor() {
-        this.name = 'universalAiApi';
-        this.displayName = 'Universal AI API';
-        this.documentationUrl = 'universal-ai';
-        this.properties = [
-            {
-                displayName: 'API Key',
-                name: 'apiKey',
-                type: 'string',
-                default: '',
-                required: false,
-                typeOptions: {
-                    password: true,
-                },
-                description: 'Optional API key for the AI provider',
-            },
-            {
-                displayName: 'Base URL',
-                name: 'baseURL',
-                type: 'string',
-                default: '',
-                required: false,
-                description: 'Optional custom base URL for the API endpoint',
-            },
-        ];
-    }
-}
-exports.UniversalAiApi = UniversalAiApi;
-//# sourceMappingURL=UniversalAi.credentials.js.map

package/dist/credentials/UniversalAi.credentials.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"UniversalAi.credentials.js","sourceRoot":"","sources":["../../credentials/UniversalAi.credentials.ts"],"names":[],"mappings":";;;AAKA,MAAa,cAAc;IAA3B;QACC,SAAI,GAAG,gBAAgB,CAAC;QACxB,gBAAW,GAAG,kBAAkB,CAAC;QACjC,qBAAgB,GAAG,cAAc,CAAC;QAClC,eAAU,GAAsB;YAC/B;gBACC,WAAW,EAAE,SAAS;gBACtB,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,KAAK;gBACf,WAAW,EAAE;oBACZ,QAAQ,EAAE,IAAI;iBACd;gBACD,WAAW,EAAE,sCAAsC;aACnD;YACD;gBACC,WAAW,EAAE,UAAU;gBACvB,IAAI,EAAE,SAAS;gBACf,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,EAAE;gBACX,QAAQ,EAAE,KAAK;gBACf,WAAW,EAAE,+CAA+C;aAC5D;SACD,CAAC;IACH,CAAC;CAAA;AAzBD,wCAyBC"}

package/dist/nodes/DeepSeek/DeepSeek.node.d.ts

@@ -1,10 +0,0 @@
-import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
-export declare class DeepSeek implements INodeType {
-    description: INodeTypeDescription;
-    methods: {
-        loadOptions: {
-            getModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
-        };
-    };
-    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
-}

package/dist/nodes/DeepSeek/DeepSeek.node.js

@@ -1,574 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeepSeek = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
-const deepseek_1 = require("@ai-sdk/deepseek");
-const ai_1 = require("ai");
-const zod_1 = require("zod");
-const ajv_1 = __importDefault(require("ajv"));
-async function buildInput(exec, itemIndex) {
-    const inputType = exec.getNodeParameter('inputType', itemIndex);
-    if (inputType === 'prompt') {
-        const promptVal = exec.getNodeParameter('prompt', itemIndex);
-        const systemVal = exec.getNodeParameter('system', itemIndex);
-        return {
-            prompt: promptVal,
-            system: systemVal,
-        };
-    }
-    else {
-        const messageAsJson = exec.getNodeParameter('messageAsJson', itemIndex, false);
-        if (messageAsJson) {
-            const rawJson = exec.getNodeParameter('messagesJson', itemIndex);
-            let arr;
-            try {
-                arr = JSON.parse(rawJson);
-            }
-            catch (error) {
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid JSON in "Messages (JSON)" field: ${error.message}`);
-            }
-            const parseRes = zod_1.z
-                .array(zod_1.z.object({
-                role: zod_1.z.enum(['system', 'user', 'assistant']),
-                content: zod_1.z.string(),
-            }))
-                .safeParse(arr);
-            if (!parseRes.success) {
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Messages must be an array of objects with role and content.');
-            }
-            const messages = parseRes.data.map((m) => ({
-                role: m.role,
-                content: m.content,
-            }));
-            return { messages };
-        }
-        else {
-            const messagesUi = exec.getNodeParameter('messages.messagesUi', itemIndex, []);
-            const messages = messagesUi.map((msg) => {
-                const role = msg.role;
-                return {
-                    role,
-                    content: role === 'system' ? msg.systemContent || '' : msg.content || '',
-                };
-            });
-            return { messages };
-        }
-    }
-}
-function formatTextResult(result, includeRequestBody) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-    const out = {
-        text: result.text,
-        reasoning: result === null || result === void 0 ? void 0 : result.reasoning,
-        finishReason: result.finishReason,
-        usage: {
-            promptTokens: (_a = result.usage) === null || _a === void 0 ? void 0 : _a.promptTokens,
-            completionTokens: (_b = result.usage) === null || _b === void 0 ? void 0 : _b.completionTokens,
-            totalTokens: (_c = result.usage) === null || _c === void 0 ? void 0 : _c.totalTokens,
-            cacheMetrics: {
-                promptCacheHitTokens: (_e = (_d = result.experimental_providerMetadata) === null || _d === void 0 ? void 0 : _d.deepseek) === null || _e === void 0 ? void 0 : _e.promptCacheHitTokens,
-                promptCacheMissTokens: (_g = (_f = result.experimental_providerMetadata) === null || _f === void 0 ? void 0 : _f.deepseek) === null || _g === void 0 ? void 0 : _g.promptCacheMissTokens,
-            },
-        },
-        response: {
-            id: (_h = result.response) === null || _h === void 0 ? void 0 : _h.id,
-            modelId: (_j = result.response) === null || _j === void 0 ? void 0 : _j.modelId,
-            timestamp: (_k = result.response) === null || _k === void 0 ? void 0 : _k.timestamp,
-            headers: (_l = result.response) === null || _l === void 0 ? void 0 : _l.headers,
-        },
-        warnings: result.warnings || [],
-    };
-    if (includeRequestBody) {
-        out.request = { body: (_m = result.request) === null || _m === void 0 ? void 0 : _m.body };
-    }
-    return out;
-}
-function formatObjectResult(result, includeRequestBody) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const out = {
-        object: result.object,
-        finishReason: result.finishReason,
-        usage: {
-            promptTokens: (_a = result.usage) === null || _a === void 0 ? void 0 : _a.promptTokens,
-            completionTokens: (_b = result.usage) === null || _b === void 0 ? void 0 : _b.completionTokens,
-            totalTokens: (_c = result.usage) === null || _c === void 0 ? void 0 : _c.totalTokens,
-        },
-        response: {
-            id: (_d = result.response) === null || _d === void 0 ? void 0 : _d.id,
-            modelId: (_e = result.response) === null || _e === void 0 ? void 0 : _e.modelId,
-            timestamp: (_f = result.response) === null || _f === void 0 ? void 0 : _f.timestamp,
-            headers: (_g = result.response) === null || _g === void 0 ? void 0 : _g.headers,
-        },
-        warnings: result.warnings || [],
-    };
-    if (includeRequestBody) {
-        out.request = { body: (_h = result.request) === null || _h === void 0 ? void 0 : _h.body };
-    }
-    return out;
-}
-class DeepSeek {
-    constructor() {
-        this.description = {
-            displayName: 'DeepSeek',
-            name: 'deepSeek',
-            icon: 'file:icons/deepseek.svg',
-            group: ['transform'],
-            version: 1,
-            subtitle: '={{$parameter["operation"] + ": " + $parameter["model"]}}',
-            description: 'Use DeepSeek models via Vercel AI SDK',
-            defaults: {
-                name: 'DeepSeek',
-            },
-            inputs: [{ type: "main" }],
-            outputs: [{ type: "main" }],
-            credentials: [
-                {
-                    name: 'deepSeekApi',
-                    required: true,
-                },
-            ],
-            properties: [
-                {
-                    displayName: 'Model Name or ID',
-                    name: 'model',
-                    type: 'options',
-                    required: true,
-                    typeOptions: {
-                        loadOptionsMethod: 'getModels',
-                    },
-                    default: '',
-                    description: 'Select which DeepSeek model to use. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
-                },
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    required: true,
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Generate Text',
-                            value: 'generateText',
-                            description: 'Generate text using simple prompt or chat messages',
-                            action: 'Generate text',
-                        },
-                        {
-                            name: 'Generate Object',
-                            value: 'generateObject',
-                            description: 'Generate a structured object based on a JSON schema',
-                            action: 'Generate object',
-                        },
-                    ],
-                    displayOptions: {
-                        show: {
-                            model: ['deepseek-chat'],
-                        },
-                    },
-                    default: 'generateText',
-                    description: 'Which type of output you want to generate',
-                },
-                {
-                    displayName: 'Operation',
-                    name: 'operation',
-                    type: 'options',
-                    required: true,
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'Generate Text',
-                            value: 'generateText',
-                            description: 'Generate text using simple prompt or chat messages',
-                            action: 'Generate text',
-                        },
-                    ],
-                    displayOptions: {
-                        show: {
-                            model: ['deepseek-reasoner'],
-                        },
-                    },
-                    default: 'generateText',
-                    description: 'Which type of output you want to generate',
-                },
-                {
-                    displayName: 'Input Type',
-                    name: 'inputType',
-                    type: 'options',
-                    required: true,
-                    options: [
-                        {
-                            name: 'Simple Prompt',
-                            value: 'prompt',
-                            description: 'Use a single prompt',
-                        },
-                        {
-                            name: 'Messages',
-                            value: 'messages',
-                            description: 'Use a conversation with multiple messages',
-                        },
-                    ],
-                    default: 'prompt',
-                    description: 'Choose how you want to provide input to the model',
-                },
-                {
-                    displayName: 'System',
-                    name: 'system',
-                    type: 'string',
-                    typeOptions: {
-                        rows: 4,
-                    },
-                    displayOptions: {
-                        show: {
-                            inputType: ['prompt'],
-                        },
-                    },
-                    default: 'You are a helpful assistant.',
-                    description: "System prompt that specifies the model's behavior",
-                    hint: "This field is optional, but can help guide the model's responses.",
-                    requiresDataPath: 'single',
-                },
-                {
-                    displayName: 'Prompt',
-                    name: 'prompt',
-                    type: 'string',
-                    typeOptions: {
-                        rows: 4,
-                    },
-                    displayOptions: {
-                        show: {
-                            inputType: ['prompt'],
-                        },
-                    },
-                    default: '',
-                    required: true,
-                    description: 'The single text prompt to generate a completion for',
-                    hint: 'You can drag data from previous nodes here using expressions.',
-                    requiresDataPath: 'single',
-                },
-                {
-                    displayName: 'Messages',
-                    name: 'messages',
-                    type: 'fixedCollection',
-                    typeOptions: {
-                        multipleValues: true,
-                        sortable: true,
-                        minValue: 1,
-                    },
-                    displayOptions: {
-                        show: {
-                            inputType: ['messages'],
-                            messageAsJson: [false],
-                        },
-                    },
-                    description: 'The messages for the conversation',
-                    default: {
-                        messagesUi: [
-                            {
-                                role: 'system',
-                                systemContent: 'You are a helpful assistant.',
-                            },
-                            {
-                                role: 'user',
-                                content: 'How can you help me?',
-                            },
-                        ],
-                    },
-                    required: true,
-                    options: [
-                        {
-                            name: 'messagesUi',
-                            displayName: 'Message',
-                            values: [
-                                {
-                                    displayName: 'Role',
-                                    name: 'role',
-                                    type: 'options',
-                                    options: [
-                                        {
-                                            name: 'Assistant',
-                                            value: 'assistant',
-                                        },
-                                        {
-                                            name: 'System',
-                                            value: 'system',
-                                        },
-                                        {
-                                            name: 'User',
-                                            value: 'user',
-                                        },
-                                    ],
-                                    default: 'user',
-                                    required: true,
-                                },
-                                {
-                                    displayName: 'System Content',
-                                    name: 'systemContent',
-                                    type: 'string',
-                                    description: 'The text content if role is System',
-                                    required: true,
-                                    typeOptions: {
-                                        rows: 4,
-                                    },
-                                    default: '',
-                                    displayOptions: {
-                                        show: {
-                                            role: ['system'],
-                                        },
-                                    },
-                                    requiresDataPath: 'single',
-                                },
-                                {
-                                    displayName: 'Content',
-                                    name: 'content',
-                                    type: 'string',
-                                    typeOptions: {
-                                        rows: 4,
-                                    },
-                                    displayOptions: {
-                                        show: {
-                                            role: ['assistant', 'user'],
-                                        },
-                                    },
-                                    default: '',
-                                    description: 'The text content of the message',
-                                    required: true,
-                                    requiresDataPath: 'single',
-                                },
-                            ],
-                        },
-                    ],
-                },
-                {
-                    displayName: 'Messages as JSON',
-                    name: 'messageAsJson',
-                    type: 'boolean',
-                    default: false,
-                    description: 'Whether to input messages as a JSON array instead of using the UI',
-                    displayOptions: {
-                        show: {
-                            operation: ['generateText', 'generateObject'],
-                            inputType: ['messages'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Messages (JSON)',
-                    name: 'messagesJson',
-                    type: 'string',
-                    default: '=[{"role": "user", "content": "Hello!"}]',
-                    description: 'Enter an array of message objects in JSON format (role, content)',
-                    required: true,
-                    typeOptions: {
-                        rows: 4,
-                    },
-                    noDataExpression: false,
-                    requiresDataPath: 'single',
-                    displayOptions: {
-                        show: {
-                            operation: ['generateText', 'generateObject'],
-                            inputType: ['messages'],
-                            messageAsJson: [true],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Schema Name',
-                    name: 'schemaName',
-                    type: 'string',
-                    default: '',
-                    description: 'Name of the output schema (optional)',
-                    hint: 'Some providers use this name for additional guidance when generating objects.',
-                    displayOptions: {
-                        show: {
-                            operation: ['generateObject'],
-                            model: ['deepseek-chat'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Schema Description',
-                    name: 'schemaDescription',
-                    type: 'string',
-                    default: '',
-                    description: 'Description of the output schema (optional)',
-                    hint: 'Some providers use this description for additional guidance when generating objects.',
-                    displayOptions: {
-                        show: {
-                            operation: ['generateObject'],
-                            model: ['deepseek-chat'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Schema',
-                    name: 'schema',
-                    type: 'json',
-                    displayOptions: {
-                        show: {
-                            operation: ['generateObject'],
-                            model: ['deepseek-chat'],
-                        },
-                    },
-                    default: `{\n\t"type": "object",\n\t"properties": {\n\t\t"sentiment": {\n\t\t"type": "string",\n\t\t"enum": ["positive","negative","neutral"],\n\t\t"description": "The overall sentiment of the text"\n\t\t},\n\t\t"score": {\n\t\t"type": "number",\n\t\t"minimum": -1,\n\t\t"maximum": 1,\n\t\t"description": "Sentiment score from -1 (negative) to 1 (positive)"\n\t\t},\n\t\t"text": {\n\t\t"type": "string",\n\t\t"description": "The text content to analyze"\n\t\t}\n\t}\n}`,
-                    required: true,
-                    description: 'JSON schema describing the structure and constraints of the object to generate',
-                    hint: 'For example, a schema describing sentiment analysis output.',
-                    requiresDataPath: 'single',
-                },
-                {
-                    displayName: 'Options',
-                    name: 'options',
-                    type: 'collection',
-                    placeholder: 'Add Option',
-                    default: {},
-                    options: [
-                        {
-                            displayName: 'Max Tokens',
-                            name: 'maxTokens',
-                            type: 'number',
-                            typeOptions: {
-                                minValue: 1,
-                            },
-                            default: 2048,
-                            description: 'The maximum number of tokens to generate',
-                        },
-                        {
-                            displayName: 'Temperature',
-                            name: 'temperature',
-                            type: 'number',
-                            typeOptions: {
-                                minValue: 0,
-                                maxValue: 2,
-                                numberPrecision: 2,
-                            },
-                            default: 0.7,
-                            description: 'Higher values produce more random outputs',
-                        },
-                        {
-                            displayName: 'Include Request Body',
-                            name: 'includeRequestBody',
-                            type: 'boolean',
-                            default: false,
-                            description: 'Whether to include the request body in the output',
-                        },
-                    ],
-                },
-            ],
-        };
-        this.methods = {
-            loadOptions: {
-                async getModels() {
-                    const credentials = await this.getCredentials('deepSeekApi');
-                    try {
-                        const response = await this.helpers.request({
-                            method: 'GET',
-                            url: 'https://api.deepseek.com/v1/models/list',
-                            headers: {
-                                Authorization: `Bearer ${credentials.apiKey}`,
-                            },
-                            json: true,
-                        });
-                        const returnData = [];
-                        if (response.data) {
-                            for (const model of response.data) {
-                                returnData.push({
-                                    name: model.name,
-                                    value: model.id,
-                                    description: model.description || '',
-                                });
-                            }
-                        }
-                        return returnData.sort((a, b) => a.name.localeCompare(b.name));
-                    }
-                    catch (error) {
-                        return [
-                            {
-                                name: 'DeepSeek Chat',
-                                value: 'deepseek-chat',
-                                description: 'Chat model optimized for conversations and structured outputs',
-                            },
-                            {
-                                name: 'DeepSeek Reasoner',
-                                value: 'deepseek-reasoner',
-                                description: 'Model optimized for reasoning and problem-solving',
-                            },
-                        ].sort((a, b) => a.name.localeCompare(b.name));
-                    }
-                },
-            },
-        };
-    }
-    async execute() {
-        const items = this.getInputData();
-        const returnData = [];
-        const credentials = await this.getCredentials('deepSeekApi');
-        if (!(credentials === null || credentials === void 0 ? void 0 : credentials.apiKey)) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No API key provided in credentials');
-        }
-        const deepSeekProvider = (0, deepseek_1.createDeepSeek)({
-            apiKey: credentials.apiKey,
-        });
-        for (let i = 0; i < items.length; i++) {
-            try {
-                const model = this.getNodeParameter('model', i);
-                const operation = this.getNodeParameter('operation', i);
-                const options = this.getNodeParameter('options', i, {});
-                const input = await buildInput(this, i);
-                if (operation === 'generateText') {
-                    const result = await (0, ai_1.generateText)({
-                        model: deepSeekProvider(model),
-                        messages: input.messages,
-                        maxTokens: options.maxTokens,
-                        temperature: options.temperature,
-                        prompt: input.prompt,
-                        system: input.system,
-                    });
-                    const formatted = formatTextResult(result, options.includeRequestBody);
-                    returnData.push({ json: formatted });
-                }
-                else if (operation === 'generateObject' && model === 'deepseek-chat') {
-                    const schemaName = this.getNodeParameter('schemaName', i, '');
-                    const schemaDescription = this.getNodeParameter('schemaDescription', i, '');
-                    const rawSchema = this.getNodeParameter('schema', i);
-                    let parsedSchema;
-                    try {
-                        parsedSchema = JSON.parse(rawSchema);
-                    }
-                    catch (err) {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Schema is not valid JSON: ' + err.message);
-                    }
-                    const ajv = new ajv_1.default();
-                    if (!ajv.validateSchema(parsedSchema)) {
-                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid JSON Schema: ${ajv.errorsText(ajv.errors)}`);
-                    }
-                    const result = await (0, ai_1.generateObject)({
-                        model: deepSeekProvider(model),
-                        schema: (0, ai_1.jsonSchema)(parsedSchema),
-                        schemaName,
-                        schemaDescription,
-                        prompt: input.prompt,
-                        system: input.system,
-                        messages: input.messages,
-                        maxTokens: options.maxTokens,
-                        temperature: options.temperature,
-                    });
-                    const formatted = formatObjectResult(result, options.includeRequestBody);
-                    returnData.push({ json: formatted });
-                }
-            }
-            catch (error) {
-                if (this.continueOnFail()) {
-                    returnData.push({ json: { error: error.message } });
-                }
-                else {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
-                }
-            }
-        }
-        return [returnData];
-    }
-}
-exports.DeepSeek = DeepSeek;
-//# sourceMappingURL=DeepSeek.node.js.map