n8n-nodes-vercel-ai-sdk-universal-temp 0.1.51 → 0.1.53

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

@@ -41,15 +41,42 @@ const n8n_workflow_1 = require("n8n-workflow");
 const ai_1 = require("ai");
 const zod_1 = require("zod");
 const ajv_1 = __importDefault(require("ajv"));
+const crypto_1 = require("crypto");
 const descriptions_1 = require("../shared/descriptions");
+class UniversalAIError extends Error {
+    constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = 'UniversalAIError';
+    }
+}
+class CacheError extends UniversalAIError {
+    constructor(message, context) {
+        super(message, 'CACHE_ERROR', context);
+    }
+}
+class ProviderError extends UniversalAIError {
+    constructor(message, context) {
+        super(message, 'PROVIDER_ERROR', context);
+    }
+}
+class ValidationError extends UniversalAIError {
+    constructor(message, context) {
+        super(message, 'VALIDATION_ERROR', context);
+    }
+}
 class Cache {
-    constructor(maxSize = 100, ttl = 5 * 60 * 1000) {
+    constructor(_name, maxSize = 100, ttl = 5 * 60 * 1000) {
         this.cache = new Map();
         this.totalHits = 0;
         this.totalMisses = 0;
         this.totalEvictions = 0;
         this.maxSize = maxSize;
         this.ttl = ttl;
+        if (ttl > 0) {
+            setInterval(() => this.cleanupExpired(), Math.min(ttl, 60000));
+        }
     }
     get(key) {
         const item = this.cache.get(key);
@@ -65,6 +92,7 @@ class Cache {
             return undefined;
         }
         item.hits++;
+        item.lastAccessed = now;
         this.totalHits++;
         return item.value;
     }
@@ -72,20 +100,42 @@ class Cache {
         const now = Date.now();
         const expiresAt = customTTL ? now + customTTL : (this.ttl > 0 ? now + this.ttl : undefined);
         if (this.cache.size >= this.maxSize) {
-            let oldestKey;
-            let oldestTime = now;
-            for (const [k, v] of this.cache.entries()) {
-                if (v.timestamp < oldestTime) {
-                    oldestTime = v.timestamp;
-                    oldestKey = k;
-                }
+            this.evictLRU();
+        }
+        this.cache.set(key, {
+            value,
+            timestamp: now,
+            hits: 0,
+            expiresAt,
+            lastAccessed: now
+        });
+    }
+    evictLRU() {
+        let lruKey;
+        let oldestAccess = Date.now();
+        for (const [key, item] of this.cache.entries()) {
+            if (item.lastAccessed < oldestAccess) {
+                oldestAccess = item.lastAccessed;
+                lruKey = key;
             }
-            if (oldestKey) {
-                this.cache.delete(oldestKey);
-                this.totalEvictions++;
+        }
+        if (lruKey) {
+            this.cache.delete(lruKey);
+            this.totalEvictions++;
+        }
+    }
+    cleanupExpired() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, item] of this.cache.entries()) {
+            if (item.expiresAt && now > item.expiresAt) {
+                this.cache.delete(key);
+                cleaned++;
             }
         }
-        this.cache.set(key, { value, timestamp: now, hits: 0, expiresAt });
+        if (cleaned > 0) {
+            this.totalEvictions += cleaned;
+        }
     }
     delete(key) {
         return this.cache.delete(key);
@@ -96,93 +146,111 @@ class Cache {
         this.totalMisses = 0;
         this.totalEvictions = 0;
     }
+    entries() {
+        return this.cache.entries();
+    }
+    getMetadata(key) {
+        return this.cache.get(key);
+    }
     getStats() {
+        const totalRequests = this.totalHits + this.totalMisses;
+        let totalSize = 0;
+        for (const item of this.cache.values()) {
+            totalSize += this.estimateSize(item.value);
+        }
         return {
             size: this.cache.size,
             maxSize: this.maxSize,
-            hitRate: this.totalHits / (this.totalHits + this.totalMisses) || 0,
+            hitRate: totalRequests > 0 ? this.totalHits / totalRequests : 0,
             totalHits: this.totalHits,
             totalMisses: this.totalMisses,
             totalEvictions: this.totalEvictions,
             ttl: this.ttl,
+            averageItemSize: this.cache.size > 0 ? totalSize / this.cache.size : 0,
         };
     }
+    estimateSize(value) {
+        try {
+            return JSON.stringify(value).length;
+        }
+        catch {
+            return 1024;
+        }
+    }
 }
-const modelCache = new Cache(50);
-const providerCache = new Cache(20);
-const schemaCache = new Cache(30);
-const googleCacheClients = new Cache(10, 60 * 60 * 1000);
-const googleCachedContexts = new Cache(50, 55 * 60 * 1000);
+function generateCacheKey(data, prefix = '') {
+    const dataStr = typeof data === 'string' ? data : JSON.stringify(data);
+    const hash = (0, crypto_1.createHash)('sha256').update(dataStr).digest('hex').substring(0, 16);
+    return `${prefix}${hash}`;
+}
+const modelCache = new Cache('models', 50, 10 * 60 * 1000);
+const providerCache = new Cache('providers', 20, 30 * 60 * 1000);
+const schemaCache = new Cache('schemas', 30, 60 * 60 * 1000);
+const googleCacheClients = new Cache('google_clients', 10, 60 * 60 * 1000);
+const googleCachedContexts = new Cache('google_contexts', 50, 55 * 60 * 1000);
+async function cleanupExpiredGoogleCaches() {
+    const now = Date.now();
+    for (const [key, entry] of googleCachedContexts.entries()) {
+        if (entry.expiresAt && now > entry.expiresAt) {
+            try {
+                const client = await getGoogleCacheManager(entry.value.apiKey);
+                await client.caches.delete(entry.value.name);
+            }
+            catch (error) {
+                console.warn(`Failed to cleanup Google cache ${entry.value.name}:`, error);
+            }
+            finally {
+                googleCachedContexts.delete(key);
+            }
+        }
+    }
+}
+setInterval(() => {
+    cleanupExpiredGoogleCaches().catch(console.error);
+}, 5 * 60 * 1000);
 async function getGoogleCacheManager(apiKey) {
-    let client = googleCacheClients.get(apiKey);
-    if (!client) {
+    const cacheKey = generateCacheKey(apiKey, 'google_client:');
+    const cachedClient = googleCacheClients.get(cacheKey);
+    if (cachedClient) {
+        return cachedClient;
+    }
+    try {
         const { GoogleGenAI } = await Promise.resolve().then(() => __importStar(require('@google/genai')));
-        client = new GoogleGenAI({ apiKey });
-        googleCacheClients.set(apiKey, client);
+        const client = new GoogleGenAI({ apiKey });
+        googleCacheClients.set(cacheKey, client);
+        return client;
+    }
+    catch (error) {
+        throw new CacheError(`Failed to initialize Google cache client: ${error.message}`, { apiKey: apiKey.substring(0, 8) + '...' });
     }
-    return client;
 }
-async function createGoogleCache(exec, index, apiKey, cacheContent, tools) {
-    var _a;
+function isUrl(str) {
+    if (typeof str !== 'string')
+        return false;
     try {
-        const useGoogleCache = exec.getNodeParameter('useGoogleCache', index, false);
-        if (!useGoogleCache) {
-            return null;
-        }
-        const googleCacheManager = await getGoogleCacheManager(apiKey);
-        const normalizedCacheContent = (_a = cacheContent === null || cacheContent === void 0 ? void 0 : cacheContent.trim()) !== null && _a !== void 0 ? _a : '';
-        if (!normalizedCacheContent) {
-            return null;
-        }
-        const cacheKeyData = {
-            content: normalizedCacheContent,
-            tools: tools ? Object.keys(tools).sort() : [],
-            model: 'gemini-2.0-flash-001',
-        };
-        const cacheKey = JSON.stringify(cacheKeyData);
-        const existingCache = googleCachedContexts.get(cacheKey);
-        if (existingCache) {
-            return existingCache.name;
-        }
-        const ttlSeconds = 3600;
-        const displayName = `universal_ai_cache_${Date.now()}`;
-        const cacheConfig = {
-            model: 'gemini-2.0-flash-001',
-            config: {
-                displayName,
-                ttl: `${ttlSeconds}s`,
-                contents: [{
-                        role: 'user',
-                        parts: [{ text: normalizedCacheContent }],
-                    }],
-            },
-        };
-        if (tools && Object.keys(tools).length > 0) {
-            cacheConfig.config.tools = Object.values(tools);
-        }
-        const result = await googleCacheManager.caches.create(cacheConfig);
-        const cachedContentName = result === null || result === void 0 ? void 0 : result.name;
-        if (!cachedContentName) {
-            throw new Error('Failed to get cached content name from creation response');
-        }
-        googleCachedContexts.set(cacheKey, { name: cachedContentName }, ttlSeconds * 1000);
-        return cachedContentName;
+        const url = new URL(str);
+        return url.protocol === 'http:' || url.protocol === 'https:';
     }
-    catch (error) {
-        console.error('UniversalAI: Failed to create Google cache. Falling back to non-cached execution:', error);
-        return null;
+    catch {
+        return str.startsWith('data:');
     }
 }
-function canUseCache(cacheContent) {
-    return Boolean(cacheContent && cacheContent.trim().length > 0);
+function isLikelyBase64(str) {
+    if (typeof str !== 'string')
+        return false;
+    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;
 }
 function extractTextFromMessageContent(content) {
-    if (!content) {
+    if (!content)
         return '';
-    }
-    if (typeof content === 'string') {
+    if (typeof content === 'string')
         return content;
-    }
     if (Array.isArray(content)) {
         return content
             .map((part) => {
@@ -202,16 +270,20 @@ function extractTextFromMessageContent(content) {
     }
     return '';
 }
+function canUseCache(cacheContent) {
+    return Boolean(cacheContent && cacheContent.trim().length > 0);
+}
 function resolveCacheContent(input) {
+    var _a, _b, _c;
     const sections = [];
     let hasSystem = false;
     let hasMessages = false;
     let hasPrompt = false;
-    if (input.system && input.system.trim()) {
+    if ((_a = input.system) === null || _a === void 0 ? void 0 : _a.trim()) {
         sections.push(`System Instruction:\n${input.system.trim()}`);
         hasSystem = true;
     }
-    if (input.messages && input.messages.length > 0) {
+    if ((_b = input.messages) === null || _b === void 0 ? void 0 : _b.length) {
         const messageSections = [];
         for (const message of input.messages) {
             const text = extractTextFromMessageContent(message.content);
@@ -222,34 +294,31 @@ function resolveCacheContent(input) {
                     sections.push(`System Instruction (from messages):\n${text.trim()}`);
                     hasSystem = true;
                 }
-                continue;
             }
-            messageSections.push(`${message.role.toUpperCase()}:\n${text.trim()}`);
+            else {
+                messageSections.push(`${message.role.toUpperCase()}:\n${text.trim()}`);
+            }
         }
         if (messageSections.length > 0) {
             sections.push(`Messages:\n${messageSections.join('\n\n')}`);
             hasMessages = true;
         }
     }
-    if (input.prompt && input.prompt.trim()) {
+    if ((_c = input.prompt) === null || _c === void 0 ? void 0 : _c.trim()) {
         sections.push(`Prompt Template:\n${input.prompt.trim()}`);
         hasPrompt = true;
     }
     const content = sections.join('\n\n').trim();
     let source;
     const sourceCount = [hasSystem, hasMessages, hasPrompt].filter(Boolean).length;
-    if (sourceCount > 1) {
+    if (sourceCount > 1)
         source = 'combined';
-    }
-    else if (hasSystem) {
+    else if (hasSystem)
         source = 'system';
-    }
-    else if (hasMessages) {
+    else if (hasMessages)
         source = 'messages';
-    }
-    else if (hasPrompt) {
+    else if (hasPrompt)
         source = 'prompt';
-    }
     return {
         content: content || undefined,
         hasSystem,
@@ -258,120 +327,234 @@ function resolveCacheContent(input) {
         source,
     };
 }
-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) => {
-    if (typeof str !== 'string')
-        return false;
-    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 createGoogleCache(exec, index, apiKey, cacheContent, tools) {
+    try {
+        const useGoogleCache = exec.getNodeParameter('useGoogleCache', index, false);
+        if (!useGoogleCache || !(cacheContent === null || cacheContent === void 0 ? void 0 : cacheContent.trim())) {
+            return null;
+        }
+        const googleCacheManager = await getGoogleCacheManager(apiKey);
+        const normalizedCacheContent = cacheContent.trim();
+        const cacheKeyData = {
+            content: normalizedCacheContent,
+            tools: tools ? Object.keys(tools).sort() : [],
+            model: 'gemini-2.0-flash-001',
+        };
+        const cacheKey = generateCacheKey(cacheKeyData, 'google_cache:');
+        const existingCache = googleCachedContexts.get(cacheKey);
+        if (existingCache) {
+            return existingCache.name;
+        }
+        const ttlSeconds = 3600;
+        const displayName = `n8n_cache_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const cacheConfig = {
+            model: 'gemini-2.0-flash-001',
+            config: {
+                displayName,
+                ttl: `${ttlSeconds}s`,
+                contents: [{
+                        role: 'user',
+                        parts: [{ text: normalizedCacheContent }],
+                    }],
+            },
+        };
+        if (tools && Object.keys(tools).length > 0) {
+            cacheConfig.config.tools = Object.values(tools);
+        }
+        const result = await googleCacheManager.caches.create(cacheConfig);
+        const cachedContentName = result === null || result === void 0 ? void 0 : result.name;
+        if (!cachedContentName) {
+            throw new CacheError('Failed to create cache: No name in response', { displayName });
+        }
+        googleCachedContexts.set(cacheKey, {
+            name: cachedContentName,
+            apiKey
+        }, ttlSeconds * 1000);
+        return cachedContentName;
+    }
+    catch (error) {
+        if (error instanceof CacheError)
+            throw error;
+        throw new CacheError(`Google cache creation failed: ${error.message}`, {
+            cacheContentLength: cacheContent === null || cacheContent === void 0 ? void 0 : cacheContent.length,
+            hasTools: !!tools && Object.keys(tools).length > 0
+        });
+    }
+}
 async function buildInput(exec, itemIndex) {
     const inputType = exec.getNodeParameter('inputType', itemIndex);
     if (inputType === 'prompt') {
-        const promptValue = exec.getNodeParameter('prompt', itemIndex, '');
-        const systemValue = exec.getNodeParameter('system', itemIndex, '');
-        const result = {};
-        const trimmedPrompt = typeof promptValue === 'string' ? promptValue.trim() : '';
-        if (trimmedPrompt) {
-            result.prompt = trimmedPrompt;
-        }
-        const trimmedSystem = typeof systemValue === 'string' ? systemValue.trim() : '';
-        if (trimmedSystem) {
-            result.system = trimmedSystem;
-        }
-        return result;
+        return buildPromptInput(exec, itemIndex);
     }
     const messageAsJson = exec.getNodeParameter('messageAsJson', itemIndex, false);
     return messageAsJson
         ? buildMessagesFromJson(exec, itemIndex)
         : buildMessagesFromUI(exec, itemIndex);
 }
+function buildPromptInput(exec, itemIndex) {
+    const result = {};
+    const promptValue = exec.getNodeParameter('prompt', itemIndex, '').trim();
+    if (promptValue) {
+        if (promptValue.length > 100000) {
+            throw new ValidationError('Prompt is too long (max 100,000 characters)');
+        }
+        result.prompt = promptValue;
+    }
+    const systemValue = exec.getNodeParameter('system', itemIndex, '').trim();
+    if (systemValue) {
+        if (systemValue.length > 50000) {
+            throw new ValidationError('System instruction is too long (max 50,000 characters)');
+        }
+        result.system = systemValue;
+    }
+    return result;
+}
+const messageSchema = zod_1.z.object({
+    role: zod_1.z.enum(['system', 'user', 'assistant', 'tool']),
+    content: zod_1.z.any(),
+});
+const messagesArraySchema = zod_1.z.array(messageSchema);
+const ajv = new ajv_1.default({
+    allErrors: true,
+    verbose: true,
+    strict: false,
+    useDefaults: true,
+    removeAdditional: true,
+});
 async function buildMessagesFromJson(exec, itemIndex) {
     const rawJson = exec.getNodeParameter('messagesJson', itemIndex);
+    if (!rawJson.trim()) {
+        throw new ValidationError('Messages JSON field is empty');
+    }
+    if (rawJson.length > 200000) {
+        throw new ValidationError('Messages JSON is too large (max 200,000 characters)');
+    }
     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.');
+            const errorDetails = result.error.issues
+                .map((issue) => {
+                const path = issue.path.length > 0 ? issue.path.join('.') : '(root)';
+                return `${path}: ${issue.message}`;
+            })
+                .join('; ');
+            throw new ValidationError(`Invalid messages format: ${errorDetails}`);
+        }
+        if (result.data.length > 100) {
+            throw new ValidationError('Too many messages (max 100)');
         }
         return { messages: result.data };
     }
     catch (error) {
-        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid JSON in "Messages (JSON)" field: ${error.message}`);
+        if (error instanceof ValidationError)
+            throw error;
+        throw new ValidationError(`Invalid JSON in messages field: ${error.message}`);
     }
 }
 async function buildMessagesFromUI(exec, itemIndex) {
-    var _a;
+    var _a, _b, _c;
     const items = exec.getInputData();
     const messagesUi = exec.getNodeParameter('messages.messagesUi', itemIndex, []);
+    if (messagesUi.length > 100) {
+        throw new ValidationError('Too many messages (max 100)');
+    }
     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 || '' });
+            if ((_a = msg.systemContent) === null || _a === void 0 ? void 0 : _a.trim()) {
+                builtMessages.push({ role, content: msg.systemContent.trim() });
+            }
             continue;
         }
-        const attachments = ((_a = msg.attachments) === null || _a === void 0 ? void 0 : _a.attachment) || [];
+        const attachments = ((_b = msg.attachments) === null || _b === void 0 ? void 0 : _b.attachment) || [];
+        const content = ((_c = msg.content) === null || _c === void 0 ? void 0 : _c.trim()) || '';
         if (attachments.length === 0) {
-            builtMessages.push({ role, content: msg.content || '' });
+            if (content) {
+                builtMessages.push({ role, content });
+            }
         }
         else {
-            const messageWithAttachments = await buildMessageWithAttachments(role, msg.content, attachments, itemBinary, exec, itemIndex);
+            const messageWithAttachments = await buildMessageWithAttachments(role, content, attachments, itemBinary, exec, itemIndex);
             if (messageWithAttachments) {
                 builtMessages.push(messageWithAttachments);
             }
         }
     }
     const convertMessagesToModel = exec.getNodeParameter('convertMessagesToModel', itemIndex, false);
-    if (convertMessagesToModel) {
-        return { messages: (0, ai_1.convertToModelMessages)(builtMessages) };
-    }
-    return { messages: builtMessages };
+    return {
+        messages: convertMessagesToModel ? (0, ai_1.convertToModelMessages)(builtMessages) : builtMessages
+    };
 }
+const MAX_ATTACHMENT_SIZE = 50 * 1024 * 1024;
+const MAX_TOTAL_ATTACHMENTS_SIZE = 100 * 1024 * 1024;
 async function buildMessageWithAttachments(role, content, attachments, itemBinary, exec, itemIndex) {
     const parts = [];
     if (content) {
         parts.push({ type: 'text', text: content });
     }
+    let totalSize = 0;
     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);
+        const processedAttachments = await Promise.all(batchPromises);
+        for (const attachment of processedAttachments) {
+            if (attachment) {
+                if (attachment.data instanceof Buffer) {
+                    totalSize += attachment.data.length;
+                    if (totalSize > MAX_TOTAL_ATTACHMENTS_SIZE) {
+                        throw new ValidationError(`Total attachments size exceeds limit of ${MAX_TOTAL_ATTACHMENTS_SIZE / 1024 / 1024}MB`);
+                    }
+                }
+                parts.push(attachment);
+            }
         }
     }
     return parts.length > 0 ? { role, content: parts } : null;
 }
+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];
+        if (binaryData.data) {
+            const buffer = Buffer.from(binaryData.data, 'base64');
+            if (buffer.length > MAX_ATTACHMENT_SIZE) {
+                throw new ValidationError(`Attachment too large: ${buffer.length / 1024 / 1024}MB (max ${MAX_ATTACHMENT_SIZE / 1024 / 1024}MB)`);
+            }
+            return {
+                data: buffer,
+                mimeType: binaryData.mimeType
+            };
+        }
+    }
+    try {
+        if (isLikelyBase64(fileContentInput)) {
+            const buffer = Buffer.from(fileContentInput, 'base64');
+            if (buffer.length > MAX_ATTACHMENT_SIZE) {
+                throw new ValidationError(`Attachment too large: ${buffer.length / 1024 / 1024}MB (max ${MAX_ATTACHMENT_SIZE / 1024 / 1024}MB)`);
+            }
+            if (buffer.length > 0) {
+                return { data: buffer, mimeType: undefined };
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof ValidationError)
+            throw error;
+        throw new ValidationError(`Invalid file content for attachment: ${error.message}`);
+    }
+    return { data: null, mimeType: undefined };
+}
 async function processAttachment(attachment, itemBinary, exec, itemIndex) {
     const fileContentInput = attachment.fileContent;
-    if (!fileContentInput || typeof fileContentInput !== 'string')
+    if (!fileContentInput || typeof fileContentInput !== 'string') {
         return null;
+    }
     let mimeType = getMimeType(attachment);
     let fileData;
     if (isUrl(fileContentInput)) {
@@ -379,46 +562,19 @@ async function processAttachment(attachment, itemBinary, exec, itemIndex) {
     }
     else {
         const result = await getBinaryData(fileContentInput, itemBinary, exec, itemIndex);
+        if (!result.data)
+            return null;
         fileData = result.data;
         if (!mimeType && result.mimeType) {
             mimeType = result.mimeType;
         }
     }
-    if (!fileData || (Buffer.isBuffer(fileData) && fileData.length === 0)) {
-        return null;
-    }
     return {
         type: 'file',
         data: fileData,
-        mediaType: mimeType || 'application/octet-stream',
+        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 {
-            data: Buffer.from(binaryData.data, 'base64'),
-            mimeType: binaryData.mimeType,
-        };
-    }
-    try {
-        if (isLikelyBase64(fileContentInput)) {
-            const buffer = Buffer.from(fileContentInput, 'base64');
-            if (buffer.length > 0 && buffer.length < 50 * 1024 * 1024) {
-                return { data: buffer, mimeType: undefined };
-            }
-        }
-    }
-    catch (error) {
-        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid file content for attachment: ${error.message}`);
-    }
-    return { data: null, mimeType: undefined };
-}
 function formatTextResult(result, includeRequestBody, provider) {
     var _a, _b, _c, _d, _e;
     let { text, reasoning } = result;
@@ -532,163 +688,159 @@ function getCacheMetrics(result, provider, metadata) {
 }
 function formatResponse(result) {
     var _a, _b, _c, _d;
-    const response = {
+    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,
     };
-    return response;
 }
-async function getProvider(provider, apiKey, baseURL, customHeaders) {
-    const headersKey = customHeaders
-        ? JSON.stringify(Object.keys(customHeaders)
+async function getProvider(provider, config) {
+    const headersKey = config.customHeaders
+        ? generateCacheKey(Object.keys(config.customHeaders)
             .sort()
-            .map((key) => [key, customHeaders[key]]))
+            .map((key) => [key, config.customHeaders[key]]), 'headers:')
         : '';
-    const cacheKey = `${provider}:${apiKey}:${baseURL || ''}:${headersKey}`;
+    const cacheKey = generateCacheKey(`${provider}:${config.apiKey}:${config.baseURL || ''}:${headersKey}`, 'provider:');
     const cached = providerCache.get(cacheKey);
     if (cached)
         return cached;
-    let providerInstance;
     try {
+        let providerInstance;
         switch (provider) {
             case 'google':
                 const { createGoogleGenerativeAI } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/google')));
                 providerInstance = createGoogleGenerativeAI({
-                    apiKey,
-                    ...(baseURL && { baseURL }),
-                    ...(customHeaders && Object.keys(customHeaders).length > 0 && { headers: customHeaders }),
+                    apiKey: config.apiKey,
+                    ...(config.baseURL && { baseURL: config.baseURL }),
+                    ...(config.customHeaders && Object.keys(config.customHeaders).length > 0 && {
+                        headers: config.customHeaders
+                    }),
                 });
                 break;
             case 'deepseek':
                 const { createDeepSeek } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/deepseek')));
-                providerInstance = createDeepSeek({ apiKey, ...(baseURL && { baseURL }) });
+                providerInstance = createDeepSeek({
+                    apiKey: config.apiKey,
+                    ...(config.baseURL && { baseURL: config.baseURL })
+                });
                 break;
             case 'groq':
                 const { createGroq } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/groq')));
-                providerInstance = createGroq({ apiKey, ...(baseURL && { baseURL }) });
+                providerInstance = createGroq({
+                    apiKey: config.apiKey,
+                    ...(config.baseURL && { baseURL: config.baseURL })
+                });
                 break;
             case 'openrouter':
                 const { createOpenRouter } = await Promise.resolve().then(() => __importStar(require('@openrouter/ai-sdk-provider')));
-                providerInstance = createOpenRouter({ apiKey, ...(baseURL && { baseURL }) });
+                providerInstance = createOpenRouter({
+                    apiKey: config.apiKey,
+                    ...(config.baseURL && { baseURL: config.baseURL })
+                });
                 break;
             default:
-                throw new Error(`Unsupported provider: ${provider}`);
+                throw new ProviderError(`Unsupported provider: ${provider}`);
         }
         providerCache.set(cacheKey, providerInstance);
         return providerInstance;
     }
     catch (error) {
-        throw new Error(`Failed to initialize ${provider} provider: ${error.message}`);
+        throw new ProviderError(`Failed to initialize ${provider} provider: ${error.message}`, { provider, baseURL: config.baseURL });
     }
 }
 function parseAndValidateSchema(rawSchema, exec) {
-    const cacheKey = `schema:${Buffer.from(rawSchema).toString('base64').substring(0, 50)}`;
+    if (!rawSchema.trim()) {
+        throw new ValidationError('Schema field is empty');
+    }
+    if (rawSchema.length > 100000) {
+        throw new ValidationError('Schema is too large (max 100,000 characters)');
+    }
+    const cacheKey = generateCacheKey(rawSchema, 'schema:');
     const cached = schemaCache.get(cacheKey);
     if (cached)
         return cached;
-    let parsedSchema;
     try {
-        parsedSchema = JSON.parse(rawSchema);
+        const parsedSchema = JSON.parse(rawSchema);
+        if (!ajv.validateSchema(parsedSchema)) {
+            throw new ValidationError(`Invalid JSON Schema: ${ajv.errorsText(ajv.errors)}`);
+        }
+        schemaCache.set(cacheKey, parsedSchema);
+        return parsedSchema;
     }
     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)}`);
+        throw new ValidationError(`Schema is not valid JSON: ${err.message}`);
     }
-    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);
+    const sequences = stopSequencesStr
+        .split(',')
+        .map(s => s.trim())
+        .filter(Boolean);
+    return sequences.length > 0 ? sequences : undefined;
 }
 function applyNumericOptions(params, options, keys) {
     for (const key of keys) {
         const value = options[key];
         if (value !== undefined && value !== null && value !== '') {
-            params[key] = value;
+            const numValue = Number(value);
+            if (!isNaN(numValue)) {
+                params[key] = numValue;
+            }
         }
     }
 }
-class UniversalAI {
-    constructor() {
-        this.description = descriptions_1.UNIVERSAL_AI_DESCRIPTION;
-        this.methods = {
-            loadOptions: {
-                async getModels() {
-                    const provider = this.getCurrentNodeParameter('provider');
-                    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;
-                },
-            },
-        };
+function resolveFinalContext(input, cachedContentName, cacheContentInfo) {
+    const finalContext = {};
+    if (!cachedContentName) {
+        return input;
     }
-    async execute() {
-        const items = this.getInputData();
-        const returnData = [];
-        const provider = this.getNodeParameter('provider', 0);
-        const credentialType = {
-            google: 'googleGenerativeAIApi',
-            deepseek: 'deepSeekApi',
-            groq: 'groqApi',
-            openrouter: 'openRouterApi',
-        }[provider];
-        if (!credentialType) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unsupported provider: ${provider}`);
+    if (input.prompt) {
+        finalContext.prompt = input.prompt;
+    }
+    else if (input.messages) {
+        const filteredMessages = input.messages.filter(msg => msg.role !== 'system');
+        if (filteredMessages.length > 0) {
+            finalContext.messages = filteredMessages;
         }
-        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');
+    }
+    return finalContext;
+}
+function withErrorHandling(fn, context, exec, itemIndex) {
+    return fn().catch((error) => {
+        if (error instanceof UniversalAIError) {
+            throw error;
         }
-        const customHeaders = provider === 'google' ? getGoogleCustomHeaders(this, 0) : undefined;
-        const aiProvider = await getProvider(provider, credentials.apiKey, credentials.baseUrl, customHeaders);
-        for (let i = 0; i < items.length; i++) {
-            if (this.continueOnFail()) {
-                try {
-                    const result = await processItem(this, i, provider, aiProvider, credentials.apiKey);
-                    returnData.push(...result);
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                    returnData.push({
-                        json: { error: errorMessage },
-                        pairedItem: { item: i },
-                    });
+        if (error instanceof n8n_workflow_1.NodeOperationError) {
+            throw error;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const enhancedError = new UniversalAIError(`${context}: ${errorMessage}`, 'UNKNOWN_ERROR', { originalError: error });
+        if (exec && itemIndex !== undefined && exec.continueOnFail()) {
+            return {
+                json: {
+                    error: enhancedError.message,
+                    errorCode: enhancedError.code,
+                    success: false
                 }
-            }
-            else {
-                const result = await processItem(this, i, provider, aiProvider, credentials.apiKey);
-                returnData.push(...result);
-            }
+            };
         }
-        return [returnData];
-    }
+        throw enhancedError;
+    });
 }
-exports.UniversalAI = UniversalAI;
 async function processItem(exec, index, provider, aiProvider, apiKey) {
-    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, apiKey)
-        : await generateObjectOperation(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey);
+    return withErrorHandling(async () => {
+        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, apiKey)
+            : await generateObjectOperation(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey);
+    }, 'processItem', exec, index);
 }
 function getModelSettings(exec, index, provider, operation, options) {
     const settings = {};
@@ -699,12 +851,14 @@ function getModelSettings(exec, index, provider, operation, options) {
     if (provider === 'google') {
         const safetySettingsRaw = exec.getNodeParameter('safetySettings.settings', index, []);
         if (safetySettingsRaw.length > 0) {
-            settings.safetySettings = safetySettingsRaw.map((s) => ({
+            settings.safetySettings = safetySettingsRaw.map(s => ({
                 category: s.category,
                 threshold: s.threshold,
             }));
         }
-        settings.structuredOutputs = operation === 'generateObject';
+        if (operation === 'generateObject') {
+            settings.structuredOutputs = true;
+        }
         const responseModalities = exec.getNodeParameter('responseModalities', index, []);
         if (responseModalities.length > 0) {
             settings.responseModalities = responseModalities;
@@ -719,7 +873,7 @@ function buildGoogleProviderOptions(exec, index, cachedContentName) {
     if (!Number.isNaN(thinkingBudgetValue) && thinkingBudgetValue > -1) {
         options.thinkingConfig = {
             thinkingBudget: Math.max(0, thinkingBudgetValue),
-            includeThoughts,
+            includeThoughts
         };
     }
     if (cachedContentName) {
@@ -728,20 +882,16 @@ function buildGoogleProviderOptions(exec, index, cachedContentName) {
     return Object.keys(options).length > 0 ? options : undefined;
 }
 function getGoogleCustomHeaders(exec, index) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const headersCollection = exec.getNodeParameter('customHeaders', index, {});
     const entries = (_a = headersCollection === null || headersCollection === void 0 ? void 0 : headersCollection.headers) !== null && _a !== void 0 ? _a : [];
-    if (!entries || entries.length === 0) {
+    if (!entries.length)
         return undefined;
-    }
     const headers = {};
     for (const entry of entries) {
-        if (!entry)
-            continue;
-        const name = (entry.name || '').trim();
-        if (!name)
-            continue;
-        headers[name] = (_b = entry.value) !== null && _b !== void 0 ? _b : '';
+        if ((_b = entry === null || entry === void 0 ? void 0 : entry.name) === null || _b === void 0 ? void 0 : _b.trim()) {
+            headers[entry.name.trim()] = (_d = (_c = entry.value) === null || _c === void 0 ? void 0 : _c.trim()) !== null && _d !== void 0 ? _d : '';
+        }
     }
     return Object.keys(headers).length > 0 ? headers : undefined;
 }
@@ -754,82 +904,101 @@ async function prepareGoogleCache(exec, index, apiKey, input, tools, context) {
             cachedContentName = await createGoogleCache(exec, index, apiKey, cacheContentInfo.content, tools);
         }
         catch (error) {
-            console.warn(`UniversalAI: Cache creation for ${context} generation failed, continuing without cache:`, error);
+            if (error instanceof CacheError) {
+                console.warn(`Cache creation failed for ${context}:`, error.message);
+            }
+            else {
+                console.warn(`Unexpected cache error for ${context}:`, error);
+            }
         }
     }
     const googleProviderOptions = buildGoogleProviderOptions(exec, index, cachedContentName || undefined);
     return {
         cachedContentName,
         cacheContentInfo,
-        googleProviderOptions,
+        googleProviderOptions
     };
 }
-function resolveFinalContext(input, cachedContentName, cacheContentInfo) {
-    const finalContext = {};
-    if (!cachedContentName) {
-        return input;
-    }
-    if (input.system) {
-    }
-    if (input.prompt) {
-        finalContext.prompt = input.prompt;
-    }
-    else if (input.messages) {
-        const filteredMessages = input.messages.filter(msg => msg.role !== 'system');
-        if (filteredMessages.length > 0) {
-            finalContext.messages = filteredMessages;
+async function generateTextOperation(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey) {
+    return withErrorHandling(async () => {
+        const enableStreaming = exec.getNodeParameter('enableStreaming', index, false);
+        const includeRequestBody = options.includeRequestBody;
+        const tools = provider === 'google' ? await buildGoogleTools(exec, index) : undefined;
+        let cachedContentName = null;
+        let googleProviderOptions;
+        let cacheContentInfo;
+        if (provider === 'google') {
+            const cacheSetup = await prepareGoogleCache(exec, index, apiKey, input, tools, 'text');
+            cachedContentName = cacheSetup.cachedContentName;
+            cacheContentInfo = cacheSetup.cacheContentInfo;
+            googleProviderOptions = cacheSetup.googleProviderOptions;
         }
-    }
-    return finalContext;
+        const finalContext = resolveFinalContext(input, cachedContentName, cacheContentInfo);
+        const params = {
+            model: aiProvider(model, modelSettings),
+            ...finalContext,
+        };
+        if (tools && !cachedContentName) {
+            params.tools = tools;
+        }
+        if (provider === 'google' && googleProviderOptions) {
+            params.providerOptions = {
+                google: googleProviderOptions,
+            };
+        }
+        applyNumericOptions(params, options, [
+            'maxTokens', 'temperature', 'topP', 'topK',
+            'frequencyPenalty', 'presencePenalty', 'seed'
+        ]);
+        if (enableStreaming) {
+            return await handleStreaming(params, provider, includeRequestBody);
+        }
+        const result = await (0, ai_1.generateText)(params);
+        const formattedResult = formatTextResult(result, includeRequestBody, provider);
+        return [{ json: formattedResult }];
+    }, 'generateTextOperation', exec, index);
 }
-async function generateTextOperation(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey) {
-    const enableStreaming = exec.getNodeParameter('enableStreaming', index, false);
-    const includeRequestBody = options.includeRequestBody;
-    const tools = provider === 'google' ? await buildGoogleTools(exec, index) : undefined;
-    let cachedContentName = null;
-    let googleProviderOptions;
-    let cacheContentInfo;
-    if (provider === 'google') {
-        const cacheSetup = await prepareGoogleCache(exec, index, apiKey, input, tools, 'text');
-        cachedContentName = cacheSetup.cachedContentName;
-        cacheContentInfo = cacheSetup.cacheContentInfo;
-        googleProviderOptions = cacheSetup.googleProviderOptions;
-    }
-    const finalContext = resolveFinalContext(input, cachedContentName, cacheContentInfo);
-    const params = {
-        model: aiProvider(model, modelSettings),
-        ...finalContext,
-    };
-    if (tools && !cachedContentName) {
-        params.tools = tools;
-    }
-    if (provider === 'google' && googleProviderOptions) {
-        params.providerOptions = {
-            google: googleProviderOptions,
+async function generateObjectOperation(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey) {
+    return withErrorHandling(async () => {
+        const schemaName = exec.getNodeParameter('schemaName', index, '').trim();
+        const schemaDescription = exec.getNodeParameter('schemaDescription', index, '').trim();
+        const rawSchema = exec.getNodeParameter('schema', index);
+        const parsedSchema = parseAndValidateSchema(rawSchema, exec);
+        let cachedContentName = null;
+        let googleProviderOptions;
+        let cacheContentInfo;
+        if (provider === 'google') {
+            const cacheSetup = await prepareGoogleCache(exec, index, apiKey, input, undefined, 'object');
+            cachedContentName = cacheSetup.cachedContentName;
+            cacheContentInfo = cacheSetup.cacheContentInfo;
+            googleProviderOptions = cacheSetup.googleProviderOptions;
+        }
+        const finalContext = resolveFinalContext(input, cachedContentName, cacheContentInfo);
+        const params = {
+            model: aiProvider(model, modelSettings),
+            schema: (0, ai_1.jsonSchema)(parsedSchema),
+            schemaName,
+            schemaDescription,
+            ...finalContext,
         };
-    }
-    const textNumericKeys = [
-        'maxTokens',
-        'temperature',
-        'topP',
-        'topK',
-        'frequencyPenalty',
-        'presencePenalty',
-        'seed',
-    ];
-    applyNumericOptions(params, options, textNumericKeys);
-    if (enableStreaming) {
-        return await handleStreaming(params, provider, includeRequestBody);
-    }
-    const result = await (0, ai_1.generateText)(params);
-    const formattedResult = formatTextResult(result, includeRequestBody, provider);
-    return [{ json: formattedResult }];
+        if (provider === 'google' && googleProviderOptions) {
+            params.providerOptions = {
+                google: googleProviderOptions,
+            };
+        }
+        applyNumericOptions(params, options, [
+            'temperature', 'topP', 'topK',
+            'frequencyPenalty', 'presencePenalty', 'seed'
+        ]);
+        const result = await (0, ai_1.generateObject)(params);
+        const formattedResult = formatObjectResult(result, options.includeRequestBody, provider);
+        return [{ json: formattedResult }];
+    }, 'generateObjectOperation', exec, index);
 }
 async function buildGoogleTools(exec, index) {
     const googleTools = exec.getNodeParameter('googleTools', index, []);
-    if (!googleTools || googleTools.length === 0) {
+    if (!(googleTools === null || googleTools === void 0 ? void 0 : googleTools.length))
         return undefined;
-    }
     const tools = {};
     const { google } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/google')));
     const toolSet = new Set(googleTools);
@@ -845,82 +1014,127 @@ async function buildGoogleTools(exec, index) {
     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 } });
-    }
-    let finalUsage;
-    try {
-        finalUsage = await stream.usage;
-    }
-    catch (error) {
-        console.warn('UniversalAI: Failed to get usage from stream:', error);
-        finalUsage = undefined;
-    }
-    const finalJson = {
-        text: fullText,
-        toolCalls: stream.toolCalls || [],
-        toolResults: stream.toolResults || [],
-        finishReason: stream.finishReason,
-        usage: finalUsage ? formatUsage({ usage: finalUsage }, provider) : undefined,
-        isStreaming: false,
-        isFinal: true,
-    };
-    if (includeRequestBody) {
+    return withErrorHandling(async () => {
+        const stream = await (0, ai_1.streamText)(params);
+        const chunks = [];
+        let fullText = '';
         try {
-            const requestMetadata = stream.request ? await stream.request : undefined;
-            if ((requestMetadata === null || requestMetadata === void 0 ? void 0 : requestMetadata.body) !== undefined) {
-                finalJson.request = { body: requestMetadata.body };
+            for await (const textPart of stream.textStream) {
+                fullText += textPart;
+                chunks.push({
+                    json: {
+                        chunk: textPart,
+                        isStreaming: true
+                    }
+                });
             }
         }
         catch (error) {
-            console.warn('UniversalAI: Failed to get request metadata from stream:', error);
+            throw new UniversalAIError(`Stream processing failed: ${error.message}`, 'STREAM_ERROR', { provider });
         }
-    }
-    chunks.push({ json: finalJson });
-    return chunks;
+        let finalUsage;
+        let requestMetadata;
+        try {
+            finalUsage = await stream.usage;
+        }
+        catch (error) {
+            console.warn('Could not get usage from stream:', error);
+        }
+        try {
+            requestMetadata = stream.request ? await stream.request : undefined;
+        }
+        catch (error) {
+            console.warn('Could not get request metadata from stream:', error);
+        }
+        const finalJson = {
+            text: fullText,
+            toolCalls: stream.toolCalls || [],
+            toolResults: stream.toolResults || [],
+            finishReason: stream.finishReason,
+            usage: finalUsage ? formatUsage({ usage: finalUsage }, provider) : undefined,
+            isStreaming: false,
+            isFinal: true,
+        };
+        if (includeRequestBody && (requestMetadata === null || requestMetadata === void 0 ? void 0 : requestMetadata.body) !== undefined) {
+            finalJson.request = { body: requestMetadata.body };
+        }
+        chunks.push({ json: finalJson });
+        return chunks;
+    }, 'handleStreaming');
 }
-async function generateObjectOperation(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey) {
-    const schemaName = exec.getNodeParameter('schemaName', index, '');
-    const schemaDescription = exec.getNodeParameter('schemaDescription', index, '');
-    const rawSchema = exec.getNodeParameter('schema', index);
-    const parsedSchema = parseAndValidateSchema(rawSchema, exec);
-    let cachedContentName = null;
-    let googleProviderOptions;
-    let cacheContentInfo;
-    if (provider === 'google') {
-        const cacheSetup = await prepareGoogleCache(exec, index, apiKey, input, undefined, 'object');
-        cachedContentName = cacheSetup.cachedContentName;
-        cacheContentInfo = cacheSetup.cacheContentInfo;
-        googleProviderOptions = cacheSetup.googleProviderOptions;
-    }
-    const finalContext = resolveFinalContext(input, cachedContentName, cacheContentInfo);
-    const params = {
-        model: aiProvider(model, modelSettings),
-        schema: (0, ai_1.jsonSchema)(parsedSchema),
-        schemaName,
-        schemaDescription,
-        ...finalContext,
-    };
-    if (provider === 'google' && googleProviderOptions) {
-        params.providerOptions = {
-            google: googleProviderOptions,
+class UniversalAI {
+    constructor() {
+        this.description = descriptions_1.UNIVERSAL_AI_DESCRIPTION;
+        this.methods = {
+            loadOptions: {
+                async getModels() {
+                    return withErrorHandling(async () => {
+                        const provider = this.getCurrentNodeParameter('provider');
+                        const cacheKey = generateCacheKey(provider, 'models:');
+                        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;
+                    }, 'getModels');
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const provider = this.getNodeParameter('provider', 0);
+        const credentialType = {
+            google: 'googleGenerativeAIApi',
+            deepseek: 'deepSeekApi',
+            groq: 'groqApi',
+            openrouter: 'openRouterApi'
+        }[provider];
+        if (!credentialType) {
+            throw new ValidationError(`Unsupported provider: ${provider}`);
+        }
+        const credentials = await this.getCredentials(credentialType);
+        if (!(credentials === null || credentials === void 0 ? void 0 : credentials.apiKey)) {
+            throw new ValidationError('No API key provided in credentials');
+        }
+        const customHeaders = provider === 'google' ? getGoogleCustomHeaders(this, 0) : undefined;
+        const providerConfig = {
+            apiKey: credentials.apiKey,
+            customHeaders,
+            ...(credentials.baseUrl ? { baseURL: credentials.baseUrl } : {}),
         };
+        const aiProvider = await getProvider(provider, providerConfig);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const result = await processItem(this, i, provider, aiProvider, credentials.apiKey);
+                returnData.push(...result);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : 'Unknown error',
+                            errorCode: error instanceof UniversalAIError ? error.code : 'UNKNOWN_ERROR',
+                            itemIndex: i,
+                            success: false
+                        },
+                        pairedItem: { item: i }
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
     }
-    const objectNumericKeys = [
-        'temperature',
-        'topP',
-        'topK',
-        'frequencyPenalty',
-        'presencePenalty',
-        'seed',
-    ];
-    applyNumericOptions(params, options, objectNumericKeys);
-    const result = await (0, ai_1.generateObject)(params);
-    const formattedResult = formatObjectResult(result, options.includeRequestBody, provider);
-    return [{ json: formattedResult }];
 }
+exports.UniversalAI = UniversalAI;
 //# sourceMappingURL=UniversalAI.node.js.map