@juspay/neurolink 7.10.2 → 7.11.0

package/dist/lib/factories/providerRegistry.js

@@ -24,17 +24,17 @@ export class ProviderRegistry {
             // Register providers with dynamic import factory functions
             const { ProviderFactory } = await import("./providerFactory.js");
             // Register Google AI Studio Provider (our validated baseline)
-            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, providerName, sdk) => {
+            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"]);
             // Register OpenAI provider
-            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk) => {
                 const { OpenAIProvider } = await import("../providers/openAI.js");
-                return new OpenAIProvider(modelName);
+                return new OpenAIProvider(modelName, sdk);
             }, OpenAIModels.GPT_4O_MINI, ["gpt", "chatgpt"]);
             // Register Anthropic provider
-            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, _providerName, sdk) => {
                 const { AnthropicProvider } = await import("../providers/anthropic.js");
                 return new AnthropicProvider(modelName, sdk);
             }, "claude-3-5-sonnet-20241022", ["claude", "anthropic"]);
@@ -62,7 +62,7 @@ export class ProviderRegistry {
                 return new HuggingFaceProvider(modelName);
             }, process.env.HUGGINGFACE_MODEL || "microsoft/DialoGPT-medium", ["huggingface", "hf"]);
             // Register Mistral AI provider
-            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, _providerName, sdk) => {
                 const { MistralProvider } = await import("../providers/mistral.js");
                 return new MistralProvider(modelName, sdk);
             }, "mistral-large-latest", ["mistral"]);
@@ -72,18 +72,18 @@ export class ProviderRegistry {
                 return new OllamaProvider(modelName);
             }, process.env.OLLAMA_MODEL || "llama3.1:8b", ["ollama", "local"]);
             // Register LiteLLM provider
-            ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, _providerName, sdk) => {
                 const { LiteLLMProvider } = await import("../providers/litellm.js");
                 return new LiteLLMProvider(modelName, sdk);
             }, process.env.LITELLM_MODEL || "openai/gpt-4o-mini", ["litellm"]);
             // Register OpenAI Compatible provider
-            ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, _providerName, sdk) => {
                 const { OpenAICompatibleProvider } = await import("../providers/openaiCompatible.js");
                 return new OpenAICompatibleProvider(modelName, sdk);
             }, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
             ["openai-compatible", "openrouter", "vllm", "compatible"]);
             // Register Amazon SageMaker provider
-            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk) => {
                 const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
                 return new AmazonSageMakerProvider(modelName);
             }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);

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

@@ -5,6 +5,7 @@
 import { createMCPServer } from "../../factory.js";
 import { directAgentTools } from "../../../agent/directTools.js";
 import { logger } from "../../../utils/logger.js";
+import { shouldDisableBuiltinTools } from "../../../utils/toolUtils.js";
 /**
  * Direct Tools Server - Agent direct tools for immediate use
  */
@@ -17,58 +18,77 @@ export const directToolsServer = createMCPServer({
 });
 /**
  * Wrap each direct tool and register it with the server
+ * Only register if built-in tools are not disabled
  */
