@juspay/neurolink 7.10.2 → 7.11.0

package/dist/mcp/toolRegistry.js

@@ -5,6 +5,7 @@
 import { MCPRegistry } from "./registry.js";
 import { registryLogger } from "../utils/logger.js";
 import { randomUUID } from "crypto";
+import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { directAgentTools } from "../agent/directTools.js";
 export class MCPToolRegistry extends MCPRegistry {
     tools = new Map();
@@ -12,8 +13,13 @@ export class MCPToolRegistry extends MCPRegistry {
     toolExecutionStats = new Map();
     constructor() {
         super();
-        // Auto-register direct tools on initialization
-        this.registerDirectTools();
+        // 🔧 CONDITIONAL: Only auto-register direct tools if not disabled via configuration
+        if (!shouldDisableBuiltinTools()) {
+            this.registerDirectTools();
+        }
+        else {
+            registryLogger.debug("Built-in direct tools disabled via configuration");
+        }
     }
     /**
      * Register all direct tools from directAgentTools

package/dist/neurolink.js

@@ -337,6 +337,11 @@ export class NeuroLink {
             // Create provider and generate
             const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
             this);
+            // Enable tool execution for the provider using BaseProvider method
+            provider.setupToolExecutor({
+                customTools: this.customTools,
+                executeTool: this.executeTool.bind(this),
+            }, functionTag);
             const result = await provider.generate({
                 ...options,
                 systemPrompt: enhancedSystemPrompt,
@@ -410,6 +415,11 @@ export class NeuroLink {
                 logger.debug(`[${functionTag}] Attempting provider: ${providerName}`);
                 const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
                 this);
+                // Enable tool execution for direct provider generation using BaseProvider method
+                provider.setupToolExecutor({
+                    customTools: this.customTools,
+                    executeTool: this.executeTool.bind(this),
+                }, functionTag);
                 const result = await provider.generate(options);
                 const responseTime = Date.now() - startTime;
                 if (!result) {
@@ -599,6 +609,11 @@ export class NeuroLink {
             });
             // Create provider using the same factory pattern as generate
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, true, this);
+            // Enable tool execution for streaming using BaseProvider method
+            provider.setupToolExecutor({
+                customTools: this.customTools,
+                executeTool: this.executeTool.bind(this),
+            }, functionTag);
             // Create clean options for provider (remove factoryConfig)
             const cleanOptions = createCleanStreamOptions(enhancedOptions);
             // Call the provider's stream method with clean options
@@ -650,6 +665,11 @@ export class NeuroLink {
             // Use factory to create provider without MCP
             const provider = await AIProviderFactory.createBestProvider(providerName, options.model, false, // Disable MCP for fallback
             this);
+            // Enable tool execution for fallback streaming using BaseProvider method
+            provider.setupToolExecutor({
+                customTools: this.customTools,
+                executeTool: this.executeTool.bind(this),
+            }, functionTag);
             // Create clean options for fallback provider (remove factoryConfig)
             const cleanOptions = createCleanStreamOptions(enhancedOptions);
             const streamResult = await provider.stream(cleanOptions);

package/dist/providers/amazonBedrock.d.ts

@@ -27,6 +27,5 @@ export declare class AmazonBedrockProvider extends BaseProvider {
     protected getAISDKModel(): LanguageModelV1;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     protected handleProviderError(error: unknown): Error;
-    private validateStreamOptions;
 }
 export default AmazonBedrockProvider;

package/dist/providers/amazonBedrock.js

@@ -116,18 +116,5 @@ export class AmazonBedrockProvider extends BaseProvider {
         }
         return new Error(`❌ Amazon Bedrock Provider Error\n\n${errorMessage || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check AWS credentials and permissions\n2. Verify model availability\n3. Check network connectivity`);
     }
-    validateStreamOptions(options) {
-        if (!options.input?.text?.trim()) {
-            throw new Error("Prompt is required for streaming");
-        }
-        if (options.maxTokens &&
-            (options.maxTokens < 1 || options.maxTokens > 4096)) {
-            throw new Error("maxTokens must be between 1 and 4096 for Amazon Bedrock");
-        }
-        if (options.temperature &&
-            (options.temperature < 0 || options.temperature > 1)) {
-            throw new Error("temperature must be between 0 and 1");
-        }
-    }
 }
 export default AmazonBedrockProvider;

package/dist/providers/anthropic.js

@@ -3,7 +3,7 @@ import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createAnthropicConfig, getProviderModel, } from "../utils/providerConfig.js";
 // Configuration helpers - now using consolidated utility
 const getAnthropicApiKey = () => {
@@ -87,52 +87,35 @@ export class AnthropicProvider extends BaseProvider {
     }
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, analysisSchema) {
-        // Convert StreamOptions to TextGenerationOptions for validation
-        const validationOptions = {
-            prompt: options.input.text,
-            systemPrompt: options.systemPrompt,
-            temperature: options.temperature,
-            maxTokens: options.maxTokens,
-        };
-        this.validateOptions(validationOptions);
+        this.validateStreamOptions(options);
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
             // ✅ Get tools for streaming (same as generate method)
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const tools = shouldUseTools ? await this.getAllTools() : {};
-            // 🔧 CRITICAL FIX: Vercel AI SDK streamText() hangs with tools and maxSteps > 1
-            // For stream-focused SDK, we need reliable streaming, so avoid the hanging case
-            if (shouldUseTools && Object.keys(tools).length > 0) {
-                throw new Error("Vercel AI SDK streamText() limitation with tools - falling back to synthetic streaming");
-            }
             const result = await streamText({
                 model: this.model,
                 prompt: options.input.text,
                 system: options.systemPrompt || undefined,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
-                tools: {}, // 🔧 Force empty tools for real streaming to avoid hanging
-                maxSteps: 1, // 🔧 Force single step for real streaming
-                toolChoice: "none", // 🔧 Force no tools for real streaming
+                tools,
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
             });
             timeoutController?.cleanup();
-            // Transform string stream to content object stream
-            const transformedStream = async function* () {
-                for await (const chunk of result.textStream) {
-                    yield { content: chunk };
-                }
-            };
+            const transformedStream = this.createTextStream(result);
             // ✅ Note: Vercel AI SDK's streamText() method limitations with tools
             // The streamText() function doesn't provide the same tool result access as generateText()
-            // For full tool support, the BaseProvider will fall back to synthetic streaming when needed
+            // Full tool support is now available with real streaming
             const toolCalls = [];
             const toolResults = [];
             const usage = await result.usage;
             const finishReason = await result.finishReason;
             return {
-                stream: transformedStream(),
+                stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 toolCalls, // ✅ Include tool calls in stream result

package/dist/providers/googleAiStudio.d.ts

@@ -18,6 +18,5 @@ export declare class GoogleAIStudioProvider extends BaseProvider {
     protected handleProviderError(error: unknown): Error;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     private getApiKey;
-    private validateStreamOptions;
 }
 export default GoogleAIStudioProvider;

package/dist/providers/googleAiStudio.js

@@ -4,7 +4,7 @@ import { GoogleAIModels } from "../core/types.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 // Environment variable setup
 if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY &&
@@ -73,30 +73,30 @@ export class GoogleAIStudioProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Get tools consistently with generate method
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools ? await this.getAllTools() : {};
             const result = await streamText({
                 model,
                 prompt: options.input.text,
                 system: options.systemPrompt,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
-                tools: options.tools,
-                toolChoice: "auto",
+                tools,
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
             });
             timeoutController?.cleanup();
-            // Transform string stream to content object stream
-            const transformedStream = async function* () {
-                for await (const chunk of result.textStream) {
-                    yield { content: chunk };
-                }
-            };
+            // Transform string stream to content object stream using BaseProvider method
+            const transformedStream = this.createTextStream(result);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
                 requestId: `google-ai-stream-${Date.now()}`,
                 streamingMode: true,
             });
             return {
-                stream: transformedStream(),
+                stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 analytics: analyticsPromise,
@@ -121,10 +121,5 @@ export class GoogleAIStudioProvider extends BaseProvider {
         }
         return apiKey;
     }
-    validateStreamOptions(options) {
-        if (!options.input?.text || options.input.text.trim().length === 0) {
-            throw new Error("Input text is required and cannot be empty");
-        }
-    }
 }
 export default GoogleAIStudioProvider;

package/dist/providers/googleVertex.d.ts

@@ -40,7 +40,6 @@ export declare class GoogleVertexProvider extends BaseProvider {
     private getModel;
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     protected handleProviderError(error: unknown): Error;
-    private validateStreamOptions;
     /**
      * Memory-safe cache management for model configurations
      * Implements LRU eviction to prevent memory leaks in long-running processes

package/dist/providers/googleVertex.js

@@ -2,8 +2,8 @@ import { createVertex, } from "@ai-sdk/google-vertex";
 import { streamText, Output, } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { TimeoutError } from "../utils/timeout.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { ModelConfigurationManager } from "../core/modelConfiguration.js";
 import { validateApiKey, createVertexProjectConfig, createGoogleAuthConfig, } from "../utils/providerConfig.js";
 // Cache for anthropic module to avoid repeated imports
@@ -184,6 +184,9 @@ export class GoogleVertexProvider extends BaseProvider {
     async executeStream(options, analysisSchema) {
         const functionTag = "GoogleVertexProvider.executeStream";
         let chunkCount = 0;
+        // Add timeout controller for consistency with other providers
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
             this.validateStreamOptions(options);
             logger.debug(`${functionTag}: Starting stream request`, {
@@ -200,6 +203,9 @@ export class GoogleVertexProvider extends BaseProvider {
             const maxTokens = shouldSetMaxTokens
                 ? options.maxTokens || DEFAULT_MAX_TOKENS
                 : undefined;
+            // Get tools consistently with generate method (using BaseProvider pattern)
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools ? await this.getAllTools() : {};
             // Build complete stream options with proper typing
             let streamOptions = {
                 model: model,
@@ -207,6 +213,10 @@ export class GoogleVertexProvider extends BaseProvider {
                 system: options.systemPrompt,
                 temperature: options.temperature,
                 ...(maxTokens && { maxTokens }),
+                tools,
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                toolChoice: shouldUseTools ? "auto" : "none",
+                abortSignal: timeoutController?.controller.signal,
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -243,17 +253,17 @@ export class GoogleVertexProvider extends BaseProvider {
                 }
             }
             const result = streamText(streamOptions);
+            timeoutController?.cleanup();
+            // Transform string stream to content object stream using BaseProvider method
+            const transformedStream = this.createTextStream(result);
             return {
-                stream: (async function* () {
-                    for await (const chunk of result.textStream) {
-                        yield { content: chunk };
-                    }
-                })(),
+                stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
             };
         }
         catch (error) {
+            timeoutController?.cleanup();
             logger.error(`${functionTag}: Exception`, {
                 provider: this.providerName,
                 modelName: this.modelName,
@@ -287,23 +297,6 @@ export class GoogleVertexProvider extends BaseProvider {
         }
         return new Error(`❌ Google Vertex AI Provider Error\n\n${message}\n\nTroubleshooting:\n1. Check Google Cloud credentials and permissions\n2. Verify project ID and location settings\n3. Ensure Vertex AI API is enabled\n4. Check network connectivity`);
     }
-    validateStreamOptions(options) {
-        if (!options.input?.text?.trim()) {
-            throw new Error("Prompt is required for streaming");
-        }
-        // Use cached model configuration for validation performance
-        const modelName = this.modelName || getDefaultVertexModel();
-        const shouldValidateMaxTokens = this.shouldSetMaxTokensCached(modelName);
-        if (shouldValidateMaxTokens &&
-            options.maxTokens &&
-            (options.maxTokens < 1 || options.maxTokens > 8192)) {
-            throw new Error("maxTokens must be between 1 and 8192 for Google Vertex AI");
-        }
-        if (options.temperature &&
-            (options.temperature < 0 || options.temperature > 2)) {
-            throw new Error("temperature must be between 0 and 2");
-        }
-    }
     /**
      * Memory-safe cache management for model configurations
      * Implements LRU eviction to prevent memory leaks in long-running processes

package/dist/providers/huggingFace.d.ts

@@ -75,6 +75,5 @@ export declare class HuggingFaceProvider extends BaseProvider {
      * Returns the Vercel AI SDK model instance for HuggingFace
      */
     protected getAISDKModel(): LanguageModelV1;
-    private validateStreamOptions;
 }
 export default HuggingFaceProvider;

package/dist/providers/huggingFace.js

@@ -272,14 +272,6 @@ Available tools will be provided in the function calling format. Use them when t
     getAISDKModel() {
         return this.model;
     }
-    // ===================
-    // PRIVATE VALIDATION METHODS
-    // ===================
-    validateStreamOptions(options) {
-        if (!options.input?.text || options.input.text.trim().length === 0) {
-            throw new Error("Input text is required and cannot be empty");
-        }
-    }
 }
 // Export for factory registration
 export default HuggingFaceProvider;

