@juspay/neurolink 8.2.0 → 8.4.0

package/dist/lib/types/multimodal.js

@@ -0,0 +1,101 @@
+/**
+ * Multimodal Content Types for NeuroLink
+ *
+ * Central registry for all multimodal input/output types.
+ * This file consolidates types from content.ts and conversation.ts
+ * to provide a single source of truth for multimodal functionality.
+ *
+ * @module types/multimodal
+ *
+ * @example Basic Multimodal Input
+ * ```typescript
+ * import type { MultimodalInput } from './types/multimodal.js';
+ *
+ * const input: MultimodalInput = {
+ *   text: "What's in this image?",
+ *   images: [imageBuffer, "https://example.com/image.jpg"],
+ *   pdfFiles: [pdfBuffer]
+ * };
+ * ```
+ *
+ * @example Audio/Video Input (Future)
+ * ```typescript
+ * const avInput: MultimodalInput = {
+ *   text: "Transcribe this audio and analyze this video",
+ *   audioFiles: [audioBuffer],
+ *   videoFiles: ["path/to/video.mp4"]
+ * };
+ * ```
+ *
+ * @example Advanced Content Array
+ * ```typescript
+ * const advanced: MultimodalInput = {
+ *   text: "irrelevant", // ignored when content[] is provided
+ *   content: [
+ *     { type: "text", text: "Analyze these items:" },
+ *     { type: "image", data: imageBuffer, mediaType: "image/jpeg" },
+ *     { type: "pdf", data: pdfBuffer, metadata: { filename: "report.pdf" } }
+ *   ]
+ * };
+ * ```
+ */
+// ============================================
+// TYPE GUARDS
+// ============================================
+/**
+ * Type guard to check if content is TextContent
+ */
+export function isTextContent(content) {
+    return content.type === "text";
+}
+/**
+ * Type guard to check if content is ImageContent
+ */
+export function isImageContent(content) {
+    return content.type === "image";
+}
+/**
+ * Type guard to check if content is CSVContent
+ */
+export function isCSVContent(content) {
+    return content.type === "csv";
+}
+/**
+ * Type guard to check if content is PDFContent
+ */
+export function isPDFContent(content) {
+    return content.type === "pdf";
+}
+/**
+ * Type guard to check if content is AudioContent
+ */
+export function isAudioContent(content) {
+    return content.type === "audio";
+}
+/**
+ * Type guard to check if content is VideoContent
+ */
+export function isVideoContent(content) {
+    return content.type === "video";
+}
+/**
+ * Type guard to check if input contains multimodal content
+ * Now includes audio and video detection
+ */
+export function isMultimodalInput(input) {
+    const maybeInput = input;
+    return !!(maybeInput?.images?.length ||
+        maybeInput?.csvFiles?.length ||
+        maybeInput?.pdfFiles?.length ||
+        maybeInput?.files?.length ||
+        maybeInput?.content?.length ||
+        maybeInput?.audioFiles?.length ||
+        maybeInput?.videoFiles?.length);
+}
+/**
+ * Type guard to check if message content is multimodal (array)
+ */
+export function isMultimodalMessageContent(content) {
+    return Array.isArray(content);
+}
+//# sourceMappingURL=multimodal.js.map

package/dist/lib/types/streamTypes.d.ts

@@ -1,7 +1,7 @@
 import type { Tool } from "ai";
 import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
 import type { AIModelProviderConfig } from "./providers.js";
-import type { TextContent, ImageContent } from "./content.js";
+import type { Content } from "./content.js";
 import type { AnalyticsData, ToolExecutionEvent, ToolExecutionSummary } from "../types/index.js";
 import { AIProviderName } from "../constants/enums.js";
 import type { TokenUsage } from "./analytics.js";
