@juspay/neurolink 7.37.0 → 7.38.0

package/dist/core/baseProvider.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { generateText } from "ai";
 import { MiddlewareFactory } from "../middleware/factory.js";
 import { logger } from "../utils/logger.js";
@@ -9,6 +10,7 @@ import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { buildMessagesArray, buildMultimodalMessagesArray, } from "../utils/messageBuilder.js";
 import { getKeysAsString, getKeyCount } from "../utils/transformationUtils.js";
 import { validateStreamOptions as validateStreamOpts, validateTextGenerationOptions, ValidationError, createValidationSummary, } from "../utils/parameterValidation.js";
+import { convertJsonSchemaToZod } from "../utils/schemaConversion.js";
 import { recordProviderPerformanceFromMetrics, getPerformanceOptimizedProvider, } from "./evaluationProviders.js";
 import { modelConfig } from "./modelConfiguration.js";
 /**
@@ -53,18 +55,46 @@ export class BaseProvider {
      */
     async stream(optionsOrPrompt, analysisSchema) {
         const options = this.normalizeStreamOptions(optionsOrPrompt);
+        logger.info(`Starting stream`, {
+            provider: this.providerName,
+            hasTools: !options.disableTools && this.supportsTools(),
+            disableTools: !!options.disableTools,
+            supportsTools: this.supportsTools(),
+            inputLength: options.input?.text?.length || 0,
+            maxTokens: options.maxTokens,
+            temperature: options.temperature,
+            timestamp: Date.now(),
+        });
         // CRITICAL FIX: Always prefer real streaming over fake streaming
         // Try real streaming first, use fake streaming only as fallback
         try {
+            logger.debug(`Attempting real streaming`, {
+                provider: this.providerName,
+                timestamp: Date.now(),
+            });
             const realStreamResult = await this.executeStream(options, analysisSchema);
+            logger.info(`Real streaming succeeded`, {
+                provider: this.providerName,
+                timestamp: Date.now(),
+            });
             // If real streaming succeeds, return it (with tools support via Vercel AI SDK)
             return realStreamResult;
         }
         catch (realStreamError) {
-            logger.warn(`Real streaming failed for ${this.providerName}, falling back to fake streaming:`, realStreamError);
+            logger.warn(`Real streaming failed for ${this.providerName}, falling back to fake streaming:`, {
+                error: realStreamError instanceof Error
+                    ? realStreamError.message
+                    : String(realStreamError),
+                timestamp: Date.now(),
+            });
             // Fallback to fake streaming only if real streaming fails AND tools are enabled
             if (!options.disableTools && this.supportsTools()) {
                 try {
+                    logger.info(`Starting fake streaming with tools`, {
+                        provider: this.providerName,
+                        supportsTools: this.supportsTools(),
+                        timestamp: Date.now(),
+                    });
                     // Convert stream options to text generation options
                     const textOptions = {
                         prompt: options.input?.text || "",
@@ -82,7 +112,20 @@ export class BaseProvider {
                         toolUsageContext: options.toolUsageContext,
                         context: options.context,
                     };
+                    logger.debug(`Calling generate for fake streaming`, {
+                        provider: this.providerName,
+                        maxSteps: textOptions.maxSteps,
+                        disableTools: textOptions.disableTools,
+                        timestamp: Date.now(),
+                    });
                     const result = await this.generate(textOptions, analysisSchema);
+                    logger.info(`Generate completed for fake streaming`, {
+                        provider: this.providerName,
+                        hasContent: !!result?.content,
+                        contentLength: result?.content?.length || 0,
+                        toolsUsed: result?.toolsUsed?.length || 0,
+                        timestamp: Date.now(),
+                    });
                     // Create a synthetic stream from the generate result that simulates progressive delivery
                     return {
                         stream: (async function* () {
@@ -153,285 +196,377 @@ export class BaseProvider {
         }
     }
     /**
-     * Text generation method - implements AIProvider interface
-     * Tools are always available unless explicitly disabled
-     * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
-     * for consistency and better performance
+     * Prepare generation context including tools and model
      */
-    async generate(optionsOrPrompt, _analysisSchema) {
-        const options = this.normalizeTextOptions(optionsOrPrompt);
-        // Validate options before proceeding
-        this.validateOptions(options);
-        const startTime = Date.now();
-        try {
-            // Import streamText dynamically to avoid circular dependencies
-            // Using streamText instead of generateText for unified implementation
-            // const { streamText } = await import("ai");
-            // Get ALL available tools (direct + MCP + external from options)
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const baseTools = shouldUseTools ? await this.getAllTools() : {};
-            const tools = shouldUseTools
-                ? {
-                    ...baseTools,
-                    ...(options.tools || {}), // Include external tools passed from NeuroLink
-                }
-                : {};
-            // DEBUG: Log detailed tool information for generate
-            logger.debug("BaseProvider Generate - Tool Loading Debug", {
-                provider: this.providerName,
-                shouldUseTools,
-                baseToolsProvided: !!baseTools,
-                baseToolCount: baseTools ? Object.keys(baseTools).length : 0,
-                finalToolCount: tools ? Object.keys(tools).length : 0,
-                toolNames: tools ? Object.keys(tools).slice(0, 10) : [],
-                disableTools: options.disableTools,
-                supportsTools: this.supportsTools(),
-                externalToolsCount: options.tools
-                    ? Object.keys(options.tools).length
-                    : 0,
-            });
-            if (tools && Object.keys(tools).length > 0) {
-                logger.debug("BaseProvider Generate - First 5 Tools Detail", {
-                    provider: this.providerName,
-                    tools: Object.keys(tools)
-                        .slice(0, 5)
-                        .map((name) => ({
-                        name,
-                        description: tools[name]?.description?.substring(0, 100),
-                    })),
-                });
+    async prepareGenerationContext(options) {
+        const shouldUseTools = !options.disableTools && this.supportsTools();
+        const baseTools = shouldUseTools ? await this.getAllTools() : {};
+        const tools = shouldUseTools
+            ? {
+                ...baseTools,
+                ...(options.tools || {}),
             }
-            logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}:`, {
-                directTools: getKeyCount(baseTools),
-                directToolNames: getKeysAsString(baseTools),
-                externalTools: getKeyCount(options.tools || {}),
-                externalToolNames: getKeysAsString(options.tools || {}),
-                totalTools: getKeyCount(tools),
-                totalToolNames: getKeysAsString(tools),
-            });
-            const model = await this.getAISDKModelWithMiddleware(options);
-            // Build proper message array with conversation history
-            // Check if this is a multimodal request (images or content present)
-            let messages;
-            // Type guard to check if options has multimodal input
-            const hasMultimodalInput = (opts) => {
-                const input = opts.input;
-                const hasImages = !!input?.images?.length;
-                const hasContent = !!input?.content?.length;
-                return hasImages || hasContent;
+            : {};
+        logger.debug(`Final tools prepared for AI`, {
+            provider: this.providerName,
+            directTools: getKeyCount(baseTools),
+            directToolNames: getKeysAsString(baseTools),
+            externalTools: getKeyCount(options.tools || {}),
+            externalToolNames: getKeysAsString(options.tools || {}),
+            totalTools: getKeyCount(tools),
+            totalToolNames: getKeysAsString(tools),
+            shouldUseTools,
+            timestamp: Date.now(),
+        });
+        const model = await this.getAISDKModelWithMiddleware(options);
+        return { tools, model };
+    }
+    /**
+     * Build messages array for generation
+     */
+    async buildMessages(options) {
+        const hasMultimodalInput = (opts) => {
+            const input = opts.input;
+            const hasImages = !!input?.images?.length;
+            const hasContent = !!input?.content?.length;
+            return hasImages || hasContent;
+        };
+        let messages;
+        if (hasMultimodalInput(options)) {
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                logger.debug("Detected multimodal input, using multimodal message builder");
+            }
+            const input = options.input;
+            const multimodalOptions = {
+                input: {
+                    text: options.prompt || options.input?.text || "",
+                    images: input?.images,
+                    content: input?.content,
+                },
+                provider: options.provider,
+                model: options.model,
+                temperature: options.temperature,
+                maxTokens: options.maxTokens,
+                systemPrompt: options.systemPrompt,
+                enableAnalytics: options.enableAnalytics,
+                enableEvaluation: options.enableEvaluation,
+                context: options.context,
             };
-            if (hasMultimodalInput(options)) {
-                if (process.env.NEUROLINK_DEBUG === "true") {
-                    logger.info("🖼️ [MULTIMODAL-REQUEST] Detected multimodal input, using multimodal message builder");
-                }
-                // This is a multimodal request - use multimodal message builder
-                // Convert TextGenerationOptions to GenerateOptions format for multimodal processing
-                const input = options.input;
-                const multimodalOptions = {
-                    input: {
-                        text: options.prompt || options.input?.text || "",
-                        images: input?.images,
-                        content: input?.content,
-                    },
-                    provider: options.provider,
-                    model: options.model,
-                    temperature: options.temperature,
-                    maxTokens: options.maxTokens,
-                    systemPrompt: options.systemPrompt,
-                    enableAnalytics: options.enableAnalytics,
-                    enableEvaluation: options.enableEvaluation,
-                    context: options.context,
+            messages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+        }
+        else {
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                logger.debug("No multimodal input detected, using standard message builder");
+            }
+            messages = buildMessagesArray(options);
+        }
+        // Convert messages to Vercel AI SDK format
+        return messages.map((msg) => {
+            if (typeof msg.content === "string") {
+                return {
+                    role: msg.role,
+                    content: msg.content,
                 };
-                messages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
             }
             else {
-                if (process.env.NEUROLINK_DEBUG === "true") {
-                    logger.info("📝 [TEXT-ONLY-REQUEST] No multimodal input detected, using standard message builder");
-                }
-                // Standard text-only request
-                messages = buildMessagesArray(options);
+                return {
+                    role: msg.role,
+                    content: msg.content.map((item) => {
+                        if (item.type === "text") {
+                            return { type: "text", text: item.text || "" };
+                        }
+                        else if (item.type === "image") {
+                            return { type: "image", image: item.image || "" };
+                        }
+                        return item;
+                    }),
+                };
             }
-            // Convert messages to Vercel AI SDK format
-            const aiSDKMessages = messages.map((msg) => {
-                if (typeof msg.content === "string") {
-                    // Simple text content
-                    return {
-                        role: msg.role,
-                        content: msg.content,
-                    };
-                }
-                else {
-                    // Multimodal content array - convert to Vercel AI SDK format
-                    // The Vercel AI SDK expects content to be in a specific format
-                    return {
-                        role: msg.role,
-                        content: msg.content.map((item) => {
-                            if (item.type === "text") {
-                                return { type: "text", text: item.text || "" };
-                            }
-                            else if (item.type === "image") {
-                                return { type: "image", image: item.image || "" };
-                            }
-                            return item;
-                        }),
-                    };
-                }
+        });
+    }
+    /**
+     * Execute the generation with AI SDK
+     */
+    async executeGeneration(model, messages, tools, options) {
+        const shouldUseTools = !options.disableTools && this.supportsTools();
+        return await generateText({
+            model,
+            messages,
+            tools,
+            maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+            toolChoice: shouldUseTools ? "auto" : "none",
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+            onStepFinish: ({ toolCalls, toolResults }) => {
+                logger.info("Tool execution completed", { toolResults, toolCalls });
+                // Handle tool execution storage
+                this.handleToolExecutionStorage(toolCalls, toolResults, options).catch((error) => {
+                    logger.warn("[BaseProvider] Failed to store tool executions", {
+                        provider: this.providerName,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                });
+            },
+        });
+    }
+    /**
+     * Log generation completion information
+     */
+    logGenerationComplete(generateResult) {
+        logger.debug(`generateText completed`, {
+            provider: this.providerName,
+            model: this.modelName,
+            responseLength: generateResult.text?.length || 0,
+            toolResultsCount: generateResult.toolResults?.length || 0,
+            finishReason: generateResult.finishReason,
+            usage: generateResult.usage,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Record performance metrics
+     */
+    async recordPerformanceMetrics(usage, responseTime) {
+        try {
+            const actualCost = await this.calculateActualCost(usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 });
+            recordProviderPerformanceFromMetrics(this.providerName, {
+                responseTime,
+                tokensGenerated: usage?.totalTokens || 0,
+                cost: actualCost,
+                success: true,
             });
-            const generateResult = await generateText({
-                model,
-                messages: aiSDKMessages,
-                tools,
-                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                toolChoice: shouldUseTools ? "auto" : "none",
-                temperature: options.temperature,
-                maxTokens: options.maxTokens, // No default limit - unlimited unless specified
+            const optimizedProvider = getPerformanceOptimizedProvider("speed");
+            logger.debug(`🚀 Performance recorded for ${this.providerName}:`, {
+                responseTime: `${responseTime}ms`,
+                tokens: usage?.totalTokens || 0,
+                estimatedCost: `$${actualCost.toFixed(6)}`,
+                recommendedSpeedProvider: optimizedProvider?.provider || "none",
             });
-            const responseTime = Date.now() - startTime;
-            // Extract properties from generateResult
-            const usage = generateResult.usage;
-            const toolCalls = generateResult.toolCalls;
-            const toolResults = generateResult.toolResults;
-            try {
-                const actualCost = await this.calculateActualCost(usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 });
-                recordProviderPerformanceFromMetrics(this.providerName, {
-                    responseTime,
-                    tokensGenerated: usage?.totalTokens || 0,
-                    cost: actualCost,
-                    success: true,
-                });
-                // Show what the system learned (updated to include cost)
-                const optimizedProvider = getPerformanceOptimizedProvider("speed");
-                logger.debug(`🚀 Performance recorded for ${this.providerName}:`, {
-                    responseTime: `${responseTime}ms`,
-                    tokens: usage?.totalTokens || 0,
-                    estimatedCost: `$${actualCost.toFixed(6)}`,
-                    recommendedSpeedProvider: optimizedProvider?.provider || "none",
-                });
-            }
-            catch (perfError) {
-                logger.warn("⚠️ Performance recording failed:", perfError);
-            }
-            // Extract tool names from tool calls for tracking
-            // AI SDK puts tool calls in steps array for multi-step generation
-            const toolsUsed = [];
-            // First check direct tool calls (fallback)
-            if (toolCalls && toolCalls.length > 0) {
-                toolsUsed.push(...toolCalls.map((tc) => {
-                    return tc.toolName || tc.name || "unknown";
-                }));
-            }
-            // Then check steps for tool calls (primary source for multi-step)
-            if (generateResult.steps &&
-                Array.isArray(generateResult.steps)) {
-                for (const step of generateResult
-                    .steps || []) {
-                    if (step?.toolCalls && Array.isArray(step.toolCalls)) {
-                        toolsUsed.push(...step.toolCalls.map((tc) => {
-                            return tc.toolName || tc.name || "unknown";
-                        }));
-                    }
-                }
-            }
-            // Remove duplicates
-            const uniqueToolsUsed = [...new Set(toolsUsed)];
-            // ✅ Extract tool executions from AI SDK result
-            const toolExecutions = [];
-            // Create a map of tool calls to their arguments for matching with results
+        }
+        catch (perfError) {
+            logger.warn("⚠️ Performance recording failed:", perfError);
+        }
+    }
+    /**
+     * Extract tool information from generation result
+     */
+    extractToolInformation(generateResult) {
+        const toolsUsed = [];
+        const toolExecutions = [];
+        // Extract tool names from tool calls
+        if (generateResult.toolCalls && generateResult.toolCalls.length > 0) {
+            toolsUsed.push(...generateResult.toolCalls.map((tc) => {
+                return tc.toolName || tc.name || "unknown";
+            }));
+        }
+        // Extract from steps
+        if (generateResult.steps &&
+            Array.isArray(generateResult.steps)) {
             const toolCallArgsMap = new Map();
-            // Extract tool executions from AI SDK result steps
-            if (generateResult.steps &&
-                Array.isArray(generateResult.steps)) {
-                for (const step of generateResult
-                    .steps || []) {
-                    // First, collect tool calls and their arguments
-                    if (step?.toolCalls && Array.isArray(step.toolCalls)) {
-                        for (const toolCall of step.toolCalls) {
-                            const tcRecord = toolCall;
-                            const toolName = tcRecord.toolName ||
-                                tcRecord.name ||
-                                "unknown";
-                            const toolId = tcRecord.toolCallId ||
-                                tcRecord.id ||
-                                toolName;
-                            // Extract arguments from tool call
-                            let callArgs = {};
-                            if (tcRecord.args) {
-                                callArgs = tcRecord.args;
-                            }
-                            else if (tcRecord.arguments) {
-                                callArgs = tcRecord.arguments;
-                            }
-                            else if (tcRecord.parameters) {
-                                callArgs = tcRecord.parameters;
-                            }
-                            toolCallArgsMap.set(toolId, callArgs);
-                            toolCallArgsMap.set(toolName, callArgs); // Also map by name as fallback
+            for (const step of generateResult
+                .steps || []) {
+                // Collect tool calls and their arguments
+                if (step?.toolCalls && Array.isArray(step.toolCalls)) {
+                    for (const toolCall of step.toolCalls) {
+                        const tcRecord = toolCall;
+                        const toolName = tcRecord.toolName ||
+                            tcRecord.name ||
+                            "unknown";
+                        const toolId = tcRecord.toolCallId ||
+                            tcRecord.id ||
+                            toolName;
+                        toolsUsed.push(toolName);
+                        let callArgs = {};
+                        if (tcRecord.args) {
+                            callArgs = tcRecord.args;
                         }
+                        else if (tcRecord.arguments) {
+                            callArgs = tcRecord.arguments;
+                        }
+                        else if (tcRecord.parameters) {
+                            callArgs = tcRecord.parameters;
+                        }
+                        toolCallArgsMap.set(toolId, callArgs);
+                        toolCallArgsMap.set(toolName, callArgs);
                     }
-                    // Then, process tool results and match with call arguments
-                    if (step?.toolResults && Array.isArray(step.toolResults)) {
-                        for (const toolResult of step.toolResults) {
-                            const trRecord = toolResult;
-                            const toolName = trRecord.toolName || "unknown";
-                            const toolId = trRecord.toolCallId || trRecord.id;
-                            // Try to get arguments from the tool result first
-                            let toolArgs = {};
-                            if (trRecord.args) {
-                                toolArgs = trRecord.args;
-                            }
-                            else if (trRecord.arguments) {
-                                toolArgs = trRecord.arguments;
-                            }
-                            else if (trRecord.parameters) {
-                                toolArgs = trRecord.parameters;
-                            }
-                            else if (trRecord.input) {
-                                toolArgs = trRecord.input;
-                            }
-                            else {
-                                // Fallback: get arguments from the corresponding tool call
-                                toolArgs = toolCallArgsMap.get(toolId || toolName) || {};
-                            }
-                            toolExecutions.push({
-                                name: toolName,
-                                input: toolArgs,
-                                output: trRecord.result || "success",
-                            });
+                }
+                // Process tool results
+                if (step?.toolResults && Array.isArray(step.toolResults)) {
+                    for (const toolResult of step.toolResults) {
+                        const trRecord = toolResult;
+                        const toolName = trRecord.toolName || "unknown";
+                        const toolId = trRecord.toolCallId || trRecord.id;
+                        let toolArgs = {};
+                        if (trRecord.args) {
+                            toolArgs = trRecord.args;
                         }
+                        else if (trRecord.arguments) {
+                            toolArgs = trRecord.arguments;
+                        }
+                        else if (trRecord.parameters) {
+                            toolArgs = trRecord.parameters;
+                        }
+                        else if (trRecord.input) {
+                            toolArgs = trRecord.input;
+                        }
+                        else {
+                            toolArgs = toolCallArgsMap.get(toolId || toolName) || {};
+                        }
+                        toolExecutions.push({
+                            name: toolName,
+                            input: toolArgs,
+                            output: trRecord.result || "success",
+                        });
                     }
                 }
             }
-            // Format the result with tool executions included
-            const enhancedResult = {
-                content: generateResult.text,
-                usage: {
-                    input: generateResult.usage?.promptTokens || 0,
-                    output: generateResult.usage?.completionTokens || 0,
-                    total: generateResult.usage?.totalTokens || 0,
-                },
-                provider: this.providerName,
-                model: this.modelName,
-                toolCalls: toolCalls
-                    ? toolCalls.map((tc) => ({
-                        toolCallId: tc.toolCallId || "unknown",
-                        toolName: tc.toolName || "unknown",
-                        args: tc.args || {},
-                    }))
-                    : [],
-                toolResults: toolResults || [],
-                toolsUsed: uniqueToolsUsed,
-                toolExecutions, // ✅ Add extracted tool executions
-                availableTools: Object.keys(tools).map((name) => {
-                    const tool = tools[name];
-                    return {
-                        name,
-                        description: tool.description || "No description available",
-                        parameters: tool.parameters || {},
-                        server: tool.serverId || "direct",
-                    };
-                }),
-            };
-            // Enhanced result with analytics and evaluation
+        }
+        return { toolsUsed: [...new Set(toolsUsed)], toolExecutions };
+    }
+    /**
+     * Format the enhanced result
+     */
+    formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions) {
+        return {
+            content: generateResult.text,
+            usage: {
+                input: generateResult.usage?.promptTokens || 0,
+                output: generateResult.usage?.completionTokens || 0,
+                total: generateResult.usage?.totalTokens || 0,
+            },
+            provider: this.providerName,
+            model: this.modelName,
+            toolCalls: generateResult.toolCalls
+                ? generateResult.toolCalls.map((tc) => ({
+                    toolCallId: tc.toolCallId || "unknown",
+                    toolName: tc.toolName || "unknown",
+                    args: tc.args || {},
+                }))
+                : [],
+            toolResults: generateResult.toolResults || [],
+            toolsUsed,
+            toolExecutions,
+            availableTools: Object.keys(tools).map((name) => {
+                const tool = tools[name];
+                return {
+                    name,
+                    description: tool.description || "No description available",
+                    parameters: tool.parameters || {},
+                    server: tool.serverId || "direct",
+                };
+            }),
+        };
+    }
+    /**
+     * Analyze AI response structure and log detailed debugging information
+     * Extracted from generate method to reduce complexity
+     */
+    analyzeAIResponse(result) {
+        // 🔧 NEUROLINK RAW AI RESPONSE TRACE: Log everything about the raw AI response before parameter extraction
+        logger.debug("NeuroLink Raw AI Response Analysis", {
+            provider: this.providerName,
+            model: this.modelName,
+            responseTextLength: result.text?.length || 0,
+            responsePreview: result.text?.substring(0, 500) + "...",
+            finishReason: result.finishReason,
+            usage: result.usage,
+        });
+        // 🔧 NEUROLINK TOOL CALLS ANALYSIS: Analyze raw tool calls structure
+        const toolCallsAnalysis = {
+            hasToolCalls: !!result.toolCalls,
+            toolCallsLength: result.toolCalls?.length || 0,
+            toolCalls: result.toolCalls?.map((toolCall, index) => {
+                const tcRecord = toolCall;
+                const toolName = tcRecord.toolName || tcRecord.name || "unknown";
+                const isTargetTool = toolName.toString().includes("SuccessRateSRByTime") ||
+                    toolName.toString().includes("juspay-analytics");
+                return {
+                    index: index + 1,
+                    toolName,
+                    toolId: tcRecord.toolCallId || tcRecord.id || "none",
+                    hasArgs: !!tcRecord.args,
+                    argsKeys: tcRecord.args && typeof tcRecord.args === "object"
+                        ? Object.keys(tcRecord.args)
+                        : [],
+                    isTargetTool,
+                    ...(isTargetTool && {
+                        targetToolDetails: {
+                            argsType: typeof tcRecord.args,
+                            startTime: tcRecord.args?.startTime ||
+                                "MISSING",
+                            endTime: tcRecord.args?.endTime ||
+                                "MISSING",
+                        },
+                    }),
+                };
+            }) || [],
+        };
+        logger.debug("Tool Calls Analysis", toolCallsAnalysis);
+        // 🔧 NEUROLINK STEPS ANALYSIS: Analyze steps structure (AI SDK multi-step format)
+        const steps = result.steps;
+        const stepsAnalysis = {
+            hasSteps: !!steps,
+            stepsLength: Array.isArray(steps) ? steps.length : 0,
+            steps: Array.isArray(steps)
+                ? steps.map((step, stepIndex) => ({
+                    stepIndex: stepIndex + 1,
+                    hasToolCalls: !!step.toolCalls,
+                    toolCallsLength: step.toolCalls?.length || 0,
+                    hasToolResults: !!step.toolResults,
+                    toolResultsLength: step.toolResults?.length || 0,
+                    targetToolsInStep: step.toolCalls
+                        ?.filter((tc) => {
+                        const toolName = tc.toolName || tc.name || "unknown";
+                        return (toolName.toString().includes("SuccessRateSRByTime") ||
+                            toolName.toString().includes("juspay-analytics"));
+                    })
+                        .map((tc) => ({
+                        toolName: tc.toolName || tc.name,
+                        hasArgs: !!tc.args,
+                        argsKeys: tc.args && typeof tc.args === "object"
+                            ? Object.keys(tc.args)
+                            : [],
+                        startTime: tc.args?.startTime,
+                        endTime: tc.args?.endTime,
+                    })) || [],
+                }))
+                : [],
+        };
+        logger.debug("[BaseProvider] Steps Analysis", stepsAnalysis);
+        // 🔧 NEUROLINK TOOL RESULTS ANALYSIS: Analyze top-level tool results
+        const toolResultsAnalysis = {
+            hasToolResults: !!result.toolResults,
+            toolResultsLength: result.toolResults?.length || 0,
+            toolResults: result.toolResults?.map((toolResult, index) => ({
+                index: index + 1,
+                toolName: toolResult.toolName || "unknown",
+                hasResult: !!toolResult.result,
+                hasError: !!toolResult.error,
+            })) || [],
+        };
+        logger.debug("[BaseProvider] Tool Results Analysis", toolResultsAnalysis);
+        logger.debug("[BaseProvider] NeuroLink Raw AI Response Analysis Complete");
+    }
+    /**
+     * Text generation method - implements AIProvider interface
+     * Tools are always available unless explicitly disabled
+     * IMPLEMENTATION NOTE: Uses streamText() under the hood and accumulates results
+     * for consistency and better performance
+     */
+    async generate(optionsOrPrompt, _analysisSchema) {
+        const options = this.normalizeTextOptions(optionsOrPrompt);
+        this.validateOptions(options);
+        const startTime = Date.now();
+        try {
+            const { tools, model } = await this.prepareGenerationContext(options);
+            const messages = await this.buildMessages(options);
+            const generateResult = await this.executeGeneration(model, messages, tools, options);
+            this.analyzeAIResponse(generateResult);
+            this.logGenerationComplete(generateResult);
+            const responseTime = Date.now() - startTime;
+            await this.recordPerformanceMetrics(generateResult.usage, responseTime);
+            const { toolsUsed, toolExecutions } = this.extractToolInformation(generateResult);
+            const enhancedResult = this.formatEnhancedResult(generateResult, tools, toolsUsed, toolExecutions);
             return await this.enhanceResult(enhancedResult, options, startTime);
         }
         catch (error) {
@@ -451,11 +586,12 @@ export class BaseProvider {
      * Ensures existing scripts using createAIProvider().generateText() continue to work
      */
     async generateText(options) {
-        // Validate required parameters for backward compatibility
-        if (!options.prompt ||
-            typeof options.prompt !== "string" ||
-            options.prompt.trim() === "") {
-            throw new Error("GenerateText options must include prompt as a non-empty string");
+        // Validate required parameters for backward compatibility - support both prompt and input.text
+        const promptText = options.prompt || options.input?.text;
+        if (!promptText ||
+            typeof promptText !== "string" ||
+            promptText.trim() === "") {
+            throw new Error("GenerateText options must include prompt or input.text as a non-empty string");
         }
         // Call the main generate method
         const result = await this.generate(options);
@@ -567,6 +703,7 @@ export class BaseProvider {
     }
     /**
      * 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
@@ -576,10 +713,24 @@ export class BaseProvider {
                 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";
-                throw new Error(errorMsg);
+                // 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;
@@ -593,14 +744,106 @@ export class BaseProvider {
             // Convert to AI SDK tool format
             const { tool: createAISDKTool } = await import("ai");
             const { z } = await import("zod");
+            let finalSchema;
+            const schemaSource = toolInfo.parameters || toolInfo.inputSchema;
+            if (this.isZodSchema(schemaSource)) {
+                finalSchema = schemaSource;
+                logger.debug(`[BaseProvider] ${toolName}: Using existing Zod schema from ${toolInfo.parameters ? "parameters" : "inputSchema"} field`);
+            }
+            else if (schemaSource && typeof schemaSource === "object") {
+                logger.debug(`[BaseProvider] ${toolName}: Converting JSON Schema to Zod from ${toolInfo.parameters ? "parameters" : "inputSchema"} field`);
+                finalSchema = convertJsonSchemaToZod(schemaSource);
+            }
+            else {
+                finalSchema = z.object({});
+                logger.debug(`[BaseProvider] ${toolName}: No schema found, using empty object`);
+            }
             return createAISDKTool({
                 description: toolInfo.description || `Tool ${toolName}`,
-                parameters: this.isZodSchema(toolInfo.parameters)
-                    ? toolInfo.parameters
-                    : z.object({}),
+                parameters: finalSchema,
                 execute: async (params) => {
-                    const result = await toolInfo.execute(params);
-                    return await this.convertToolResult(result);
+                    const startTime = Date.now();
+                    let executionId;
+                    if (this.neurolink?.emitToolStart) {
+                        executionId = this.neurolink.emitToolStart(toolName, params, startTime);
+                        logger.debug(`Custom tool:start emitted via NeuroLink for ${toolName}`, {
+                            toolName,
+                            executionId,
+                            input: params,
+                            hasNativeEmission: true,
+                        });
+                    }
+                    try {
+                        // 🔧 PARAMETER FLOW TRACING - Before NeuroLink executeTool call
+                        logger.debug(`About to call NeuroLink executeTool for ${toolName}`, {
+                            toolName,
+                            paramsBeforeExecution: {
+                                type: typeof params,
+                                isNull: params === null,
+                                isUndefined: params === undefined,
+                                isEmpty: params &&
+                                    typeof params === "object" &&
+                                    Object.keys(params).length === 0,
+                                keys: params && typeof params === "object"
+                                    ? Object.keys(params)
+                                    : "NOT_OBJECT",
+                                keysLength: params && typeof params === "object"
+                                    ? Object.keys(params).length
+                                    : 0,
+                            },
+                            executorInfo: {
+                                hasExecutor: typeof toolInfo.execute === "function",
+                                executorType: typeof toolInfo.execute,
+                            },
+                            timestamp: Date.now(),
+                            phase: "BEFORE_NEUROLINK_EXECUTE",
+                        });
+                        const result = await toolInfo.execute(params);
+                        // 🔧 PARAMETER FLOW TRACING - After NeuroLink executeTool call
+                        logger.debug(`NeuroLink executeTool completed for ${toolName}`, {
+                            toolName,
+                            resultInfo: {
+                                type: typeof result,
+                                isNull: result === null,
+                                isUndefined: result === undefined,
+                                hasError: result && typeof result === "object" && "error" in result,
+                            },
+                            timestamp: Date.now(),
+                            phase: "AFTER_NEUROLINK_EXECUTE",
+                        });
+                        const convertedResult = await this.convertToolResult(result);
+                        const endTime = Date.now();
+                        // 🔧 NATIVE NEUROLINK EVENT EMISSION - Tool End (Success)
+                        if (this.neurolink?.emitToolEnd) {
+                            this.neurolink.emitToolEnd(toolName, convertedResult, undefined, // no error
+                            startTime, endTime, executionId);
+                            logger.debug(`Custom tool:end emitted via NeuroLink for ${toolName}`, {
+                                toolName,
+                                executionId,
+                                duration: endTime - startTime,
+                                hasResult: convertedResult !== undefined,
+                                hasNativeEmission: true,
+                            });
+                        }
+                        return convertedResult;
+                    }
+                    catch (error) {
+                        const endTime = Date.now();
+                        const errorMsg = error instanceof Error ? error.message : String(error);
+                        // 🔧 NATIVE NEUROLINK EVENT EMISSION - Tool End (Error)
+                        if (this.neurolink?.emitToolEnd) {
+                            this.neurolink.emitToolEnd(toolName, undefined, // no result
+                            errorMsg, startTime, endTime, executionId);
+                            logger.info(`Custom tool:end error emitted via NeuroLink for ${toolName}`, {
+                                toolName,
+                                executionId,
+                                duration: endTime - startTime,
+                                error: errorMsg,
+                                hasNativeEmission: true,
+                            });
+                        }
+                        throw error;
+                    }
                 },
             });
         }
@@ -609,6 +852,85 @@ export class BaseProvider {
             return null;
         }
     }
+    /**
+     * Process direct tools with event emission wrapping
+     */
+    async processDirectTools(tools) {
+        if (!this.directTools || Object.keys(this.directTools).length === 0) {
+            return;
+        }
+        logger.debug(`Loading ${Object.keys(this.directTools).length} direct tools with event emission`);
+        for (const [toolName, directTool] of Object.entries(this.directTools)) {
+            logger.debug(`Processing direct tool: ${toolName}`, {
+                toolName,
+                hasExecute: directTool &&
+                    typeof directTool === "object" &&
+                    "execute" in directTool,
+                hasDescription: directTool &&
+                    typeof directTool === "object" &&
+                    "description" in directTool,
+            });
+            // Wrap the direct tool's execute function with event emission
+            if (directTool &&
+                typeof directTool === "object" &&
+                "execute" in directTool) {
+                const originalExecute = directTool.execute;
+                // Create a new tool with wrapped execute function
+                tools[toolName] = {
+                    ...directTool,
+                    execute: async (params) => {
+                        // 🔧 EMIT TOOL START EVENT - Bedrock-compatible format
+                        if (this.neurolink?.getEventEmitter) {
+                            const emitter = this.neurolink.getEventEmitter();
+                            emitter.emit("tool:start", { tool: toolName, input: params });
+                            logger.debug(`Direct tool:start event emitted for ${toolName}`, {
+                                toolName,
+                                input: params,
+                                hasEmitter: !!emitter,
+                            });
+                        }
+                        try {
+                            const result = await originalExecute(params);
+                            // 🔧 EMIT TOOL END EVENT - Bedrock-compatible format
+                            if (this.neurolink?.getEventEmitter) {
+                                const emitter = this.neurolink.getEventEmitter();
+                                emitter.emit("tool:end", { tool: toolName, result });
+                                logger.debug(`Direct tool:end event emitted for ${toolName}`, {
+                                    toolName,
+                                    result: typeof result === "string"
+                                        ? result.substring(0, 100)
+                                        : JSON.stringify(result).substring(0, 100),
+                                    hasEmitter: !!emitter,
+                                });
+                            }
+                            return result;
+                        }
+                        catch (error) {
+                            // 🔧 EMIT TOOL END EVENT FOR ERROR - Bedrock-compatible format
+                            if (this.neurolink?.getEventEmitter) {
+                                const emitter = this.neurolink.getEventEmitter();
+                                const errorMsg = error instanceof Error ? error.message : String(error);
+                                emitter.emit("tool:end", { tool: toolName, error: errorMsg });
+                                logger.debug(`Direct tool:end error event emitted for ${toolName}`, {
+                                    toolName,
+                                    error: errorMsg,
+                                    hasEmitter: !!emitter,
+                                });
+                            }
+                            throw error;
+                        }
+                    },
+                };
+            }
+            else {
+                // Fallback: include tool as-is if it doesn't have execute function
+                tools[toolName] = directTool;
+            }
+        }
+        logger.debug(`Direct tools processing complete`, {
+            directToolsProcessed: Object.keys(this.directTools).length,
+        });
+    }
     /**
      * Process custom tools from setupToolExecutor
      */
@@ -618,7 +940,7 @@ export class BaseProvider {
         }
         logger.debug(`[BaseProvider] Loading ${this.customTools.size} custom tools from setupToolExecutor`);
         for (const [toolName, toolDef] of this.customTools.entries()) {
-            logger.debug(`[BaseProvider] Processing custom tool: ${toolName}`, {
+            logger.debug(`Processing custom tool: ${toolName}`, {
                 toolDef: typeof toolDef,
                 hasExecute: toolDef && typeof toolDef === "object" && "execute" in toolDef,
                 hasName: toolDef && typeof toolDef === "object" && "name" in toolDef,
@@ -647,16 +969,101 @@ export class BaseProvider {
             const { tool: createAISDKTool } = await import("ai");
             return createAISDKTool({
                 description: tool.description || `External MCP tool ${tool.name}`,
-                parameters: await this.convertMCPSchemaToZod(tool.inputSchema),
+                parameters: this.createPermissiveZodSchema(),
                 execute: async (params) => {
-                    logger.debug(`[BaseProvider] Executing external MCP tool: ${tool.name}`, { params });
+                    logger.debug(`Executing external MCP tool: ${tool.name}`, {
+                        toolName: tool.name,
+                        serverId: tool.serverId,
+                        params: JSON.stringify(params),
+                        paramsType: typeof params,
+                        hasNeurolink: !!this.neurolink,
+                        hasExecuteFunction: this.neurolink &&
+                            typeof this.neurolink.executeExternalMCPTool === "function",
+                        timestamp: Date.now(),
+                    });
+                    // 🔧 EMIT TOOL START EVENT - Bedrock-compatible format
+                    if (this.neurolink?.getEventEmitter) {
+                        const emitter = this.neurolink.getEventEmitter();
+                        emitter.emit("tool:start", { tool: tool.name, input: params });
+                        logger.debug(`tool:start event emitted for ${tool.name}`, {
+                            toolName: tool.name,
+                            input: params,
+                            hasEmitter: !!emitter,
+                        });
+                    }
                     // Execute via NeuroLink's direct tool execution
                     if (this.neurolink &&
                         typeof this.neurolink.executeExternalMCPTool === "function") {
-                        return await this.neurolink.executeExternalMCPTool(tool.serverId || "unknown", tool.name, params);
+                        try {
+                            const result = await this.neurolink.executeExternalMCPTool(tool.serverId || "unknown", tool.name, params);
+                            // 🔧 EMIT TOOL END EVENT - Bedrock-compatible format
+                            if (this.neurolink?.getEventEmitter) {
+                                const emitter = this.neurolink.getEventEmitter();
+                                emitter.emit("tool:end", { tool: tool.name, result });
+                                logger.debug(`tool:end event emitted for ${tool.name}`, {
+                                    toolName: tool.name,
+                                    result: typeof result === "string"
+                                        ? result.substring(0, 100)
+                                        : JSON.stringify(result).substring(0, 100),
+                                    hasEmitter: !!emitter,
+                                });
+                            }
+                            logger.debug(`External MCP tool executed: ${tool.name}`, {
+                                toolName: tool.name,
+                                result: typeof result === "string"
+                                    ? result.substring(0, 200)
+                                    : JSON.stringify(result).substring(0, 200),
+                                resultType: typeof result,
+                                timestamp: Date.now(),
+                            });
+                            return result;
+                        }
+                        catch (mcpError) {
+                            // 🔧 EMIT TOOL END EVENT FOR ERROR - Bedrock-compatible format
+                            if (this.neurolink?.getEventEmitter) {
+                                const emitter = this.neurolink.getEventEmitter();
+                                const errorMsg = mcpError instanceof Error
+                                    ? mcpError.message
+                                    : String(mcpError);
+                                emitter.emit("tool:end", { tool: tool.name, error: errorMsg });
+                                logger.debug(`tool:end error event emitted for ${tool.name}`, {
+                                    toolName: tool.name,
+                                    error: errorMsg,
+                                    hasEmitter: !!emitter,
+                                });
+                            }
+                            logger.error(`External MCP tool failed: ${tool.name}`, {
+                                toolName: tool.name,
+                                serverId: tool.serverId,
+                                error: mcpError instanceof Error
+                                    ? mcpError.message
+                                    : String(mcpError),
+                                errorStack: mcpError instanceof Error ? mcpError.stack : undefined,
+                                params: JSON.stringify(params),
+                                timestamp: Date.now(),
+                            });
+                            throw mcpError;
+                        }
                     }
                     else {
-                        throw new Error(`Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`);
+                        const error = `Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`;
+                        // 🔧 EMIT TOOL END EVENT FOR ERROR - Bedrock-compatible format
+                        if (this.neurolink?.getEventEmitter) {
+                            const emitter = this.neurolink.getEventEmitter();
+                            emitter.emit("tool:end", { tool: tool.name, error });
+                            logger.debug(`tool:end error event emitted for ${tool.name}`, {
+                                toolName: tool.name,
+                                error,
+                                hasEmitter: !!emitter,
+                            });
+                        }
+                        logger.error(`${error}`, {
+                            toolName: tool.name,
+                            hasNeurolink: !!this.neurolink,
+                            neurolinkType: typeof this.neurolink,
+                            timestamp: Date.now(),
+                        });
+                        throw new Error(error);
                     }
                 },
             });
@@ -718,9 +1125,10 @@ export class BaseProvider {
      * MCP tools are added when available (without blocking)
      */
     async getAllTools() {
-        const tools = {
-            ...this.directTools, // Always include direct tools
-        };
+        // Start with wrapped direct tools that emit events
+        const tools = {};
+        // Wrap direct tools with event emission
+        await this.processDirectTools(tools);
         logger.debug(`[BaseProvider] getAllTools called for ${this.providerName}`, {
             neurolinkAvailable: !!this.neurolink,
             neurolinkType: typeof this.neurolink,
@@ -756,76 +1164,15 @@ export class BaseProvider {
         }
     }
     /**
-     * Convert MCP JSON Schema to Zod schema for AI SDK tools
-     * Handles common MCP schema patterns safely
+     * Create a permissive Zod schema that accepts all parameters as-is
      */
-    async convertMCPSchemaToZod(inputSchema) {
-        const { z } = await import("zod");
-        if (!inputSchema || typeof inputSchema !== "object") {
-            return z.object({});
-        }
-        try {
-            const schema = inputSchema;
-            const zodFields = {};
-            // Handle JSON Schema properties
-            if (schema.properties && typeof schema.properties === "object") {
-                const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-                for (const [propName, propDef] of Object.entries(schema.properties)) {
-                    const prop = propDef;
-                    let zodType;
-                    // Convert based on JSON Schema type
-                    switch (prop.type) {
-                        case "string":
-                            zodType = z.string();
-                            if (prop.description && typeof prop.description === "string") {
-                                zodType = zodType.describe(prop.description);
-                            }
-                            break;
-                        case "number":
-                        case "integer":
-                            zodType = z.number();
-                            if (prop.description && typeof prop.description === "string") {
-                                zodType = zodType.describe(prop.description);
-                            }
-                            break;
-                        case "boolean":
-                            zodType = z.boolean();
-                            if (prop.description && typeof prop.description === "string") {
-                                zodType = zodType.describe(prop.description);
-                            }
-                            break;
-                        case "array":
-                            zodType = z.array(z.unknown());
-                            if (prop.description && typeof prop.description === "string") {
-                                zodType = zodType.describe(prop.description);
-                            }
-                            break;
-                        case "object":
-                            zodType = z.object({});
-                            if (prop.description && typeof prop.description === "string") {
-                                zodType = zodType.describe(prop.description);
-                            }
-                            break;
-                        default:
-                            // Unknown type, use string as fallback
-                            zodType = z.string();
-                            if (prop.description && typeof prop.description === "string") {
-                                zodType = zodType.describe(prop.description);
-                            }
-                    }
-                    // Make optional if not required
-                    if (!required.has(propName)) {
-                        zodType = zodType.optional();
-                    }
-                    zodFields[propName] = zodType;
-                }
-            }
-            return getKeyCount(zodFields) > 0 ? z.object(zodFields) : z.object({});
-        }
-        catch (error) {
-            logger.warn(`Failed to convert MCP schema to Zod, using empty schema:`, error);
-            return z.object({});
-        }
+    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;
+        });
     }
     /**
      * Set session context for MCP tools
@@ -1133,6 +1480,36 @@ export class BaseProvider {
         }
         return this.defaultTimeout;
     }
+    /**
+     * Check if tool executions should be stored and handle storage
+     */
+    async handleToolExecutionStorage(toolCalls, toolResults, options) {
+        // Check if tools are not empty
+        const hasToolData = (toolCalls && toolCalls.length > 0) ||
+            (toolResults && toolResults.length > 0);
+        // Check if NeuroLink instance is available and has tool execution storage
+        const hasStorageAvailable = this.neurolink?.isToolExecutionStorageAvailable();
+        // Early return if storage is not available or no tool data
+        if (!hasStorageAvailable || !hasToolData || !this.neurolink) {
+            return;
+        }
+        const sessionId = options.context?.sessionId ||
+            options.sessionId ||
+            `session-${Date.now()}`;
+        const userId = options.context?.userId ||
+            options.userId;
+        try {
+            await this.neurolink.storeToolExecutions(sessionId, userId, toolCalls, toolResults);
+        }
+        catch (error) {
+            logger.warn("[BaseProvider] Failed to store tool executions", {
+                provider: this.providerName,
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Don't throw - tool storage failures shouldn't break generation
+        }
+    }
     /**
      * Utility method to chunk large prompts into smaller pieces
      * @param prompt The prompt to chunk