@juspay/neurolink 7.50.0 → 7.51.1

package/dist/lib/utils/schemaConversion.js

@@ -138,3 +138,4 @@ export function convertJsonSchemaToZod(jsonSchema) {
         return z.object({}).passthrough();
     }
 }
+//# sourceMappingURL=schemaConversion.js.map

package/dist/lib/utils/taskClassificationUtils.js

@@ -147,3 +147,4 @@ export function analyzePrompt(prompt) {
     reasoningScore += domainScores.reasoningScore;
     return { fastScore, reasoningScore, reasons };
 }
+//# sourceMappingURL=taskClassificationUtils.js.map

package/dist/lib/utils/taskClassifier.js

@@ -92,3 +92,4 @@ export class BinaryTaskClassifier {
         return { correct, classification };
     }
 }
+//# sourceMappingURL=taskClassifier.js.map

package/dist/lib/utils/timeout.js

@@ -342,3 +342,4 @@ export function mergeAbortSignals(signals) {
     }
     return controller;
 }
+//# sourceMappingURL=timeout.js.map

package/dist/lib/utils/tokenLimits.js

@@ -123,3 +123,4 @@ export function getAllProviderLimits() {
     }
     return result;
 }
+//# sourceMappingURL=tokenLimits.js.map

package/dist/lib/utils/toolUtils.js

@@ -58,3 +58,4 @@ export function getMaxToolsPerProvider(toolConfig) {
     }
     return 100; // Default
 }
+//# sourceMappingURL=toolUtils.js.map

package/dist/lib/utils/transformationUtils.js

@@ -563,3 +563,4 @@ export function optimizeToolForCollection(tool, defaults) {
     }
     return optimizedTool;
 }
+//# sourceMappingURL=transformationUtils.js.map

package/dist/lib/utils/typeUtils.js

@@ -95,3 +95,4 @@ export function isNullish(value) {
 export function isDefined(value) {
     return value !== undefined;
 }
+//# sourceMappingURL=typeUtils.js.map

package/dist/mcp/mcpClientFactory.js

@@ -7,7 +7,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";
-import { spawn } from "child_process";
+import { spawn, ChildProcess } from "child_process";
 import { mcpLogger } from "../utils/logger.js";
 import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
 /**

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

@@ -2,6 +2,7 @@
  * NeuroLink Direct Tools Server
  * Wraps the agent direct tools as an MCP server for proper registration
  */
+import { z } from "zod";
 import { createMCPServer } from "../../factory.js";
 import { directAgentTools } from "../../../agent/directTools.js";
 import { logger } from "../../../utils/logger.js";

package/dist/models/modelResolver.js

@@ -3,6 +3,7 @@
  * Provides model resolution, search, and recommendation functionality
  * Part of Phase 4.1 - Models Command System
  */
+import { AIProviderName } from "../types/index.js";
 import { MODEL_REGISTRY, MODEL_ALIASES, USE_CASE_RECOMMENDATIONS, getAllModels, getModelById, getModelsByProvider, getAvailableProviders, calculateCost, formatModelForDisplay, } from "./modelRegistry.js";
 import { isNonNullObject } from "../utils/typeUtils.js";
 /**

package/dist/neurolink.d.ts

@@ -1076,6 +1076,12 @@ export declare class NeuroLink {
      * Unregister all external MCP tools from the main registry
      */
     private unregisterAllExternalMCPToolsFromRegistry;
+    /**
+     * Dispose of all resources and cleanup connections
+     * Call this method when done using the NeuroLink instance to prevent resource leaks
+     * Especially important in test environments where multiple instances are created
+     */
+    dispose(): Promise<void>;
 }
 export declare const neurolink: NeuroLink;
 export default neurolink;

package/dist/neurolink.js

@@ -31,6 +31,8 @@ import { transformToolExecutions, transformToolExecutionsForMCP, transformAvaila
 // Enhanced error handling imports
 import { ErrorFactory, NeuroLinkError, withTimeout, withRetry, isRetriableError, logStructuredError, CircuitBreaker, } from "./utils/errorHandling.js";
 import { EventEmitter } from "events";
+import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
+import { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { getConversationMessages, storeConversationTurn, } from "./utils/conversationMemory.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 import { HITLManager } from "./hitl/hitlManager.js";
@@ -2051,15 +2053,16 @@ export class NeuroLink {
             customTools: this.getCustomTools(),
             executeTool: this.executeTool.bind(this),
         }, "NeuroLink.createMCPStream");
-        // Get conversation messages for context by creating a minimal TextGenerationOptions object
+        // Get conversation messages for context
         const conversationMessages = await getConversationMessages(this.conversationMemory, {
             prompt: options.input.text,
             context: options.context,
         });
-        // Pass conversation history to stream just like in generate method
+        // Let provider handle tools and system prompt automatically via Vercel AI SDK
+        // This ensures proper tool integration in stream mode
         const streamResult = await provider.stream({
             ...options,
-            conversationMessages, // Inject conversation history
+            conversationMessages,
         });
         return { stream: streamResult.stream, provider: providerName };
     }
