n8n-nodes-vercel-ai-sdk-universal-temp 0.2.88 → 0.2.90

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

@@ -32,425 +32,19 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UniversalAI = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const ai_1 = require("ai");
-const zod_1 = require("zod");
-const ajv_1 = __importDefault(require("ajv"));
 const descriptions_1 = require("../shared/descriptions");
 const helpers_1 = require("../shared/helpers");
 const cache_1 = require("../shared/cache/cache");
 const constants_1 = require("../shared/constants");
+const providers_1 = require("./providers");
 const nodeCacheManagers = new cache_1.LRUCache(constants_1.CACHE_SIZE.NODE_INSTANCES);
-const messageSchema = zod_1.z.object({
-    role: zod_1.z.enum(['system', 'user', 'assistant']),
-    content: zod_1.z.any(),
-});
-const messagesArraySchema = zod_1.z.array(messageSchema);
-const ajv = new ajv_1.default({
-    allErrors: true,
-    verbose: true,
-    strict: false,
-});
-const isUrl = (str) => {
-    return typeof str === 'string' && /^(https?:|data:)/i.test(str);
-};
-const isLikelyBase64 = (str) => {
-    return str.length % 4 === 0 && /^[A-Za-z0-9+/]*={0,2}$/.test(str) && str.length > 10000;
-};
-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 cachePrompt = exec.getNodeParameter('cachePrompt', itemIndex, false);
-        const cacheSystemInstruction = exec.getNodeParameter('cacheSystemInstruction', itemIndex, false);
-        const result = {};
-        const cacheableContent = [];
-        if (cacheSystemInstruction && systemValue?.trim()) {
-            cacheableContent.push({
-                role: 'user',
-                parts: [{ text: systemValue.trim() }],
-            });
-        }
-        if (cachePrompt && promptValue?.trim()) {
-            cacheableContent.push({
-                role: 'user',
-                parts: [{ text: promptValue.trim() }],
-            });
-        }
-        const trimmedPrompt = typeof promptValue === 'string' ? promptValue.trim() : '';
-        if (trimmedPrompt && !cachePrompt) {
-            result.prompt = trimmedPrompt;
-        }
-        const trimmedSystem = typeof systemValue === 'string' ? systemValue.trim() : '';
-        if (trimmedSystem && !cacheSystemInstruction) {
-            result.system = trimmedSystem;
-        }
-        if (cacheableContent.length > 0) {
-            result.cacheableContent = cacheableContent;
-        }
-        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);
-    try {
-        const parsed = JSON.parse(rawJson);
-        const result = messagesArraySchema.safeParse(parsed);
-        if (!result.success) {
-            const formattedError = result.error.format();
-            const errorMessage = JSON.stringify(formattedError, null, 2);
-            throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid JSON structure for messages: ${errorMessage}`);
-        }
-        return { messages: result.data };
-    }
-    catch (error) {
-        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid JSON in "Messages (JSON)" field: ${error.message}`);
-    }
-}
-async function buildMessagesFromUI(exec, itemIndex) {
-    const items = exec.getInputData();
-    const messagesUi = exec.getNodeParameter('messages.messagesUi', itemIndex, []);
-    const builtMessages = [];
-    const cacheableContent = [];
-    const itemBinary = items[itemIndex].binary;
-    for (const msg of messagesUi) {
-        const role = msg.role;
-        const shouldCache = msg.cacheMessage === true;
-        if (role === 'system') {
-            const systemText = msg.systemContent || '';
-            if (shouldCache && systemText.trim()) {
-                cacheableContent.push({
-                    role: 'user',
-                    parts: [{ text: systemText.trim() }],
-                });
-            }
-            else {
-                builtMessages.push({ role, content: systemText });
-            }
-            continue;
-        }
-        const attachments = msg.attachments?.attachment || [];
-        if (attachments.length === 0) {
-            const messageText = msg.content || '';
-            if (shouldCache && messageText.trim()) {
-                const cacheRole = role === 'assistant' ? 'model' : 'user';
-                cacheableContent.push({
-                    role: cacheRole,
-                    parts: [{ text: messageText.trim() }],
-                });
-            }
-            else {
-                builtMessages.push({ role, content: messageText });
-            }
-        }
-        else {
-            const messageWithAttachments = await buildMessageWithAttachments(role, msg.content, attachments, itemBinary, exec, itemIndex, shouldCache, cacheableContent);
-            if (messageWithAttachments) {
-                builtMessages.push(messageWithAttachments);
-            }
-        }
-    }
-    const convertMessagesToModel = exec.getNodeParameter('convertMessagesToModel', itemIndex, false);
-    const result = {
-        messages: convertMessagesToModel ? (0, ai_1.convertToModelMessages)(builtMessages) : builtMessages,
-    };
-    if (cacheableContent.length > 0) {
-        result.cacheableContent = cacheableContent;
-    }
-    return result;
-}
-async function buildMessageWithAttachments(role, content, attachments, itemBinary, exec, itemIndex, shouldCacheMessage, cacheableContent) {
-    const parts = [];
-    if (content) {
-        parts.push({ type: 'text', text: content });
-    }
-    for (const attachment of attachments) {
-        const filePart = await processAttachment(attachment, itemBinary, exec, itemIndex, shouldCacheMessage, cacheableContent);
-        if (filePart) {
-            parts.push(filePart);
-        }
-    }
-    return parts.length > 0 ? { role, content: parts } : null;
-}
-async function processAttachment(attachment, itemBinary, exec, itemIndex, shouldCacheMessage, cacheableContent) {
-    const fileResult = await processFileData(attachment.fileContent, itemBinary, attachment, cacheableContent, exec, itemIndex);
-    if (!fileResult)
-        return null;
-    if (isUrl(attachment.fileContent)) {
-        return {
-            type: 'file',
-            data: fileResult.data,
-            mediaType: fileResult.mimeType,
-        };
-    }
-    else {
-        return {
-            type: 'file',
-            data: fileResult.data,
-            mediaType: fileResult.mimeType,
-        };
-    }
-}
-async function processFileData(fileContentInput, itemBinary, attachment, cacheableContent, exec, itemIndex) {
-    if (!fileContentInput || typeof fileContentInput !== 'string') {
-        return null;
-    }
-    let mimeType = attachment.mimeType === 'other' ? attachment.mimeTypeOther : attachment.mimeType;
-    let fileData;
-    let shouldCache = attachment.cacheAttachment === true;
-    function detectMimeTypeFromUrl(url) {
-        if (url.includes('youtube.com') || url.includes('youtu.be')) {
-            return 'video/mp4';
-        }
-        if (url.includes('generativelanguage.googleapis.com') && url.includes('/files/')) {
-            return undefined;
-        }
-        const extension = url.split('.').pop()?.toLowerCase();
-        const mimeTypes = {
-            png: 'image/png',
-            jpg: 'image/jpeg',
-            jpeg: 'image/jpeg',
-            gif: 'image/gif',
-            webp: 'image/webp',
-            svg: 'image/svg+xml',
-            pdf: 'application/pdf',
-            txt: 'text/plain',
-            json: 'application/json',
-            xml: 'application/xml',
-            html: 'text/html',
-            mp4: 'video/mp4',
-            avi: 'video/x-msvideo',
-            mov: 'video/quicktime',
-            mkv: 'video/x-matroska',
-            mp3: 'audio/mpeg',
-            wav: 'audio/wav',
-            flac: 'audio/flac',
-        };
-        return extension ? mimeTypes[extension] : undefined;
-    }
-    try {
-        if (isUrl(fileContentInput)) {
-            fileData = fileContentInput;
-            if (shouldCache) {
-                cacheableContent.push({
-                    role: 'user',
-                    parts: [
-                        {
-                            fileUri: fileContentInput,
-                            mimeType: mimeType || detectMimeTypeFromUrl(fileContentInput) || 'application/octet-stream',
-                        },
-                    ],
-                });
-                return null;
-            }
-            if (!mimeType) {
-                mimeType = detectMimeTypeFromUrl(fileContentInput);
-            }
-        }
-        else if (fileContentInput.startsWith('data:')) {
-            const dataUriMatch = fileContentInput.match(/^data:([^;]+);base64,(.+)$/);
-            if (!dataUriMatch)
-                return null;
-            const [, extractedMimeType, base64Data] = dataUriMatch;
-            fileData = Buffer.from(base64Data, 'base64');
-            if (fileData.length > 20 * 1024 * 1024) {
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Base64 data exceeds 20MB limit');
-            }
-            mimeType = mimeType || extractedMimeType;
-        }
-        else if (isLikelyBase64(fileContentInput)) {
-            fileData = Buffer.from(fileContentInput, 'base64');
-            if (fileData.length > 20 * 1024 * 1024) {
-                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Base64 data exceeds 20MB limit');
-            }
-        }
-        else if (itemBinary?.[fileContentInput]) {
-            const binaryData = itemBinary[fileContentInput];
-            fileData = Buffer.from(binaryData.data, 'base64');
-            mimeType = mimeType || binaryData.mimeType;
-        }
-        else {
-            return null;
-        }
-        if (!fileData || (Buffer.isBuffer(fileData) && fileData.length === 0)) {
-            return null;
-        }
-        return { data: fileData, mimeType: mimeType || 'application/octet-stream', shouldCache };
-    }
-    catch (error) {
-        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid file content for attachment: ${error.message}`);
-    }
-}
-function formatTextResult(result, includeRequestBody, provider) {
-    const baseResult = {
-        text: result.text,
-        reasoning: result.reasoning,
-        reasoningText: result.reasoningText,
-        toolCalls: result.toolCalls || [],
-        toolResults: result.toolResults || [],
-        finishReason: result.finishReason,
-        sources: result.sources || [],
-        files: result.files || [],
-        usage: formatUsage(result, provider),
-        response: formatResponse(result),
-        steps: result.steps || [],
-        warnings: result.warnings || [],
-        experimental_providerMetadata: result.experimental_providerMetadata,
-        providerMetadata: result.providerMetadata ?? result.experimentalProviderMetadata,
-    };
-    if (provider === 'google') {
-        const providerMetadata = result.experimental_providerMetadata;
-        baseResult.groundingMetadata = providerMetadata?.google?.groundingMetadata;
-        baseResult.safetyRatings = providerMetadata?.google?.safetyRatings;
-        baseResult.urlContextMetadata = providerMetadata?.google?.urlContextMetadata;
-    }
-    if (includeRequestBody) {
-        const requestBody = result.request?.body;
-        if (requestBody !== undefined) {
-            baseResult.request = { body: requestBody };
-        }
-    }
-    return baseResult;
-}
-function formatObjectResult(result, includeRequestBody, provider) {
-    const out = {
-        object: result.object,
-        finishReason: result.finishReason,
-        usage: formatUsage(result, provider),
-        response: formatResponse(result),
-        warnings: result.warnings || [],
-        experimental_providerMetadata: result.experimental_providerMetadata,
-        providerMetadata: result.providerMetadata ?? result.experimentalProviderMetadata,
-    };
-    if (includeRequestBody) {
-        out.request = { body: result.request?.body };
-    }
-    return out;
-}
-function formatUsage(result, provider) {
-    const usage = {
-        promptTokens: result.usage?.promptTokens,
-        completionTokens: result.usage?.completionTokens,
-        totalTokens: result.usage?.totalTokens,
-    };
-    const metadata = result.experimental_providerMetadata ??
-        result.experimentalProviderMetadata ??
-        result.providerMetadata ??
-        result.experimental_provider_metadata;
-    const cacheMetrics = getCacheMetrics(result, provider, metadata);
-    if (Object.keys(cacheMetrics).length > 0) {
-        usage.cacheMetrics = cacheMetrics;
-    }
-    return usage;
-}
-function getCacheMetrics(result, provider, metadata) {
-    const resolvedMetadata = metadata ?? result.experimental_providerMetadata;
-    const metrics = {};
-    switch (provider) {
-        case 'deepseek':
-            if (resolvedMetadata?.deepseek?.promptCacheHitTokens !== undefined) {
-                metrics.promptCacheHitTokens = resolvedMetadata.deepseek.promptCacheHitTokens;
-            }
-            if (resolvedMetadata?.deepseek?.promptCacheMissTokens !== undefined) {
-                metrics.promptCacheMissTokens = resolvedMetadata.deepseek.promptCacheMissTokens;
-            }
-            break;
-        case 'groq':
-            if (resolvedMetadata?.groq?.promptCacheHitTokens !== undefined) {
-                metrics.promptCacheHitTokens = resolvedMetadata.groq.promptCacheHitTokens;
-            }
-            if (resolvedMetadata?.groq?.promptCacheMissTokens !== undefined) {
-                metrics.promptCacheMissTokens = resolvedMetadata.groq.promptCacheMissTokens;
-            }
-            break;
-        case 'google':
-            let cachedTokens;
-            if (resolvedMetadata?.google?.usageMetadata?.cachedContentTokenCount !== undefined) {
-                cachedTokens = resolvedMetadata.google.usageMetadata.cachedContentTokenCount;
-            }
-            if (cachedTokens === undefined &&
-                result.response?.usageMetadata?.cachedContentTokenCount !== undefined) {
-                cachedTokens = result.response.usageMetadata.cachedContentTokenCount;
-            }
-            if (cachedTokens === undefined &&
-                resolvedMetadata?.google?.candidates?.[0]?.usageMetadata?.cachedContentTokenCount !==
-                    undefined) {
-                cachedTokens = resolvedMetadata.google.candidates[0].usageMetadata.cachedContentTokenCount;
-            }
-            if (cachedTokens === undefined &&
-                result.providerMetadata?.google?.usageMetadata?.cachedContentTokenCount !== undefined) {
-                cachedTokens = result.providerMetadata.google.usageMetadata.cachedContentTokenCount;
-            }
-            if (cachedTokens === undefined &&
-                result.rawResponse?.usageMetadata?.cachedContentTokenCount !== undefined) {
-                cachedTokens = result.rawResponse.usageMetadata.cachedContentTokenCount;
-            }
-            if (cachedTokens !== undefined) {
-                metrics.cachedContentTokenCount = cachedTokens;
-            }
-            if (resolvedMetadata?.google?.usageMetadata?.thoughtsTokenCount !== undefined) {
-                metrics.thoughtsTokenCount = resolvedMetadata.google.usageMetadata.thoughtsTokenCount;
-            }
-            if (resolvedMetadata?.google?.usageMetadata?.totalBillableTokenCount !== undefined) {
-                metrics.totalBillableTokenCount =
-                    resolvedMetadata.google.usageMetadata.totalBillableTokenCount;
-            }
-            break;
-    }
-    return metrics;
-}
-function formatResponse(result) {
-    return {
-        id: result.response?.id,
-        modelId: result.response?.modelId,
-        timestamp: result.response?.timestamp,
-        headers: result.response?.headers,
-    };
-}
-function parseAndValidateSchema(rawSchema, exec, cacheManager) {
-    const cacheKey = `schema:${Buffer.from(rawSchema).toString('base64').substring(0, 50)}`;
-    const cached = cacheManager.schema.get(cacheKey);
-    if (cached)
-        return cached;
-    let parsedSchema;
-    try {
-        parsedSchema = JSON.parse(rawSchema);
-    }
-    catch (err) {
-        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), 'Schema is not valid JSON: ' + err.message);
-    }
-    if (!ajv.validateSchema(parsedSchema)) {
-        throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid JSON Schema: ${ajv.errorsText(ajv.errors)}`);
-    }
-    cacheManager.schema.set(cacheKey, parsedSchema);
-    return parsedSchema;
-}
-function parseStopSequences(stopSequencesStr) {
-    if (!stopSequencesStr)
-        return 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 !== '') {
-            params[key] = value;
-        }
-    }
-}
+const inputBuilder_1 = require("./helpers/inputBuilder");
+const responseFormatter_1 = require("./helpers/responseFormatter");
+const utils_1 = require("./helpers/utils");
 class UniversalAI {
     constructor() {
         this.description = descriptions_1.UNIVERSAL_AI_DESCRIPTION;
@@ -480,19 +74,27 @@ class UniversalAI {
         const items = this.getInputData();
         const returnData = [];
         const provider = this.getNodeParameter('provider', 0);
+        const options = this.getNodeParameter('options', 0, {});
+        const cacheTTL = options.cacheTTL * 1000;
         const nodeId = this.getNode().id;
         let cacheManager = nodeCacheManagers.get(nodeId);
         if (!cacheManager) {
-            cacheManager = new cache_1.CacheManager();
+            cacheManager = new cache_1.CacheManager(cacheTTL);
             nodeCacheManagers.set(nodeId, cacheManager);
         }
         const { apiKey, baseUrl } = await (0, helpers_1.getCredentials)(this, provider);
-        const customHeaders = provider === 'google' ? getGoogleCustomHeaders(this, 0) : undefined;
+        const customHeaders = getCustomHeaders(this, 0);
         const aiProvider = await (0, helpers_1.getProvider)(this, cacheManager, provider, apiKey, baseUrl, customHeaders);
+        const operation = this.getNodeParameter('operation', 0);
+        let parsedSchema;
+        if (operation === 'generateObject') {
+            const rawSchema = this.getNodeParameter('schema', 0);
+            parsedSchema = (0, utils_1.parseAndValidateSchema)(rawSchema, this, cacheManager);
+        }
         for (let i = 0; i < items.length; i++) {
             if (this.continueOnFail()) {
                 try {
-                    const result = await processItem(this, i, provider, aiProvider, apiKey, cacheManager);
+                    const result = await processItem(this, i, provider, aiProvider, apiKey, cacheManager, parsedSchema);
                     returnData.push(...result);
                 }
                 catch (error) {
@@ -504,7 +106,7 @@ class UniversalAI {
                 }
             }
             else {
-                const result = await processItem(this, i, provider, aiProvider, apiKey, cacheManager);
+                const result = await processItem(this, i, provider, aiProvider, apiKey, cacheManager, parsedSchema);
                 returnData.push(...result);
             }
         }
@@ -516,39 +118,30 @@ class UniversalAI {
     }
 }
 exports.UniversalAI = UniversalAI;
-async function processItem(exec, index, provider, aiProvider, apiKey, cacheManager) {
+async function processItem(exec, index, provider, aiProvider, apiKey, cacheManager, parsedSchema) {
     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 input = await (0, inputBuilder_1.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, cacheManager);
+        : await generateObjectOperation(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey, cacheManager, parsedSchema);
 }
 function getModelSettings(exec, index, provider, operation, options) {
     const settings = {};
-    const stopSequences = parseStopSequences(options.stopSequences);
-    if (stopSequences && (provider === 'google' || provider === 'openrouter')) {
+    const stopSequences = (0, utils_1.parseStopSequences)(options.stopSequences);
+    if (stopSequences) {
         settings.stopSequences = stopSequences;
     }
-    if (provider === 'google') {
-        const safetySettingsRaw = exec.getNodeParameter('safetySettings.settings', index, []);
-        if (safetySettingsRaw.length > 0) {
-            settings.safetySettings = safetySettingsRaw.map((s) => ({
-                category: s.category,
-                threshold: s.threshold,
-            }));
-        }
-        settings.structuredOutputs = operation === 'generateObject';
-        const responseModalities = exec.getNodeParameter('responseModalities', index, []);
-        if (responseModalities.length > 0) {
-            settings.responseModalities = responseModalities;
-        }
+    const strategy = (0, providers_1.getProviderStrategy)(provider);
+    if (strategy.getModelSettings) {
+        const providerSettings = strategy.getModelSettings(exec, index, operation);
+        Object.assign(settings, providerSettings);
     }
     return settings;
 }
-function getGoogleCustomHeaders(exec, index) {
+function getCustomHeaders(exec, index) {
     const headersCollection = exec.getNodeParameter('customHeaders', index, {});
     const entries = headersCollection?.headers ?? [];
     if (!entries || entries.length === 0) {
@@ -565,41 +158,24 @@ function getGoogleCustomHeaders(exec, index) {
     }
     return Object.keys(headers).length > 0 ? headers : undefined;
 }
-function getGroqProviderOptions(exec, index, options) {
-    const reasoningFormat = options.reasoningFormat;
-    if (!reasoningFormat) {
-        return undefined;
-    }
-    return {
-        reasoningFormat,
-    };
-}
 async function buildRequestParams(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey) {
-    const googleProviderOptions = provider === 'google'
-        ? await (0, helpers_1.setupGoogleProviderOptions)(exec, index, input, model, apiKey)
-        : undefined;
-    const groqProviderOptions = provider === 'groq' ? getGroqProviderOptions(exec, index, options) : undefined;
-    const params = {
-        model: aiProvider(model, modelSettings),
-    };
-    if (input.prompt)
-        params.prompt = input.prompt;
-    if (input.system)
-        params.system = input.system;
-    if (input.messages)
-        params.messages = input.messages;
-    if (provider === 'google' && googleProviderOptions) {
-        params.providerOptions = {
-            google: googleProviderOptions,
-        };
-    }
-    if (provider === 'groq' && groqProviderOptions) {
-        params.providerOptions = {
-            groq: groqProviderOptions,
-        };
-    }
-    if (provider === 'google' && !googleProviderOptions?.cachedContent) {
-        (0, helpers_1.restoreCacheableContent)(params, input);
+    const strategy = (0, providers_1.getProviderStrategy)(provider);
+    const params = await strategy.buildApiParams(exec, index, aiProvider, model, modelSettings, input, options, apiKey);
+    const customTools = exec.getNodeParameter('customTools.tools', index, []);
+    if (customTools.length > 0) {
+        params.tools = {};
+        for (const tool of customTools) {
+            try {
+                const parameters = JSON.parse(tool.parameters);
+                params.tools[tool.name] = {
+                    description: tool.description,
+                    parameters: parameters,
+                };
+            }
+            catch (error) {
+                throw new n8n_workflow_1.NodeOperationError(exec.getNode(), `Invalid JSON in parameters for tool "${tool.name}": ${error.message}`);
+            }
+        }
     }
     return params;
 }
@@ -616,12 +192,12 @@ async function generateTextOperation(exec, index, provider, aiProvider, model, m
         'presencePenalty',
         'seed',
     ];
-    applyNumericOptions(params, options, textNumericKeys);
+    (0, utils_1.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);
+    const formattedResult = (0, responseFormatter_1.formatTextResult)(result, includeRequestBody, provider);
     return [{ json: formattedResult }];
 }
 async function handleStreaming(params, provider, includeRequestBody) {
@@ -645,7 +221,7 @@ async function handleStreaming(params, provider, includeRequestBody) {
         toolCalls: stream.toolCalls || [],
         toolResults: stream.toolResults || [],
         finishReason: stream.finishReason,
-        usage: finalUsage ? formatUsage({ usage: finalUsage }, provider) : undefined,
+        usage: finalUsage ? (0, responseFormatter_1.formatUsage)({ usage: finalUsage }, provider) : undefined,
         isStreaming: false,
         isFinal: true,
     };
@@ -663,11 +239,9 @@ async function handleStreaming(params, provider, includeRequestBody) {
     chunks.push({ json: finalJson });
     return chunks;
 }
-async function generateObjectOperation(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey, cacheManager) {
+async function generateObjectOperation(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey, cacheManager, parsedSchema) {
     const schemaName = exec.getNodeParameter('schemaName', index, '');
     const schemaDescription = exec.getNodeParameter('schemaDescription', index, '');
-    const rawSchema = exec.getNodeParameter('schema', index);
-    const parsedSchema = parseAndValidateSchema(rawSchema, exec, cacheManager);
     const params = await buildRequestParams(exec, index, provider, aiProvider, model, modelSettings, input, options, apiKey);
     params.schema = (0, ai_1.jsonSchema)(parsedSchema);
     params.schemaName = schemaName;
@@ -680,9 +254,9 @@ async function generateObjectOperation(exec, index, provider, aiProvider, model,
         'presencePenalty',
         'seed',
     ];
-    applyNumericOptions(params, options, objectNumericKeys);
+    (0, utils_1.applyNumericOptions)(params, options, objectNumericKeys);
     const result = await (0, ai_1.generateObject)(params);
-    const formattedResult = formatObjectResult(result, options.includeRequestBody, provider);
+    const formattedResult = (0, responseFormatter_1.formatObjectResult)(result, options.includeRequestBody, provider);
     return [{ json: formattedResult }];
 }
 //# sourceMappingURL=UniversalAI.node.js.map