n8n-nodes-vercel-ai-sdk-universal-temp 0.1.0

package/dist/nodes/UniversalAI/UniversalAI.node.js

@@ -0,0 +1,1273 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniversalAI = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const { createGoogleGenerativeAI } = require('@ai-sdk/google');
+const { createDeepSeek } = require('@ai-sdk/deepseek');
+const { createGroq } = require('@ai-sdk/groq');
+const { createOpenRouter } = require('@ai-sdk/openrouter');
+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.any(),
+            }))
+                .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 items = exec.getInputData();
+            const messagesUi = exec.getNodeParameter('messages.messagesUi', itemIndex, []);
+            const builtMessages = [];
+            for (const msg of messagesUi) {
+                const role = msg.role;
+                if (role === 'system') {
+                    builtMessages.push({
+                        role,
+                        content: msg.systemContent || '',
+                    });
+                    continue;
+                }
+                if (msg.contentType === 'text') {
+                    builtMessages.push({
+                        role,
+                        content: msg.content || '',
+                    });
+                }
+                else {
+                    const parts = [];
+                    if (msg.content) {
+                        parts.push({
+                            type: 'text',
+                            text: msg.content,
+                        });
+                    }
+                    let selectedMimeType = msg.mimeType || 'application/octet-stream';
+                    if (selectedMimeType === 'other' && msg.mimeTypeOther) {
+                        selectedMimeType = msg.mimeTypeOther;
+                    }
+                    if (msg.fileDataSource === 'url') {
+                        parts.push({
+                            type: 'file',
+                            data: msg.fileUrl,
+                            mimeType: selectedMimeType,
+                        });
+                    }
+                    else {
+                        const binaryProperty = msg.fileContent || 'data';
+                        const itemBinary = items[itemIndex].binary;
+                        if (!itemBinary || !itemBinary[binaryProperty]) {
+                            throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Binary property "${binaryProperty}" not found on item index ${itemIndex}`);
+                        }
+                        const binaryData = itemBinary[binaryProperty];
+                        const buffer = Buffer.from(binaryData.data, binaryData.data ? 'base64' : undefined);
+                        if (selectedMimeType === 'application/octet-stream' && binaryData.mimeType) {
+                            selectedMimeType = binaryData.mimeType;
+                        }
+                        parts.push({
+                            type: 'file',
+                            data: buffer,
+                            mimeType: selectedMimeType,
+                        });
+                    }
+                    builtMessages.push({
+                        role,
+                        content: parts,
+                    });
+                }
+            }
+            return { messages: builtMessages };
+        }
+    }
+}
+function formatTextResult(result, includeRequestBody, provider) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    let text = result.text;
+    let reasoning = result.reasoning;
+    if (provider === 'groq' && text.includes('<think>')) {
+        const thinkMatch = text.match(/<think>(.*?)<\/think>/s);
+        if (thinkMatch) {
+            reasoning = thinkMatch[1].trim();
+            text = text.replace(/<think>.*?<\/think>\s*/s, '').trim();
+        }
+    }
+    const out = {
+        text,
+        reasoning,
+        toolCalls: result.toolCalls || [],
+        toolResults: result.toolResults || [],
+        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,
+            ...(provider === 'deepseek' && {
+                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,
+                },
+            }),
+            ...(provider === 'groq' && {
+                cacheMetrics: {
+                    promptCacheHitTokens: (_j = (_h = result.experimental_providerMetadata) === null || _h === void 0 ? void 0 : _h.groq) === null || _j === void 0 ? void 0 : _j.promptCacheHitTokens,
+                    promptCacheMissTokens: (_l = (_k = result.experimental_providerMetadata) === null || _k === void 0 ? void 0 : _k.groq) === null || _l === void 0 ? void 0 : _l.promptCacheMissTokens,
+                },
+            }),
+        },
+        response: {
+            id: (_m = result.response) === null || _m === void 0 ? void 0 : _m.id,
+            modelId: (_o = result.response) === null || _o === void 0 ? void 0 : _o.modelId,
+            timestamp: (_p = result.response) === null || _p === void 0 ? void 0 : _p.timestamp,
+            headers: (_q = result.response) === null || _q === void 0 ? void 0 : _q.headers,
+        },
+        steps: result.steps || [],
+        warnings: result.warnings || [],
+        experimental_providerMetadata: result.experimental_providerMetadata,
+    };
+    if (includeRequestBody) {
+        out.request = { body: (_r = result.request) === null || _r === void 0 ? void 0 : _r.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 || [],
+        experimental_providerMetadata: result.experimental_providerMetadata,
+    };
+    if (includeRequestBody) {
+        out.request = { body: (_h = result.request) === null || _h === void 0 ? void 0 : _h.body };
+    }
+    return out;
+}
+class UniversalAI {
+    constructor() {
+        this.description = {
+            displayName: 'Universal AI',
+            name: 'universalAi',
+            icon: 'file:icons/UniversalAI.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["provider"] + ": " + $parameter["model"]}}',
+            description: 'Use multiple AI providers via Vercel AI SDK',
+            defaults: {
+                name: 'Universal AI',
+            },
+            inputs: [{ type: "main" }],
+            outputs: [{ type: "main" }],
+            credentials: [],
+            properties: [
+                {
+                    displayName: 'Provider',
+                    name: 'provider',
+                    type: 'options',
+                    required: true,
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Google Generative AI',
+                            value: 'google',
+                        },
+                        {
+                            name: 'DeepSeek',
+                            value: 'deepseek',
+                        },
+                        {
+                            name: 'Groq',
+                            value: 'groq',
+                        },
+                        {
+                            name: 'OpenRouter',
+                            value: 'openrouter',
+                        },
+                    ],
+                    default: 'google',
+                    description: 'Choose which AI provider to use',
+                },
+                {
+                    displayName: 'API Key',
+                    name: 'apiKey',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    default: '',
+                    required: false,
+                    description: 'API key for the selected provider. Leave empty to use credentials.',
+                    displayOptions: {
+                        show: {
+                            provider: ['google', 'deepseek', 'groq', 'openrouter'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Base URL',
+                    name: 'baseURL',
+                    type: 'string',
+                    default: `={{ $parameter.provider === 'google' ? 'https://generativelanguage.googleapis.com/v1beta' : $parameter.provider === 'deepseek' ? 'https://api.deepseek.com' : $parameter.provider === 'groq' ? 'https://api.groq.com' : $parameter.provider === 'openrouter' ? 'https://openrouter.ai/api/v1' : '' }}`,
+                    required: false,
+                    description: 'Base URL for the provider API. Defaults are set automatically based on the selected provider.',
+                },
+                {
+                    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',
+                        },
+                    ],
+                    default: 'generateText',
+                    description: 'Which type of output you want to generate',
+                },
+                {
+                    displayName: 'Model Name or ID',
+                    name: 'model',
+                    type: 'options',
+                    required: true,
+                    typeOptions: {
+                        loadOptionsMethod: 'getModels',
+                        loadOptionsDependsOn: ['provider'],
+                    },
+                    default: '',
+                    description: 'Select which model to use. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
+                },
+                {
+                    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',
+                                contentType: 'text',
+                                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 Type',
+                                    name: 'contentType',
+                                    type: 'options',
+                                    options: [
+                                        {
+                                            name: 'Text',
+                                            value: 'text',
+                                        },
+                                        {
+                                            name: 'Binary File',
+                                            value: 'file',
+                                        },
+                                    ],
+                                    default: 'text',
+                                    description: 'The type of content to send',
+                                    required: true,
+                                    displayOptions: {
+                                        show: {
+                                            role: ['assistant', 'user'],
+                                        },
+                                    },
+                                },
+                                {
+                                    displayName: 'Text Content',
+                                    name: 'content',
+                                    type: 'string',
+                                    typeOptions: {
+                                        rows: 4,
+                                    },
+                                    displayOptions: {
+                                        show: {
+                                            role: ['assistant', 'user'],
+                                            contentType: ['text'],
+                                        },
+                                    },
+                                    default: '',
+                                    description: 'The text content of the message',
+                                    required: true,
+                                    requiresDataPath: 'single',
+                                },
+                                {
+                                    displayName: 'File Source',
+                                    name: 'fileDataSource',
+                                    type: 'options',
+                                    options: [
+                                        {
+                                            name: 'Binary',
+                                            value: 'binary',
+                                            description: 'Use a binary property from n8n input',
+                                        },
+                                        {
+                                            name: 'URL',
+                                            value: 'url',
+                                            description: 'Send a URL for the AI to fetch',
+                                        },
+                                    ],
+                                    default: 'binary',
+                                    description: 'Where the file is coming from',
+                                    displayOptions: {
+                                        show: {
+                                            role: ['assistant', 'user'],
+                                            contentType: ['file'],
+                                        },
+                                    },
+                                },
+                                {
+                                    displayName: 'Binary Property',
+                                    name: 'fileContent',
+                                    type: 'string',
+                                    default: 'data',
+                                    description: 'Name of the binary property containing the file data',
+                                    required: true,
+                                    displayOptions: {
+                                        show: {
+                                            role: ['assistant', 'user'],
+                                            contentType: ['file'],
+                                            fileDataSource: ['binary'],
+                                        },
+                                    },
+                                },
+                                {
+                                    displayName: 'File URL',
+                                    name: 'fileUrl',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'URL of the file to download',
+                                    required: true,
+                                    displayOptions: {
+                                        show: {
+                                            role: ['assistant', 'user'],
+                                            contentType: ['file'],
+                                            fileDataSource: ['url'],
+                                        },
+                                    },
+                                    requiresDataPath: 'single',
+                                },
+                                {
+                                    displayName: 'MIME Type',
+                                    name: 'mimeType',
+                                    type: 'options',
+                                    default: 'application/octet-stream',
+                                    description: 'Select the MIME type of the file; choose Other to specify a custom MIME type',
+                                    options: [
+                                        {
+                                            name: 'JPEG Image (Image/jpeg)',
+                                            value: 'image/jpeg',
+                                        },
+                                        {
+                                            name: 'JSON (Application/json)',
+                                            value: 'application/json',
+                                        },
+                                        {
+                                            name: 'MP3 Audio (Audio/mpeg)',
+                                            value: 'audio/mpeg',
+                                        },
+                                        {
+                                            name: 'MP4 Video (Video/mp4)',
+                                            value: 'video/mp4',
+                                        },
+                                        {
+                                            name: 'Octet Stream (Default)',
+                                            value: 'application/octet-stream',
+                                        },
+                                        {
+                                            name: 'Other (Specify Below)',
+                                            value: 'other',
+                                        },
+                                        {
+                                            name: 'PDF (Application/pdf)',
+                                            value: 'application/pdf',
+                                        },
+                                        {
+                                            name: 'Plain Text (Text/plain)',
+                                            value: 'text/plain',
+                                        },
+                                        {
+                                            name: 'PNG Image (Image/png)',
+                                            value: 'image/png',
+                                        },
+                                        {
+                                            name: 'WAV Audio (Audio/wav)',
+                                            value: 'audio/wav',
+                                        },
+                                    ],
+                                    displayOptions: {
+                                        show: {
+                                            role: ['assistant', 'user'],
+                                            contentType: ['file'],
+                                            fileDataSource: ['url'],
+                                        },
+                                    },
+                                },
+                                {
+                                    displayName: 'Other MIME Type',
+                                    name: 'mimeTypeOther',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Specify a custom MIME type, e.g. application/x-zip-compressed',
+                                    displayOptions: {
+                                        show: {
+                                            role: ['assistant', 'user'],
+                                            contentType: ['file'],
+                                            mimeType: ['other'],
+                                        },
+                                    },
+                                },
+                                {
+                                    displayName: 'Additional Text',
+                                    name: 'content',
+                                    type: 'string',
+                                    typeOptions: {
+                                        rows: 2,
+                                    },
+                                    displayOptions: {
+                                        show: {
+                                            role: ['assistant', 'user'],
+                                            contentType: ['file'],
+                                        },
+                                    },
+                                    default: 'Please analyze this file.',
+                                    description: 'Additional text to include with the file',
+                                    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'],
+                        },
+                    },
+                },
+                {
+                    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'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Schema',
+                    name: 'schema',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            operation: ['generateObject'],
+                        },
+                    },
+                    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: 'Stop Sequences',
+                            name: 'stopSequences',
+                            type: 'string',
+                            default: '',
+                            description: 'Sequences where the API will stop generating text. Separate multiple sequences with commas.',
+                            displayOptions: {
+                                show: {
+                                    '/provider': ['google', 'openrouter'],
+                                },
+                            },
+                        },
+                        {
+                            displayName: 'Include Request Body',
+                            name: 'includeRequestBody',
+                            type: 'boolean',
+                            default: false,
+                            description: 'Whether to include the request body in the output',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Safety Settings',
+                    name: 'safetySettings',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            provider: ['google'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'settings',
+                            displayName: 'Setting',
+                            values: [
+                                {
+                                    displayName: 'Category',
+                                    name: 'category',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Hate Speech', value: 'HARM_CATEGORY_HATE_SPEECH' },
+                                        { name: 'Dangerous Content', value: 'HARM_CATEGORY_DANGEROUS_CONTENT' },
+                                        { name: 'Harassment', value: 'HARM_CATEGORY_HARASSMENT' },
+                                        { name: 'Sexually Explicit', value: 'HARM_CATEGORY_SEXUALLY_EXPLICIT' },
+                                    ],
+                                    default: 'HARM_CATEGORY_HATE_SPEECH',
+                                },
+                                {
+                                    displayName: 'Threshold',
+                                    name: 'threshold',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Block Low and Above', value: 'BLOCK_LOW_AND_ABOVE' },
+                                        { name: 'Block Medium and Above', value: 'BLOCK_MEDIUM_AND_ABOVE' },
+                                        { name: 'Block Only High', value: 'BLOCK_ONLY_HIGH' },
+                                        { name: 'Block None', value: 'BLOCK_NONE' },
+                                    ],
+                                    default: 'BLOCK_MEDIUM_AND_ABOVE',
+                                },
+                            ],
+                        },
+                    ],
+                    description: 'Set safety categories and thresholds to block or filter certain outputs',
+                },
+                {
+                    displayName: 'Use Search Grounding',
+                    name: 'useSearchGrounding',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            provider: ['google'],
+                        },
+                    },
+                    description: 'Whether to enable real-time or up-to-date information if supported by the model',
+                },
+                {
+                    displayName: 'Cached Content',
+                    name: 'cachedContent',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            provider: ['google'],
+                        },
+                    },
+                    description: 'Name of cached content to use (format: cachedContents/{cachedContent}). Reduces costs for repetitive content.',
+                },
+                {
+                    displayName: 'Response Modalities',
+                    name: 'responseModalities',
+                    type: 'multiOptions',
+                    options: [
+                        { name: 'Text', value: 'TEXT' },
+                        { name: 'Image', value: 'IMAGE' },
+                    ],
+                    default: [],
+                    displayOptions: {
+                        show: {
+                            provider: ['google'],
+                        },
+                    },
+                    description: 'Output modalities for the response. Leave empty for text-only (default).',
+                },
+                {
+                    displayName: 'Thinking Budget',
+                    name: 'thinkingBudget',
+                    type: 'number',
+                    default: 0,
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 8192,
+                    },
+                    displayOptions: {
+                        show: {
+                            provider: ['google'],
+                        },
+                    },
+                    description: 'Number of thinking tokens for reasoning models (Gemini 2.5+). Set to 0 to disable thinking.',
+                },
+                {
+                    displayName: 'Include Thoughts',
+                    name: 'includeThoughts',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            provider: ['google'],
+                        },
+                    },
+                    description: 'Whether to include thought summaries in the response (reasoning insights)',
+                },
+                {
+                    displayName: 'Google Tools',
+                    name: 'googleTools',
+                    type: 'multiOptions',
+                    options: [
+                        { name: 'Google Search', value: 'google_search' },
+                        { name: 'URL Context', value: 'url_context' },
+                        { name: 'Code Execution', value: 'code_execution' },
+                    ],
+                    default: [],
+                    displayOptions: {
+                        show: {
+                            provider: ['google'],
+                        },
+                    },
+                    description: 'Enable Google-specific tools for enhanced capabilities',
+                },
+                {
+                    displayName: 'Enable Streaming',
+                    name: 'enableStreaming',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['generateText'],
+                        },
+                    },
+                    description: 'Whether to stream the response in chunks. Output will contain multiple items.',
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getModels() {
+                    const provider = this.getCurrentNodeParameter('provider');
+                    try {
+                        switch (provider) {
+                            case 'google': {
+                                const credentials = await this.getCredentials('googleGenerativeAIApi');
+                                const response = await this.helpers.request({
+                                    method: 'GET',
+                                    url: 'https://generativelanguage.googleapis.com/v1beta/models',
+                                    headers: {
+                                        'x-goog-api-key': credentials.apiKey,
+                                    },
+                                    json: true,
+                                });
+                                const returnData = [];
+                                if (response.models) {
+                                    for (const model of response.models) {
+                                        if (model.name.includes('gemini')) {
+                                            const modelId = model.name.split('/').pop();
+                                            const displayName = model.displayName || modelId;
+                                            const version = modelId.includes('latest')
+                                                ? '(Latest)'
+                                                : `(${model.version || 'v1'})`;
+                                            returnData.push({
+                                                name: `${displayName} ${version}`,
+                                                value: modelId,
+                                                description: model.description || '',
+                                            });
+                                        }
+                                    }
+                                }
+                                return returnData.sort((a, b) => a.name.localeCompare(b.name));
+                            }
+                            case 'deepseek': {
+                                return [
+                                    {
+                                        name: 'DeepSeek Chat',
+                                        value: 'deepseek-chat',
+                                        description: 'DeepSeek chat model',
+                                    },
+                                    {
+                                        name: 'DeepSeek Coder',
+                                        value: 'deepseek-coder',
+                                        description: 'DeepSeek coding model',
+                                    },
+                                ];
+                            }
+                            case 'groq': {
+                                return [
+                                    {
+                                        name: 'Llama 3.1 8B',
+                                        value: 'llama-3.1-8b-instant',
+                                        description: 'Fast and efficient 8B model',
+                                    },
+                                    {
+                                        name: 'Llama 3.1 70B',
+                                        value: 'llama-3.1-70b-versatile',
+                                        description: 'High-performance 70B model',
+                                    },
+                                    {
+                                        name: 'Llama 3.1 405B',
+                                        value: 'llama-3.1-405b-instruct',
+                                        description: 'Most capable Llama model',
+                                    },
+                                    {
+                                        name: 'Mixtral 8x7B',
+                                        value: 'mixtral-8x7b-32768',
+                                        description: 'Mixture of experts model',
+                                    },
+                                    {
+                                        name: 'Gemma 7B',
+                                        value: 'gemma-7b-it',
+                                        description: 'Google Gemma model',
+                                    },
+                                ];
+                            }
+                            case 'openrouter': {
+                                try {
+                                    const credentials = await this.getCredentials('openRouterApi');
+                                    const response = await this.helpers.request({
+                                        method: 'GET',
+                                        url: 'https://openrouter.ai/api/v1/models',
+                                        headers: {
+                                            Authorization: `Bearer ${credentials.apiKey}`,
+                                        },
+                                        json: true,
+                                    });
+                                    const returnData = [];
+                                    if (response.data) {
+                                        for (const model of response.data) {
+                                            returnData.push({
+                                                name: model.name || model.id,
+                                                value: model.id,
+                                                description: model.description || '',
+                                            });
+                                        }
+                                    }
+                                    return returnData.sort((a, b) => a.name.localeCompare(b.name));
+                                }
+                                catch (error) {
+                                    return [
+                                        {
+                                            name: 'GPT-4o',
+                                            value: 'openai/gpt-4o',
+                                            description: 'OpenAI GPT-4o via OpenRouter',
+                                        },
+                                        {
+                                            name: 'GPT-4o Mini',
+                                            value: 'openai/gpt-4o-mini',
+                                            description: 'OpenAI GPT-4o Mini via OpenRouter',
+                                        },
+                                        {
+                                            name: 'Claude 3.5 Sonnet',
+                                            value: 'anthropic/claude-3.5-sonnet',
+                                            description: 'Anthropic Claude 3.5 Sonnet via OpenRouter',
+                                        },
+                                        {
+                                            name: 'Gemini 1.5 Pro',
+                                            value: 'google/gemini-pro-1.5',
+                                            description: 'Google Gemini 1.5 Pro via OpenRouter',
+                                        },
+                                    ];
+                                }
+                            }
+                            default:
+                                return [];
+                        }
+                    }
+                    catch (error) {
+                        switch (provider) {
+                            case 'google':
+                                return [
+                                    {
+                                        name: 'Gemini 1.5 Pro (Latest)',
+                                        value: 'gemini-1.5-pro-latest',
+                                        description: 'Most capable Gemini model for text generation',
+                                    },
+                                    {
+                                        name: 'Gemini 1.5 Flash (Latest)',
+                                        value: 'gemini-1.5-flash-latest',
+                                        description: 'Optimized for speed while maintaining high quality',
+                                    },
+                                ];
+                            case 'deepseek':
+                                return [
+                                    {
+                                        name: 'DeepSeek Chat',
+                                        value: 'deepseek-chat',
+                                        description: 'DeepSeek chat model',
+                                    },
+                                ];
+                            case 'groq':
+                                return [
+                                    {
+                                        name: 'Llama 3.1 8B',
+                                        value: 'llama-3.1-8b-instant',
+                                        description: 'Fast and efficient 8B model',
+                                    },
+                                ];
+                            case 'openrouter':
+                                return [
+                                    {
+                                        name: 'GPT-4o',
+                                        value: 'openai/gpt-4o',
+                                        description: 'OpenAI GPT-4o via OpenRouter',
+                                    },
+                                    {
+                                        name: 'Claude 3.5 Sonnet',
+                                        value: 'anthropic/claude-3.5-sonnet',
+                                        description: 'Anthropic Claude 3.5 Sonnet via OpenRouter',
+                                    },
+                                ];
+                            default:
+                                return [];
+                        }
+                    }
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const provider = this.getNodeParameter('provider', 0);
+        const apiKey = this.getNodeParameter('apiKey', 0, '');
+        const baseURL = this.getNodeParameter('baseURL', 0, '');
+        let credentials = null;
+        if (!apiKey) {
+            switch (provider) {
+                case 'google':
+                    credentials = await this.getCredentials('googleGenerativeAIApi');
+                    break;
+                case 'deepseek':
+                    credentials = await this.getCredentials('deepSeekApi');
+                    break;
+                case 'groq':
+                    credentials = await this.getCredentials('groqApi');
+                    break;
+                case 'openrouter':
+                    credentials = await this.getCredentials('openRouterApi');
+                    break;
+            }
+            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 actualApiKey = apiKey || credentials.apiKey;
+        let aiProvider;
+        switch (provider) {
+            case 'google':
+                aiProvider = createGoogleGenerativeAI({
+                    apiKey: actualApiKey,
+                    baseURL: baseURL || 'https://generativelanguage.googleapis.com/v1beta',
+                    headers: {
+                        'x-goog-api-key': actualApiKey,
+                    },
+                });
+                break;
+            case 'deepseek':
+                aiProvider = createDeepSeek({
+                    apiKey: actualApiKey,
+                    baseURL: baseURL || 'https://api.deepseek.com',
+                });
+                break;
+            case 'groq':
+                aiProvider = createGroq({
+                    apiKey: actualApiKey,
+                    baseURL: baseURL || 'https://api.groq.com',
+                });
+                break;
+            case 'openrouter':
+                aiProvider = createOpenRouter({
+                    apiKey: actualApiKey,
+                    baseURL: baseURL || 'https://openrouter.ai/api/v1',
+                });
+                break;
+        }
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter('operation', i);
+                const model = this.getNodeParameter('model', i);
+                const options = this.getNodeParameter('options', i, {});
+                let modelSettings = {};
+                let stopSequences;
+                if (options.stopSequences && (provider === 'google' || provider === 'openrouter')) {
+                    stopSequences = options.stopSequences.split(',').map(s => s.trim()).filter(s => s.length > 0);
+                }
+                if (provider === 'google') {
+                    const safetySettingsRaw = this.getNodeParameter('safetySettings.settings', i, []);
+                    const useSearchGrounding = this.getNodeParameter('useSearchGrounding', i, false);
+                    const cachedContent = this.getNodeParameter('cachedContent', i, '');
+                    const responseModalities = this.getNodeParameter('responseModalities', i, []);
+                    const thinkingBudget = this.getNodeParameter('thinkingBudget', i, 0);
+                    const includeThoughts = this.getNodeParameter('includeThoughts', i, false);
+                    const safetySettings = safetySettingsRaw.map((s) => ({
+                        category: s.category,
+                        threshold: s.threshold,
+                    }));
+                    modelSettings = {
+                        structuredOutputs: operation === 'generateObject',
+                        safetySettings: safetySettings.length > 0 ? safetySettings : undefined,
+                        useSearchGrounding,
+                        ...(cachedContent && { cachedContent }),
+                        ...(responseModalities.length > 0 && { responseModalities }),
+                        ...(thinkingBudget > 0 && {
+                            thinkingConfig: {
+                                thinkingBudget,
+                                includeThoughts,
+                            },
+                        }),
+                    };
+                }
+                else if (provider === 'openrouter') {
+                    modelSettings = {};
+                }
+                const input = await buildInput(this, i);
+                let tools = undefined;
+                if (provider === 'google') {
+                    const googleTools = this.getNodeParameter('googleTools', i, []);
+                    if (googleTools.length > 0) {
+                        tools = {};
+                        const google = require('@ai-sdk/google').google;
+                        if (googleTools.includes('google_search')) {
+                            tools.google_search = google.tools.googleSearch({});
+                        }
+                        if (googleTools.includes('url_context')) {
+                            tools.url_context = google.tools.urlContext({});
+                        }
+                        if (googleTools.includes('code_execution')) {
+                            tools.code_execution = google.tools.codeExecution({});
+                        }
+                    }
+                }
+                const enableStreaming = this.getNodeParameter('enableStreaming', i, false);
+                if (operation === 'generateText') {
+                    const generateTextParams = {
+                        model: aiProvider(model, modelSettings),
+                        messages: input.messages,
+                        maxTokens: options.maxTokens,
+                        temperature: options.temperature,
+                        prompt: input.prompt,
+                        system: input.system,
+                        ...(tools && { tools }),
+                    };
+                    if (stopSequences && (provider === 'google' || provider === 'openrouter')) {
+                        generateTextParams.stopSequences = stopSequences;
+                    }
+                    if (enableStreaming) {
+                        const stream = await (0, ai_1.streamText)(generateTextParams);
+                        let fullText = '';
+                        const chunks = [];
+                        for await (const textPart of stream.textStream) {
+                            fullText += textPart;
+                            chunks.push(textPart);
+                        }
+                        const finalUsage = await stream.usage;
+                        for (const chunk of chunks) {
+                            returnData.push({
+                                json: {
+                                    chunk,
+                                    isStreaming: true,
+                                }
+                            });
+                        }
+                        returnData.push({
+                            json: {
+                                text: fullText,
+                                toolCalls: stream.toolCalls || [],
+                                toolResults: stream.toolResults || [],
+                                finishReason: stream.finishReason,
+                                usage: {
+                                    promptTokens: finalUsage.promptTokens,
+                                    completionTokens: finalUsage.completionTokens,
+                                    totalTokens: finalUsage.totalTokens,
+                                },
+                                isStreaming: false,
+                                isFinal: true,
+                            }
+                        });
+                    }
+                    else {
+                        const result = await (0, ai_1.generateText)(generateTextParams);
+                        const formatted = formatTextResult(result, options.includeRequestBody, provider);
+                        if (tools && result.toolCalls) {
+                            formatted.toolCalls = result.toolCalls;
+                            formatted.toolResults = result.toolResults;
+                        }
+                        returnData.push({ json: formatted });
+                    }
+                }
+                else {
+                    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: aiProvider(model, modelSettings),
+                        schema: (0, ai_1.jsonSchema)(parsedSchema),
+                        schemaName,
+                        schemaDescription,
+                        prompt: input.prompt,
+                        system: input.system,
+                        messages: input.messages,
+                        maxTokens: options.maxTokens,
+                        temperature: options.temperature,
+                        ...(stopSequences && (provider === 'google' || provider === 'openrouter') && { stopSequences }),
+                    });
+                    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.UniversalAI = UniversalAI;
+//# sourceMappingURL=UniversalAI.node.js.map