-Object.entries(directAgentTools).forEach(([toolName, toolDef]) => {
-    // The toolDef is a Vercel AI SDK Tool object
-    // Extract properties from the Tool object
-    const toolSpec = toolDef._spec || toolDef;
-    const description = typeof toolSpec === "object" &&
-        toolSpec &&
-        "description" in toolSpec &&
-        typeof toolSpec.description === "string"
-        ? toolSpec.description
-        : `Direct tool: ${toolName}`;
-    const inputSchema = typeof toolSpec === "object" && toolSpec && "parameters" in toolSpec
-        ? toolSpec.parameters
-        : undefined;
-    const execute = typeof toolSpec === "object" && toolSpec && "execute" in toolSpec
-        ? toolSpec.execute
-        : undefined;
-    directToolsServer.registerTool({
-        name: toolName,
-        description: description,
-        category: getToolCategory(toolName),
-        inputSchema: inputSchema,
-        isImplemented: true,
-        execute: async (params, context) => {
-            const startTime = Date.now();
-            try {
-                logger.debug(`[Direct Tools] Executing ${toolName} with params:`, params);
-                // Execute the direct tool
-                if (!execute || typeof execute !== "function") {
-                    throw new Error(`Tool ${toolName} has no execute function`);
+if (!shouldDisableBuiltinTools()) {
+    Object.entries(directAgentTools).forEach(([toolName, toolDef]) => {
+        // The toolDef is a Vercel AI SDK Tool object
+        // Extract properties from the Tool object
+        const toolSpec = toolDef._spec || toolDef;
+        const description = typeof toolSpec === "object" &&
+            toolSpec &&
+            "description" in toolSpec &&
+            typeof toolSpec.description === "string"
+            ? toolSpec.description
+            : `Direct tool: ${toolName}`;
+        const inputSchema = typeof toolSpec === "object" && toolSpec && "parameters" in toolSpec
+            ? toolSpec.parameters
+            : undefined;
+        const execute = typeof toolSpec === "object" && toolSpec && "execute" in toolSpec
+            ? toolSpec.execute
+            : undefined;
+        directToolsServer.registerTool({
+            name: toolName,
+            description: description,
+            category: getToolCategory(toolName),
+            inputSchema: inputSchema,
+            isImplemented: true,
+            execute: async (params, context) => {
+                const startTime = Date.now();
+                try {
+                    logger.debug(`[Direct Tools] Executing ${toolName} with params:`, params);
+                    // Execute the direct tool
+                    if (!execute || typeof execute !== "function") {
+                        throw new Error(`Tool ${toolName} has no execute function`);
+                    }
+                    const result = await execute(params);
+                    // Convert direct tool result to ToolResult format
+                    if (result?.success) {
+                        return {
+                            success: true,
+                            data: result.data || result,
+                            usage: {
+                                executionTime: Date.now() - startTime,
+                            },
+                            metadata: {
+                                toolName,
+                                serverId: "neurolink-direct",
+                                sessionId: context.sessionId,
+                            },
+                        };
+                    }
+                    else {
+                        return {
+                            success: false,
+                            data: null,
+                            error: String(result?.error) || "Unknown error",
+                            usage: {
+                                executionTime: Date.now() - startTime,
+                            },
+                            metadata: {
+                                toolName,
+                                serverId: "neurolink-direct",
+                                sessionId: context.sessionId,
+                            },
+                        };
+                    }
                 }
-                const result = await execute(params);
-                // Convert direct tool result to ToolResult format
-                if (result?.success) {
-                    return {
-                        success: true,
-                        data: result.data || result,
-                        usage: {
-                            executionTime: Date.now() - startTime,
-                        },
-                        metadata: {
-                            toolName,
-                            serverId: "neurolink-direct",
-                            sessionId: context.sessionId,
-                        },
-                    };
-                }
-                else {
+                catch (error) {
+                    logger.error(`[Direct Tools] Error executing ${toolName}:`, error);
                     return {
                         success: false,
                         data: null,
-                        error: String(result?.error) || "Unknown error",
+                        error: error instanceof Error ? error.message : String(error),
                         usage: {
                             executionTime: Date.now() - startTime,
                         },
@@ -79,26 +99,13 @@ Object.entries(directAgentTools).forEach(([toolName, toolDef]) => {
                         },
                     };
                 }
-            }
-            catch (error) {
-                logger.error(`[Direct Tools] Error executing ${toolName}:`, error);
-                return {
-                    success: false,
-                    data: null,
-                    error: error instanceof Error ? error.message : String(error),
-                    usage: {
-                        executionTime: Date.now() - startTime,
-                    },
-                    metadata: {
-                        toolName,
-                        serverId: "neurolink-direct",
-                        sessionId: context.sessionId,
-                    },
-                };
-            }
-        },
+            },
+        });
     });
-});
+}
+else {
+    logger.info("[Direct Tools] Built-in tools disabled via configuration");
+}
 /**
  * Get tool category based on tool name
  */
@@ -117,5 +124,10 @@ function getToolCategory(toolName) {
             return "utility";
     }
 }
-// Log successful registration
-logger.info(`[Direct Tools] Registered ${Object.keys(directAgentTools).length} direct tools`);
+// Log successful registration or disable status
+if (!shouldDisableBuiltinTools()) {
+    logger.info(`[Direct Tools] Registered ${Object.keys(directAgentTools).length} direct tools`);
+}
+else {
+    logger.info("[Direct Tools] 0 direct tools registered (disabled via environment variable)");
+}

package/dist/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/providers/litellm.d.ts

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

package/dist/lib/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");
-        }
-    }
 }