@discomedia/utils 1.0.71 → 1.0.72

package/dist/index-frontend.mjs

@@ -12252,7 +12252,7 @@ function zodTextFormat(zodObject, name, props) {
     }, (content) => zodObject.parse(JSON.parse(content)));
 }
 
-const DEFAULT_MODEL = 'gpt-5-mini';
+const DEFAULT_MODEL = 'gpt-5.4-mini';
 const GPT_5_HIGH_CONTEXT_THRESHOLD_TOKENS = 272_000;
 const GPT_5_HIGH_CONTEXT_INPUT_MULTIPLIER = 2;
 const GPT_5_HIGH_CONTEXT_OUTPUT_MULTIPLIER = 1.5;
@@ -12890,6 +12890,7 @@ async function parseResponse(content, responseFormat) {
 }
 
 // llm-openai.ts
+const DEFAULT_IMAGE_MIME_TYPE = 'image/webp';
 /**
  * Checks if the given direct OpenAI model supports the temperature parameter.
  * @param model The model to check.
@@ -12924,6 +12925,135 @@ function buildJsonSchemaFormat(schema, schemaName, schemaDescription, schemaStri
         ...(schemaStrict !== undefined ? { strict: schemaStrict } : {}),
     };
 }
+function resolveOpenAIApiKey(apiKey) {
+    const resolvedApiKey = apiKey || process.env.OPENAI_API_KEY;
+    if (!resolvedApiKey) {
+        throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
+    }
+    return resolvedApiKey;
+}
+function createOpenAIClient(apiKey) {
+    return new OpenAI({
+        apiKey,
+    });
+}
+function normalizeImageDataUrl(imageData, mimeType = DEFAULT_IMAGE_MIME_TYPE) {
+    return imageData.startsWith('data:') ? imageData : `data:${mimeType};base64,${imageData}`;
+}
+function getFilenameFromPath(filePath) {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const pathSegments = normalizedPath.split('/');
+    const filename = pathSegments[pathSegments.length - 1];
+    if (!filename) {
+        throw new Error(`Could not determine a filename from file path: ${filePath}`);
+    }
+    return filename;
+}
+function inferImageMimeType(filePath) {
+    const normalizedPath = filePath.toLowerCase();
+    if (normalizedPath.endsWith('.png')) {
+        return 'image/png';
+    }
+    if (normalizedPath.endsWith('.jpg') || normalizedPath.endsWith('.jpeg')) {
+        return 'image/jpeg';
+    }
+    if (normalizedPath.endsWith('.webp')) {
+        return 'image/webp';
+    }
+    if (normalizedPath.endsWith('.gif')) {
+        return 'image/gif';
+    }
+    return undefined;
+}
+async function readLocalFileBytes(filePath) {
+    try {
+        const dynamicImport = new Function('specifier', 'return import(specifier);');
+        const { readFile } = await dynamicImport('node:fs/promises');
+        return await readFile(filePath);
+    }
+    catch {
+        throw new Error('Local image file uploads require a Node.js runtime with access to node:fs/promises');
+    }
+}
+async function uploadVisionFileFromPath(openai, filePath, filename, mimeType) {
+    const fileBytes = await readLocalFileBytes(filePath);
+    const resolvedFilename = filename || getFilenameFromPath(filePath);
+    const resolvedMimeType = mimeType || inferImageMimeType(filePath);
+    const uploadableFile = await OpenAI.toFile(fileBytes, resolvedFilename, resolvedMimeType ? { type: resolvedMimeType } : undefined);
+    const uploadedFile = await openai.files.create({
+        file: uploadableFile,
+        purpose: 'vision',
+    });
+    return uploadedFile.id;
+}
+function collectImageInputs(image, images, imageBase64) {
+    const collectedImages = [];
+    if (image) {
+        collectedImages.push(image);
+    }
+    if (images && images.length > 0) {
+        collectedImages.push(...images);
+    }
+    if (imageBase64) {
+        collectedImages.push({ base64: imageBase64 });
+    }
+    return collectedImages;
+}
+function hasLocalFileImage(images) {
+    return images.some((image) => 'filePath' in image);
+}
+async function buildImageContentPart(image, defaultDetail, openai) {
+    const detail = image.detail ?? defaultDetail;
+    if ('url' in image) {
+        return {
+            type: 'input_image',
+            detail,
+            image_url: image.url,
+        };
+    }
+    if ('dataUrl' in image) {
+        return {
+            type: 'input_image',
+            detail,
+            image_url: image.dataUrl,
+        };
+    }
+    if ('base64' in image) {
+        return {
+            type: 'input_image',
+            detail,
+            image_url: normalizeImageDataUrl(image.base64, image.mimeType),
+        };
+    }
+    if ('fileId' in image) {
+        return {
+            type: 'input_image',
+            detail,
+            file_id: image.fileId,
+        };
+    }
+    if (!openai) {
+        throw new Error('A local image file path was provided, but no OpenAI client is available to upload it');
+    }
+    const fileId = await uploadVisionFileFromPath(openai, image.filePath, image.filename, image.mimeType);
+    return {
+        type: 'input_image',
+        detail,
+        file_id: fileId,
+    };
+}
+async function buildPromptContent(input, imageInputs, imageDetail, openai) {
+    if (imageInputs.length === 0) {
+        return input;
+    }
+    const imageContent = await Promise.all(imageInputs.map((image) => buildImageContentPart(image, imageDetail, openai)));
+    return [{ type: 'input_text', text: input }, ...imageContent];
+}
+async function uploadVisionFile(filePath, options = {}) {
+    const resolvedApiKey = resolveOpenAIApiKey(options.apiKey);
+    const openai = createOpenAIClient(resolvedApiKey);
+    return await uploadVisionFileFromPath(openai, filePath, options.filename, options.mimeType);
+}
 /**
  * Makes a call to OpenAI's Responses API for more advanced use cases with built-in tools.
  *
@@ -12955,13 +13085,8 @@ const makeResponsesAPICall = async (input, options = {}) => {
     if (!isOpenAIModel(normalizedModel)) {
         throw new Error(`Unsupported OpenAI model: ${normalizedModel}. Please use a supported GPT-5 model.`);
     }
-    const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-        throw new Error('OpenAI API key is not provided and OPENAI_API_KEY environment variable is not set');
-    }
-    const openai = new OpenAI({
-        apiKey: apiKey,
-    });
+    const apiKey = resolveOpenAIApiKey(options.apiKey);
+    const openai = createOpenAIClient(apiKey);
     // Remove apiKey from options before creating request body
     const { apiKey: _, model: __, ...cleanOptions } = options;
     const requestBody = {
@@ -13072,12 +13197,16 @@ const makeResponsesAPICall = async (input, options = {}) => {
  * });
  */
 async function makeLLMCall(input, options = {}) {
-    const { apiKey, model = DEFAULT_MODEL, responseFormat = 'text', schema, schemaName = 'response', schemaDescription, schemaStrict, tools, useCodeInterpreter = false, useWebSearch = false, imageBase64, imageDetail = 'high', context, } = options;
+    const { apiKey, model = DEFAULT_MODEL, responseFormat = 'text', schema, schemaName = 'response', schemaDescription, schemaStrict, tools, useCodeInterpreter = false, useWebSearch = false, image, images, imageBase64, imageDetail = 'high', context, } = options;
     // Validate model
     const normalizedModel = normalizeModelName(model);
     if (!isOpenAIModel(normalizedModel)) {
         throw new Error(`Unsupported OpenAI model: ${normalizedModel}. Please use a supported GPT-5 model.`);
     }
+    const resolvedApiKey = resolveOpenAIApiKey(apiKey);
+    const imageInputs = collectImageInputs(image, images, imageBase64);
+    const openai = hasLocalFileImage(imageInputs) ? createOpenAIClient(resolvedApiKey) : undefined;
+    const promptContent = await buildPromptContent(input, imageInputs, imageDetail, openai);
     // Process input for conversation context and image analysis
     let processedInput;
     if (context && context.length > 0) {
@@ -13092,18 +13221,11 @@ async function makeLLMCall(input, options = {}) {
             });
         }
         // Add current input message
