n8n-nodes-vercel-ai-sdk-universal-temp 0.1.20 → 0.1.22

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

@@ -1,149 +1,268 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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('@openrouter/ai-sdk-provider');
+let googleProvider;
+let deepseekProvider;
+let groqProvider;
+let openrouterProvider;
 const ai_1 = require("ai");
 const zod_1 = require("zod");
 const ajv_1 = __importDefault(require("ajv"));
-const model_lists_1 = require("./model-lists");
-const modelCache = new Map();
-const providerCache = new Map();
+const descriptions_1 = require("../shared/descriptions");
+class Cache {
+    constructor(maxSize = 100, ttl = 5 * 60 * 1000) {
+        this.cache = new Map();
+        this.totalHits = 0;
+        this.totalMisses = 0;
+        this.maxSize = maxSize;
+        this.ttl = ttl;
+    }
+    get(key) {
+        const item = this.cache.get(key);
+        if (!item) {
+            this.totalMisses++;
+            return undefined;
+        }
+        if (Date.now() - item.timestamp > this.ttl) {
+            this.cache.delete(key);
+            this.totalMisses++;
+            return undefined;
+        }
+        item.hits++;
+        this.totalHits++;
+        return item.value;
+    }
+    set(key, value) {
+        if (this.cache.size >= this.maxSize) {
+            let minHits = Infinity;
+            let keyToDelete;
+            for (const [k, v] of this.cache.entries()) {
+                if (v.hits < minHits) {
+                    minHits = v.hits;
+                    keyToDelete = k;
+                }
+            }
+            if (keyToDelete) {
+                this.cache.delete(keyToDelete);
+            }
+        }
+        this.cache.set(key, { value, timestamp: Date.now(), hits: 0 });
+    }
+    getStats() {
+        return {
+            size: this.cache.size,
+            hits: this.totalHits,
+            misses: this.totalMisses,
+            hitRate: this.totalHits / (this.totalHits + this.totalMisses) || 0
+        };
+    }
+    clear() {
+        this.cache.clear();
+        this.totalHits = 0;
+        this.totalMisses = 0;
+    }
+}
+const modelCache = new Cache(50);
+const providerCache = new Cache(20);
+const schemaCache = new Cache(30);
+const messageSchema = zod_1.z.object({
+    role: zod_1.z.enum(['system', 'user', 'assistant']),
+    content: zod_1.z.any(),
+});
+const messagesArraySchema = zod_1.z.array(messageSchema);
+const ajv = new ajv_1.default({
+    allErrors: true,
+    verbose: true,
+    strict: false,
+});
+const isUrl = (str) => {
+    return str.startsWith('http://') ||
+        str.startsWith('https://') ||
+        str.startsWith('data:');
+};
+const isLikelyBase64 = (str) => {
+    if (str.length % 4 !== 0)
+        return false;
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(str))
+        return false;
+    if (str.length > 10000)
+        return true;
+    return true;
+};
 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,
+            prompt: exec.getNodeParameter('prompt', itemIndex),
+            system: exec.getNodeParameter('system', itemIndex),
         };
     }
