@juspay/neurolink 8.3.0 → 8.4.1

package/dist/lib/types/multimodal.js

@@ -0,0 +1,101 @@
+/**
+ * Multimodal Content Types for NeuroLink
+ *
+ * Central registry for all multimodal input/output types.
+ * This file consolidates types from content.ts and conversation.ts
+ * to provide a single source of truth for multimodal functionality.
+ *
+ * @module types/multimodal
+ *
+ * @example Basic Multimodal Input
+ * ```typescript
+ * import type { MultimodalInput } from './types/multimodal.js';
+ *
+ * const input: MultimodalInput = {
+ *   text: "What's in this image?",
+ *   images: [imageBuffer, "https://example.com/image.jpg"],
+ *   pdfFiles: [pdfBuffer]
+ * };
+ * ```
+ *
+ * @example Audio/Video Input (Future)
+ * ```typescript
+ * const avInput: MultimodalInput = {
+ *   text: "Transcribe this audio and analyze this video",
+ *   audioFiles: [audioBuffer],
+ *   videoFiles: ["path/to/video.mp4"]
+ * };
+ * ```
+ *
+ * @example Advanced Content Array
+ * ```typescript
+ * const advanced: MultimodalInput = {
+ *   text: "irrelevant", // ignored when content[] is provided
+ *   content: [
+ *     { type: "text", text: "Analyze these items:" },
+ *     { type: "image", data: imageBuffer, mediaType: "image/jpeg" },
+ *     { type: "pdf", data: pdfBuffer, metadata: { filename: "report.pdf" } }
+ *   ]
+ * };
+ * ```
+ */
+// ============================================
+// TYPE GUARDS
+// ============================================
+/**
+ * Type guard to check if content is TextContent
+ */
+export function isTextContent(content) {
+    return content.type === "text";
+}
+/**
+ * Type guard to check if content is ImageContent
+ */
+export function isImageContent(content) {
+    return content.type === "image";
+}
+/**
+ * Type guard to check if content is CSVContent
+ */
+export function isCSVContent(content) {
+    return content.type === "csv";
+}
+/**
+ * Type guard to check if content is PDFContent
+ */
+export function isPDFContent(content) {
+    return content.type === "pdf";
+}
+/**
+ * Type guard to check if content is AudioContent
+ */
+export function isAudioContent(content) {
+    return content.type === "audio";
+}
+/**
+ * Type guard to check if content is VideoContent
+ */
+export function isVideoContent(content) {
+    return content.type === "video";
+}
+/**
+ * Type guard to check if input contains multimodal content
+ * Now includes audio and video detection
+ */
+export function isMultimodalInput(input) {
+    const maybeInput = input;
+    return !!(maybeInput?.images?.length ||
+        maybeInput?.csvFiles?.length ||
+        maybeInput?.pdfFiles?.length ||
+        maybeInput?.files?.length ||
+        maybeInput?.content?.length ||
+        maybeInput?.audioFiles?.length ||
+        maybeInput?.videoFiles?.length);
+}
+/**
+ * Type guard to check if message content is multimodal (array)
+ */
+export function isMultimodalMessageContent(content) {
+    return Array.isArray(content);
+}
+//# sourceMappingURL=multimodal.js.map

package/dist/lib/types/streamTypes.d.ts

@@ -1,7 +1,7 @@
 import type { Tool } from "ai";
 import type { ValidationSchema, StandardRecord } from "./typeAliases.js";
 import type { AIModelProviderConfig } from "./providers.js";
-import type { TextContent, ImageContent } from "./content.js";
+import type { Content } from "./content.js";
 import type { AnalyticsData, ToolExecutionEvent, ToolExecutionSummary } from "../types/index.js";
 import { AIProviderName } from "../constants/enums.js";
 import type { TokenUsage } from "./analytics.js";