-        if (imageBase64) {
-            // Current message includes both text and image
+        if (imageInputs.length > 0) {
+            // Current message includes text and one or more images
             conversationMessages.push({
                 role: 'user',
-                content: [
-                    { type: 'input_text', text: input },
-                    {
-                        type: 'input_image',
-                        detail: imageDetail,
-                        image_url: imageBase64.startsWith('data:') ? imageBase64 : `data:image/webp;base64,${imageBase64}`,
-                    },
-                ],
+                content: promptContent,
                 type: 'message',
             });
         }
@@ -13117,19 +13239,12 @@ async function makeLLMCall(input, options = {}) {
         }
         processedInput = conversationMessages;
     }
-    else if (imageBase64) {
-        // No context, but has image - use the original image logic
+    else if (imageInputs.length > 0) {
+        // No context, but has image(s)
         processedInput = [
             {
                 role: 'user',
-                content: [
-                    { type: 'input_text', text: input },
-                    {
-                        type: 'input_image',
-                        detail: imageDetail,
-                        image_url: imageBase64.startsWith('data:') ? imageBase64 : `data:image/webp;base64,${imageBase64}`,
-                    },
-                ],
+                content: promptContent,
                 type: 'message',
             },
         ];
@@ -13140,7 +13255,7 @@ async function makeLLMCall(input, options = {}) {
     }
     // Build the options object for makeResponsesAPICall
     let responsesOptions = {
-        apiKey,
+        apiKey: resolvedApiKey,
         model: normalizedModel,
         parallel_tool_calls: false,
         tools,
@@ -14626,11 +14741,12 @@ const disco = {
     types: Types,
     llm: {
         call: makeLLMCall,
+        uploadVisionFile: uploadVisionFile,
         seek: makeDeepseekCall,
         images: makeImagesCall,
     },
     time,
 };
 
-export { OPENAI_IMAGE_MODELS, OPENAI_MODELS, OPENROUTER_MODELS, disco, isOpenAIImageModel, isOpenAIModel, isOpenRouterModel, supportsTemperature };
+export { OPENAI_IMAGE_MODELS, OPENAI_MODELS, OPENROUTER_MODELS, disco, isOpenAIImageModel, isOpenAIModel, isOpenRouterModel, supportsTemperature, uploadVisionFile };
 //# sourceMappingURL=index-frontend.mjs.map