-    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 };
+    const messageAsJson = exec.getNodeParameter('messageAsJson', itemIndex, false);
+    return messageAsJson
+        ? buildMessagesFromJson(exec, itemIndex)
+        : buildMessagesFromUI(exec, itemIndex);
+}
+async function buildMessagesFromJson(exec, itemIndex) {
+    const rawJson = exec.getNodeParameter('messagesJson', itemIndex);
+    try {
+        const parsed = JSON.parse(rawJson);
+        const result = messagesArraySchema.safeParse(parsed);
+        if (!result.success) {
+            throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Messages must be an array of objects with role and content.');
+        }
+        return { messages: result.data };
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid JSON in "Messages (JSON)" field: ${error.message}`);
+    }
+}
+async function buildMessagesFromUI(exec, itemIndex) {
+    var _a;
+    const items = exec.getInputData();
+    const messagesUi = exec.getNodeParameter('messages.messagesUi', itemIndex, []);
+    const builtMessages = [];
+    const itemBinary = items[itemIndex].binary;
+    for (const msg of messagesUi) {
+        const role = msg.role;
+        if (role === 'system') {
+            builtMessages.push({ role, content: msg.systemContent || '' });
+            continue;
+        }
+        const attachments = ((_a = msg.attachments) === null || _a === void 0 ? void 0 : _a.attachment) || [];
+        if (attachments.length === 0) {
+            builtMessages.push({ role, content: msg.content || '' });
         }
         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,
-                        });
-                    }
-                    const fileContentInput = msg.fileContent || '';
-                    let fileData;
-                    let detectedMimeType = msg.mimeType || undefined;
-                    if (detectedMimeType === 'other') {
-                        detectedMimeType = msg.mimeTypeOther || undefined;
-                    }
-                    if (fileContentInput.startsWith('http://') || fileContentInput.startsWith('https://') || fileContentInput.startsWith('data:')) {
-                        fileData = fileContentInput;
-                    }
-                    else {
-                        const itemBinary = items[itemIndex].binary;
-                        if (itemBinary && itemBinary[fileContentInput]) {
-                            const binaryData = itemBinary[fileContentInput];
-                            const buffer = Buffer.from(binaryData.data, binaryData.data ? 'base64' : undefined);
-                            fileData = buffer;
-                            if (!detectedMimeType && binaryData.mimeType) {
-                                detectedMimeType = binaryData.mimeType;
-                            }
-                        }
-                        else {
-                            try {
-                                fileData = Buffer.from(fileContentInput, 'base64');
-                            }
-                            catch (error) {
-                                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid base64 data in file content for message ${itemIndex + 1}: ${error.message}`);
-                            }
-                        }
-                    }
-                    if (fileData == null || (Buffer.isBuffer(fileData) && fileData.length === 0)) {
-                        continue;
-                    }
-                    const mediaType = detectedMimeType || 'application/octet-stream';
-                    parts.push({
-                        type: 'file',
-                        data: fileData,
-                        mediaType,
-                    });
-                    if (parts.length > 0) {
-                        builtMessages.push({
-                            role,
-                            content: parts,
-                        });
-                    }
-                }
+            const messageWithAttachments = await buildMessageWithAttachments(role, msg.content, attachments, itemBinary, exec, itemIndex);
+            if (messageWithAttachments) {
+                builtMessages.push(messageWithAttachments);
             }