@@ -129,7 +129,7 @@ export type StreamOptions = {
         csvFiles?: Array<Buffer | string>;
         pdfFiles?: Array<Buffer | string>;
         files?: Array<Buffer | string>;
-        content?: Array<TextContent | ImageContent>;
+        content?: Content[];
     };
     output?: {
         format?: "text" | "structured" | "json";

package/dist/lib/utils/imageProcessor.d.ts

@@ -2,7 +2,7 @@
  * Image processing utilities for multimodal support
  * Handles format conversion for different AI providers
  */
-import type { ProcessedImage } from "../types/content.js";
+import type { ProcessedImage } from "../types/multimodal.js";
 import type { FileProcessingResult } from "../types/fileTypes.js";
 /**
  * Image processor class for handling provider-specific image formatting

package/dist/lib/utils/messageBuilder.js

@@ -473,6 +473,26 @@ export async function buildMultimodalMessagesArray(options, provider, model) {
     if (hasConversationHistory) {
         systemPrompt = `${systemPrompt.trim()}${CONVERSATION_INSTRUCTIONS}`;
     }
+    // Add file handling guidance when multimodal files are present
+    const hasCSVFiles = (options.input.csvFiles && options.input.csvFiles.length > 0) ||
+        (options.input.files &&
+            options.input.files.some((f) => typeof f === "string" ? f.toLowerCase().endsWith(".csv") : false));
+    const hasPDFFiles = pdfFiles.length > 0;
+    if (hasCSVFiles || hasPDFFiles) {
+        const fileTypes = [];
+        if (hasPDFFiles) {
+            fileTypes.push("PDFs");
+        }
+        if (hasCSVFiles) {
+            fileTypes.push("CSVs");
+        }
+        systemPrompt += `\n\nIMPORTANT FILE HANDLING INSTRUCTIONS:
+- File content (${fileTypes.join(", ")}, images) is already processed and included in this message
+- DO NOT use GitHub tools (get_file_contents, search_code, etc.) for local files - they only work for remote repository files
+- Analyze the provided file content directly without attempting to fetch or read files using tools
+- GitHub MCP tools are ONLY for remote repository operations, not local filesystem access
+- Use the file content shown in this message for your analysis`;
+    }
     // Add system message if we have one
     if (systemPrompt.trim()) {
         messages.push({
@@ -739,7 +759,10 @@ async function convertMultimodalToProviderFormat(text, images, pdfFiles, provide
             });
         }
     }
-    // Add PDFs using Vercel AI SDK standard format (works for all providers)
+    // Add PDFs using Vercel AI SDK standard format (works for all providers except Mistral)
+    // NOTE: Mistral API has a fundamental limitation - it does NOT support PDFs in any form.
+    // The API strictly requires image content to start with data:image/, rejecting data:application/pdf
+    // See: MISTRAL_PDF_FIX_SUMMARY.md for full investigation details
     content.push(...pdfFiles.map((pdf) => {
         logger.info(`[PDF] ✅ Added to content (Vercel AI SDK format): ${pdf.filename}`);
         return {
@@ -769,6 +792,6 @@ function extractFilename(file, index = 0) {
     return `file-${index + 1}`;
 }
 function buildCSVToolInstructions(filePath) {
-    return `\n**IMPORTANT**: For counting, aggregation, or statistical operations, use the analyzeCSV tool with filePath="${filePath}". The tool reads the file directly - do NOT pass CSV content.\n\nExample: analyzeCSV(filePath="${filePath}", operation="count_by_column", column="merchant_id")\n\n`;
+    return `\n**NOTE**: You can perform calculations directly on the CSV data shown above. For advanced operations on the full file (counting by column, grouping, etc.), you may optionally use the analyzeCSV tool with filePath="${filePath}".\n\nExample: analyzeCSV(filePath="${filePath}", operation="count_by_column", column="merchant_id")\n\n`;
 }
 //# sourceMappingURL=messageBuilder.js.map

package/dist/lib/utils/multimodalOptionsBuilder.d.ts

@@ -45,7 +45,7 @@ export declare function buildMultimodalOptions(options: StreamOptions, providerN
     input: {
         text: string;
         images: (string | Buffer<ArrayBufferLike>)[] | undefined;
-        content: (import("../types/content.js").TextContent | import("../types/content.js").ImageContent)[] | undefined;
+        content: import("../types/multimodal.js").Content[] | undefined;
         files: (string | Buffer<ArrayBufferLike>)[] | undefined;
         csvFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;
         pdfFiles: (string | Buffer<ArrayBufferLike>)[] | undefined;

package/dist/lib/utils/pdfProcessor.d.ts

@@ -7,4 +7,13 @@ export declare class PDFProcessor {
     private static isValidPDF;
     private static extractBasicMetadata;
     static estimateTokens(pageCount: number, mode?: "text-only" | "visual"): number;
+    static convertPDFToImages(pdfBuffer: Buffer, options?: {
+        maxPages?: number;
+        scale?: number;
+        format?: "png" | "jpeg";
+        quality?: number;
+    }): Promise<Array<{
+        buffer: Buffer;
+        pageNumber: number;
+    }>>;
 }

package/dist/lib/utils/pdfProcessor.js

@@ -1,4 +1,6 @@
 import { logger } from "./logger.js";
+import * as pdfjs from "pdfjs-dist/legacy/build/pdf.mjs";
+import { createCanvas } from "canvas";
 const PDF_PROVIDER_CONFIGS = {
     anthropic: {
         maxSizeMB: 5,
@@ -87,7 +89,7 @@ const PDF_PROVIDER_CONFIGS = {
     mistral: {
         maxSizeMB: 10,
         maxPages: 100,
-        supportsNative: true,
+        supportsNative: false,
         requiresCitations: false,
         apiType: "files-api",
     },
@@ -115,16 +117,14 @@ export class PDFProcessor {
         if (!this.isValidPDF(content)) {
             throw new Error("Invalid PDF file format. File must start with %PDF- header.");
         }
-        if (!config || !config.supportsNative) {
-            const supportedProviders = Object.keys(PDF_PROVIDER_CONFIGS)
-                .filter((p) => PDF_PROVIDER_CONFIGS[p].supportsNative)
-                .join(", ");
-            throw new Error(`PDF files are not currently supported with ${provider} provider.\n` +
-                `Supported providers: ${supportedProviders}\n` +
+        if (!config) {
+            const supportedProviders = Object.keys(PDF_PROVIDER_CONFIGS).join(", ");
+            throw new Error(`PDF files are not configured for ${provider} provider.\n` +
+                `Configured providers: ${supportedProviders}\n` +
                 `Current provider: ${provider}\n\n` +
                 `Options:\n` +
-                `1. Switch to a supported provider (--provider openai or --provider vertex)\n` +
-                `2. Convert your PDF to text manually`);
+                `1. Switch to a configured provider (--provider openai or --provider vertex)\n` +
+                `2. Contact support to add ${provider} PDF configuration`);
         }
         const sizeMB = content.length / (1024 * 1024);
         if (sizeMB > config.maxSizeMB) {
@@ -195,5 +195,63 @@ export class PDFProcessor {
             return Math.ceil((pageCount / 3) * 7000);
         }
     }
+    static async convertPDFToImages(pdfBuffer, options) {
+        const maxPages = options?.maxPages || 10;
+        const scale = options?.scale || 2.0;
+        const format = options?.format || "png";
+        const quality = options?.quality || 0.9;
+        let pdfDocument = null;
+        try {
+            const loadingTask = pdfjs.getDocument({
+                data: new Uint8Array(pdfBuffer),
+                useSystemFonts: true,
+                standardFontDataUrl: `https://cdn.jsdelivr.net/npm/pdfjs-dist@${pdfjs.version}/standard_fonts/`,
+            });
+            pdfDocument = await loadingTask.promise;
+            const numPages = Math.min(pdfDocument.numPages, maxPages);
+            const images = [];
+            logger.info(`[PDF→Image] Converting ${numPages} page(s) from PDF (total: ${pdfDocument.numPages})`);
+            for (let pageNum = 1; pageNum <= numPages; pageNum++) {
+                const page = await pdfDocument.getPage(pageNum);
+                const viewport = page.getViewport({ scale });
+                const canvas = createCanvas(viewport.width, viewport.height);
+                const context = canvas.getContext("2d");
+                await page.render({
+                    canvasContext: context,
+                    viewport,
+                    // @ts-expect-error - canvas type mismatch between node-canvas and pdfjs-dist
+                    canvas: canvas,
+                }).promise;
+                const imageBuffer = format === "png"
+                    ? canvas.toBuffer("image/png")
+                    : canvas.toBuffer("image/jpeg", { quality });
+                images.push({ buffer: imageBuffer, pageNumber: pageNum });
+                logger.debug(`[PDF→Image] ✅ Converted page ${pageNum}/${numPages} (${(imageBuffer.length / 1024).toFixed(1)}KB)`);
+            }
+            if (pdfDocument.numPages > maxPages) {
+                logger.warn(`[PDF→Image] PDF has ${pdfDocument.numPages} pages, converted only first ${maxPages} pages`);
+            }
+            logger.info(`[PDF→Image] ✅ Successfully converted ${images.length} page(s) to images`);
+            return images;
+        }
+        catch (error) {
+            logger.error(`[PDF→Image] ❌ Failed to convert PDF to images:`, error instanceof Error ? error.message : String(error));
+            throw new Error(`PDF to image conversion failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            // Ensure pdfDocument is destroyed regardless of success or failure
+            if (pdfDocument) {
+                try {
+                    pdfDocument.destroy();
+                    logger.debug("[PDF→Image] PDF document resources cleaned up");
+                }
+                catch (destroyError) {
+                    logger.warn("[PDF→Image] Error destroying PDF document:", destroyError instanceof Error
+                        ? destroyError.message
+                        : String(destroyError));
+                }
+            }
+        }
+    }
 }
 //# sourceMappingURL=pdfProcessor.js.map

package/dist/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/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/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/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/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/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 };
     }
     /**