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

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

@@ -41,42 +41,15 @@ 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(_name, maxSize = 100, ttl = 5 * 60 * 1000) {
+    constructor(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);
@@ -92,7 +65,6 @@ class Cache {
             return undefined;
         }
         item.hits++;
-        item.lastAccessed = now;
         this.totalHits++;
         return item.value;
     }
@@ -100,42 +72,20 @@ class Cache {
         const now = Date.now();
         const expiresAt = customTTL ? now + customTTL : (this.ttl > 0 ? now + this.ttl : undefined);
         if (this.cache.size >= this.maxSize) {
-            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;
+            let oldestKey;
+            let oldestTime = now;
+            for (const [k, v] of this.cache.entries()) {
+                if (v.timestamp < oldestTime) {
+                    oldestTime = v.timestamp;
+                    oldestKey = k;
+                }
             }
-        }
-        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++;
+            if (oldestKey) {
+                this.cache.delete(oldestKey);
+                this.totalEvictions++;
             }
         }
-        if (cleaned > 0) {
-            this.totalEvictions += cleaned;
-        }
+        this.cache.set(key, { value, timestamp: now, hits: 0, expiresAt });
     }
     delete(key) {
         return this.cache.delete(key);
@@ -146,111 +96,93 @@ 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: totalRequests > 0 ? this.totalHits / totalRequests : 0,
+            hitRate: this.totalHits / (this.totalHits + this.totalMisses) || 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;
-        }
-    }
 }
-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);
+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);
 async function getGoogleCacheManager(apiKey) {
-    const cacheKey = generateCacheKey(apiKey, 'google_client:');
-    const cachedClient = googleCacheClients.get(cacheKey);
-    if (cachedClient) {
-        return cachedClient;
-    }
-    try {
+    let client = googleCacheClients.get(apiKey);
+    if (!client) {
         const { GoogleGenAI } = await Promise.resolve().then(() => __importStar(require('@google/genai')));
-        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) + '...' });
+        client = new GoogleGenAI({ apiKey });
+        googleCacheClients.set(apiKey, client);
     }
+    return client;
 }