-            const convertMessagesToModel = exec.getNodeParameter('convertMessagesToModel', itemIndex, false);
-            let finalMessages = builtMessages;
-            if (convertMessagesToModel) {
-                finalMessages = (0, ai_1.convertToModelMessages)(builtMessages);
+        }
+    }
+    const convertMessagesToModel = exec.getNodeParameter('convertMessagesToModel', itemIndex, false);
+    if (convertMessagesToModel) {
+        return { messages: (0, ai_1.convertToModelMessages)(builtMessages) };
+    }
+    return { messages: builtMessages };
+}
+async function buildMessageWithAttachments(role, content, attachments, itemBinary, exec, itemIndex) {
+    const parts = [];
+    if (content) {
+        parts.push({ type: 'text', text: content });
+    }
+    const MAX_CONCURRENT_ATTACHMENTS = 3;
+    const processedAttachments = [];
+    for (let i = 0; i < attachments.length; i += MAX_CONCURRENT_ATTACHMENTS) {
+        const batch = attachments.slice(i, i + MAX_CONCURRENT_ATTACHMENTS);
+        const batchPromises = batch.map(attachment => processAttachment(attachment, itemBinary, exec, itemIndex));
+        const batchResults = await Promise.all(batchPromises);
+        processedAttachments.push(...batchResults);
+    }
+    for (const attachment of processedAttachments) {
+        if (attachment) {
+            parts.push(attachment);
+        }
+    }
+    return parts.length > 0 ? { role, content: parts } : null;
+}
+async function processAttachment(attachment, itemBinary, exec, itemIndex) {
+    const fileContentInput = attachment.fileContent;
+    if (!fileContentInput)
+        return null;
+    let mimeType = getMimeType(attachment);
+    let fileData;
+    if (isUrl(fileContentInput)) {
+        fileData = fileContentInput;
+    }
+    else {
+        fileData = await getBinaryData(fileContentInput, itemBinary, exec, itemIndex);
+        if (!fileData)
+            return null;
+        const binaryItem = itemBinary === null || itemBinary === void 0 ? void 0 : itemBinary[fileContentInput];
+        if (!mimeType && (binaryItem === null || binaryItem === void 0 ? void 0 : binaryItem.mimeType)) {
+            mimeType = binaryItem.mimeType;
+        }
+    }
+    if (!fileData || (Buffer.isBuffer(fileData) && fileData.length === 0)) {
+        return null;
+    }
+    return {
+        type: 'file',
+        data: fileData,
+        mediaType: mimeType || 'application/octet-stream',
+    };
+}
+function getMimeType(attachment) {
+    return attachment.mimeType === 'other'
+        ? attachment.mimeTypeOther
+        : attachment.mimeType;
+}
+async function getBinaryData(fileContentInput, itemBinary, exec, itemIndex) {
+    if (itemBinary === null || itemBinary === void 0 ? void 0 : itemBinary[fileContentInput]) {
+        const binaryData = itemBinary[fileContentInput];
+        return Buffer.from(binaryData.data, 'base64');
+    }
+    try {
+        if (isLikelyBase64(fileContentInput)) {
+            const buffer = Buffer.from(fileContentInput, 'base64');
+            if (buffer.length > 0 && buffer.length < 50 * 1024 * 1024) {
+                return buffer;
             }
-            return { messages: finalMessages };
         }
     }
+    catch (error) {
+        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid file content for attachment: ${error.message}`);
+    }
+    return null;
 }
 function formatTextResult(result, includeRequestBody, provider) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
-    let text = result.text;
-    let reasoning = result.reasoning;
+    var _a, _b, _c;
+    let { text, reasoning } = result;
     if (provider === 'groq' && text.includes('<think>')) {
         const thinkMatch = text.match(/<think>(.*?)<\/think>/s);
         if (thinkMatch) {
-            reasoning = [{ text: thinkMatch[1].trim() }];
+            reasoning = [{ type: 'reasoning', text: thinkMatch[1].trim() }];
             text = text.replace(/<think>.*?<\/think>\s*/s, '').trim();
         }
     }
-    const out = {
+    const baseResult = {
         text,
         reasoning,
         reasoningText: result.reasoningText,
@@ -152,855 +271,169 @@ function formatTextResult(result, includeRequestBody, provider) {
         finishReason: result.finishReason,
         sources: result.sources || [],
         files: result.files || [],
-        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,
-                },
-            }),
-            ...(provider === 'google' && {
-                cacheMetrics: {
-                    cachedContentTokenCount: (_p = (_o = (_m = result.experimental_providerMetadata) === null || _m === void 0 ? void 0 : _m.google) === null || _o === void 0 ? void 0 : _o.usageMetadata) === null || _p === void 0 ? void 0 : _p.cachedContentTokenCount,
-                    thoughtsTokenCount: (_s = (_r = (_q = result.experimental_providerMetadata) === null || _q === void 0 ? void 0 : _q.google) === null || _r === void 0 ? void 0 : _r.usageMetadata) === null || _s === void 0 ? void 0 : _s.thoughtsTokenCount,
-                },
-            }),
-        },
-        response: {
-            id: (_t = result.response) === null || _t === void 0 ? void 0 : _t.id,
-            modelId: (_u = result.response) === null || _u === void 0 ? void 0 : _u.modelId,
-            timestamp: (_v = result.response) === null || _v === void 0 ? void 0 : _v.timestamp,
-            headers: (_w = result.response) === null || _w === void 0 ? void 0 : _w.headers,
-        },
+        usage: formatUsage(result, provider),
+        response: formatResponse(result),
         steps: result.steps || [],
         warnings: result.warnings || [],
         experimental_providerMetadata: result.experimental_providerMetadata,
-        ...(provider === 'google' && {
-            groundingMetadata: (_y = (_x = result.experimental_providerMetadata) === null || _x === void 0 ? void 0 : _x.google) === null || _y === void 0 ? void 0 : _y.groundingMetadata,
-            safetyRatings: (_0 = (_z = result.experimental_providerMetadata) === null || _z === void 0 ? void 0 : _z.google) === null || _0 === void 0 ? void 0 : _0.safetyRatings,
-        }),
     };
+    if (provider === 'google') {
+        const providerMetadata = result.experimental_providerMetadata;
+        baseResult.groundingMetadata = (_a = providerMetadata === null || providerMetadata === void 0 ? void 0 : providerMetadata.google) === null || _a === void 0 ? void 0 : _a.groundingMetadata;
+        baseResult.safetyRatings = (_b = providerMetadata === null || providerMetadata === void 0 ? void 0 : providerMetadata.google) === null || _b === void 0 ? void 0 : _b.safetyRatings;
+    }
     if (includeRequestBody) {
-        out.request = { body: (_1 = result.request) === null || _1 === void 0 ? void 0 : _1.body };
+        const requestBody = (_c = result.request) === null || _c === void 0 ? void 0 : _c.body;
+        if (requestBody !== undefined) {
+            baseResult.request = { body: requestBody };
+        }
     }
-    return out;
+    return baseResult;
 }
-function formatObjectResult(result, includeRequestBody) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
+function formatObjectResult(result, includeRequestBody, provider) {
+    var _a;
     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,
-        },
+        usage: formatUsage(result, provider),
+        response: formatResponse(result),
         warnings: result.warnings || [],
         experimental_providerMetadata: result.experimental_providerMetadata,
     };
     if (includeRequestBody) {
-        out.request = { body: (_h = result.request) === null || _h === void 0 ? void 0 : _h.body };
+        out.request = { body: (_a = result.request) === null || _a === void 0 ? void 0 : _a.body };
     }
     return out;
 }
+function formatUsage(result, provider) {
+    var _a, _b, _c;
+    const 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,
+    };
+    const cacheMetrics = getCacheMetrics(result, provider);
+    if (Object.keys(cacheMetrics).length > 0) {
+        usage.cacheMetrics = cacheMetrics;
+    }
+    return usage;
+}
+function getCacheMetrics(result, provider) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const metadata = result.experimental_providerMetadata;
+    switch (provider) {
+        case 'deepseek':
+            return {
+                promptCacheHitTokens: (_a = metadata === null || metadata === void 0 ? void 0 : metadata.deepseek) === null || _a === void 0 ? void 0 : _a.promptCacheHitTokens,
+                promptCacheMissTokens: (_b = metadata === null || metadata === void 0 ? void 0 : metadata.deepseek) === null || _b === void 0 ? void 0 : _b.promptCacheMissTokens,
+            };
+        case 'groq':
+            return {
+                promptCacheHitTokens: (_c = metadata === null || metadata === void 0 ? void 0 : metadata.groq) === null || _c === void 0 ? void 0 : _c.promptCacheHitTokens,
+                promptCacheMissTokens: (_d = metadata === null || metadata === void 0 ? void 0 : metadata.groq) === null || _d === void 0 ? void 0 : _d.promptCacheMissTokens,
+            };
+        case 'google':
+            return {
+                cachedContentTokenCount: (_f = (_e = metadata === null || metadata === void 0 ? void 0 : metadata.google) === null || _e === void 0 ? void 0 : _e.usageMetadata) === null || _f === void 0 ? void 0 : _f.cachedContentTokenCount,
+                thoughtsTokenCount: (_h = (_g = metadata === null || metadata === void 0 ? void 0 : metadata.google) === null || _g === void 0 ? void 0 : _g.usageMetadata) === null || _h === void 0 ? void 0 : _h.thoughtsTokenCount,
+            };
+        default:
+            return {};
+    }
+}
+function formatResponse(result) {
+    var _a, _b, _c, _d;
+    return {
+        id: (_a = result.response) === null || _a === void 0 ? void 0 : _a.id,
+        modelId: (_b = result.response) === null || _b === void 0 ? void 0 : _b.modelId,
+        timestamp: (_c = result.response) === null || _c === void 0 ? void 0 : _c.timestamp,
+        headers: (_d = result.response) === null || _d === void 0 ? void 0 : _d.headers,
+    };
+}
+async function getProvider(provider, apiKey, baseURL) {
+    const cacheKey = `${provider}:${apiKey}:${baseURL || ''}`;
+    const cached = providerCache.get(cacheKey);
+    if (cached)
+        return cached;
+    let providerInstance;
+    try {
+        switch (provider) {
+            case 'google':
+                if (!googleProvider) {
+                    googleProvider = require('@ai-sdk/google').createGoogleGenerativeAI;
+                }
+                providerInstance = googleProvider({ apiKey, ...(baseURL && { baseURL }) });
+                break;
+            case 'deepseek':
+                if (!deepseekProvider) {
+                    deepseekProvider = require('@ai-sdk/deepseek').createDeepSeek;
+                }
+                providerInstance = deepseekProvider({ apiKey, ...(baseURL && { baseURL }) });
+                break;
+            case 'groq':
+                if (!groqProvider) {
+                    groqProvider = require('@ai-sdk/groq').createGroq;
+                }
+                providerInstance = groqProvider({ apiKey, ...(baseURL && { baseURL }) });
+                break;
+            case 'openrouter':
+                if (!openrouterProvider) {
+                    openrouterProvider = require('@openrouter/ai-sdk-provider').createOpenRouter;
+                }
+                providerInstance = openrouterProvider({ apiKey, ...(baseURL && { baseURL }) });
+                break;
+            default:
+                throw new Error(`Unsupported provider: ${provider}`);
+        }
+        providerCache.set(cacheKey, providerInstance);
+        return providerInstance;
+    }
+    catch (error) {
+        throw new Error(`Failed to initialize ${provider} provider: ${error.message}`);
+    }
+}
+function parseAndValidateSchema(rawSchema, exec) {
+    const cacheKey = `schema:${Buffer.from(rawSchema).toString('base64').substring(0, 50)}`;
+    const cached = schemaCache.get(cacheKey);
+    if (cached)
+        return cached;
+    let parsedSchema;
+    try {
+        parsedSchema = JSON.parse(rawSchema);
+    }
+    catch (err) {
+        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Schema is not valid JSON: ' + err.message);
+    }
+    if (!ajv.validateSchema(parsedSchema)) {
+        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid JSON Schema: ${ajv.errorsText(ajv.errors)}`);
+    }
+    schemaCache.set(cacheKey, parsedSchema);
+    return parsedSchema;
+}
+function parseStopSequences(stopSequencesStr) {
+    if (!stopSequencesStr)
+        return undefined;
+    return stopSequencesStr.split(',').map(s => s.trim()).filter(s => s.length > 0);
+}
 class UniversalAI {
     constructor() {
-        this.description = {
-            displayName: 'Universal AI',
-            name: 'universalAi',
-            icon: 'file:icons/UniversalAI.svg',
-            group: ['transform'],
-            version: 2,
-            subtitle: '={{$parameter["resource"] + ": " + $parameter["provider"] + ": " + $parameter["model"]}}',
-            description: 'Use multiple AI providers via Vercel AI SDK',
-            defaults: {
-                name: 'Universal AI',
-            },
-            inputs: [{ type: "main" }],
-            outputs: [{ type: "main" }],
-            credentials: [
-                {
-                    name: 'googleGenerativeAIApi',
-                    required: false,
-                    displayOptions: {
-                        show: {
-                            provider: ['google'],
-                        },
-                    },
-                },
-                {
-                    name: 'deepSeekApi',
-                    required: false,
-                    displayOptions: {
-                        show: {
-                            provider: ['deepseek'],
-                        },
-                    },
-                },
-                {
-                    name: 'groqApi',
-                    required: false,
-                    displayOptions: {
-                        show: {
-                            provider: ['groq'],
-                        },
-                    },
-                },
-                {
-                    name: 'openRouterApi',
-                    required: false,
-                    displayOptions: {
-                        show: {
-                            provider: ['openrouter'],
-                        },
-                    },
-                },
-            ],
-            properties: [
-                {
-                    displayName: 'Resource',
-                    name: 'resource',
-                    type: 'options',
-                    required: true,
-                    noDataExpression: true,
-                    options: [
-                        {
-                            name: 'AI',
-                            value: 'ai',
-                        },
-                    ],
-                    default: 'ai',
-                    description: 'The resource to operate on',
-                },
-                {
-                    displayName: 'Provider',
-                    name: 'provider',
-                    type: 'options',
-                    required: true,
-                    noDataExpression: true,
-                    displayOptions: {
-                        show: {
-                            resource: ['ai'],
-                        },
-                    },
-                    options: [
-                        {
-                            name: 'Google Generative AI',
-                            value: 'google',
-                            description: 'Google Gemini models with multimodal support',
-                        },
-                        {
-                            name: 'DeepSeek',
-                            value: 'deepseek',
-                            description: 'DeepSeek models with strong reasoning capabilities',
-                        },
-                        {
-                            name: 'Groq',
-                            value: 'groq',
-                            description: 'High-performance models via Groq LPU',
-                        },
-                        {
-                            name: 'OpenRouter',
-                            value: 'openrouter',
-                            description: 'Access multiple models through OpenRouter',
-                        },
-                    ],
-                    default: 'google',
-                    description: 'Choose which AI provider to use',
-                },
-                {
-                    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,
-                    noDataExpression: 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',
-                                    noDataExpression: true,
-                                    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',
-                                    noDataExpression: true,
-                                    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 Content',
-                                    name: 'fileContent',
-                                    type: 'string',
-                                    default: '',
-                                    displayOptions: {
-                                        show: {
-                                            role: ['assistant', 'user'],
-                                            contentType: ['file'],
-                                        },
-                                    },
-                                    description: 'File content: binary property name, base64 string, or http(s)/data: URL',
-                                    required: true,
-                                },
-                                {
-                                    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'],
-                                        },
-                                    },
-                                },
-                                {
-                                    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: 'Convert Messages to Model Messages',
-                    name: 'convertMessagesToModel',
-                    type: 'boolean',
-                    default: false,
-                    description: 'Convert UI messages to ModelMessage format using convertToModelMessages. Enable if you get "Invalid prompt: The messages must be a ModelMessage[]" errors.',
-                    displayOptions: {
-                        show: {
-                            inputType: ['messages'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Messages as JSON',
-                    name: 'messageAsJson',
-                    type: 'boolean',
-                    default: false,
-                    noDataExpression: true,
-                    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: 'Top P',
-                            name: 'topP',
-                            type: 'number',
-                            typeOptions: {
-                                minValue: 0,
-                                maxValue: 1,
-                                numberPrecision: 2,
-                            },
-                            default: 1,
-                            description: 'Controls diversity via nucleus sampling. Lower values make outputs more focused.',
-                        },
-                        {
-                            displayName: 'Top K',
-                            name: 'topK',
-                            type: 'number',
-                            typeOptions: {
-                                minValue: 1,
-                            },
-                            default: 50,
-                            description: 'Limits the number of tokens considered for sampling. Only applies to some providers.',
-                            displayOptions: {
-                                show: {
-                                    '/provider': ['google'],
-                                },
-                            },
-                        },
-                        {
-                            displayName: 'Frequency Penalty',
-                            name: 'frequencyPenalty',
-                            type: 'number',
-                            typeOptions: {
-                                minValue: -2,
-                                maxValue: 2,
-                                numberPrecision: 2,
-                            },
-                            default: 0,
-                            description: 'Reduces repetition of frequent tokens. Positive values decrease repetition.',
-                        },
-                        {
-                            displayName: 'Presence Penalty',
-                            name: 'presencePenalty',
-                            type: 'number',
-                            typeOptions: {
-                                minValue: -2,
-                                maxValue: 2,
-                                numberPrecision: 2,
-                            },
-                            default: 0,
-                            description: 'Encourages talking about new topics. Positive values increase likelihood of new topics.',
-                        },
-                        {
-                            displayName: 'Seed',
-                            name: 'seed',
-                            type: 'number',
-                            default: 0,
-                            description: 'Random seed for reproducible outputs. Not supported by all providers.',
-                        },
-                        {
-                            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',
-                                    noDataExpression: true,
-                                    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',
-                                    noDataExpression: true,
-                                    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.description = descriptions_1.UNIVERSAL_AI_DESCRIPTION;
         this.methods = {
             loadOptions: {
                 async getModels() {
                     const provider = this.getCurrentNodeParameter('provider');
-                    if (modelCache.has(provider)) {
-                        return modelCache.get(provider);
-                    }
-                    let models = [];
-                    switch (provider) {
-                        case 'google':
-                            models = model_lists_1.GOOGLE_GEMINI_MODELS;
-                            break;
-                        case 'deepseek':
-                            models = model_lists_1.DEEPSEEK_MODELS;
-                            break;
-                        case 'groq':
-                            models = model_lists_1.GROQ_MODELS;
-                            break;
-                        case 'openrouter':
-                            models = model_lists_1.OPENROUTER_MODELS;
-                            break;
-                    }
-                    modelCache.set(provider, models);
+                    const cacheKey = `models:${provider}`;
+                    const cached = modelCache.get(cacheKey);
+                    if (cached)
+                        return cached;
+                    const { OPENROUTER_MODELS, GOOGLE_GEMINI_MODELS, DEEPSEEK_MODELS, GROQ_MODELS } = await Promise.resolve().then(() => __importStar(require('./model-lists')));
+                    const models = {
+                        google: GOOGLE_GEMINI_MODELS,
+                        deepseek: DEEPSEEK_MODELS,
+                        groq: GROQ_MODELS,
+                        openrouter: OPENROUTER_MODELS,
+                    }[provider] || [];
+                    modelCache.set(cacheKey, models);
                     return models;
                 },
             },
@@ -1010,223 +443,33 @@ class UniversalAI {
         const items = this.getInputData();
         const returnData = [];
         const provider = this.getNodeParameter('provider', 0);
-        let credentials = null;
-        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;
+        const credentialType = {
+            google: 'googleGenerativeAIApi',
+            deepseek: 'deepSeekApi',
+            groq: 'groqApi',
+            openrouter: 'openRouterApi',
+        }[provider];
+        if (!credentialType) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported provider: ${provider}`);
         }
+        const credentials = await this.getCredentials(credentialType);
         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 = credentials.apiKey;
-        const actualBaseURL = credentials.baseUrl;
-        const providerCacheKey = `${provider}:${actualApiKey || ''}:${actualBaseURL || ''}`;
-        let aiProvider;
-        if (providerCache.has(providerCacheKey)) {
-            aiProvider = providerCache.get(providerCacheKey);
-        }
-        else {
-            switch (provider) {
-                case 'google':
-                    aiProvider = createGoogleGenerativeAI({
-                        apiKey: actualApiKey,
-                        ...(actualBaseURL && { baseURL: actualBaseURL }),
-                    });
-                    break;
-                case 'deepseek':
-                    aiProvider = createDeepSeek({
-                        apiKey: actualApiKey,
-                        ...(actualBaseURL && { baseURL: actualBaseURL }),
-                    });
-                    break;
-                case 'groq':
-                    aiProvider = createGroq({
-                        apiKey: actualApiKey,
-                        ...(actualBaseURL && { baseURL: actualBaseURL }),
-                    });
-                    break;
-                case 'openrouter':
-                    aiProvider = createOpenRouter({
-                        apiKey: actualApiKey,
-                        ...(actualBaseURL && { baseURL: actualBaseURL }),
-                    });
-                    break;
-            }
-            providerCache.set(providerCacheKey, aiProvider);
-        }
+        const aiProvider = await getProvider(provider, credentials.apiKey, credentials.baseUrl);
         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,
-                        topP: options.topP,
-                        topK: options.topK,
-                        frequencyPenalty: options.frequencyPenalty,
-                        presencePenalty: options.presencePenalty,
-                        seed: options.seed,
-                        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 generateObjectParams = {
-                        model: aiProvider(model, modelSettings),
-                        schema: (0, ai_1.jsonSchema)(parsedSchema),
-                        schemaName,
-                        schemaDescription,
-                        temperature: options.temperature,
-                        topP: options.topP,
-                        topK: options.topK,
-                        frequencyPenalty: options.frequencyPenalty,
-                        presencePenalty: options.presencePenalty,
-                        seed: options.seed,
-                        ...(stopSequences && (provider === 'google' || provider === 'openrouter') && { stopSequences }),
-                    };
-                    if (input.messages && input.messages.length > 0) {
-                        generateObjectParams.messages = input.messages;
-                    }
-                    else if (input.prompt) {
-                        generateObjectParams.prompt = input.prompt;
-                    }
-                    if (input.system) {
-                        generateObjectParams.system = input.system;
-                    }
-                    const result = await (0, ai_1.generateObject)(generateObjectParams);
-                    const formatted = formatObjectResult(result, options.includeRequestBody);
-                    returnData.push({ json: formatted });
-                }
+                const result = await processItem(this, i, provider, aiProvider);
+                returnData.push(...result);
             }
             catch (error) {
                 if (this.continueOnFail()) {
-                    returnData.push({ json: { error: error.message } });
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                            itemIndex: i
+                        }
+                    });
                 }
                 else {
                     throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
@@ -1237,4 +480,153 @@ class UniversalAI {
     }
 }
 exports.UniversalAI = UniversalAI;
+async function processItem(exec, index, provider, aiProvider) {
+    const operation = exec.getNodeParameter('operation', index);
+    const model = exec.getNodeParameter('model', index);
+    const options = exec.getNodeParameter('options', index, {});
+    const input = await buildInput(exec, index);
+    const modelSettings = getModelSettings(exec, index, provider, operation, options);
+    return operation === 'generateText'
+        ? await generateTextOperation(exec, index, provider, aiProvider, model, modelSettings, input, options)
+        : await generateObjectOperation(exec, index, provider, aiProvider, model, modelSettings, input, options);
+}
+function getModelSettings(exec, index, provider, operation, options) {
+    const settings = {};
+    const stopSequences = parseStopSequences(options.stopSequences);
+    if (stopSequences && (provider === 'google' || provider === 'openrouter')) {
+        settings.stopSequences = stopSequences;
+    }
+    if (provider === 'google') {
+        const safetySettingsRaw = exec.getNodeParameter('safetySettings.settings', index, []);
+        if (safetySettingsRaw.length > 0) {
+            settings.safetySettings = safetySettingsRaw.map((s) => ({
+                category: s.category,
+                threshold: s.threshold,
+            }));
+        }
+        settings.structuredOutputs = operation === 'generateObject';
+        settings.useSearchGrounding = exec.getNodeParameter('useSearchGrounding', index, false);
+        const cachedContent = exec.getNodeParameter('cachedContent', index, '');
+        if (cachedContent) {
+            settings.cachedContent = cachedContent;
+        }
+        const thinkingBudgetValue = Number(exec.getNodeParameter('thinkingBudget', index, 0));
+        if (!Number.isNaN(thinkingBudgetValue) && thinkingBudgetValue > 0) {
+            settings.thinkingConfig = {
+                thinkingBudget: thinkingBudgetValue,
+                includeThoughts: exec.getNodeParameter('includeThoughts', index, false),
+            };
+        }
+        const responseModalities = exec.getNodeParameter('responseModalities', index, []);
+        if (responseModalities.length > 0) {
+            settings.responseModalities = responseModalities;
+        }
+    }
+    return settings;
+}
+async function generateTextOperation(exec, index, provider, aiProvider, model, modelSettings, input, options) {
+    const enableStreaming = exec.getNodeParameter('enableStreaming', index, false);
+    const includeRequestBody = options.includeRequestBody;
+    const tools = provider === 'google' ? await buildGoogleTools(exec, index) : undefined;
+    const params = {
+        model: aiProvider(model, modelSettings),
+        ...input,
+        ...(tools && { tools }),
+    };
+    const numericOptionKeys = [
+        'maxTokens',
+        'temperature',
+        'topP',
+        'topK',
+        'frequencyPenalty',
+        'presencePenalty',
+        'seed',
+    ];
+    for (const key of numericOptionKeys) {
+        const value = options[key];
+        if (value !== undefined && value !== null && value !== '') {
+            params[key] = value;
+        }
+    }
+    if (enableStreaming) {
+        return await handleStreaming(params, provider, includeRequestBody);
+    }
+    const result = await (0, ai_1.generateText)(params);
+    return [{ json: formatTextResult(result, includeRequestBody, provider) }];
+}
+async function buildGoogleTools(exec, index) {
+    const googleTools = exec.getNodeParameter('googleTools', index, []);
+    if (!googleTools || googleTools.length === 0) {
+        return undefined;
+    }
+    const tools = {};
+    const google = require('@ai-sdk/google').google;
+    const toolSet = new Set(googleTools);
+    if (toolSet.has('google_search')) {
+        tools.google_search = google.tools.googleSearch({});
+    }
+    if (toolSet.has('url_context')) {
+        tools.url_context = google.tools.urlContext({});
+    }
+    if (toolSet.has('code_execution')) {
+        tools.code_execution = google.tools.codeExecution({});
+    }
+    return tools;
+}
+async function handleStreaming(params, provider, includeRequestBody) {
+    const stream = await (0, ai_1.streamText)(params);
+    const chunks = [];
+    let fullText = '';
+    for await (const textPart of stream.textStream) {
+        fullText += textPart;
+        chunks.push({ json: { chunk: textPart, isStreaming: true } });
+    }
+    const finalUsage = await stream.usage;
+    const finalJson = {
+        text: fullText,
+        toolCalls: stream.toolCalls || [],
+        toolResults: stream.toolResults || [],
+        finishReason: stream.finishReason,
+        usage: formatUsage({ usage: finalUsage }, provider),
+        isStreaming: false,
+        isFinal: true,
+    };
+    if (includeRequestBody) {
+        const requestMetadata = stream.request ? await stream.request : undefined;
+        if ((requestMetadata === null || requestMetadata === void 0 ? void 0 : requestMetadata.body) !== undefined) {
+            finalJson.request = { body: requestMetadata.body };
+        }
+    }
+    chunks.push({ json: finalJson });
+    return chunks;
+}
+async function generateObjectOperation(exec, index, provider, aiProvider, model, modelSettings, input, options) {
+    const schemaName = exec.getNodeParameter('schemaName', index, '');
+    const schemaDescription = exec.getNodeParameter('schemaDescription', index, '');
+    const rawSchema = exec.getNodeParameter('schema', index);
+    const parsedSchema = parseAndValidateSchema(rawSchema, exec);
+    const params = {
+        model: aiProvider(model, modelSettings),
+        schema: (0, ai_1.jsonSchema)(parsedSchema),
+        schemaName,
+        schemaDescription,
+        ...input,
+    };
+    const numericOptionKeys = [
+        'temperature',
+        'topP',
+        'topK',
+        'frequencyPenalty',
+        'presencePenalty',
+        'seed',
+    ];
+    for (const key of numericOptionKeys) {
+        const value = options[key];
+        if (value !== undefined && value !== null && value !== '') {
+            params[key] = value;
+        }
+    }
+    const result = await (0, ai_1.generateObject)(params);
+    return [{ json: formatObjectResult(result, options.includeRequestBody, provider) }];
+}
 //# sourceMappingURL=UniversalAI.node.js.map