package/dist/providers/litellm.d.ts

@@ -39,5 +39,4 @@ export declare class LiteLLMProvider extends BaseProvider {
      * @private
      */
     private fetchModelsFromAPI;
-    private validateStreamOptions;
 }

package/dist/providers/litellm.js

@@ -264,12 +264,4 @@ export class LiteLLMProvider extends BaseProvider {
             throw error;
         }
     }
-    // ===================
-    // PRIVATE VALIDATION METHODS
-    // ===================
-    validateStreamOptions(options) {
-        if (!options.input?.text || options.input.text.trim().length === 0) {
-            throw new Error("Input text is required and cannot be empty");
-        }
-    }
 }

package/dist/providers/mistral.d.ts

@@ -1,5 +1,6 @@
-import { type LanguageModelV1 } from "ai";
-import type { AIProviderName, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
+import type { ZodType, ZodTypeDef } from "zod";
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**
@@ -9,30 +10,14 @@ import { BaseProvider } from "../core/baseProvider.js";
 export declare class MistralProvider extends BaseProvider {
     private model;
     constructor(modelName?: string, sdk?: unknown);
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
     /**
-     * Generate text using Mistral API
+     * Returns the Vercel AI SDK model instance for Mistral
      */
-    generate(options: TextGenerationOptions): Promise<EnhancedGenerateResult>;
-    /**
-     * Stream text generation using Mistral API
-     */
-    executeStream(options: StreamOptions): Promise<StreamResult>;
-    /**
-     * Get default model name for this provider
-     */
-    getDefaultModel(): string;
-    /**
-     * Get provider name
-     */
-    getProviderName(): AIProviderName;
-    /**
-     * Get AI SDK model instance
-     */
-    getAISDKModel(): LanguageModelV1;
-    /**
-     * Handle provider-specific errors
-     */
-    handleProviderError(error: unknown): Error;
+    protected getAISDKModel(): LanguageModelV1;
+    protected handleProviderError(error: unknown): Error;
     /**
      * Validate provider configuration
      */

package/dist/providers/mistral.js

@@ -2,7 +2,8 @@ import { createMistral } from "@ai-sdk/mistral";
 import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createAnalytics } from "../core/analytics.js";
+import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createMistralConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 // Configuration helpers - now using consolidated utility
@@ -29,85 +30,43 @@ export class MistralProvider extends BaseProvider {
         const mistral = createMistral({
             apiKey: apiKey,
         });
-        this.model = mistral(this.modelName || getDefaultMistralModel());
+        this.model = mistral(this.modelName);
         logger.debug("Mistral Provider v2 initialized", {
             modelName: this.modelName,
             providerName: this.providerName,
         });
     }
-    /**
-     * Generate text using Mistral API
-     */
-    async generate(options) {
-        const startTime = Date.now();
-        try {
-            const result = await this.model.doGenerate({
-                inputFormat: "prompt",
-                mode: { type: "regular" },
-                prompt: [
-                    {
-                        role: "user",
-                        content: [{ type: "text", text: options.prompt || "" }],
-                    },
-                ],
-                temperature: options.temperature,
-                maxTokens: options.maxTokens,
-            });
-            const responseTime = Date.now() - startTime;
-            // Extract token usage and text content
-            const tokenUsage = result.usage;
-            const textContent = result.text || "";
-            // Create analytics data using helper
-            const analytics = createAnalytics("mistral", this.modelName, { usage: tokenUsage, content: textContent }, responseTime, { requestId: `mistral-${Date.now()}` });
-            return {
-                content: textContent,
-                usage: {
-                    inputTokens: tokenUsage?.promptTokens || 0,
-                    outputTokens: tokenUsage?.completionTokens || 0,
-                    totalTokens: (tokenUsage?.promptTokens || 0) +
-                        (tokenUsage?.completionTokens || 0),
-                },
-                provider: this.providerName,
-                model: this.modelName,
-                analytics,
-            };
-        }
-        catch (error) {
-            const responseTime = Date.now() - startTime;
-            logger.error("Mistral generation failed", {
-                error: error instanceof Error ? error.message : String(error),
-                responseTime,
-            });
-            throw new Error(`Mistral generation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Stream text generation using Mistral API
-     */
-    async executeStream(options) {
+    // generate() method is inherited from BaseProvider; this provider uses the base implementation for generation with tools
+    async executeStream(options, analysisSchema) {
+        this.validateStreamOptions(options);
         const startTime = Date.now();
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Get tools consistently with generate method
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools ? await this.getAllTools() : {};
             const result = await streamText({
                 model: this.model,
                 prompt: options.input.text,
+                system: options.systemPrompt,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens,
-                tools: options.tools,
-                toolChoice: "auto",
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                tools,
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                toolChoice: shouldUseTools ? "auto" : "none",
+                abortSignal: timeoutController?.controller.signal,
             });
-            // Transform stream to match StreamResult interface
-            const transformedStream = async function* () {
-                for await (const chunk of result.textStream) {
-                    yield { content: chunk };
-                }
-            };
+            timeoutController?.cleanup();
+            // Transform string stream to content object stream using BaseProvider method
+            const transformedStream = this.createTextStream(result);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
                 requestId: `mistral-stream-${Date.now()}`,
                 streamingMode: true,
             });
             return {
-                stream: transformedStream(),
+                stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 analytics: analyticsPromise,
@@ -118,38 +77,41 @@ export class MistralProvider extends BaseProvider {
             };
         }
         catch (error) {
-            logger.error("Mistral streaming failed", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw new Error(`Mistral streaming failed: ${error instanceof Error ? error.message : String(error)}`);
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
         }
     }
-    /**
-     * Get default model name for this provider
-     */
-    getDefaultModel() {
-        return getDefaultMistralModel();
-    }
-    /**
-     * Get provider name
-     */
+    // ===================
+    // ABSTRACT METHOD IMPLEMENTATIONS
+    // ===================
     getProviderName() {
         return this.providerName;
     }
+    getDefaultModel() {
+        return getDefaultMistralModel();
+    }
     /**
-     * Get AI SDK model instance
+     * Returns the Vercel AI SDK model instance for Mistral
      */
     getAISDKModel() {
         return this.model;
     }
-    /**
-     * Handle provider-specific errors
-     */
     handleProviderError(error) {
-        if (error instanceof Error) {
-            return error;
+        if (error instanceof TimeoutError) {
+            return new Error(`Mistral request timed out: ${error.message}`);
+        }
+        const errorRecord = error;
+        const message = typeof errorRecord?.message === "string"
+            ? errorRecord.message
+            : "Unknown error";
+        if (message.includes("API_KEY_INVALID") ||
+            message.includes("Invalid API key")) {
+            return new Error("Invalid Mistral API key. Please check your MISTRAL_API_KEY environment variable.");
+        }
+        if (message.includes("rate limit")) {
+            return new Error("Mistral rate limit exceeded. Please try again later.");
         }
-        return new Error(`Mistral provider error: ${String(error)}`);
+        return new Error(`Mistral error: ${message}`);
     }
     /**
      * Validate provider configuration

package/dist/providers/ollama.d.ts

@@ -75,7 +75,6 @@ export declare class OllamaProvider extends BaseProvider {
      */
     private createOllamaStream;
     protected handleProviderError(error: unknown): Error;
-    private validateStreamOptions;
     /**
      * Check if Ollama service is healthy and accessible
      */

package/dist/providers/ollama.js

@@ -560,18 +560,6 @@ export class OllamaProvider extends BaseProvider {
         }
         return new Error(`❌ Ollama Provider Error\n\n${error.message || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check if Ollama service is running\n2. Verify model is installed: 'ollama list'\n3. Check network connectivity to ${this.baseUrl}\n4. Review Ollama logs for details`);
     }
-    validateStreamOptions(options) {
-        if (!options.input?.text?.trim()) {
-            throw new Error("Prompt is required for streaming");
-        }
-        if (options.maxTokens && options.maxTokens < 1) {
-            throw new Error("maxTokens must be greater than 0");
-        }
-        if (options.temperature &&
-            (options.temperature < 0 || options.temperature > 2)) {
-            throw new Error("temperature must be between 0 and 2");
-        }
-    }
     /**
      * Check if Ollama service is healthy and accessible
      */