-function isUrl(str) {
-    if (typeof str !== 'string')
-        return false;
+async function createGoogleCache(exec, index, apiKey, cacheContent, tools) {
+    var _a;
     try {
-        const url = new URL(str);
-        return url.protocol === 'http:' || url.protocol === 'https:';
+        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;
     }
-    catch {
-        return str.startsWith('data:');
+    catch (error) {
+        console.error('UniversalAI: Failed to create Google cache. Falling back to non-cached execution:', error);
+        return null;
     }
 }
-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 canUseCache(cacheContent) {
+    return Boolean(cacheContent && cacheContent.trim().length > 0);
 }
 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) => {
@@ -270,20 +202,16 @@ 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 ((_a = input.system) === null || _a === void 0 ? void 0 : _a.trim()) {
+    if (input.system && input.system.trim()) {
         sections.push(`System Instruction:\n${input.system.trim()}`);
         hasSystem = true;
     }
-    if ((_b = input.messages) === null || _b === void 0 ? void 0 : _b.length) {
+    if (input.messages && input.messages.length > 0) {
         const messageSections = [];
         for (const message of input.messages) {
             const text = extractTextFromMessageContent(message.content);
@@ -294,31 +222,34 @@ function resolveCacheContent(input) {
                     sections.push(`System Instruction (from messages):\n${text.trim()}`);
                     hasSystem = true;
                 }
+                continue;
             }
-            else {
-                messageSections.push(`${message.role.toUpperCase()}:\n${text.trim()}`);
-            }
+            messageSections.push(`${message.role.toUpperCase()}:\n${text.trim()}`);
         }
         if (messageSections.length > 0) {
             sections.push(`Messages:\n${messageSections.join('\n\n')}`);
             hasMessages = true;
         }
     }
-    if ((_c = input.prompt) === null || _c === void 0 ? void 0 : _c.trim()) {
+    if (input.prompt && input.prompt.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,
@@ -327,90 +258,8 @@ function resolveCacheContent(input) {
         source,
     };
 }
-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') {
-        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']),
+    role: zod_1.z.enum(['system', 'user', 'assistant']),
     content: zod_1.z.any(),
 });
 const messagesArraySchema = zod_1.z.array(messageSchema);
@@ -418,143 +267,111 @@ const ajv = new ajv_1.default({
     allErrors: true,
     verbose: true,
     strict: false,
-    useDefaults: true,
-    removeAdditional: true,
 });
+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 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;
+    }
+    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);
-    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) {
-            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)');
+            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) {
-        if (error instanceof ValidationError)
-            throw error;
-        throw new ValidationError(`Invalid JSON in messages field: ${error.message}`);
+        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid JSON in "Messages (JSON)" field: ${error.message}`);
     }
 }
 async function buildMessagesFromUI(exec, itemIndex) {
-    var _a, _b, _c;
+    var _a;
     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') {
-            if ((_a = msg.systemContent) === null || _a === void 0 ? void 0 : _a.trim()) {
-                builtMessages.push({ role, content: msg.systemContent.trim() });
-            }
+            builtMessages.push({ role, content: msg.systemContent || '' });
             continue;
         }
-        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()) || '';
+        const attachments = ((_a = msg.attachments) === null || _a === void 0 ? void 0 : _a.attachment) || [];
         if (attachments.length === 0) {
-            if (content) {
-                builtMessages.push({ role, content });
-            }
+            builtMessages.push({ role, content: msg.content || '' });
         }
         else {
-            const messageWithAttachments = await buildMessageWithAttachments(role, content, attachments, itemBinary, exec, itemIndex);
+            const messageWithAttachments = await buildMessageWithAttachments(role, msg.content, attachments, itemBinary, exec, itemIndex);
             if (messageWithAttachments) {
                 builtMessages.push(messageWithAttachments);
             }
         }
     }
     const convertMessagesToModel = exec.getNodeParameter('convertMessagesToModel', itemIndex, false);
-    return {
-        messages: convertMessagesToModel ? (0, ai_1.convertToModelMessages)(builtMessages) : builtMessages
-    };
+    if (convertMessagesToModel) {
+        return { messages: (0, ai_1.convertToModelMessages)(builtMessages) };
+    }
+    return { messages: 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 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
-            };
-        }
+        const batchResults = await Promise.all(batchPromises);
+        processedAttachments.push(...batchResults);
     }
-    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 };
-            }
+    for (const attachment of processedAttachments) {
+        if (attachment) {
+            parts.push(attachment);
         }
     }
-    catch (error) {
-        if (error instanceof ValidationError)
-            throw error;
-        throw new ValidationError(`Invalid file content for attachment: ${error.message}`);
-    }
-    return { data: null, mimeType: undefined };
+    return parts.length > 0 ? { role, content: parts } : null;
 }
 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)) {
@@ -562,19 +379,46 @@ 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;
@@ -688,159 +532,163 @@ function getCacheMetrics(result, provider, metadata) {
 }
 function formatResponse(result) {
     var _a, _b, _c, _d;
-    return {
+    const response = {
         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, config) {
-    const headersKey = config.customHeaders
-        ? generateCacheKey(Object.keys(config.customHeaders)
+async function getProvider(provider, apiKey, baseURL, customHeaders) {
+    const headersKey = customHeaders
+        ? JSON.stringify(Object.keys(customHeaders)
             .sort()
-            .map((key) => [key, config.customHeaders[key]]), 'headers:')
+            .map((key) => [key, customHeaders[key]]))
         : '';
-    const cacheKey = generateCacheKey(`${provider}:${config.apiKey}:${config.baseURL || ''}:${headersKey}`, 'provider:');
+    const cacheKey = `${provider}:${apiKey}:${baseURL || ''}:${headersKey}`;
     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: config.apiKey,
-                    ...(config.baseURL && { baseURL: config.baseURL }),
-                    ...(config.customHeaders && Object.keys(config.customHeaders).length > 0 && {
-                        headers: config.customHeaders
-                    }),
+                    apiKey,
+                    ...(baseURL && { baseURL }),
+                    ...(customHeaders && Object.keys(customHeaders).length > 0 && { headers: customHeaders }),
                 });
                 break;
             case 'deepseek':
                 const { createDeepSeek } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/deepseek')));
-                providerInstance = createDeepSeek({
-                    apiKey: config.apiKey,
-                    ...(config.baseURL && { baseURL: config.baseURL })
-                });
+                providerInstance = createDeepSeek({ apiKey, ...(baseURL && { baseURL }) });
                 break;
             case 'groq':
                 const { createGroq } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/groq')));
-                providerInstance = createGroq({
-                    apiKey: config.apiKey,
-                    ...(config.baseURL && { baseURL: config.baseURL })
-                });
+                providerInstance = createGroq({ apiKey, ...(baseURL && { baseURL }) });
                 break;
             case 'openrouter':
                 const { createOpenRouter } = await Promise.resolve().then(() => __importStar(require('@openrouter/ai-sdk-provider')));
-                providerInstance = createOpenRouter({
-                    apiKey: config.apiKey,
-                    ...(config.baseURL && { baseURL: config.baseURL })
-                });
+                providerInstance = createOpenRouter({ apiKey, ...(baseURL && { baseURL }) });
                 break;
             default:
-                throw new ProviderError(`Unsupported provider: ${provider}`);
+                throw new Error(`Unsupported provider: ${provider}`);
         }
         providerCache.set(cacheKey, providerInstance);
         return providerInstance;
     }
     catch (error) {
-        throw new ProviderError(`Failed to initialize ${provider} provider: ${error.message}`, { provider, baseURL: config.baseURL });
+        throw new Error(`Failed to initialize ${provider} provider: ${error.message}`);
     }
 }
 function parseAndValidateSchema(rawSchema, exec) {
-    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 cacheKey = `schema:${Buffer.from(rawSchema).toString('base64').substring(0, 50)}`;
     const cached = schemaCache.get(cacheKey);
     if (cached)
         return cached;
+    let parsedSchema;
     try {
-        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;
+        parsedSchema = JSON.parse(rawSchema);
     }
     catch (err) {
-        throw new ValidationError(`Schema is not valid JSON: ${err.message}`);
+        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;
-    const sequences = stopSequencesStr
-        .split(',')
-        .map(s => s.trim())
-        .filter(Boolean);
-    return sequences.length > 0 ? sequences : undefined;
+    return stopSequencesStr.split(',').map(s => s.trim()).filter(s => s.length > 0);
 }
 function applyNumericOptions(params, options, keys) {
     for (const key of keys) {
         const value = options[key];
         if (value !== undefined && value !== null && value !== '') {
-            const numValue = Number(value);
-            if (!isNaN(numValue)) {
-                params[key] = numValue;
-            }
+            params[key] = value;
         }
     }
 }
-function resolveFinalContext(input, cachedContentName, cacheContentInfo) {
-    const finalContext = {};
-    if (!cachedContentName) {
-        return input;
-    }
-    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;
-        }
+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;
+                },
+            },
+        };
     }
-    return finalContext;
-}
-function withErrorHandling(fn, context, exec, itemIndex) {
-    return fn().catch((error) => {
-        if (error instanceof UniversalAIError) {
-            throw error;
+    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 (error instanceof n8n_workflow_1.NodeOperationError) {
-            throw error;
+        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 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
+        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 },
+                    });
+                }
+            }
+            else {
+                const result = await processItem(this, i, provider, aiProvider, credentials.apiKey);
+                returnData.push(...result);
+            }
         }
-        throw enhancedError;
-    });
+        return [returnData];
+    }
 }
+exports.UniversalAI = UniversalAI;
 async function processItem(exec, index, provider, aiProvider, 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);
+    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);
 }
 function getModelSettings(exec, index, provider, operation, options) {
     const settings = {};
@@ -851,14 +699,12 @@ 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,
             }));
         }
-        if (operation === 'generateObject') {
-            settings.structuredOutputs = true;
-        }
+        settings.structuredOutputs = operation === 'generateObject';
         const responseModalities = exec.getNodeParameter('responseModalities', index, []);
         if (responseModalities.length > 0) {
             settings.responseModalities = responseModalities;
@@ -873,7 +719,7 @@ function buildGoogleProviderOptions(exec, index, cachedContentName) {
     if (!Number.isNaN(thinkingBudgetValue) && thinkingBudgetValue > -1) {
         options.thinkingConfig = {
             thinkingBudget: Math.max(0, thinkingBudgetValue),
-            includeThoughts
+            includeThoughts,
         };
     }
     if (cachedContentName) {
@@ -882,16 +728,20 @@ function buildGoogleProviderOptions(exec, index, cachedContentName) {
     return Object.keys(options).length > 0 ? options : undefined;
 }
 function getGoogleCustomHeaders(exec, index) {
-    var _a, _b, _c, _d;
+    var _a, _b;
     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.length)
+    if (!entries || entries.length === 0) {
         return undefined;
+    }
     const headers = {};
     for (const entry of entries) {
-        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 : '';
-        }
+        if (!entry)
+            continue;
+        const name = (entry.name || '').trim();
+        if (!name)
+            continue;
+        headers[name] = (_b = entry.value) !== null && _b !== void 0 ? _b : '';
     }
     return Object.keys(headers).length > 0 ? headers : undefined;
 }
@@ -904,101 +754,82 @@ async function prepareGoogleCache(exec, index, apiKey, input, tools, context) {
             cachedContentName = await createGoogleCache(exec, index, apiKey, cacheContentInfo.content, tools);
         }
         catch (error) {
-            if (error instanceof CacheError) {
-                console.warn(`Cache creation failed for ${context}:`, error.message);
-            }
-            else {
-                console.warn(`Unexpected cache error for ${context}:`, error);
-            }
+            console.warn(`UniversalAI: Cache creation for ${context} generation failed, continuing without cache:`, error);
         }
     }
     const googleProviderOptions = buildGoogleProviderOptions(exec, index, cachedContentName || undefined);
     return {
         cachedContentName,
         cacheContentInfo,
-        googleProviderOptions
+        googleProviderOptions,
     };
 }
-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;
-        }
-        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);
+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;
         }
-        const result = await (0, ai_1.generateText)(params);
-        const formattedResult = formatTextResult(result, includeRequestBody, provider);
-        return [{ json: formattedResult }];
-    }, 'generateTextOperation', exec, index);
+    }
+    return finalContext;
 }
-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,
+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,
         };
-        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);
+    }
+    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 }];
 }
 async function buildGoogleTools(exec, index) {
     const googleTools = exec.getNodeParameter('googleTools', index, []);
-    if (!(googleTools === null || googleTools === void 0 ? void 0 : googleTools.length))
+    if (!googleTools || googleTools.length === 0) {
         return undefined;
+    }
     const tools = {};
     const { google } = await Promise.resolve().then(() => __importStar(require('@ai-sdk/google')));
     const toolSet = new Set(googleTools);
@@ -1014,127 +845,82 @@ async function buildGoogleTools(exec, index) {
     return tools;
 }
 async function handleStreaming(params, provider, includeRequestBody) {
-    return withErrorHandling(async () => {
-        const stream = await (0, ai_1.streamText)(params);
-        const chunks = [];
-        let fullText = '';
+    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) {
         try {
-            for await (const textPart of stream.textStream) {
-                fullText += textPart;
-                chunks.push({
-                    json: {
-                        chunk: textPart,
-                        isStreaming: true
-                    }
-                });
+            const requestMetadata = stream.request ? await stream.request : undefined;
+            if ((requestMetadata === null || requestMetadata === void 0 ? void 0 : requestMetadata.body) !== undefined) {
+                finalJson.request = { body: requestMetadata.body };
             }
         }
         catch (error) {
-            throw new UniversalAIError(`Stream processing failed: ${error.message}`, 'STREAM_ERROR', { provider });
-        }
-        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 };
+            console.warn('UniversalAI: Failed to get request metadata from stream:', error);
         }
-        chunks.push({ json: finalJson });
-        return chunks;
-    }, 'handleStreaming');
-}
-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 } : {}),
+    chunks.push({ json: finalJson });
+    return chunks;
+}
+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,
         };
-        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