@juspay/neurolink 8.3.0 → 8.4.1

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

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

package/dist/lib/factories/providerRegistry.js

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

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

@@ -135,7 +135,6 @@ function getToolCategory(toolName) {
         case "readFile":
         case "writeFile":
         case "listDirectory":
-        case "searchFiles":
             return "filesystem";
         case "websearchGrounding":
             return "search";

package/dist/lib/memory/mem0Initializer.d.ts

@@ -8,8 +8,39 @@ import { MemoryClient } from "mem0ai";
  */
 export interface Mem0Config {
     apiKey: string;
+    /**
+     * Optional organization ID - if not provided, will be auto-populated from ping() response
+     */
+    organizationId?: string;
+    /**
+     * Optional project ID - if not provided, will be auto-populated from ping() response
+     */
+    projectId?: string;
+    /**
+     * Whether to update project-level custom instructions during initialization
+     * Default: false (don't update project settings)
+     *
+     * Note: organizationId and projectId are NOT required - they will be auto-populated
+     * from the mem0 API via ping() if not provided
+     */
+    updateProjectSettings?: boolean;
+    /**
+     * Custom instructions and categories for mem0 extraction behavior
+     * Only used if updateProjectSettings is true
+     */
+    customPrompts?: {
+        /**
+         * Custom instructions for how mem0 should extract and store memories
+         * This applies to ALL memories added to the project
+         */
+        custom_instructions?: string;
+        /**
+         * Custom categories for organizing memories
+         */
+        custom_categories?: Array<Record<string, unknown>>;
+    };
 }
 /**
- * Initialize mem0 memory instance with cloud API
+ * Initialize mem0 memory instance with cloud API and optional project settings
  */
 export declare function initializeMem0(mem0Config: Mem0Config): Promise<MemoryClient | null>;

package/dist/lib/memory/mem0Initializer.js

@@ -5,7 +5,7 @@
 import { MemoryClient } from "mem0ai";
 import { logger } from "../utils/logger.js";
 /**
- * Initialize mem0 memory instance with cloud API
+ * Initialize mem0 memory instance with cloud API and optional project settings
  */
 export async function initializeMem0(mem0Config) {
     // Guard: skip initialization if API key is missing
@@ -18,8 +18,61 @@ export async function initializeMem0(mem0Config) {
         // Create MemoryClient instance with cloud API
         const client = new MemoryClient({
             apiKey: mem0Config.apiKey,
+            organizationId: mem0Config.organizationId,
+            projectId: mem0Config.projectId,
+        });
+        // Track whether project settings were actually updated (not just requested)
+        let projectSettingsUpdated = false;
+        // Update project-level settings if requested
+        if (mem0Config.updateProjectSettings && mem0Config.customPrompts) {
+            // Build update payload - only include fields that are actually provided
+            const updatePayload = {};
+            if (mem0Config.customPrompts.custom_instructions &&
+                mem0Config.customPrompts.custom_instructions.trim() !== "") {
+                updatePayload.custom_instructions =
+                    mem0Config.customPrompts.custom_instructions;
+            }
+            if (Array.isArray(mem0Config.customPrompts.custom_categories) &&
+                mem0Config.customPrompts.custom_categories.length > 0) {
+                updatePayload.custom_categories =
+                    mem0Config.customPrompts.custom_categories;
+            }
+            // Only proceed if there's something to update
+            if (Object.keys(updatePayload).length > 0) {
+                try {
+                    // Note: updateProject() internally calls ping() first, which auto-populates
+                    // organizationId and projectId from the server, so they're not required
+                    await client.updateProject(updatePayload);
+                    projectSettingsUpdated = true; // Only set to true on successful update
+                    logger.info("[mem0Initializer] Project settings updated successfully", {
+                        hasInstructions: !!updatePayload.custom_instructions,
+                        hasCategories: !!updatePayload.custom_categories,
+                        // Note: These IDs are auto-populated by ping() inside updateProject()
+                        organizationId: client.organizationId,
+                        projectId: client.projectId,
+                    });
+                }
+                catch (error) {
+                    logger.warn("[mem0Initializer] Failed to update project settings", {
+                        error: error instanceof Error ? error.message : String(error),
+                        hint: "Ensure your MEM0_API_KEY has permission to update project settings",
+                    });
+                    // Continue initialization even if project update fails
+                    // projectSettingsUpdated remains false
+                }
+            }
+            else {
+                logger.warn("[mem0Initializer] updateProjectSettings=true but no custom instructions or categories provided - nothing to update");
+            }
+        }
+        else if (mem0Config.updateProjectSettings && !mem0Config.customPrompts) {
+            logger.warn("[mem0Initializer] updateProjectSettings=true but customPrompts not provided - nothing to update");
+        }
+        logger.info("[mem0Initializer] Mem0 cloud API initialized successfully", {
+            hasOrgId: !!client.organizationId,
+            hasProjectId: !!client.projectId,
+            projectSettingsUpdated,
         });
-        logger.info("[mem0Initializer] Mem0 cloud API initialized successfully");
         return client;
     }
     catch (error) {

package/dist/lib/models/modelRegistry.js

@@ -188,6 +188,50 @@ export const MODEL_REGISTRY = {
         category: "general",
     },
     // Anthropic Models
+    [AnthropicModels.CLAUDE_4_5_HAIKU]: {
+        id: AnthropicModels.CLAUDE_4_5_HAIKU,
+        name: "Claude 4.5 Haiku",
+        provider: AIProviderName.ANTHROPIC,
+        description: "Latest fast and efficient Claude model with vision support",
+        capabilities: {
+            vision: true,
+            functionCalling: true,
+            codeGeneration: true,
+            reasoning: true,
+            multimodal: true,
+            streaming: true,
+            jsonMode: false,
+        },
+        pricing: {
+            inputCostPer1K: 0.001,
+            outputCostPer1K: 0.005,
+            currency: "USD",
+        },
+        performance: {
+            speed: "fast",
+            quality: "high",
+            accuracy: "high",
+        },
+        limits: {
+            maxContextTokens: 200000,
+            maxOutputTokens: 64000,
+            maxRequestsPerMinute: 100,
+        },
+        useCases: {
+            coding: 8,
+            creative: 8,
+            analysis: 8,
+            conversation: 9,
+            reasoning: 8,
+            translation: 8,
+            summarization: 9,
+        },
+        aliases: ["claude-4.5-haiku", "claude-haiku-latest", "haiku-4.5"],
+        deprecated: false,
+        isLocal: false,
+        releaseDate: "2025-10-15",
+        category: "general",
+    },
     [AnthropicModels.CLAUDE_3_5_SONNET]: {
         id: AnthropicModels.CLAUDE_3_5_SONNET,
         name: "Claude 3.5 Sonnet",

package/dist/lib/neurolink.d.ts

@@ -137,7 +137,7 @@ export declare class NeuroLink {
     /** Extract memory context from search results */
     private extractMemoryContext;
     /** Store conversation turn in mem0 */
-    private storeConversationTurn;
+    private storeMem0ConversationTurn;
     /**
      * Set up HITL event forwarding to main emitter
      */

package/dist/lib/neurolink.js

@@ -402,9 +402,12 @@ Current user's request: ${currentInput}`;
             .join("\n");
     }
     /** Store conversation turn in mem0 */
-    async storeConversationTurn(mem0, userContent, userId, metadata) {
-        // Store user message only, reducing latency in mem0
-        const conversationTurn = [{ role: "user", content: userContent }];
+    async storeMem0ConversationTurn(mem0, userContent, aiResponse, userId, metadata) {
+        // Store both user message and AI response for better context extraction
+        const conversationTurn = [
+            { role: "user", content: userContent },
+            { role: "assistant", content: aiResponse },
+        ];
         await mem0.add(conversationTurn, {
             user_id: userId,
             metadata,
@@ -455,7 +458,7 @@ Current user's request: ${currentInput}`;
         try {
             this.externalServerManager = new ExternalServerManager({
                 maxServers: 20,
-                defaultTimeout: 15000,
+                defaultTimeout: 30000, // Increased from 15s to 30s for proxy latency (e.g., LiteLLM)
                 enableAutoRestart: true,
                 enablePerformanceMonitoring: true,
             }, {
@@ -1366,7 +1369,7 @@ Current user's request: ${currentInput}`;
                     try {
                         const mem0 = await this.ensureMem0Ready();
                         if (mem0) {
-                            await this.storeConversationTurn(mem0, originalPrompt, options.context?.userId, {
+                            await this.storeMem0ConversationTurn(mem0, originalPrompt, generateResult.content, options.context?.userId, {
                                 timestamp: new Date().toISOString(),
                                 provider: generateResult.provider,
                                 model: generateResult.model,
@@ -1963,6 +1966,29 @@ Current user's request: ${currentInput}`;
                         // Continue with original options if orchestration fails
                     }
                 }
+                // 🔧 AUTO-DISABLE TOOLS: For Ollama models that don't support tools (same logic as generate())
+                // This prevents overwhelming smaller models with massive tool descriptions in the system message
+                if ((options.provider === "ollama" ||
+                    options.provider?.toLowerCase().includes("ollama")) &&
+                    !options.disableTools) {
+                    const { ModelConfigurationManager } = await import("./core/modelConfiguration.js");
+                    const modelConfig = ModelConfigurationManager.getInstance();
+                    const ollamaConfig = modelConfig.getProviderConfiguration("ollama");
+                    const toolCapableModels = ollamaConfig?.modelBehavior?.toolCapableModels || [];
+                    // Only disable tools if we have explicit evidence the model doesn't support them
+                    // If toolCapableModels is empty or model is not specified, don't make assumptions
+                    const modelName = options.model;
+                    if (toolCapableModels.length > 0 && modelName) {
+                        const modelSupportsTools = toolCapableModels.some((capableModel) => modelName.toLowerCase().includes(capableModel.toLowerCase()));
+                        if (!modelSupportsTools) {
+                            options.disableTools = true;
+                            logger.debug("Auto-disabled tools for Ollama model that doesn't support them (stream)", {
+                                model: options.model,
+                                toolCapableModels: toolCapableModels.slice(0, 3), // Show first 3 for brevity
+                            });
+                        }
+                    }
+                }
                 factoryResult = processStreamingFactoryOptions(options);
                 enhancedOptions = createCleanStreamOptions(options);
                 if (options.input?.text) {
@@ -2014,11 +2040,9 @@ Current user's request: ${currentInput}`;
                                 try {
                                     const mem0 = await self.ensureMem0Ready();
                                     if (mem0) {
-                                        await self.storeConversationTurn(mem0, originalPrompt, enhancedOptions.context?.userId, {
+                                        await self.storeMem0ConversationTurn(mem0, originalPrompt, accumulatedContent.trim(), enhancedOptions.context?.userId, {
                                             timestamp: new Date().toISOString(),
                                             type: "conversation_turn_stream",
-                                            userMessage: originalPrompt,
-                                            aiResponse: accumulatedContent.trim(),
                                         });
                                     }
                                 }
@@ -2091,17 +2115,26 @@ Current user's request: ${currentInput}`;
             customTools: this.getCustomTools(),
             executeTool: this.executeTool.bind(this),
         }, "NeuroLink.createMCPStream");
+        // 🔧 FIX: Get available tools and create tool-aware system prompt
+        // Use SAME pattern as tryMCPGeneration (generate mode)
+        const availableTools = await this.getAllAvailableTools();
+        const enhancedSystemPrompt = this.createToolAwareSystemPrompt(options.systemPrompt, availableTools);
         // Get conversation messages for context
         const conversationMessages = await getConversationMessages(this.conversationMemory, {
             prompt: options.input.text,
             context: options.context,
         });
-        // Let provider handle tools and system prompt automatically via Vercel AI SDK
-        // This ensures proper tool integration in stream mode
+        // 🔧 FIX: Pass enhanced system prompt to real streaming
+        // Tools will be accessed through the streamText call in executeStream
         const streamResult = await provider.stream({
             ...options,
+            systemPrompt: enhancedSystemPrompt, // Use enhanced prompt with tool descriptions
             conversationMessages,
         });
+        logger.debug("[createMCPStream] Stream created successfully", {
+            provider: providerName,
+            systemPromptPassedLength: enhancedSystemPrompt.length,
+        });
         return { stream: streamResult.stream, provider: providerName };
     }
     /**