@juspay/neurolink 8.2.0 → 8.4.0

package/dist/lib/core/modules/Utilities.js

@@ -0,0 +1,330 @@
+/**
+ * Utilities Module
+ *
+ * Handles validation, normalization, schema conversion, and error handling utilities.
+ * Extracted from BaseProvider to follow Single Responsibility Principle.
+ *
+ * Responsibilities:
+ * - Options validation (text generation and stream options)
+ * - Options normalization (string to object conversion)
+ * - Provider information formatting
+ * - Timeout parsing and calculation
+ * - Schema utilities (Zod detection, permissive schema creation, OpenAI strict mode fixes)
+ * - Tool result conversion
+ * - Middleware options extraction
+ * - Common error pattern handling
+ *
+ * @module core/modules/Utilities
+ */
+import { z } from "zod";
+import { logger } from "../../utils/logger.js";
+import { getSafeMaxTokens } from "../../utils/tokenLimits.js";
+import { TimeoutError } from "../../utils/timeout.js";
+import { validateStreamOptions as validateStreamOpts, validateTextGenerationOptions, ValidationError, createValidationSummary, } from "../../utils/parameterValidation.js";
+import { STEP_LIMITS } from "../constants.js";
+/**
+ * Utilities class - Provides validation, normalization, and utility methods
+ */
+export class Utilities {
+    providerName;
+    modelName;
+    defaultTimeout;
+    middlewareOptions;
+    constructor(providerName, modelName, defaultTimeout = 30000, middlewareOptions) {
+        this.providerName = providerName;
+        this.modelName = modelName;
+        this.defaultTimeout = defaultTimeout;
+        this.middlewareOptions = middlewareOptions;
+    }
+    /**
+     * Validate text generation options
+     */
+    validateOptions(options) {
+        const validation = validateTextGenerationOptions(options);
+        if (!validation.isValid) {
+            const summary = createValidationSummary(validation);
+            throw new ValidationError(`Text generation options validation failed: ${summary}`, "options", "VALIDATION_FAILED", validation.suggestions);
+        }
+        // Log warnings if any
+        if (validation.warnings.length > 0) {
+            logger.warn("Text generation options validation warnings:", validation.warnings);
+        }
+        // Additional BaseProvider-specific validation
+        if (options.maxSteps !== undefined) {
+            if (options.maxSteps < STEP_LIMITS.min ||
+                options.maxSteps > STEP_LIMITS.max) {
+                throw new ValidationError(`maxSteps must be between ${STEP_LIMITS.min} and ${STEP_LIMITS.max}`, "maxSteps", "OUT_OF_RANGE", [
+                    `Use a value between ${STEP_LIMITS.min} and ${STEP_LIMITS.max} for optimal performance`,
+                ]);
+            }
+        }
+    }
+    /**
+     * Validate stream options
+     */
+    validateStreamOptions(options) {
+        const validation = validateStreamOpts(options);
+        if (!validation.isValid) {
+            const summary = createValidationSummary(validation);
+            throw new ValidationError(`Stream options validation failed: ${summary}`, "options", "VALIDATION_FAILED", validation.suggestions);
+        }
+        // Log warnings if any
+        if (validation.warnings.length > 0) {
+            logger.warn("Stream options validation warnings:", validation.warnings);
+        }
+        // Additional BaseProvider-specific validation
+        if (options.maxSteps !== undefined) {
+            if (options.maxSteps < STEP_LIMITS.min ||
+                options.maxSteps > STEP_LIMITS.max) {
+                throw new ValidationError(`maxSteps must be between ${STEP_LIMITS.min} and ${STEP_LIMITS.max}`, "maxSteps", "OUT_OF_RANGE", [
+                    `Use a value between ${STEP_LIMITS.min} and ${STEP_LIMITS.max} for optimal performance`,
+                ]);
+            }
+        }
+    }
+    /**
+     * Normalize text generation options from string or object
+     */
+    normalizeTextOptions(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === "string") {
+            const safeMaxTokens = getSafeMaxTokens(this.providerName, this.modelName);
+            return {
+                prompt: optionsOrPrompt,
+                provider: this.providerName,
+                model: this.modelName,
+                maxTokens: safeMaxTokens,
+            };
+        }
+        // Handle both prompt and input.text formats
+        const prompt = optionsOrPrompt.prompt || optionsOrPrompt.input?.text || "";
+        const modelName = optionsOrPrompt.model || this.modelName;
+        const providerName = optionsOrPrompt.provider || this.providerName;
+        // Apply safe maxTokens based on provider and model
+        const safeMaxTokens = getSafeMaxTokens(providerName, modelName, optionsOrPrompt.maxTokens);
+        // CRITICAL FIX: Preserve the entire input object for multimodal support
+        // This ensures images and content arrays are not lost during normalization
+        const normalizedOptions = {
+            ...optionsOrPrompt,
+            prompt,
+            provider: providerName,
+            model: modelName,
+            maxTokens: safeMaxTokens,
+        };
+        // Ensure input object is preserved if it exists (for multimodal support)
+        if (optionsOrPrompt.input) {
+            normalizedOptions.input = {
+                ...optionsOrPrompt.input,
+                text: prompt, // Ensure text is consistent
+            };
+        }
+        return normalizedOptions;
+    }
+    /**
+     * Normalize stream options from string or object
+     */
+    normalizeStreamOptions(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === "string") {
+            const safeMaxTokens = getSafeMaxTokens(this.providerName, this.modelName);
+            return {
+                input: { text: optionsOrPrompt },
+                provider: this.providerName,
+                model: this.modelName,
+                maxTokens: safeMaxTokens,
+            };
+        }
+        const modelName = optionsOrPrompt.model || this.modelName;
+        const providerName = optionsOrPrompt.provider || this.providerName;
+        // Apply safe maxTokens based on provider and model
+        const safeMaxTokens = getSafeMaxTokens(providerName, modelName, optionsOrPrompt.maxTokens);
+        return {
+            ...optionsOrPrompt,
+            provider: providerName,
+            model: modelName,
+            maxTokens: safeMaxTokens,
+        };
+    }
+    /**
+     * Get provider information
+     */
+    getProviderInfo() {
+        return {
+            provider: this.providerName,
+            model: this.modelName,
+        };
+    }
+    /**
+     * Get timeout value in milliseconds from options
+     * Supports number or string formats (e.g., '30s', '2m', '1h')
+     */
+    getTimeout(options) {
+        if (!options.timeout) {
+            return this.defaultTimeout;
+        }
+        if (typeof options.timeout === "number") {
+            return options.timeout;
+        }
+        // Parse string timeout (e.g., '30s', '2m', '1h')
+        const timeoutStr = options.timeout.toLowerCase();
+        const value = parseInt(timeoutStr);
+        if (timeoutStr.includes("h")) {
+            return value * 60 * 60 * 1000;
+        }
+        else if (timeoutStr.includes("m")) {
+            return value * 60 * 1000;
+        }
+        else if (timeoutStr.includes("s")) {
+            return value * 1000;
+        }
+        return this.defaultTimeout;
+    }
+    /**
+     * Check if a schema is a Zod schema
+     */
+    isZodSchema(schema) {
+        return (typeof schema === "object" &&
+            schema !== null &&
+            // Most Zod schemas have an internal _def and a parse method
+            typeof schema.parse === "function");
+    }
+    /**
+     * Convert tool execution result from MCP format to standard format
+     * Handles tool failures gracefully to prevent stream termination
+     */
+    async convertToolResult(result) {
+        // Handle MCP-style results
+        if (result && typeof result === "object" && "success" in result) {
+            const mcpResult = result;
+            if (mcpResult.success) {
+                return mcpResult.data;
+            }
+            else {
+                // Instead of throwing, return a structured error result
+                // This prevents tool failures from terminating streams
+                const errorMsg = typeof mcpResult.error === "string"
+                    ? mcpResult.error
+                    : "Tool execution failed";
+                // Log the error for debugging but don't throw
+                logger.warn(`Tool execution failed: ${errorMsg}`);
+                // Return error as structured data that can be processed by the AI
+                return {
+                    isError: true,
+                    error: errorMsg,
+                    content: [
+                        {
+                            type: "text",
+                            text: `Tool execution failed: ${errorMsg}`,
+                        },
+                    ],
+                };
+            }
+        }
+        return result;
+    }
+    /**
+     * Create a permissive Zod schema that accepts all parameters as-is
+     */
+    createPermissiveZodSchema() {
+        // Create a permissive record that accepts any object structure
+        // This allows all parameters to pass through without validation issues
+        return z.record(z.unknown()).transform((data) => {
+            // Return the data as-is to preserve all parameter information
+            return data;
+        });
+    }
+    /**
+     * Recursively fix JSON Schema for OpenAI strict mode compatibility
+     * OpenAI requires additionalProperties: false at ALL levels and preserves required array
+     */
+    fixSchemaForOpenAIStrictMode(schema) {
+        const fixedSchema = JSON.parse(JSON.stringify(schema));
+        if (fixedSchema.type === "object" &&
+            fixedSchema.properties &&
+            typeof fixedSchema.properties === "object") {
+            const allPropertyNames = Object.keys(fixedSchema.properties);
+            if (!fixedSchema.required || !Array.isArray(fixedSchema.required)) {
+                fixedSchema.required = [];
+            }
+            fixedSchema.additionalProperties = false;
+            for (const propName of allPropertyNames) {
+                const propValue = fixedSchema.properties[propName];
+                if (propValue && typeof propValue === "object") {
+                    if (propValue.type === "object") {
+                        fixedSchema.properties[propName] =
+                            this.fixSchemaForOpenAIStrictMode(propValue);
+                    }
+                    else if (propValue.type === "array" &&
+                        propValue.items &&
+                        typeof propValue.items === "object") {
+                        fixedSchema.properties[propName].items =
+                            this.fixSchemaForOpenAIStrictMode(propValue.items);
+                    }
+                }
+            }
+        }
+        return fixedSchema;
+    }
+    /**
+     * Extract middleware options from generation/stream options
+     * This is the single source of truth for deciding if middleware should be applied
+     */
+    extractMiddlewareOptions(options) {
+        // 1. Determine effective middleware config: per-request overrides global.
+        const middlewareOpts = options.middleware ??
+            this.middlewareOptions;
+        if (!middlewareOpts) {
+            return null;
+        }
+        // 2. The middleware property must be an object with configuration.
+        if (typeof middlewareOpts !== "object" ||
+            middlewareOpts === null ||
+            middlewareOpts instanceof Date ||
+            middlewareOpts instanceof RegExp) {
+            return null;
+        }
+        // 3. Check if the middleware object has any actual configuration keys.
+        const fullOpts = middlewareOpts;
+        const hasArray = (arr) => Array.isArray(arr) && arr.length > 0;
+        const hasConfig = !!fullOpts.middlewareConfig ||
+            hasArray(fullOpts.enabledMiddleware) ||
+            hasArray(fullOpts.disabledMiddleware) ||
+            !!fullOpts.preset ||
+            hasArray(fullOpts.middleware);
+        if (!hasConfig) {
+            return null;
+        }
+        // 4. Return the formatted options if configuration is present.
+        return {
+            ...fullOpts,
+            global: {
+                collectStats: true,
+                continueOnError: true,
+                ...(fullOpts.global || {}),
+            },
+        };
+    }
+    /**
+     * Handle common error patterns across providers
+     * Returns transformed error or null if not a common pattern
+     */
+    handleCommonErrors(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`${this.providerName} request timed out after ${error.timeout}ms. Consider increasing timeout or using a lighter model.`);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        // Common API key errors
+        if (message.includes("API_KEY_INVALID") ||
+            message.includes("Invalid API key") ||
+            message.includes("authentication") ||
+            message.includes("unauthorized")) {
+            return new Error(`Invalid API key for ${this.providerName}. Please check your API key environment variable.`);
+        }
+        // Common rate limit errors
+        if (message.includes("rate limit") ||
+            message.includes("quota") ||
+            message.includes("429")) {
+            return new Error(`Rate limit exceeded for ${this.providerName}. Please wait before making more requests.`);
+        }
+        return null; // Not a common error, let provider handle it
+    }
+}
+//# sourceMappingURL=Utilities.js.map

package/dist/lib/factories/providerRegistry.js

@@ -24,7 +24,7 @@ export class ProviderRegistry {
             ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, _providerName, sdk) => {
                 const { GoogleAIStudioProvider } = await import("../providers/googleAiStudio.js");
                 return new GoogleAIStudioProvider(modelName, sdk);
-            }, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai"]);
+            }, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai", "google-ai-studio"]);
             // Register OpenAI provider
             ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk) => {
                 const { OpenAIProvider } = await import("../providers/openAI.js");

package/dist/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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,