@@ -2120,7 +2123,7 @@ export class NeuroLink {
         const originalPrompt = options.input.text;
         const responseTime = Date.now() - startTime;
         const providerName = await getBestProvider(options.provider);
-        const provider = await AIProviderFactory.createProvider(providerName, options.model, false);
+        const provider = await AIProviderFactory.createProvider(providerName, options.model);
         const fallbackStreamResult = await provider.stream({
             input: { text: options.input.text },
             model: options.model,
@@ -3330,7 +3333,7 @@ export class NeuroLink {
      */
     async testProviderConnection(providerName) {
         const { AIProviderFactory } = await import("./core/factory.js");
-        const provider = await AIProviderFactory.createProvider(providerName, null, false);
+        const provider = await AIProviderFactory.createProvider(providerName, null);
         await provider.generate({
             prompt: "test",
             maxTokens: 1,
@@ -4132,6 +4135,132 @@ export class NeuroLink {
             mcpLogger.error("[NeuroLink] Failed to unregister all external MCP tools from registry:", error);
         }
     }
+    /**
+     * Dispose of all resources and cleanup connections
+     * Call this method when done using the NeuroLink instance to prevent resource leaks
+     * Especially important in test environments where multiple instances are created
+     */
+    async dispose() {
+        logger.debug("[NeuroLink] Starting disposal of resources...");
+        const cleanupErrors = [];
+        try {
+            // 1. Flush and shutdown OpenTelemetry
+            try {
+                logger.debug("[NeuroLink] Flushing and shutting down OpenTelemetry...");
+                await flushOpenTelemetry();
+                await shutdownOpenTelemetry();
+                logger.debug("[NeuroLink] OpenTelemetry shutdown successfully");
+            }
+            catch (error) {
+                const err = error instanceof Error
+                    ? error
+                    : new Error(`OpenTelemetry shutdown error: ${String(error)}`);
+                cleanupErrors.push(err);
+                logger.warn("[NeuroLink] Error shutting down OpenTelemetry:", error);
+            }
+            // 2. Shutdown external MCP server connections
+            if (this.externalServerManager) {
+                try {
+                    logger.debug("[NeuroLink] Shutting down external MCP servers...");
+                    await this.externalServerManager.shutdown();
+                    logger.debug("[NeuroLink] External MCP servers shutdown successfully");
+                }
+                catch (error) {
+                    const err = error instanceof Error
+                        ? error
+                        : new Error(`External server shutdown error: ${String(error)}`);
+                    cleanupErrors.push(err);
+                    logger.warn("[NeuroLink] Error shutting down external MCP servers:", error);
+                }
+            }
+            // 3. Clear all event listeners to prevent memory leaks
+            if (this.emitter) {
+                try {
+                    logger.debug("[NeuroLink] Removing all event listeners...");
+                    this.emitter.removeAllListeners();
+                    logger.debug("[NeuroLink] Event listeners removed successfully");
+                }
+                catch (error) {
+                    const err = error instanceof Error
+                        ? error
+                        : new Error(`Event emitter cleanup error: ${String(error)}`);
+                    cleanupErrors.push(err);
+                    logger.warn("[NeuroLink] Error removing event listeners:", error);
+                }
+            }
+            // 4. Clear all circuit breakers
+            if (this.toolCircuitBreakers && this.toolCircuitBreakers.size > 0) {
+                try {
+                    logger.debug(`[NeuroLink] Clearing ${this.toolCircuitBreakers.size} circuit breakers...`);
+                    this.toolCircuitBreakers.clear();
+                    logger.debug("[NeuroLink] Circuit breakers cleared successfully");
+                }
+                catch (error) {
+                    const err = error instanceof Error
+                        ? error
+                        : new Error(`Circuit breaker cleanup error: ${String(error)}`);
+                    cleanupErrors.push(err);
+                    logger.warn("[NeuroLink] Error clearing circuit breakers:", error);
+                }
+            }
+            // 5. Clear all Maps and caches
+            try {
+                logger.debug("[NeuroLink] Clearing maps and caches...");
+                if (this.toolExecutionMetrics) {
+                    this.toolExecutionMetrics.clear();
+                }
+                if (this.activeToolExecutions) {
+                    this.activeToolExecutions.clear();
+                }
+                if (this.currentStreamToolExecutions) {
+                    this.currentStreamToolExecutions.length = 0;
+                }
+                if (this.toolExecutionHistory) {
+                    this.toolExecutionHistory.length = 0;
+                }
+                // Clear tool cache
+                if (this.toolCache) {
+                    this.toolCache.tools = [];
+                    this.toolCache.timestamp = 0;
+                }
+                logger.debug("[NeuroLink] Maps and caches cleared successfully");
+            }
+            catch (error) {
+                const err = error instanceof Error
+                    ? error
+                    : new Error(`Cache cleanup error: ${String(error)}`);
+                cleanupErrors.push(err);
+                logger.warn("[NeuroLink] Error clearing caches:", error);
+            }
+            // 6. Reset initialization flags
+            try {
+                logger.debug("[NeuroLink] Resetting initialization state...");
+                this.mcpInitialized = false;
+                this.conversationMemoryNeedsInit = false;
+                logger.debug("[NeuroLink] Initialization state reset successfully");
+            }
+            catch (error) {
+                const err = error instanceof Error
+                    ? error
+                    : new Error(`State reset error: ${String(error)}`);
+                cleanupErrors.push(err);
+                logger.warn("[NeuroLink] Error resetting state:", error);
+            }
+            // 6. Log completion
+            if (cleanupErrors.length === 0) {
+                logger.debug("[NeuroLink] ✅ Resource disposal completed successfully");
+            }
+            else {
+                logger.warn(`[NeuroLink] ⚠️ Resource disposal completed with ${cleanupErrors.length} errors`, {
+                    errors: cleanupErrors.map((e) => e.message),
+                });
+            }
+        }
+        catch (error) {
+            logger.error("[NeuroLink] Critical error during disposal:", error);
+            throw error;
+        }
+    }
 }
 // Create default instance
 export const neurolink = new NeuroLink();

package/dist/providers/amazonBedrock.d.ts

@@ -24,6 +24,7 @@ export declare class AmazonBedrockProvider extends BaseProvider {
     private executeSingleTool;
     private convertAISDKToolsToToolDefinitions;
     private formatToolsForBedrock;
+    private convertToBedrockMessages;
     getBedrockClient(): BedrockRuntimeClient;
     protected executeStream(options: StreamOptions): Promise<StreamResult>;
     private streamingConversationLoop;

package/dist/providers/amazonBedrock.js

@@ -1,8 +1,12 @@
-import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand, } from "@aws-sdk/client-bedrock-runtime";
+import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand, ImageFormat, } from "@aws-sdk/client-bedrock-runtime";
 import { BedrockClient, ListFoundationModelsCommand, } from "@aws-sdk/client-bedrock";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { convertZodToJsonSchema } from "../utils/schemaConversion.js";
+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";
 // Bedrock-specific types now imported from ../types/providerSpecific.js
 export class AmazonBedrockProvider extends BaseProvider {
     bedrockClient;
@@ -349,6 +353,16 @@ export class AmazonBedrockProvider extends BaseProvider {
                         text: item.text,
                     };
                 }
+                if (item.image) {
+                    return {
+                        image: item.image,
+                    };
+                }
+                if (item.document) {
+                    return {
+                        document: item.document,
+                    };
+                }
                 if (item.toolUse) {
                     return {
                         toolUse: {
@@ -520,6 +534,73 @@ export class AmazonBedrockProvider extends BaseProvider {
         logger.debug(`[AmazonBedrockProvider] Formatted ${bedrockTools.length} tools for Bedrock`);
         return { tools: bedrockTools };
     }
+    // Convert multimodal messages to Bedrock format
+    convertToBedrockMessages(messages) {
+        return messages.map((msg) => {
+            const bedrockMessage = {
+                role: msg.role === "system" ? "user" : msg.role,
+                content: [],
+            };
+            if (typeof msg.content === "string") {
+                bedrockMessage.content.push({ text: msg.content });
+            }
+            else {
+                msg.content.forEach((contentItem) => {
+                    if (contentItem.type === "text" && contentItem.text) {
+                        bedrockMessage.content.push({ text: contentItem.text });
+                    }
+                    else if (contentItem.type === "image" && contentItem.image) {
+                        const imageData = typeof contentItem.image === "string"
+                            ? Buffer.from(contentItem.image.replace(/^data:image\/\w+;base64,/, ""), "base64")
+                            : contentItem.image;
+                        let format = contentItem.mimeType?.split("/")[1] || "png";
+                        if (format === "jpg") {
+                            format = "jpeg";
+                        }
+                        bedrockMessage.content.push({
+                            image: {
+                                format: format === "jpeg"
+                                    ? ImageFormat.JPEG
+                                    : format === "png"
+                                        ? ImageFormat.PNG
+                                        : format === "gif"
+                                            ? ImageFormat.GIF
+                                            : ImageFormat.WEBP,
+                                source: {
+                                    bytes: imageData,
+                                },
+                            },
+                        });
+                    }
+                    else if (contentItem.type === "document" ||
+                        contentItem.type === "pdf" ||
+                        (contentItem.type === "file" &&
+                            contentItem.mimeType?.toLowerCase().startsWith("application/pdf"))) {
+                        let docData;
+                        if (typeof contentItem.data === "string") {
+                            const pdfString = contentItem.data.replace(/^data:application\/pdf;base64,/i, "");
+                            docData = Buffer.from(pdfString, "base64");
+                        }
+                        else {
+                            docData = contentItem.data;
+                        }
+                        bedrockMessage.content.push({
+                            document: {
+                                format: "pdf",
+                                name: typeof contentItem.name === "string" && contentItem.name
+                                    ? contentItem.name
+                                    : "document.pdf",
+                                source: {
+                                    bytes: docData,
+                                },
+                            },
+                        });
+                    }
+                });
+            }
+            return bedrockMessage;
+        });
+    }
     // Bedrock-MCP-Connector compatibility
     getBedrockClient() {
         return this.bedrockClient;
@@ -529,16 +610,43 @@ export class AmazonBedrockProvider extends BaseProvider {
         logger.info("🚀 [AmazonBedrockProvider] Attempting real streaming with ConverseStreamCommand");
         try {
             logger.debug("🟢 [TRACE] executeStream TRY block - about to call streamingConversationLoop");
-            // CRITICAL FIX: Initialize conversation history like generate() does
             // Clear conversation history for new streaming session
             this.conversationHistory = [];
-            // Add user message to conversation - exactly like generate() does
-            const userMessage = {
-                role: "user",
-                content: [{ text: options.input.text }],
-            };
-            this.conversationHistory.push(userMessage);
-            logger.debug(`[AmazonBedrockProvider] Starting streaming conversation with prompt: ${options.input.text}`);
+            // Check for multimodal input (images, PDFs, CSVs, files)
+            const hasMultimodalInput = !!(options.input?.images?.length ||
+                options.input?.content?.length ||
+                options.input?.files?.length ||
+                options.input?.csvFiles?.length ||
+                options.input?.pdfFiles?.length);
+            if (hasMultimodalInput) {
+                logger.debug(`[AmazonBedrockProvider] 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 multimodalMessages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+                // Convert to Bedrock format
+                this.conversationHistory =
+                    this.convertToBedrockMessages(multimodalMessages);
+            }
+            else {
+                logger.debug(`[AmazonBedrockProvider] Text-only input, using simple message builder`);
+                // Add user message to conversation - simple text-only case
+                const userMessage = {
+                    role: "user",
+                    content: [{ text: options.input.text }],
+                };
+                this.conversationHistory.push(userMessage);
+            }
+            logger.debug(`[AmazonBedrockProvider] Starting streaming conversation with ${this.conversationHistory.length} message(s)`);
             // Call the actual streaming implementation that already exists
             logger.debug("🟢 [TRACE] executeStream - calling streamingConversationLoop NOW");
             const result = await this.streamingConversationLoop(options);
@@ -615,7 +723,8 @@ export class AmazonBedrockProvider extends BaseProvider {
     }
     async streamingConversationLoop(options) {
         logger.debug("🟦 [TRACE] streamingConversationLoop ENTRY");
-        const maxIterations = 10;
+        const startTime = Date.now();
+        const maxIterations = options.maxSteps || DEFAULT_MAX_STEPS;
         let iteration = 0;
         // The REAL issue: ReadableStream errors don't bubble up to the caller
         // So we need to make the first streaming call synchronously to test permissions
@@ -650,7 +759,7 @@ export class AmazonBedrockProvider extends BaseProvider {
                             logger.debug(`[AmazonBedrockProvider] Streaming iteration ${iteration}`);
                             const commandInput = await this.prepareStreamCommand(options);
                             const { stopReason, assistantMessage } = await this.processStreamResponse(commandInput, controller);
-                            const shouldContinue = await this.handleStreamStopReason(stopReason, assistantMessage, controller);
+                            const shouldContinue = await this.handleStreamStopReason(stopReason, assistantMessage, controller, options);
                             if (!shouldContinue) {
                                 break;
                             }
@@ -665,11 +774,22 @@ export class AmazonBedrockProvider extends BaseProvider {
                     }
                 },
             });
+            // Create analytics promise (without token tracking for now due to AWS SDK limitations)
+            const analyticsPromise = Promise.resolve(createAnalytics(this.providerName, this.modelName || this.getDefaultModel(), { usage: { input: 0, output: 0, total: 0 } }, Date.now() - startTime, {
+                requestId: `bedrock-stream-${Date.now()}`,
+                streamingMode: true,
+                note: "Token usage not available from AWS SDK streaming responses",
+            }));
             return {
                 stream: this.convertToAsyncIterable(stream),
                 usage: { total: 0, input: 0, output: 0 },
                 model: this.modelName || this.getDefaultModel(),
                 provider: this.getProviderName(),
+                analytics: analyticsPromise,
+                metadata: {
+                    startTime,
+                    streamId: `bedrock-${Date.now()}`,
+                },
             };
         }
         catch (error) {
@@ -825,7 +945,7 @@ export class AmazonBedrockProvider extends BaseProvider {
         this.conversationHistory.push(assistantMessage);
         return { stopReason, assistantMessage };
     }
-    async handleStreamStopReason(stopReason, assistantMessage, controller) {
+    async handleStreamStopReason(stopReason, assistantMessage, controller, options) {
         if (stopReason === "end_turn" || stopReason === "stop_sequence") {
             // Conversation completed
             controller.close();
@@ -833,7 +953,7 @@ export class AmazonBedrockProvider extends BaseProvider {
         }
         else if (stopReason === "tool_use") {
             logger.debug(`🛠️ [AmazonBedrockProvider] Tool use detected in streaming - executing tools`);
-            await this.executeStreamTools(assistantMessage.content);
+            await this.executeStreamTools(assistantMessage.content, options);
             return true; // Continue conversation loop
         }
         else if (stopReason === "max_tokens") {
@@ -851,10 +971,13 @@ export class AmazonBedrockProvider extends BaseProvider {
             return false;
         }
     }
-    async executeStreamTools(messageContent) {
+    async executeStreamTools(messageContent, options) {
         // Execute all tool uses in the message - ensure 1:1 mapping like Bedrock-MCP-Connector
         const toolResults = [];
         let toolUseCount = 0;
+        // Track tool calls and results for storage (similar to Vertex onStepFinish)
+        const toolCalls = [];
+        const toolResultsForStorage = [];
         // Count toolUse blocks first to ensure 1:1 mapping
         for (const contentItem of messageContent) {
             if (contentItem.toolUse) {
@@ -865,9 +988,23 @@ export class AmazonBedrockProvider extends BaseProvider {
         for (const contentItem of messageContent) {
             if (contentItem.toolUse) {
                 logger.debug(`🔧 [AmazonBedrockProvider] Executing tool: ${contentItem.toolUse.name}`);
+                // Track tool call
+                toolCalls.push({
+                    type: "tool-call",
+                    toolCallId: contentItem.toolUse.toolUseId,
+                    toolName: contentItem.toolUse.name,
+                    args: contentItem.toolUse.input || {},
+                });
                 try {
                     const toolResult = await this.executeSingleTool(contentItem.toolUse.name, contentItem.toolUse.input || {}, contentItem.toolUse.toolUseId);
                     logger.debug(`✅ [AmazonBedrockProvider] Tool execution successful: ${contentItem.toolUse.name}`);
+                    // Track tool result for storage
+                    toolResultsForStorage.push({
+                        type: "tool-result",
+                        toolCallId: contentItem.toolUse.toolUseId,
+                        toolName: contentItem.toolUse.name,
+                        result: toolResult,
+                    });
                     // Ensure exact structure matching Bedrock-MCP-Connector
                     toolResults.push({
                         toolResult: {
@@ -880,6 +1017,13 @@ export class AmazonBedrockProvider extends BaseProvider {
                 catch (error) {
                     logger.error(`❌ [AmazonBedrockProvider] Tool execution failed: ${contentItem.toolUse.name}`, error);
                     const errorMessage = error instanceof Error ? error.message : String(error);
+                    // Track failed tool result
+                    toolResultsForStorage.push({
+                        type: "tool-result",
+                        toolCallId: contentItem.toolUse.toolUseId,
+                        toolName: contentItem.toolUse.name,
+                        result: { error: errorMessage },
+                    });
                     toolResults.push({
                         toolResult: {
                             toolUseId: contentItem.toolUse.toolUseId,
@@ -908,6 +1052,13 @@ export class AmazonBedrockProvider extends BaseProvider {
             };
             this.conversationHistory.push(userMessageWithToolResults);
             logger.debug(`📤 [AmazonBedrockProvider] Added ${toolResults.length} tool results to conversation (1:1 mapping validated)`);
+            // Store tool execution for analytics and debugging (similar to Vertex onStepFinish)
+            this.handleToolExecutionStorage(toolCalls, toolResultsForStorage, options, new Date()).catch((error) => {
+                logger.warn("[AmazonBedrockProvider] Failed to store tool executions", {
+                    provider: this.providerName,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            });
         }
     }
     /**

package/dist/providers/anthropic.js

@@ -8,6 +8,7 @@ import { AuthenticationError, NetworkError, ProviderError, RateLimitError, } fro
 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 = () => {
@@ -96,7 +97,8 @@ export class AnthropicProvider extends BaseProvider {
             const hasMultimodalInput = !!(options.input?.images?.length ||
                 options.input?.content?.length ||
                 options.input?.files?.length ||
-                options.input?.csvFiles?.length);
+                options.input?.csvFiles?.length ||
+                options.input?.pdfFiles?.length);
             let messages;
             if (hasMultimodalInput) {
                 logger.debug(`Anthropic: Detected multimodal input, using multimodal message builder`, {
@@ -108,27 +110,10 @@ export class AnthropicProvider extends BaseProvider {
                     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,
                 });
-                // Create multimodal options for buildMultimodalMessagesArray
-                const multimodalOptions = {
-                    input: {
-                        text: options.input?.text || "",
-                        images: options.input?.images,
-                        content: options.input?.content,
-                        files: options.input?.files,
-                        csvFiles: options.input?.csvFiles,
-                    },
-                    csvOptions: options.csvOptions,
-                    systemPrompt: options.systemPrompt,
-                    conversationHistory: options.conversationMessages,
-                    provider: this.providerName,
-                    model: this.modelName,
-                    temperature: options.temperature,
-                    maxTokens: options.maxTokens,
-                    enableAnalytics: options.enableAnalytics,
-                    enableEvaluation: options.enableEvaluation,
-                    context: options.context,
-                };
+                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);

package/dist/providers/azureOpenai.js

@@ -5,6 +5,7 @@ import { APIVersions } from "../types/providers.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 {
@@ -113,7 +114,8 @@ export class AzureOpenAIProvider extends BaseProvider {
             const hasMultimodalInput = !!(options.input?.images?.length ||
                 options.input?.content?.length ||
                 options.input?.files?.length ||
-                options.input?.csvFiles?.length);
+                options.input?.csvFiles?.length ||
+                options.input?.pdfFiles?.length);
             let messages;
             if (hasMultimodalInput) {
                 logger.debug(`Azure OpenAI: Detected multimodal input, using multimodal message builder`, {
@@ -122,26 +124,7 @@ export class AzureOpenAIProvider extends BaseProvider {
                     hasContent: !!options.input?.content?.length,
                     contentCount: options.input?.content?.length || 0,
                 });
-                // Create multimodal options for buildMultimodalMessagesArray
-                const multimodalOptions = {
-                    input: {
-                        text: options.input?.text || "",
-                        images: options.input?.images,
-                        content: options.input?.content,
-                        files: options.input?.files,
-                        csvFiles: options.input?.csvFiles,
-                    },
-                    csvOptions: options.csvOptions,
-                    systemPrompt: options.systemPrompt,
-                    conversationHistory: options.conversationMessages,
-                    provider: this.providerName,
-                    model: this.modelName,
-                    temperature: options.temperature,
-                    maxTokens: options.maxTokens,
-                    enableAnalytics: options.enableAnalytics,
-                    enableEvaluation: options.enableEvaluation,
-                    context: options.context,
-                };
+                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);