@@ -129,7 +129,7 @@ export type StreamOptions = {
         csvFiles?: Array<Buffer | string>;
         pdfFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string>;
-        content?: Array<TextContent | ImageContent>;
+        content?: Content[];
     };
     output?: {
         format?: "text" | "structured" | "json";

package/dist/lib/utils/imageProcessor.d.ts

@@ -2,7 +2,7 @@
  * Image processing utilities for multimodal support
  * Handles format conversion for different AI providers
  */
-import type { ProcessedImage } from "../types/content.js";
+import type { ProcessedImage } from "../types/multimodal.js";
 import type { FileProcessingResult } from "../types/fileTypes.js";
 /**
  * Image processor class for handling provider-specific image formatting

package/dist/lib/utils/messageBuilder.js

@@ -473,6 +473,26 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
     if (hasConversationHistory) {
         systemPrompt = `${systemPrompt.trim()}${CONVERSATION_INSTRUCTIONS}`;
     }
+    // Add file handling guidance when multimodal files are present
+    const hasCSVFiles = (options.input.csvFiles && options.input.csvFiles.length > 0) ||
+        (options.input.files &&
+            options.input.files.some((f) => typeof f === "string" ? f.toLowerCase().endsWith(".csv") : false));
+    const hasPDFFiles = pdfFiles.length > 0;
+    if (hasCSVFiles || hasPDFFiles) {
+        const fileTypes = [];
+        if (hasPDFFiles) {
+            fileTypes.push("PDFs");
+        }
+        if (hasCSVFiles) {
+            fileTypes.push("CSVs");
+        }
+        systemPrompt += `\n\nIMPORTANT FILE HANDLING INSTRUCTIONS:
+- File content (${fileTypes.join(", ")}, images) is already processed and included in this message
+- DO NOT use GitHub tools (get_file_contents, search_code, etc.) for local files - they only work for remote repository files
+- Analyze the provided file content directly without attempting to fetch or read files using tools
+- GitHub MCP tools are ONLY for remote repository operations, not local filesystem access
+- Use the file content shown in this message for your analysis`;
+    }
     // Add system message if we have one
     if (systemPrompt.trim()) {
         messages.push({
@@ -739,7 +759,10 @@ async function convertMultimodalToProviderFormat(text, images, pdfFiles, provide
             });
         }
     }
-    // Add PDFs using Vercel AI SDK standard format (works for all providers)
+    // Add PDFs using Vercel AI SDK standard format (works for all providers except Mistral)
+    // NOTE: Mistral API has a fundamental limitation - it does NOT support PDFs in any form.
+    // The API strictly requires image content to start with data:image/, rejecting data:application/pdf
+    // See: MISTRAL_PDF_FIX_SUMMARY.md for full investigation details
     content.push(...pdfFiles.map((pdf) => {
         logger.info(`[PDF] ✅ Added to content (Vercel AI SDK format): ${pdf.filename}`);
         return {
@@ -769,6 +792,6 @@ function extractFilename(file, index = 0) {
     return `file-${index + 1}`;
 }
 function buildCSVToolInstructions(filePath) {
-    return `\n**IMPORTANT**: For counting, aggregation, or statistical operations, use the analyzeCSV tool with filePath="${filePath}". The tool reads the file directly - do NOT pass CSV content.\n\nExample: analyzeCSV(filePath="${filePath}", operation="count_by_column", column="merchant_id")\n\n`;
+    return `\n**NOTE**: You can perform calculations directly on the CSV data shown above. For advanced operations on the full file (counting by column, grouping, etc.), you may optionally use the analyzeCSV tool with filePath="${filePath}".\n\nExample: analyzeCSV(filePath="${filePath}", operation="count_by_column", column="merchant_id")\n\n`;
 }
 //# sourceMappingURL=messageBuilder.js.map

package/dist/lib/utils/multimodalOptionsBuilder.d.ts

@@ -45,7 +45,7 @@ export declare function buildMultimodalOptions(options: StreamOptions, providerN
     input: {
         text: string;
         images: (string | Buffer<ArrayBufferLike>)[] | undefined;
-        content: (import("../types/content.js").TextContent | import("../types/content.js").ImageContent)[] | undefined;
+        content: import("../types/multimodal.js").Content[] | undefined;
         files: (string | Buffer<ArrayBufferLike>)[] | undefined;
         csvFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
         pdfFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;

package/dist/lib/utils/pdfProcessor.d.ts

@@ -7,4 +7,13 @@ export declare class PDFProcessor {
     private static isValidPDF;
     private static extractBasicMetadata;
     static estimateTokens(pageCount: number, mode?: "text-only" | "visual"): number;
+    static convertPDFToImages(pdfBuffer: Buffer, options?: {
+        maxPages?: number;
+        scale?: number;
+        format?: "png" | "jpeg";
+        quality?: number;
+    }): Promise<Array<{
+        buffer: Buffer;
+        pageNumber: number;
+    }>>;
 }

package/dist/lib/utils/pdfProcessor.js

@@ -1,4 +1,6 @@
 import { logger } from "./logger.js";
+import * as pdfjs from "pdfjs-dist/legacy/build/pdf.mjs";
+import { createCanvas } from "canvas";
 const PDF_PROVIDER_CONFIGS = {
     anthropic: {
         maxSizeMB: 5,
@@ -87,7 +89,7 @@ const PDF_PROVIDER_CONFIGS = {
     mistral: {
         maxSizeMB: 10,
         maxPages: 100,
-        supportsNative: true,
+        supportsNative: false,
         requiresCitations: false,
         apiType: "files-api",
     },
@@ -115,16 +117,14 @@ export class PDFProcessor {
         if (!this.isValidPDF(content)) {
             throw new Error("Invalid PDF file format. File must start with %PDF- header.");
         }
-        if (!config || !config.supportsNative) {
-            const supportedProviders = Object.keys(PDF_PROVIDER_CONFIGS)
-                .filter((p) => PDF_PROVIDER_CONFIGS[p].supportsNative)
-                .join(", ");
-            throw new Error(`PDF files are not currently supported with ${provider} provider.\n` +
-                `Supported providers: ${supportedProviders}\n` +
+        if (!config) {
+            const supportedProviders = Object.keys(PDF_PROVIDER_CONFIGS).join(", ");
+            throw new Error(`PDF files are not configured for ${provider} provider.\n` +
+                `Configured providers: ${supportedProviders}\n` +
                 `Current provider: ${provider}\n\n` +
                 `Options:\n` +
-                `1. Switch to a supported provider (--provider openai or --provider vertex)\n` +
-                `2. Convert your PDF to text manually`);
+                `1. Switch to a configured provider (--provider openai or --provider vertex)\n` +
+                `2. Contact support to add ${provider} PDF configuration`);
         }
         const sizeMB = content.length / (1024 * 1024);
         if (sizeMB > config.maxSizeMB) {
@@ -195,5 +195,63 @@ export class PDFProcessor {
             return Math.ceil((pageCount / 3) * 7000);
         }
     }
+    static async convertPDFToImages(pdfBuffer, options) {
+        const maxPages = options?.maxPages || 10;
+        const scale = options?.scale || 2.0;
+        const format = options?.format || "png";
+        const quality = options?.quality || 0.9;
+        let pdfDocument = null;
+        try {
+            const loadingTask = pdfjs.getDocument({
+                data: new Uint8Array(pdfBuffer),
+                useSystemFonts: true,
+                standardFontDataUrl: `https://cdn.jsdelivr.net/npm/pdfjs-dist@${pdfjs.version}/standard_fonts/`,
+            });
+            pdfDocument = await loadingTask.promise;
+            const numPages = Math.min(pdfDocument.numPages, maxPages);
+            const images = [];
+            logger.info(`[PDF→Image] Converting ${numPages} page(s) from PDF (total: ${pdfDocument.numPages})`);
+            for (let pageNum = 1; pageNum <= numPages; pageNum++) {
+                const page = await pdfDocument.getPage(pageNum);
+                const viewport = page.getViewport({ scale });
+                const canvas = createCanvas(viewport.width, viewport.height);
+                const context = canvas.getContext("2d");
+                await page.render({
+                    canvasContext: context,
+                    viewport,
+                    // @ts-expect-error - canvas type mismatch between node-canvas and pdfjs-dist
+                    canvas: canvas,
+                }).promise;
+                const imageBuffer = format === "png"
+                    ? canvas.toBuffer("image/png")
+                    : canvas.toBuffer("image/jpeg", { quality });
+                images.push({ buffer: imageBuffer, pageNumber: pageNum });
+                logger.debug(`[PDF→Image] ✅ Converted page ${pageNum}/${numPages} (${(imageBuffer.length / 1024).toFixed(1)}KB)`);
+            }
+            if (pdfDocument.numPages > maxPages) {
+                logger.warn(`[PDF→Image] PDF has ${pdfDocument.numPages} pages, converted only first ${maxPages} pages`);
+            }
+            logger.info(`[PDF→Image] ✅ Successfully converted ${images.length} page(s) to images`);
+            return images;
+        }
+        catch (error) {
+            logger.error(`[PDF→Image] ❌ Failed to convert PDF to images:`, error instanceof Error ? error.message : String(error));
+            throw new Error(`PDF to image conversion failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            // Ensure pdfDocument is destroyed regardless of success or failure
+            if (pdfDocument) {
+                try {
+                    pdfDocument.destroy();
+                    logger.debug("[PDF→Image] PDF document resources cleaned up");
+                }
+                catch (destroyError) {
+                    logger.warn("[PDF→Image] Error destroying PDF document:", destroyError instanceof Error
+                        ? destroyError.message
+                        : String(destroyError));
+                }
+            }
+        }
+    }
 }
 //# sourceMappingURL=pdfProcessor.js.map

package/dist/mcp/servers/agent/directToolsServer.js

@@ -135,7 +135,6 @@ function getToolCategory(toolName) {
         case "readFile":
         case "writeFile":
         case "listDirectory":
-        case "searchFiles":
             return "filesystem";
         case "websearchGrounding":
             return "search";

package/dist/models/modelRegistry.js

@@ -188,6 +188,50 @@ export const MODEL_REGISTRY = {
         category: "general",
     },
     // Anthropic Models
+    [AnthropicModels.CLAUDE_4_5_HAIKU]: {
+        id: AnthropicModels.CLAUDE_4_5_HAIKU,
+        name: "Claude 4.5 Haiku",
+        provider: AIProviderName.ANTHROPIC,
+        description: "Latest fast and efficient Claude model with vision support",
+        capabilities: {
+            vision: true,
+            functionCalling: true,
+            codeGeneration: true,
+            reasoning: true,
+            multimodal: true,
+            streaming: true,
+            jsonMode: false,
+        },
+        pricing: {
+            inputCostPer1K: 0.001,
+            outputCostPer1K: 0.005,
+            currency: "USD",
+        },
+        performance: {
+            speed: "fast",
+            quality: "high",
+            accuracy: "high",
+        },
+        limits: {
+            maxContextTokens: 200000,
+            maxOutputTokens: 64000,
+            maxRequestsPerMinute: 100,
+        },
+        useCases: {
+            coding: 8,
+            creative: 8,
+            analysis: 8,
+            conversation: 9,
+            reasoning: 8,
+            translation: 8,
+            summarization: 9,
+        },
+        aliases: ["claude-4.5-haiku", "claude-haiku-latest", "haiku-4.5"],
+        deprecated: false,
+        isLocal: false,
+        releaseDate: "2025-10-15",
+        category: "general",
+    },
     [AnthropicModels.CLAUDE_3_5_SONNET]: {
         id: AnthropicModels.CLAUDE_3_5_SONNET,
         name: "Claude 3.5 Sonnet",

package/dist/neurolink.js

@@ -455,7 +455,7 @@ Current user's request: ${currentInput}`;
         try {
             this.externalServerManager = new ExternalServerManager({
                 maxServers: 20,
-                defaultTimeout: 15000,
+                defaultTimeout: 30000, // Increased from 15s to 30s for proxy latency (e.g., LiteLLM)
                 enableAutoRestart: true,
                 enablePerformanceMonitoring: true,
             }, {
@@ -1963,6 +1963,29 @@ Current user's request: ${currentInput}`;
                         // Continue with original options if orchestration fails
                     }
                 }
+                // 🔧 AUTO-DISABLE TOOLS: For Ollama models that don't support tools (same logic as generate())
+                // This prevents overwhelming smaller models with massive tool descriptions in the system message
+                if ((options.provider === "ollama" ||
+                    options.provider?.toLowerCase().includes("ollama")) &&
+                    !options.disableTools) {
+                    const { ModelConfigurationManager } = await import("./core/modelConfiguration.js");
+                    const modelConfig = ModelConfigurationManager.getInstance();
+                    const ollamaConfig = modelConfig.getProviderConfiguration("ollama");
+                    const toolCapableModels = ollamaConfig?.modelBehavior?.toolCapableModels || [];
+                    // Only disable tools if we have explicit evidence the model doesn't support them
+                    // If toolCapableModels is empty or model is not specified, don't make assumptions
+                    const modelName = options.model;
+                    if (toolCapableModels.length > 0 && modelName) {
+                        const modelSupportsTools = toolCapableModels.some((capableModel) => modelName.toLowerCase().includes(capableModel.toLowerCase()));
+                        if (!modelSupportsTools) {
+                            options.disableTools = true;
+                            logger.debug("Auto-disabled tools for Ollama model that doesn't support them (stream)", {
+                                model: options.model,
+                                toolCapableModels: toolCapableModels.slice(0, 3), // Show first 3 for brevity
+                            });
+                        }
+                    }
+                }
                 factoryResult = processStreamingFactoryOptions(options);
                 enhancedOptions = createCleanStreamOptions(options);
                 if (options.input?.text) {
@@ -2091,17 +2114,26 @@ Current user's request: ${currentInput}`;
             customTools: this.getCustomTools(),
             executeTool: this.executeTool.bind(this),
         }, "NeuroLink.createMCPStream");
+        // 🔧 FIX: Get available tools and create tool-aware system prompt
+        // Use SAME pattern as tryMCPGeneration (generate mode)
+        const availableTools = await this.getAllAvailableTools();
+        const enhancedSystemPrompt = this.createToolAwareSystemPrompt(options.systemPrompt, availableTools);
         // Get conversation messages for context
         const conversationMessages = await getConversationMessages(this.conversationMemory, {
             prompt: options.input.text,
             context: options.context,
         });
-        // Let provider handle tools and system prompt automatically via Vercel AI SDK
-        // This ensures proper tool integration in stream mode
+        // 🔧 FIX: Pass enhanced system prompt to real streaming
+        // Tools will be accessed through the streamText call in executeStream
         const streamResult = await provider.stream({
             ...options,
+            systemPrompt: enhancedSystemPrompt, // Use enhanced prompt with tool descriptions
             conversationMessages,
         });
+        logger.debug("[createMCPStream] Stream created successfully", {
+            provider: providerName,
+            systemPromptPassedLength: enhancedSystemPrompt.length,
+        });
         return { stream: streamResult.stream, provider: providerName };
     }
     /**

package/dist/providers/amazonBedrock.js

@@ -8,6 +8,7 @@ import { buildMultimodalMessagesArray } from "../utils/messageBuilder.js";
 import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { createAnalytics } from "../core/analytics.js";
+import path from "path";
 // Bedrock-specific types now imported from ../types/providerSpecific.js
 export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
@@ -95,13 +96,45 @@ export class AmazonBedrockProvider extends BaseProvider {
             : optionsOrPrompt;
         // Clear conversation history for new generation
         this.conversationHistory = [];
-        // Add user message to conversation
-        const userMessage = {
-            role: "user",
-            content: [{ text: options.prompt }],
-        };
-        this.conversationHistory.push(userMessage);
-        logger.debug(`[AmazonBedrockProvider] Starting conversation with prompt: ${options.prompt}`);
+        // Check for multimodal input (images, PDFs, CSVs, files)
+        // Cast to any to access multimodal properties (runtime check is safe)
+        const input = options.input;
+        const hasMultimodalInput = !!(input?.images?.length ||
+            input?.content?.length ||
+            input?.files?.length ||
+            input?.csvFiles?.length ||
+            input?.pdfFiles?.length);
+        if (hasMultimodalInput) {
+            logger.debug(`[AmazonBedrockProvider] Detected multimodal input in generate(), using multimodal message builder`, {
+                hasImages: !!input?.images?.length,
+                imageCount: input?.images?.length || 0,
+                hasContent: !!input?.content?.length,
+                contentCount: input?.content?.length || 0,
+                hasFiles: !!input?.files?.length,
+                fileCount: input?.files?.length || 0,
+                hasCSVFiles: !!input?.csvFiles?.length,
+                csvFileCount: input?.csvFiles?.length || 0,
+                hasPDFFiles: !!input?.pdfFiles?.length,
+                pdfFileCount: input?.pdfFiles?.length || 0,
+            });
+            // Cast options to StreamOptions for multimodal processing
+            const streamOptions = options;
+            const multimodalOptions = buildMultimodalOptions(streamOptions, this.providerName, this.modelName);
+            const multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+            // Convert to Bedrock format
+            this.conversationHistory =
+                this.convertToBedrockMessages(multimodalMessages);
+        }
+        else {
+            logger.debug(`[AmazonBedrockProvider] Text-only input in generate(), using simple message builder`);
+            // Add user message to conversation - simple text-only case
+            const userMessage = {
+                role: "user",
+                content: [{ text: options.prompt }],
+            };
+            this.conversationHistory.push(userMessage);
+        }
+        logger.debug(`[AmazonBedrockProvider] Starting conversation with ${this.conversationHistory.length} message(s)`);
         // Start conversation loop and return enhanced result
         const text = await this.conversationLoop(options);
         return {
@@ -585,12 +618,28 @@ export class AmazonBedrockProvider extends BaseProvider {
                         else {
                             docData = contentItem.data;
                         }
+                        // Extract basename and sanitize for Bedrock's filename requirements
+                        // Bedrock only allows: alphanumeric, whitespace, hyphens, parentheses, brackets
+                        // NOTE: Periods (.) are NOT allowed, so we remove the extension
+                        let filename = typeof contentItem.name === "string" && contentItem.name
+                            ? path.basename(contentItem.name)
+                            : "document-pdf";
+                        // Remove file extension
+                        filename = filename.replace(/\.[^.]+$/, "");
+                        // Replace all disallowed characters with hyphens
+                        // Bedrock constraint: only alphanumeric, whitespace, hyphens, parentheses, brackets allowed
+                        filename = filename.replace(/[^a-zA-Z0-9\s\-()[\]]/g, "-");
+                        // Clean up: remove multiple consecutive hyphens and trim
+                        filename = filename
+                            .replace(/-+/g, "-")
+                            .trim()
+                            .replace(/^-+|-+$/g, "");
+                        // Fallback if filename becomes empty after sanitization
+                        filename = filename || "document";
                         bedrockMessage.content.push({
                             document: {
                                 format: "pdf",
-                                name: typeof contentItem.name === "string" && contentItem.name
-                                    ? contentItem.name
-                                    : "document.pdf",
+                                name: filename,
                                 source: {
                                     bytes: docData,
                                 },

package/dist/providers/anthropic.js

@@ -7,8 +7,6 @@ import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createAnthropicConfig, getProviderModel, } from "../utils/providerConfig.js";
-import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
-import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Configuration helpers - now using consolidated utility
 const getAnthropicApiKey = () => {
@@ -94,34 +92,8 @@ export class AnthropicProvider extends BaseProvider {
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
             // Build message array from options with multimodal support
-            const hasMultimodalInput = !!(options.input?.images?.length ||
-                options.input?.content?.length ||
-                options.input?.files?.length ||
-                options.input?.csvFiles?.length ||
-                options.input?.pdfFiles?.length);
-            let messages;
-            if (hasMultimodalInput) {
-                logger.debug(`Anthropic: Detected multimodal input, using multimodal message builder`, {
-                    hasImages: !!options.input?.images?.length,
-                    imageCount: options.input?.images?.length || 0,
-                    hasContent: !!options.input?.content?.length,
-                    contentCount: options.input?.content?.length || 0,
-                    hasFiles: !!options.input?.files?.length,
-                    fileCount: options.input?.files?.length || 0,
-                    hasCSVFiles: !!options.input?.csvFiles?.length,
-                    csvFileCount: options.input?.csvFiles?.length || 0,
-                    hasPDFFiles: !!options.input?.pdfFiles?.length,
-                    pdfFileCount: options.input?.pdfFiles?.length || 0,
-                });
-                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
-                const mm = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
-                // Convert multimodal messages to Vercel AI SDK format (CoreMessage[])
-                messages = convertToCoreMessages(mm);
-            }
-            else {
-                logger.debug(`Anthropic: Text-only input, using standard message builder`);
-                messages = await buildMessagesArray(options);
-            }
+            // Using protected helper from BaseProvider to eliminate code duplication
+            const messages = await this.buildMessagesForStream(options);
             const model = await this.getAISDKModelWithMiddleware(options);
             const result = await streamText({
                 model: model,

package/dist/providers/azureOpenai.js

@@ -4,8 +4,6 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { AIProviderName, APIVersions } from "../constants/enums.js";
 import { validateApiKey, createAzureAPIKeyConfig, createAzureEndpointConfig, } from "../utils/providerConfig.js";
 import { logger } from "../utils/logger.js";
-import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
-import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 export class AzureOpenAIProvider extends BaseProvider {
@@ -111,28 +109,8 @@ export class AzureOpenAIProvider extends BaseProvider {
                 });
             }
             // Build message array from options with multimodal support
-            const hasMultimodalInput = !!(options.input?.images?.length ||
-                options.input?.content?.length ||
-                options.input?.files?.length ||
-                options.input?.csvFiles?.length ||
-                options.input?.pdfFiles?.length);
-            let messages;
-            if (hasMultimodalInput) {
-                logger.debug(`Azure OpenAI: Detected multimodal input, using multimodal message builder`, {
-                    hasImages: !!options.input?.images?.length,
-                    imageCount: options.input?.images?.length || 0,
-                    hasContent: !!options.input?.content?.length,
-                    contentCount: options.input?.content?.length || 0,
-                });
-                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
-                const mm = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
-                // Convert multimodal messages to Vercel AI SDK format (CoreMessage[])
-                messages = convertToCoreMessages(mm);
-            }
-            else {
-                logger.debug(`Azure OpenAI: Text-only input, using standard message builder`);
-                messages = await buildMessagesArray(options);
-            }
+            // Using protected helper from BaseProvider to eliminate code duplication
+            const messages = await this.buildMessagesForStream(options);
             const model = await this.getAISDKModelWithMiddleware(options);
             const stream = await streamText({
                 model,

package/dist/providers/googleAiStudio.js

@@ -7,8 +7,6 @@ import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } from "../types/errors.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
-import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
-import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 // Google AI Live API types now imported from ../types/providerSpecific.js
 // Import proper types for multimodal message handling
 // Create Google GenAI client
@@ -93,28 +91,8 @@ export class GoogleAIStudioProvider extends BaseProvider {
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
             // Build message array from options with multimodal support
-            const hasMultimodalInput = !!(options.input?.images?.length ||
-                options.input?.content?.length ||
-                options.input?.files?.length ||
-                options.input?.csvFiles?.length ||
-                options.input?.pdfFiles?.length);
-            let messages;
-            if (hasMultimodalInput) {
-                logger.debug(`Google AI Studio: Detected multimodal input, using multimodal message builder`, {
-                    hasImages: !!options.input?.images?.length,
-                    imageCount: options.input?.images?.length || 0,
-                    hasContent: !!options.input?.content?.length,
-                    contentCount: options.input?.content?.length || 0,
-                });
-                const multimodalOptions = buildMultimodalOptions(options, this.providerName, this.modelName);
-                const mm = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
-                // Convert multimodal messages to Vercel AI SDK format (CoreMessage[])
-                messages = convertToCoreMessages(mm);
-            }
-            else {
-                logger.debug(`Google AI Studio: Text-only input, using standard message builder`);
-                messages = await buildMessagesArray(options);
-            }
+            // Using protected helper from BaseProvider to eliminate code duplication
+            const messages = await this.buildMessagesForStream(options);
             const result = await streamText({
                 model,
                 messages: messages,