@juspay/neurolink 8.3.0 → 8.4.0

package/dist/providers/googleVertex.js

@@ -12,7 +12,6 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import dns from "dns";
-import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Import proper types for multimodal message handling
 // Enhanced Anthropic support with direct imports
@@ -605,50 +604,8 @@ export class GoogleVertexProvider extends BaseProvider {
             // Validate stream options
             this.validateStreamOptionsOnly(options);
             // 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(`${functionTag}: 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,
-                    hasPDFs: !!options.input?.pdfFiles?.length,
-                    pdfCount: 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,
-                        pdfFiles: options.input?.pdfFiles,
-                    },
-                    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 mm = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
-                // Convert multimodal messages to Vercel AI SDK format (CoreMessage[])
-                messages = convertToCoreMessages(mm);
-            }
-            else {
-                logger.debug(`${functionTag}: 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); // This is where network connection happens!
             // Get all available tools (direct + MCP + external) for streaming
             const shouldUseTools = !options.disableTools && this.supportsTools();

package/dist/providers/huggingFace.js

@@ -6,8 +6,6 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createHuggingFaceConfig, 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 getHuggingFaceApiKey = () => {
@@ -116,35 +114,9 @@ export class HuggingFaceProvider extends BaseProvider {
         try {
             // Enhanced tool handling for HuggingFace models
             const streamOptions = this.prepareStreamOptions(options, analysisSchema);
-            // 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);
-            let messages;
-            if (hasMultimodalInput) {
-                logger.debug(`HuggingFace: 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(`HuggingFace: Text-only input, using standard message builder`);
-                messages = await buildMessagesArray(options);
-            }
+            // Build message array from options with multimodal support
+            // Using protected helper from BaseProvider to eliminate code duplication
+            const messages = await this.buildMessagesForStream(options);
             const result = await streamText({
                 model: this.model,
                 messages: messages,

package/dist/providers/litellm.d.ts

@@ -28,7 +28,7 @@ export declare class LiteLLMProvider extends BaseProvider {
      * Provider-specific streaming implementation
      * Note: This is only used when tools are disabled
      */
-    protected executeStream(options: StreamOptions, _analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     /**
      * Get available models from LiteLLM proxy server
      * Dynamically fetches from /v1/models endpoint with caching and fallback

package/dist/providers/litellm.js

@@ -1,5 +1,5 @@
 import { createOpenAI } from "@ai-sdk/openai";
-import { streamText } from "ai";
+import { streamText, Output } from "ai";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
@@ -7,8 +7,6 @@ import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { buildMessagesArray, buildMultimodalMessagesArray, convertToCoreMessages, } from "../utils/messageBuilder.js";
-import { buildMultimodalOptions } from "../utils/multimodalOptionsBuilder.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
 // Configuration helpers
 const getLiteLLMConfig = () => {
@@ -117,52 +115,69 @@ export class LiteLLMProvider extends BaseProvider {
      * Provider-specific streaming implementation
      * Note: This is only used when tools are disabled
      */
-    async executeStream(options, _analysisSchema) {
+    async executeStream(options, analysisSchema) {
         this.validateStreamOptions(options);
         const startTime = Date.now();
+        let chunkCount = 0; // Track chunk count for debugging
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
-            // 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);
-            let messages;
-            if (hasMultimodalInput) {
-                logger.debug(`LiteLLM: 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,
+            // Build message array from options with multimodal support
+            // Using protected helper from BaseProvider to eliminate code duplication
+            const messages = await this.buildMessagesForStream(options);
+            const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
+            // Get all available tools (direct + MCP + external) for streaming - matching Vertex pattern
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools ? await this.getAllTools() : {};
+            logger.debug(`LiteLLM: Tools for streaming`, {
+                shouldUseTools,
+                toolCount: Object.keys(tools).length,
+                toolNames: Object.keys(tools),
+            });
+            // Model-specific maxTokens handling - Gemini 2.5 models have issues with maxTokens
+            const modelName = this.modelName || getDefaultLiteLLMModel();
+            const isGemini25Model = modelName.includes("gemini-2.5") || modelName.includes("gemini/2.5");
+            const maxTokens = isGemini25Model ? undefined : options.maxTokens;
+            if (isGemini25Model && options.maxTokens) {
+                logger.debug(`LiteLLM: Skipping maxTokens for Gemini 2.5 model (known compatibility issue)`, {
+                    modelName,
+                    requestedMaxTokens: options.maxTokens,
                 });
-                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(`LiteLLM: Text-only input, using standard message builder`);
-                messages = await buildMessagesArray(options);
-            }
-            const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
-            const result = streamText({
+            // Build complete stream options with proper typing - matching Vertex pattern
+            let streamOptions = {
                 model: model,
                 messages: messages,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
-                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                tools: options.tools,
-                toolChoice: "auto",
+                ...(maxTokens && { maxTokens }), // Conditionally include maxTokens
+                ...(shouldUseTools &&
+                    Object.keys(tools).length > 0 && {
+                    tools,
+                    toolChoice: "auto",
+                    maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                }),
                 abortSignal: timeoutController?.controller.signal,
+                onError: (event) => {
+                    const error = event.error;
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    logger.error(`LiteLLM: Stream error`, {
+                        provider: this.providerName,
+                        modelName: this.modelName,
+                        error: errorMessage,
+                        chunkCount,
+                    });
+                },
+                onFinish: (event) => {
+                    logger.debug(`LiteLLM: Stream finished`, {
+                        finishReason: event.finishReason,
+                        totalChunks: chunkCount,
+                    });
+                },
+                onChunk: () => {
+                    chunkCount++;
+                },
                 onStepFinish: ({ toolCalls, toolResults }) => {
+                    logger.info("Tool execution completed", { toolResults, toolCalls });
                     this.handleToolExecutionStorage(toolCalls, toolResults, options, new Date()).catch((error) => {
                         logger.warn("LiteLLMProvider] Failed to store tool executions", {
                             provider: this.providerName,
@@ -170,21 +185,72 @@ export class LiteLLMProvider extends BaseProvider {
                         });
                     });
                 },
-            });
+            };
+            // Add analysisSchema support if provided
+            if (analysisSchema) {
+                try {
+                    streamOptions = {
+                        ...streamOptions,
+                        experimental_output: Output.object({
+                            schema: analysisSchema,
+                        }),
+                    };
+                }
+                catch (error) {
+                    logger.warn("Schema application failed, continuing without schema", {
+                        error: String(error),
+                    });
+                }
+            }
+            const result = await streamText(streamOptions);
             timeoutController?.cleanup();
-            // Transform stream to match StreamResult interface
-            const transformedStream = async function* () {
-                for await (const chunk of result.textStream) {
-                    yield { content: chunk };
+            // Transform stream to content object stream using fullStream (handles both text and tool calls)
+            // Note: fullStream includes tool results, textStream only has text
+            const transformedStream = (async function* () {
+                // Try fullStream first (handles both text and tool calls), fallback to textStream
+                const streamToUse = result.fullStream || result.textStream;
+                for await (const chunk of streamToUse) {
+                    // Handle different chunk types from fullStream
+                    if (chunk && typeof chunk === "object") {
+                        // Check for error chunks first (critical error handling)
+                        if ("type" in chunk && chunk.type === "error") {
+                            const errorChunk = chunk;
+                            logger.error(`LiteLLM: Error chunk received:`, {
+                                errorType: errorChunk.type,
+                                errorDetails: errorChunk.error,
+                            });
+                            throw new Error(`LiteLLM streaming error: ${errorChunk.error?.message ||
+                                "Unknown error"}`);
+                        }
+                        if ("textDelta" in chunk) {
+                            // Text delta from fullStream
+                            const textDelta = chunk.textDelta;
+                            if (textDelta) {
+                                yield { content: textDelta };
+                            }
+                        }
+                        else if (chunk.type === "tool-call-streaming-start") {
+                            // Tool call streaming start event - log for debugging
+                            const toolCall = chunk;
+                            logger.debug("LiteLLM: Tool call streaming start", {
+                                toolCallId: toolCall.toolCallId,
+                                toolName: toolCall.toolName,
+                            });
+                        }
+                    }
+                    else if (typeof chunk === "string") {
+                        // Direct string chunk from textStream fallback
+                        yield { content: chunk };
+                    }
                 }
-            };
+            })();
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
                 requestId: `litellm-stream-${Date.now()}`,
                 streamingMode: true,
             });
             return {
-                stream: transformedStream(),
+                stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 analytics: analyticsPromise,

package/dist/providers/mistral.js

@@ -7,15 +7,14 @@ import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createMistralConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.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 getMistralApiKey = () => {
     return validateApiKey(createMistralConfig());
 };
 const getDefaultMistralModel = () => {
-    return getProviderModel("MISTRAL_MODEL", "mistral-large-latest");
+    // Default to vision-capable Mistral Small 2506 (June 2025) with multimodal support
+    return getProviderModel("MISTRAL_MODEL", "mistral-small-2506");
 };
 /**
  * Mistral AI Provider v2 - BaseProvider Implementation
@@ -51,35 +50,9 @@ export class MistralProvider extends BaseProvider {
             // Get tools consistently with generate method
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
-            // 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);
-            let messages;
-            if (hasMultimodalInput) {
-                logger.debug(`Mistral: 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(`Mistral: Text-only input, using standard message builder`);
-                messages = await buildMessagesArray(options);
-            }
+            // Build message array from options with multimodal support
+            // Using protected helper from BaseProvider to eliminate code duplication
+            const messages = await this.buildMessagesForStream(options);
             const model = await this.getAISDKModelWithMiddleware(options); // This is where network connection happens!
             const result = await streamText({
                 model,

package/dist/providers/ollama.d.ts

@@ -114,6 +114,7 @@ export declare class OllamaProvider extends BaseProvider {
      * Create stream generator for Ollama generate API (non-tool mode)
      */
     private createOllamaStream;
+    private createOpenAIStream;
     protected handleProviderError(error: unknown): Error;
     /**
      * Check if Ollama service is healthy and accessible