@juspay/neurolink 9.30.0 → 9.31.0

package/dist/utils/fileDetector.js

@@ -8,6 +8,7 @@ import { getGlobalDispatcher, interceptors, request } from "undici";
 import { archiveProcessor } from "../processors/archive/ArchiveProcessor.js";
 import { audioProcessor } from "../processors/media/AudioProcessor.js";
 import { videoProcessor } from "../processors/media/VideoProcessor.js";
+import { tracers, ATTR, withSpan } from "../telemetry/index.js";
 import { CSVProcessor } from "./csvProcessor.js";
 import { ImageProcessor } from "./imageProcessor.js";
 import { logger } from "./logger.js";
@@ -167,7 +168,7 @@ function formatFileSize(bytes) {
  * ```typescript
  * // Auto-detect and process any file
  * const result = await FileDetector.detectAndProcess("data.csv");
- * console.log(result.type); // 'csv'
+ * logger.info(result.type); // 'csv'
  * ```
  */
 export class FileDetector {
@@ -189,43 +190,124 @@ export class FileDetector {
      * @returns Processed file result with type and content
      */
     static async detectAndProcess(input, options) {
-        const detection = await FileDetector.detect(input, options);
-        // FD-018: Comprehensive fallback parsing for extension-less files
-        // When file detection returns "unknown" or doesn't match allowedTypes,
-        // attempt parsing for each allowed type before failing. This handles cases like Slack
-        // files named "file-1", "file-2" without extensions that could be CSV, JSON, or text.
-        if (options?.allowedTypes &&
-            !options.allowedTypes.includes(detection.type)) {
-            // Try fallback parsing for both "unknown" types and when detection doesn't match allowed types
+        // Derive filename and size for tracing before detection runs
+        const inputFilename = FileDetector.deriveInputFilename(input);
+        const inputSizeBytes = FileDetector.deriveInputSize(input);
+        return withSpan({
+            name: "neurolink.file.detect_and_process",
+            tracer: tracers.file,
+            attributes: {
+                [ATTR.FILE_NAME]: inputFilename,
+                [ATTR.FILE_SIZE_BYTES]: inputSizeBytes,
+            },
+        }, async (span) => {
+            const detection = await FileDetector.detect(input, options);
+            span.setAttribute(ATTR.FILE_CATEGORY, detection.type);
+            span.setAttribute(ATTR.FILE_MIMETYPE, detection.mimeType || "unknown");
+            span.setAttribute(ATTR.FILE_CONFIDENCE, detection.metadata.confidence);
+            logger.info(`[NEUROLINK] File detected: ${inputFilename} (${detection.mimeType || "unknown"}, ${formatFileSize(inputSizeBytes)}) → category: ${detection.type}`);
+            // FD-018: Comprehensive fallback parsing for extension-less files
+            if (options?.allowedTypes &&
+                !options.allowedTypes.includes(detection.type)) {
+                const content = await FileDetector.loadContent(input, detection, options);
+                const errors = [];
+                for (const allowedType of options.allowedTypes) {
+                    try {
+                        const result = await FileDetector.tryFallbackParsing(content, allowedType, options);
+                        if (result) {
+                            logger.info(`[FileDetector] ✅ ${allowedType.toUpperCase()} fallback successful`);
+                            const outputLength = typeof result.content === "string"
+                                ? result.content.length
+                                : result.content?.length || 0;
+                            span.setAttribute(ATTR.FILE_OUTPUT_LENGTH, outputLength);
+                            span.setAttribute(ATTR.FILE_SUCCESS, true);
+                            span.setAttribute(ATTR.FILE_PROCESSOR_USED, `fallback:${allowedType}`);
+                            logger.info(`[NEUROLINK] File processed: ${inputFilename} → ${outputLength} bytes output (fallback: ${allowedType})`);
+                            return result;
+                        }
+                    }
+                    catch (error) {
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        errors.push(`${allowedType}: ${errorMsg}`);
+                        logger.debug(`[FileDetector] ${allowedType} fallback failed: ${errorMsg}`);
+                    }
+                }
+                logger.warn(`[FileDetector] All fallback parsing failed for type "${detection.type}". ` +
+                    `Attempted: ${options.allowedTypes.join(", ")}. Falling through to universal handler.`);
+                const csvOptions = options?.csvOptions;
+                const result = await FileDetector.processFile(content, detection, csvOptions, options?.provider);
+                FileDetector.setFileResultSpanAttributes(span, result, inputFilename, detection.type);
+                return result;
+            }
             const content = await FileDetector.loadContent(input, detection, options);
-            const errors = [];
-            // Try each allowed type in order of specificity
-            for (const allowedType of options.allowedTypes) {
+            const csvOptions = options?.csvOptions;
+            const result = await FileDetector.processFile(content, detection, csvOptions, options?.provider);
+            FileDetector.setFileResultSpanAttributes(span, result, inputFilename, detection.type);
+            return result;
+        });
+    }
+    /**
+     * Set span attributes and log after file processing completes.
+     */
+    static setFileResultSpanAttributes(span, result, filename, processorType) {
+        const outputLength = typeof result.content === "string"
+            ? result.content.length
+            : result.content?.length || 0;
+        const hasImages = Array.isArray(result.images)
+            ? result.images.length > 0
+            : false;
+        const imageCount = Array.isArray(result.images)
+            ? result.images.length
+            : 0;
+        span.setAttribute(ATTR.FILE_OUTPUT_LENGTH, outputLength);
+        span.setAttribute(ATTR.FILE_SUCCESS, true);
+        span.setAttribute(ATTR.FILE_PROCESSOR_USED, processorType);
+        span.setAttribute(ATTR.FILE_HAS_IMAGES, hasImages);
+        span.setAttribute(ATTR.FILE_IMAGE_COUNT, imageCount);
+        logger.info(`[NEUROLINK] File processed: ${filename} → ${outputLength} bytes output` +
+            (imageCount > 0 ? ` + ${imageCount} image(s)` : "") +
+            ` (processor: ${processorType})`);
+    }
+    /**
+     * Derive a human-readable filename from FileInput for tracing.
+     */
+    static deriveInputFilename(input) {
+        if (typeof input === "string") {
+            if (input.startsWith("data:")) {
+                return "data-uri";
+            }
+            if (input.startsWith("http")) {
                 try {
-                    const result = await FileDetector.tryFallbackParsing(content, allowedType, options);
-                    if (result) {
-                        logger.info(`[FileDetector] ✅ ${allowedType.toUpperCase()} fallback successful`);
-                        return result;
-                    }
+                    return new URL(input).pathname.split("/").pop() || "url-file";
                 }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    errors.push(`${allowedType}: ${errorMsg}`);
-                    logger.debug(`[FileDetector] ${allowedType} fallback failed: ${errorMsg}`);
+                catch {
+                    return "url-file";
                 }
             }
-            // All fallbacks failed — fall through to processFile() which handles
-            // "unknown" types gracefully by extracting binary metadata and printable
-            // strings instead of throwing.
-            logger.warn(`[FileDetector] All fallback parsing failed for type "${detection.type}". ` +
-                `Attempted: ${options.allowedTypes.join(", ")}. Falling through to universal handler.`);
-            const csvOptions = options?.csvOptions;
-            return await FileDetector.processFile(content, detection, csvOptions, options?.provider);
+            // File path
+            return input.split("/").pop() || input.split("\\").pop() || "file";
+        }
+        if (Buffer.isBuffer(input)) {
+            return "buffer";
+        }
+        return "unknown-input";
+    }
+    /**
+     * Derive byte size from FileInput for tracing.
+     */
+    static deriveInputSize(input) {
+        if (Buffer.isBuffer(input)) {
+            return input.length;
+        }
+        if (typeof input === "string") {
+            if (input.startsWith("data:")) {
+                // Rough estimate: base64 is ~4/3 of raw
+                const base64Part = input.split(",")[1];
+                return base64Part ? Math.floor((base64Part.length * 3) / 4) : 0;
+            }
+            return input.length; // path or URL string length (not file size)
         }
-        const content = await FileDetector.loadContent(input, detection, options);
-        // Extract CSV-specific options from FileDetectorOptions
-        const csvOptions = options?.csvOptions;
-        return await FileDetector.processFile(content, detection, csvOptions, options?.provider);
+        return 0;
     }
     /**
      * Try fallback parsing for a specific file type

package/dist/utils/imageProcessor.js

@@ -143,7 +143,7 @@ export class ImageProcessor {
         }
         catch (error) {
             logger.error("Failed to process image for OpenAI:", error);
-            throw new Error(`Image processing failed for OpenAI: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Image processing failed for OpenAI: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error });
         }
     }
     /**
@@ -179,7 +179,7 @@ export class ImageProcessor {
         }
         catch (error) {
             logger.error("Failed to process image for Google AI:", error);
-            throw new Error(`Image processing failed for Google AI: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Image processing failed for Google AI: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error });
         }
     }
     /**
@@ -215,7 +215,7 @@ export class ImageProcessor {
         }
         catch (error) {
             logger.error("Failed to process image for Anthropic:", error);
-            throw new Error(`Image processing failed for Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Image processing failed for Anthropic: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error });
         }
     }
     /**
@@ -239,7 +239,7 @@ export class ImageProcessor {
         }
         catch (error) {
             logger.error("Failed to process image for Vertex AI:", error);
-            throw new Error(`Image processing failed for Vertex AI: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Image processing failed for Vertex AI: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error });
         }
     }
     /**
@@ -433,7 +433,7 @@ export class ImageProcessor {
         }
         catch (error) {
             logger.error(`Failed to process image for ${provider}:`, error);
-            throw new Error(`Image processing failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Image processing failed: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error });
         }
     }
 }
@@ -521,7 +521,7 @@ export const imageUtils = {
             return `data:${mimeType};base64,${base64}`;
         }
         catch (error) {
-            throw new Error(`Failed to convert file to base64: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to convert file to base64: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error });
         }
     },
     /**
@@ -610,7 +610,7 @@ export const imageUtils = {
             });
         }
         catch (error) {
-            throw new Error(`Failed to download and convert URL to base64: ${error instanceof Error ? error.message : "Unknown error"}`);
+            throw new Error(`Failed to download and convert URL to base64: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error });
         }
     },
     /**

package/dist/utils/json/safeParse.d.ts

@@ -4,14 +4,7 @@
  * Centralized JSON parsing utilities that handle errors gracefully.
  * Provides safe parsing that doesn't throw on invalid JSON.
  */
-/**
- * Result type for safe JSON parsing operations
- */
-export type SafeParseResult<T> = {
-    success: boolean;
-    data: T | null;
-    error: Error | null;
-};
+import type { SafeParseResult } from "../../types/index.js";
 /**
  * Safely parse a JSON string without throwing.
  *

package/dist/utils/mcpDefaults.d.ts

@@ -37,7 +37,7 @@ export declare function createMCPServerInfo(options: {
  * Create MCPServerInfo for custom tool registration
  * Specialized version with smart defaults for registerTool usage
  */
-export declare function createCustomToolServerInfo(toolName: string, tool: MCPExecutableTool): MCPServerInfo;
+export declare function createCustomToolServerInfo(toolName: string, tool: MCPExecutableTool, timeoutMs?: number, maxRetries?: number): MCPServerInfo;
 /**
  * Create MCPServerInfo for external servers
  * Specialized version with smart defaults for external server usage

package/dist/utils/mcpDefaults.js

@@ -93,8 +93,8 @@ export function createMCPServerInfo(options) {
  * Create MCPServerInfo for custom tool registration
  * Specialized version with smart defaults for registerTool usage
  */
-export function createCustomToolServerInfo(toolName, tool) {
-    return createMCPServerInfo({
+export function createCustomToolServerInfo(toolName, tool, timeoutMs, maxRetries) {
+    const serverInfo = createMCPServerInfo({
         id: `custom-tool-${toolName}`,
         name: toolName,
         tool: {
@@ -105,6 +105,15 @@ export function createCustomToolServerInfo(toolName, tool) {
         },
         isCustomTool: true,
     });
+    if (serverInfo.metadata) {
+        if (timeoutMs !== undefined) {
+            serverInfo.metadata.toolTimeoutMs = timeoutMs;
+        }
+        if (maxRetries !== undefined) {
+            serverInfo.metadata.toolMaxRetries = maxRetries;
+        }
+    }
+    return serverInfo;
 }
 /**
  * Create MCPServerInfo for external servers

package/dist/utils/messageBuilder.d.ts

@@ -3,23 +3,23 @@
  * Centralized logic for building message arrays from TextGenerationOptions
  * Enhanced with multimodal support for images
  */
-import type { CoreMessage } from "ai";
+import type { ModelMessage } from "ai";
 import type { MultimodalChatMessage } from "../types/conversation.js";
 import type { GenerateOptions } from "../types/generateTypes.js";
 import type { TextGenerationOptions } from "../types/index.js";
 import type { StreamOptions } from "../types/streamTypes.js";
 /**
- * Type-safe conversion from MultimodalChatMessage[] to CoreMessage[]
- * Filters out invalid content and ensures strict CoreMessage contract compliance
+ * Type-safe conversion from MultimodalChatMessage[] to ModelMessage[]
+ * Filters out invalid content and ensures strict ModelMessage contract compliance
  */
-export declare function convertToCoreMessages(messages: MultimodalChatMessage[]): CoreMessage[];
+export declare function convertToModelMessages(messages: MultimodalChatMessage[]): ModelMessage[];
 /**
  * Build a properly formatted message array for AI providers
  * Combines system prompt, conversation history, and current user prompt
  * Supports both TextGenerationOptions and StreamOptions
  * Enhanced with CSV file processing support
  */
-export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): Promise<CoreMessage[]>;
+export declare function buildMessagesArray(options: TextGenerationOptions | StreamOptions): Promise<ModelMessage[]>;
 /**
  * Build multimodal message array with image support
  * Detects when images are present and routes through provider adapter

package/dist/utils/messageBuilder.js

@@ -10,6 +10,7 @@ import { CONVERSATION_INSTRUCTIONS, STRUCTURED_OUTPUT_INSTRUCTIONS, } from "../c
 import { getAvailableInputTokens } from "../constants/contextWindows.js";
 import { enforceAggregateFileBudget, FILE_READ_BUDGET_PERCENT, } from "../context/fileTokenBudget.js";
 import { SIZE_TIER_THRESHOLDS } from "../files/types.js";
+import { tracers, ATTR, withSpan } from "../telemetry/index.js";
 import { FileDetector } from "./fileDetector.js";
 import { getImageCache } from "./imageCache.js";
 import { logger } from "./logger.js";
@@ -280,7 +281,7 @@ function convertContentItem(item) {
         return {
             type: "image",
             image: contentItem.image,
-            ...(contentItem.mimeType && { mimeType: contentItem.mimeType }),
+            ...(contentItem.mimeType && { mediaType: contentItem.mimeType }),
         };
     }
     if (contentItem.type === "file" &&
@@ -289,16 +290,16 @@ function convertContentItem(item) {
         return {
             type: "file",
             data: contentItem.data,
-            mimeType: contentItem.mimeType,
+            mediaType: contentItem.mimeType,
         };
     }
     return null;
 }
 /**
- * Type-safe conversion from MultimodalChatMessage[] to CoreMessage[]
- * Filters out invalid content and ensures strict CoreMessage contract compliance
+ * Type-safe conversion from MultimodalChatMessage[] to ModelMessage[]
+ * Filters out invalid content and ensures strict ModelMessage contract compliance
  */
-export function convertToCoreMessages(messages) {
+export function convertToModelMessages(messages) {
     return messages
         .map((msg) => {
         // Validate role
@@ -391,9 +392,9 @@ export function convertToCoreMessages(messages) {
         .filter((msg) => msg !== null);
 }
 /**
- * Convert ChatMessage to CoreMessage for AI SDK compatibility
+ * Convert ChatMessage to ModelMessage for AI SDK compatibility
  */
-function toCoreMessage(message) {
+function toModelMessage(message) {
     // Only include messages with roles supported by AI SDK
     if (message.role === "user" ||
         message.role === "assistant" ||
@@ -490,10 +491,10 @@ export async function buildMessagesArray(options) {
         });
     }
     // Add conversation history if available
-    // Convert ChatMessages to CoreMessages and filter out tool messages
+    // Convert ChatMessages to ModelMessages and filter out tool messages
     if (hasConversationHistory && options.conversationMessages) {
         for (const chatMessage of options.conversationMessages) {
-            const coreMessage = toCoreMessage(chatMessage);
+            const coreMessage = toModelMessage(chatMessage);
             if (coreMessage) {
                 messages.push(coreMessage);
             }
@@ -773,66 +774,87 @@ async function processUnifiedFilesArray(options, maxSize, provider) {
     if (!options.input.files || options.input.files.length === 0) {
         return;
     }
-    logger.info(`[FileDetector] Processing ${options.input.files.length} file(s) with auto-detection`);
-    options.input.text = options.input.text || "";
-    const fileRegistry = options.fileRegistry;
-    for (let fileIdx = 0; fileIdx < options.input.files.length; fileIdx++) {
-        const file = options.input.files[fileIdx];
-        try {
-            // ─── Lazy file registration path ──────────────────────────────
-            const fileSize = fileRegistry ? getFileSize(file) : 0;
-            if (fileRegistry && fileSize > SIZE_TIER_THRESHOLDS.TINY_MAX) {
-                const registered = await tryRegisterFileReference(file, fileSize, fileRegistry, fileIdx);
-                if (registered) {
-                    continue;
+    const totalFiles = options.input.files.length;
+    return withSpan({
+        name: "neurolink.file.process_all",
+        tracer: tracers.file,
+        attributes: {
+            [ATTR.FILE_TOTAL_COUNT]: totalFiles,
+            [ATTR.NL_PROVIDER]: provider,
+        },
+    }, async (span) => {
+        logger.info(`[NEUROLINK] Processing ${totalFiles} file(s) with auto-detection`);
+        options.input.text = options.input.text || "";
+        let includedCount = 0;
+        const fileRegistry = options.fileRegistry;
+        for (let fileIdx = 0; fileIdx < options.input.files.length; fileIdx++) {
+            const file = options.input.files[fileIdx];
+            const filename = extractFilename(file, fileIdx);
+            try {
+                // ─── Lazy file registration path ──────────────────────────────
+                const fileSize = fileRegistry ? getFileSize(file) : 0;
+                if (fileRegistry && fileSize > SIZE_TIER_THRESHOLDS.TINY_MAX) {
+                    const registered = await tryRegisterFileReference(file, fileSize, fileRegistry, fileIdx);
+                    if (registered) {
+                        logger.info(`[NEUROLINK] File lazily registered: ${filename} (${fileSize} bytes) — deferred processing`);
+                        includedCount++;
+                        continue;
+                    }
                 }
+                // ─── Full processing path (current behavior) ──────────────────
+                const genericFileMaxSize = Math.max(maxSize, 100 * 1024 * 1024);
+                const rawFileInput = isFileWithMetadata(file) ? file.buffer : file;
+                const result = await FileDetector.detectAndProcess(rawFileInput, {
+                    maxSize: genericFileMaxSize,
+                    allowedTypes: [
+                        "csv",
+                        "image",
+                        "pdf",
+                        "svg",
+                        "video",
+                        "audio",
+                        "archive",
+                        "xlsx",
+                        "docx",
+                        "pptx",
+                        "text",
+                        "unknown",
+                    ],
+                    csvOptions: options.csvOptions,
+                    provider: provider,
+                });
+                appendDetectedFileResult(result, file, options);
+                includedCount++;
+                // Log what content type was added to the message
+                const contentType = result.type === "image" ? "image" : "text";
+                logger.info(`[NEUROLINK] File added to message: ${filename} as ${contentType} (type: ${result.type})`);
+            }
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                logger.error(`[NEUROLINK] File skipped/failed: ${filename} — reason: ${errMsg}`);
             }
-            // ─── Full processing path (current behavior) ──────────────────
-            const genericFileMaxSize = Math.max(maxSize, 100 * 1024 * 1024);
-            const rawFileInput = isFileWithMetadata(file) ? file.buffer : file;
-            const result = await FileDetector.detectAndProcess(rawFileInput, {
-                maxSize: genericFileMaxSize,
-                allowedTypes: [
-                    "csv",
-                    "image",
-                    "pdf",
-                    "svg",
-                    "video",
-                    "audio",
-                    "archive",
-                    "xlsx",
-                    "docx",
-                    "pptx",
-                    "text",
-                    "unknown",
-                ],
-                csvOptions: options.csvOptions,
-                provider: provider,
-            });
-            appendDetectedFileResult(result, file, options);
-        }
-        catch (error) {
-            logger.error(`[FileDetector] ❌ Failed to process file:`, error);
-        }
-    }
-    // After processing all files, inject previews for any lazily-registered files
-    if (fileRegistry && fileRegistry.size > 0) {
-        const previewText = await fileRegistry.generatePromptPreview();
-        if (previewText) {
-            options.input.text = (options.input.text || "") + previewText;
-            logger.info(`[FileDetector] Injected previews for ${fileRegistry.size} lazily-registered file(s)`);
         }
-        const registeredFiles = fileRegistry.list();
-        for (const ref of registeredFiles) {
-            if (ref.extractedImages && ref.extractedImages.length > 0) {
-                options.input.images = [
-                    ...(options.input.images || []),
-                    ...ref.extractedImages,
-                ];
-                logger.info(`[FileDetector] Injected ${ref.extractedImages.length} extracted images from "${ref.filename}"`);
+        span.setAttribute(ATTR.FILE_INCLUDED_COUNT, includedCount);
+        // After processing all files, inject previews for any lazily-registered files
+        if (fileRegistry && fileRegistry.size > 0) {
+            const previewText = await fileRegistry.generatePromptPreview();
+            if (previewText) {
+                options.input.text = (options.input.text || "") + previewText;
+                logger.info(`[FileDetector] Injected previews for ${fileRegistry.size} lazily-registered file(s)`);
+            }
+            const registeredFiles = fileRegistry.list();
+            for (const ref of registeredFiles) {
+                if (ref.extractedImages && ref.extractedImages.length > 0) {
+                    options.input.images = [
+                        ...(options.input.images || []),
+                        ...ref.extractedImages,
+                    ];
+                    logger.info(`[FileDetector] Injected ${ref.extractedImages.length} extracted images from "${ref.filename}"`);
+                }
             }
         }
-    }
+        logger.info(`[NEUROLINK] File processing complete: ${includedCount}/${totalFiles} files included in message`);
+    });
 }
 /**
  * Process explicit CSV files array and append to options.input.text.
@@ -1171,7 +1193,7 @@ async function downloadImageFromUrl(url) {
     }
     catch (error) {
         MultimodalLogger.logError("URL_DOWNLOAD_FAILED", error, { url });
-        throw new Error(`Failed to download image from ${url}: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Failed to download image from ${url}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
 /**
@@ -1235,17 +1257,22 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
     // Process all images (including downloaded URLs) for Vercel AI SDK
     actualImages.forEach(({ data: image }, index) => {
         try {
-            // Vercel AI SDK expects { type: 'image', image: Buffer | string, mimeType?: string }
-            // For Vertex AI, we need to include mimeType
+            // Vercel AI SDK v6 expects { type: 'image', image: Buffer | string, mimeType?: string }
+            // IMPORTANT: The `image` field must be raw base64 or a Buffer — NOT a data: URI string.
+            // The AI SDK v6's download pipeline calls `new URL(image)` on string values. A data: URI
+            // is a valid URL, so the SDK tries to "download" it, which hits SSRF validation
+            // (validateDownloadUrl) and throws "URL scheme must be http or https, got data:".
+            // Passing raw base64 avoids this because `new URL(base64string)` throws and the SDK
+            // treats the string as inline base64 data instead.
             let imageData;
             let mimeType = "image/jpeg"; // Default mime type
             if (typeof image === "string") {
                 if (image.startsWith("data:")) {
-                    // Data URI (including downloaded URLs) - extract mime type and use directly
+                    // Data URI (including downloaded URLs) - extract mime type and raw base64
                     const match = image.match(/^data:([^;]+);base64,(.+)$/);
                     if (match) {
                         mimeType = match[1];
-                        imageData = image; // Keep as data URI for Vercel AI SDK
+                        imageData = match[2]; // Raw base64 only — NOT the full data: URI
                     }
                     else {
                         imageData = image;
@@ -1257,7 +1284,7 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
                     throw new Error(`Unprocessed URL found in actualImages: ${image}`);
                 }
                 else {
-                    // File path string - convert to base64 data URI
+                    // File path string - convert to base64
                     try {
                         if (existsSync(image)) {
                             const buffer = readFileSync(image);
@@ -1285,7 +1312,7 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
                                     mimeType = "image/jpeg";
                                     break;
                             }
-                            imageData = `data:${mimeType};base64,${base64}`;
+                            imageData = base64; // Raw base64 only
                         }
                         else {
                             throw new Error(`Image file not found: ${image}`);
@@ -1296,19 +1323,18 @@ async function convertSimpleImagesToProviderFormat(text, images, provider, _mode
                             index,
                             filePath: image,
                         });
-                        throw new Error(`Failed to convert file path to base64: ${image}. ${error}`);
+                        throw new Error(`Failed to convert file path to base64: ${image}. ${error}`, { cause: error });
                     }
                 }
             }
             else {
-                // Buffer - convert to base64 data URI
-                const base64 = image.toString("base64");
-                imageData = `data:${mimeType};base64,${base64}`;
+                // Buffer - convert to raw base64
+                imageData = image.toString("base64");
             }
             content.push({
                 type: "image",
                 image: imageData,
-                mimeType: mimeType, // Add mimeType for Vertex AI compatibility
+                mimeType: mimeType,
             });
         }
         catch (error) {
@@ -1348,7 +1374,7 @@ async function convertMultimodalToProviderFormat(text, images, pdfFiles, provide
             return {
                 type: "file",
                 data: pdf.buffer,
-                mimeType: "application/pdf",
+                mediaType: "application/pdf",
             };
         }));
     }
@@ -1363,11 +1389,11 @@ async function convertMultimodalToProviderFormat(text, images, pdfFiles, provide
                     maxPages: 20, // Limit pages to prevent token overflow
                 });
                 logger.info(`[PDF→Image] ✅ Converted ${pdf.filename}: ${conversionResult.pageCount} page(s) → images`);
-                // Add each page as an ImagePart
+                // Add each page as an ImagePart (raw base64, not data: URI — see SSRF note above)
                 conversionResult.images.forEach((base64Image, pageIndex) => {
                     content.push({
                         type: "image",
-                        image: `data:image/png;base64,${base64Image}`,
+                        image: base64Image,
                         mimeType: "image/png",
                     });
                     logger.debug(`[PDF→Image] Added page ${pageIndex + 1}/${conversionResult.pageCount} of ${pdf.filename}`);
@@ -1384,7 +1410,7 @@ async function convertMultimodalToProviderFormat(text, images, pdfFiles, provide
                 logger.error(`[PDF→Image] ❌ Failed to convert ${pdf.filename}: ${errorMessage}`);
                 // Re-throw so the user knows PDF processing failed
                 throw new Error(`PDF to image conversion failed for ${pdf.filename}: ${errorMessage}. ` +
-                    `Provider ${provider} doesn't support native PDFs and image conversion failed.`);
+                    `Provider ${provider} doesn't support native PDFs and image conversion failed.`, { cause: error });
             }
         }
     }

package/dist/utils/modelChoices.d.ts

@@ -3,14 +3,7 @@
  * Derives choices from model enums to ensure consistency
  */
 import { AIProviderName } from "../constants/enums.js";
-/**
- * Model choice for CLI prompts (inquirer format)
- */
-export type ModelChoice = {
-    name: string;
-    value: string;
-    description?: string;
-};
+import type { ModelChoice } from "../types/index.js";
 /**
  * Default models per provider (first choice/recommended)
  */