@juspay/neurolink 6.1.0 → 6.2.1

package/dist/lib/providers/function-calling-provider.js

@@ -1,630 +0,0 @@
-/**
- * Enhanced AI Provider with Real Function Calling Support
- * Integrates MCP tools directly with AI SDK's function calling capabilities
- * This is the missing piece that enables true AI function calling!
- */
-import { generateText as aiGenerate, Output, } from "ai";
-import { getAvailableFunctionTools, executeFunctionCall, isFunctionCallingAvailable, } from "../mcp/function-calling.js";
-import { createExecutionContext } from "../mcp/context-manager.js";
-import { mcpLogger } from "../mcp/logging.js";
-import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
-/**
- * Enhanced provider that enables real function calling with MCP tools
- */
-export class FunctionCallingProvider {
-    baseProvider;
-    enableFunctionCalling;
-    sessionId;
-    userId;
-    cachedToolsObject = null;
-    cachedToolMap = null;
-    cacheTimestamp = null;
-    cacheExpiryMs;
-    constructor(baseProvider, options = {}) {
-        this.baseProvider = baseProvider;
-        this.enableFunctionCalling = options.enableFunctionCalling ?? true;
-        this.sessionId = options.sessionId || `function-calling-${Date.now()}`;
-        this.userId = options.userId || "function-calling-user";
-        // Configurable cache expiry: default 5 minutes, with environment override, then constructor option
-        const defaultExpiryMs = 5 * 60 * 1000; // 5 minutes
-        const envExpiryMs = process.env.NEUROLINK_CACHE_EXPIRY_MS
-            ? parseInt(process.env.NEUROLINK_CACHE_EXPIRY_MS, 10)
-            : undefined;
-        this.cacheExpiryMs =
-            options.cacheExpiryMs ?? envExpiryMs ?? defaultExpiryMs;
-    }
-    /**
-     * PRIMARY METHOD: Stream content using AI (recommended for new code)
-     * Future-ready for multi-modal capabilities with current text focus
-     */
-    async stream(optionsOrPrompt, analysisSchema) {
-        const functionTag = "FunctionCallingProvider.stream";
-        const startTime = Date.now();
-        // Parse parameters - support both string and options object
-        const options = typeof optionsOrPrompt === "string"
-            ? { input: { text: optionsOrPrompt } }
-            : optionsOrPrompt;
-        // Validate input
-        if (!options?.input?.text ||
-            typeof options.input.text !== "string" ||
-            options.input.text.trim() === "") {
-            throw new Error("Stream options must include input.text as a non-empty string");
-        }
-        // Use base provider's stream implementation
-        const baseResult = await this.baseProvider.stream(options);
-        if (!baseResult) {
-            throw new Error("No stream response received from provider");
-        }
-        // Return the result with function-calling metadata
-        return {
-            ...baseResult,
-            provider: "function-calling",
-            model: options.model || "unknown",
-            metadata: {
-                streamId: `function-calling-${Date.now()}`,
-                startTime,
-            },
-        };
-    }
-    /**
-     * Generate text with real function calling support
-     */
-    async generate(optionsOrPrompt, analysisSchema) {
-        const options = typeof optionsOrPrompt === "string"
-            ? { prompt: optionsOrPrompt }
-            : optionsOrPrompt;
-        const functionTag = "FunctionCallingProvider.generate";
-        // If function calling is disabled, use base provider
-        if (!this.enableFunctionCalling) {
-            mcpLogger.debug(`[${functionTag}] Function calling disabled, using base provider`);
-            const result = await this.baseProvider.generate(options, analysisSchema);
-            if (!result) {
-                return {
-                    content: "No response generated",
-                    provider: "function-calling",
-                    model: "unknown",
-                };
-            }
-            return result;
-        }
-        try {
-            // Check if function calling is available
-            const functionsAvailable = await isFunctionCallingAvailable();
-            if (!functionsAvailable) {
-                mcpLogger.debug(`[${functionTag}] No functions available, using base provider`);
-                const result = await this.baseProvider.generate(options, analysisSchema);
-                if (!result) {
-                    return {
-                        content: "No response generated",
-                        provider: "function-calling",
-                        model: "unknown",
-                    };
-                }
-                return result;
-            }
-            // Get available function tools (with automatic cache invalidation)
-            let toolsObject, toolMap;
-            const now = Date.now();
-            const isCacheExpired = this.cacheTimestamp === null ||
-                now - this.cacheTimestamp > this.cacheExpiryMs;
-            if (this.cachedToolsObject && this.cachedToolMap && !isCacheExpired) {
-                toolsObject = this.cachedToolsObject;
-                toolMap = this.cachedToolMap;
-                mcpLogger.debug(`[${functionTag}] Using cached tools (${Math.round((now - this.cacheTimestamp) / 1000)}s old)`);
-            }
-            else {
-                if (isCacheExpired && this.cachedToolsObject) {
-                    mcpLogger.debug(`[${functionTag}] Cache expired, refreshing tools`);
-                }
-                const result = await getAvailableFunctionTools();
-                toolsObject = result.toolsObject;
-                toolMap = result.toolMap;
-                // Cache the results for future use with timestamp
-                this.cachedToolsObject = toolsObject;
-                this.cachedToolMap = toolMap;
-                this.cacheTimestamp = now;
-                mcpLogger.debug(`[${functionTag}] Cached ${Object.keys(toolsObject).length} tools with expiry in ${this.cacheExpiryMs / 1000}s`);
-            }
-            const tools = Object.values(toolsObject);
-            if (tools.length === 0) {
-                mcpLogger.debug(`[${functionTag}] No tools available, using base provider`);
-                const result = await this.baseProvider.generate(options, analysisSchema);
-                if (!result) {
-                    return {
-                        content: "No response generated",
-                        provider: "function-calling",
-                        model: "unknown",
-                    };
-                }
-                return result;
-            }
-            mcpLogger.debug(`[${functionTag}] Function calling enabled with ${tools.length} tools`);
-            // Create execution context
-            const context = createExecutionContext({
-                sessionId: this.sessionId,
-                userId: this.userId,
-                aiProvider: this.baseProvider.constructor.name,
-            });
-            // Use the AI SDK's native function calling by calling generate directly
-            // We can now use the toolsObject directly instead of converting from array
-            const result = await this.generateWithToolsObject(options, toolsObject, toolMap, context, analysisSchema);
-            if (!result) {
-                return {
-                    content: "No response generated",
-                    provider: "function-calling",
-                    model: "unknown",
-                };
-            }
-            // Enhance result with function calling metadata
-            const enhancedResult = {
-                ...result,
-                functionCallingEnabled: true,
-                availableFunctions: tools.length,
-                mcpIntegration: {
-                    sessionId: this.sessionId,
-                    functionCallsSupported: true,
-                    toolsRegistered: tools.length,
-                },
-            };
-            mcpLogger.debug(`[${functionTag}] Function-calling generation completed with ${result.toolCalls?.length || 0} tool calls`);
-            return enhancedResult;
-        }
-        catch (error) {
-            mcpLogger.warn(`[${functionTag}] Function calling failed, using base provider:`, error);
-            const result = await this.baseProvider.generate(options, analysisSchema);
-            if (!result) {
-                return {
-                    content: "No response generated",
-                    provider: "function-calling",
-                    model: "unknown",
-                };
-            }
-            return result;
-        }
-    }
-    /**
-     * Generate text with tools using the AI SDK's generate function (with tools object)
-     */
-    async generateWithToolsObject(options, toolsObject, toolMap, context, analysisSchema) {
-        const functionTag = "FunctionCallingProvider.generateWithToolsObject";
-        try {
-            // Use the toolsObject directly with proper execution wrapped
-            const toolsWithExecution = this.wrapToolsWithExecution(toolsObject, toolMap, context);
-            mcpLogger.debug(`[${functionTag}] Using tools object with ${Object.keys(toolsWithExecution).length} tools`);
-            // Get the model from base provider
-            const modelInfo = await this.getModelFromProvider();
-            if (!modelInfo) {
-                mcpLogger.warn(`[${functionTag}] Could not get model from provider, falling back to base provider`);
-                const result = await this.baseProvider.generate(options, analysisSchema);
-                if (!result) {
-                    return {
-                        content: "No response generated",
-                        provider: "function-calling",
-                        model: "unknown",
-                    };
-                }
-                return result;
-            }
-            // Use AI SDK's generate directly with tools
-            const generateOptions = {
-                model: modelInfo.model,
-                prompt: options.prompt,
-                system: options.systemPrompt || "You are a helpful AI assistant.",
-                temperature: options.temperature || 0.7,
-                maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
-                tools: toolsWithExecution,
-                toolChoice: "auto", // Let the AI decide when to use tools
-                maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS, // Enable multi-turn tool execution
-            };
-            // Add experimental_output if schema is provided
-            if (analysisSchema) {
-                generateOptions.experimental_output = Output.object({
-                    schema: analysisSchema,
-                });
-            }
-            const result = await aiGenerate(generateOptions);
-            mcpLogger.debug(`[${functionTag}] AI SDK generate completed`, {
-                toolCalls: result.toolCalls?.length || 0,
-                finishReason: result.finishReason,
-                usage: result.usage,
-            });
-            return {
-                content: result.text,
-                provider: "function-calling",
-                model: "unknown",
-                usage: result.usage
-                    ? {
-                        inputTokens: result.usage.promptTokens,
-                        outputTokens: result.usage.completionTokens,
-                        totalTokens: result.usage.totalTokens,
-                    }
-                    : undefined,
-                responseTime: 0,
-                toolsUsed: result.toolCalls?.map((tc) => tc.toolName) || [],
-                toolExecutions: [],
-                enhancedWithTools: (result.toolCalls?.length || 0) > 0,
-                availableTools: [],
-            };
-        }
-        catch (error) {
-            mcpLogger.error(`[${functionTag}] Failed to generate text with tools:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Generate text using AI SDK's native function calling (legacy array-based)
-     */
-    async generateWithTools(options, tools, toolMap, context, analysisSchema) {
-        const functionTag = "FunctionCallingProvider.generateWithTools";
-        try {
-            // Convert our tools to AI SDK format with proper execution
-            const toolsWithExecution = this.convertToAISDKTools(tools, toolMap, context);
-            mcpLogger.debug(`[${functionTag}] Calling AI SDK generate with ${Object.keys(toolsWithExecution).length} tools and maxSteps: ${options.maxSteps ?? DEFAULT_MAX_STEPS}`);
-            mcpLogger.debug(`[${functionTag}] Sanitized tool names:`, Object.keys(toolsWithExecution));
-            // Log the first few tools to debug the issue
-            const toolNames = Object.keys(toolsWithExecution);
-            mcpLogger.debug(`[${functionTag}] First 5 tool names:`, toolNames.slice(0, 5));
-            // Get the model from base provider (this requires accessing the private model property)
-            // For now, we'll create the model directly based on the provider type
-            // This is a temporary solution until we have proper model access
-            const modelInfo = await this.getModelFromProvider();
-            if (!modelInfo) {
-                mcpLogger.warn(`[${functionTag}] Could not get model from provider, falling back to base provider`);
-                const result = await this.baseProvider.generate(options, analysisSchema);
-                if (!result) {
-                    return {
-                        content: "No response generated",
-                        provider: "function-calling",
-                        model: "unknown",
-                    };
-                }
-                return result;
-            }
-            // Use AI SDK's generate directly with tools
-            const generateOptions = {
-                model: modelInfo.model,
-                prompt: options.prompt,
-                system: options.systemPrompt || "You are a helpful AI assistant.",
-                temperature: options.temperature || 0.7,
-                maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
-                tools: toolsWithExecution,
-                toolChoice: "auto", // Let the AI decide when to use tools
-                maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS, // Enable multi-turn tool execution
-            };
-            // Add experimental_output if schema is provided
-            if (analysisSchema) {
-                generateOptions.experimental_output = Output.object({
-                    schema: analysisSchema,
-                });
-            }
-            const result = await aiGenerate(generateOptions);
-            mcpLogger.debug(`[${functionTag}] AI SDK generate completed`, {
-                toolCalls: result.toolCalls?.length || 0,
-                finishReason: result.finishReason,
-                usage: result.usage,
-            });
-            return {
-                content: result.text,
-                provider: "function-calling",
-                model: "unknown",
-                usage: result.usage
-                    ? {
-                        inputTokens: result.usage.promptTokens,
-                        outputTokens: result.usage.completionTokens,
-                        totalTokens: result.usage.totalTokens,
-                    }
-                    : undefined,
-                responseTime: 0,
-                toolsUsed: result.toolCalls?.map((tc) => tc.toolName) || [],
-                toolExecutions: [],
-                enhancedWithTools: (result.toolCalls?.length || 0) > 0,
-                availableTools: [],
-            };
-        }
-        catch (error) {
-            mcpLogger.error(`[${functionTag}] Failed to generate text with tools:`, error);
-            throw error;
-        }
-    }
-    /**
-     * Get the model from the base provider
-     * This is a temporary solution - ideally we'd have a getModel() method on AIProvider
-     */
-    async getModelFromProvider() {
-        const functionTag = "FunctionCallingProvider.getModelFromProvider";
-        try {
-            // Try to access the model property if it exists
-            const provider = this.baseProvider;
-            // Check if provider has a model property
-            if (provider.model) {
-                mcpLogger.debug(`[${functionTag}] Found model property on provider`);
-                return { model: provider.model };
-            }
-            // Check if provider has a getModel method
-            if (typeof provider.getModel === "function") {
-                mcpLogger.debug(`[${functionTag}] Found getModel method on provider`);
-                const model = await provider.getModel();
-                return { model: model };
-            }
-            mcpLogger.warn(`[${functionTag}] Could not find model on provider`);
-            return null;
-        }
-        catch (error) {
-            mcpLogger.error(`[${functionTag}] Error getting model from provider:`, error);
-            return null;
-        }
-    }
-    /**
-     * Sanitize tool name to comply with AI provider requirements
-     */
-    sanitizeToolName(name) {
-        // Replace any character that's not alphanumeric, underscore, dot, or dash
-        // Also ensure it starts with a letter or underscore
-        let sanitized = name.replace(/[^a-zA-Z0-9_.-]/g, "_");
-        // If it doesn't start with a letter or underscore, prepend an underscore
-        if (!/^[a-zA-Z_]/.test(sanitized)) {
-            sanitized = "_" + sanitized;
-        }
-        // Ensure it's not longer than 64 characters
-        if (sanitized.length > 64) {
-            sanitized = sanitized.substring(0, 64);
-        }
-        return sanitized;
-    }
-    /**
-     * Wrap tools with proper execution context (for object-based tools)
-     */
-    wrapToolsWithExecution(toolsObject, toolMap, context) {
-        const functionTag = "FunctionCallingProvider.wrapToolsWithExecution";
-        const wrappedTools = {};
-        for (const [toolName, tool] of Object.entries(toolsObject)) {
-            const toolInfo = toolMap.get(toolName);
-            const originalToolName = toolInfo ? toolInfo.toolName : toolName;
-            // Create a version with actual MCP execution
-            wrappedTools[toolName] = {
-                description: tool.description,
-                parameters: tool.parameters,
-                execute: async (args) => {
-                    // Debug logging only in debug mode
-                    if (process.env.NEUROLINK_DEBUG === "true") {
-                        const providerName = this.baseProvider.constructor.name;
-                        mcpLogger.debug(`Tool execution - Provider: ${providerName}`);
-                        mcpLogger.debug(`Tool: ${toolName} (original: ${originalToolName})`);
-                        mcpLogger.debug(`Args:`, args);
-                    }
-                    try {
-                        // Execute the actual MCP tool
-                        const result = await executeFunctionCall(toolName, args);
-                        if (process.env.NEUROLINK_DEBUG === "true") {
-                            mcpLogger.debug(`Tool result:`, result);
-                        }
-                        if (result.success) {
-                            return result.data || { success: true };
-                        }
-                        else {
-                            return { error: result.error || "Tool execution failed" };
-                        }
-                    }
-                    catch (error) {
-                        mcpLogger.error(`[${functionTag}] Tool execution error: ${toolName}`, error);
-                        return {
-                            error: error instanceof Error ? error.message : String(error),
-                        };
-                    }
-                },
-            };
-        }
-        return wrappedTools;
-    }
-    /**
-     * Convert our tools to AI SDK format with proper execution (legacy array-based)
-     */
-    convertToAISDKTools(tools, toolMap, context) {
-        const functionTag = "FunctionCallingProvider.convertToAISDKTools";
-        const convertedTools = {};
-        const sanitizedNameMap = new Map(); // Maps sanitized names back to original
-        // Convert the toolMap to easily access by index
-        const toolInfoArray = Array.from(toolMap.entries());
-        tools.forEach((tool, index) => {
-            // Use the actual tool name from the map for better debugging
-            const [mapKey, toolInfo] = toolInfoArray[index] || [
-                `tool_${index}`,
-                null,
-            ];
-            // Use the already sanitized mapKey instead of re-sanitizing the raw toolName
-            const sanitizedToolName = mapKey;
-            const originalToolName = toolInfo ? toolInfo.toolName : `tool_${index}`;
-            // Store the mapping for later reference
-            sanitizedNameMap.set(sanitizedToolName, originalToolName);
-            // Create a version with actual MCP execution
-            convertedTools[sanitizedToolName] = {
-                description: tool.description,
-                parameters: tool.parameters,
-                execute: async (args) => {
-                    // Debug logging only in debug mode
-                    if (process.env.NEUROLINK_DEBUG === "true") {
-                        const providerName = this.baseProvider.constructor.name;
-                        mcpLogger.debug(`Tool execution - Provider: ${providerName}`);
-                        mcpLogger.debug(`Tool: ${sanitizedToolName} (original: ${originalToolName})`);
-                        mcpLogger.debug("Args received:", args);
-                    }
-                    mcpLogger.debug(`[${functionTag}] Executing MCP tool: ${sanitizedToolName} (original: ${originalToolName}, ${toolInfo?.serverId}.${toolInfo?.toolName})`, args);
-                    try {
-                        if (toolInfo) {
-                            const mcpToolName = `${toolInfo.serverId}.${toolInfo.toolName}`;
-                            // Log execution details in debug mode only
-                            if (process.env.NEUROLINK_DEBUG === "true") {
-                                mcpLogger.debug("Calling executeFunctionCall with:", {
-                                    mcpToolName,
-                                    args,
-                                });
-                            }
-                            const result = await executeFunctionCall(mcpToolName, args, context);
-                            if (process.env.NEUROLINK_DEBUG === "true") {
-                                mcpLogger.debug("Tool execution result:", {
-                                    success: result.success,
-                                    hasData: !!result.data,
-                                    error: result.error,
-                                });
-                            }
-                            mcpLogger.debug(`[${functionTag}] Tool execution result for ${sanitizedToolName}:`, {
-                                success: result.success,
-                                hasData: !!result.data,
-                                error: result.error,
-                            });
-                            if (result.success) {
-                                return (result.data || {
-                                    success: true,
-                                    message: "Tool executed successfully",
-                                });
-                            }
-                            else {
-                                return { error: result.error || "Tool execution failed" };
-                            }
-                        }
-                        // Fallback execution - Tool info not found
-                        mcpLogger.warn(`[${functionTag}] Tool info not found for ${sanitizedToolName}, using fallback`);
-                        return { success: false, error: "Tool mapping not found" };
-                    }
-                    catch (error) {
-                        if (process.env.NEUROLINK_DEBUG === "true") {
-                            mcpLogger.debug("Tool execution error:", error);
-                        }
-                        mcpLogger.error(`[${functionTag}] Tool execution failed for ${sanitizedToolName}:`, error);
-                        return {
-                            error: error instanceof Error ? error.message : String(error),
-                        };
-                    }
-                },
-            };
-        });
-        mcpLogger.debug(`[${functionTag}] Converted ${Object.keys(convertedTools).length} tools for AI SDK:`, Object.keys(convertedTools));
-        // Log first tool details for debugging in debug mode only
-        if (process.env.NEUROLINK_DEBUG === "true") {
-            const firstToolName = Object.keys(convertedTools)[0];
-            if (firstToolName) {
-                mcpLogger.debug("First tool details:", {
-                    name: firstToolName,
-                    description: convertedTools[firstToolName].description,
-                    parameters: convertedTools[firstToolName].parameters,
-                });
-            }
-        }
-        return convertedTools;
-    }
-    /**
-     * Create function-aware system prompt
-     */
-    createFunctionAwareSystemPrompt(originalPrompt, tools) {
-        const basePrompt = originalPrompt || "You are a helpful AI assistant.";
-        if (tools.length === 0) {
-            return basePrompt;
-        }
-        const functionList = tools
-            .map((tool, index) => `${index + 1}. ${tool.description || "No description available"}`)
-            .join("\n");
-        return `${basePrompt}
-
-IMPORTANT: You have access to ${tools.length} specialized functions that can provide real-time information and capabilities:
-
-${functionList}
-
-CRITICAL INSTRUCTIONS:
-- When asked about the current time, date, or timezone, you MUST use the time/date functions
-- When asked to list files or access the filesystem, you MUST use the filesystem functions
-- When asked about system information, you MUST use the appropriate system functions
-- DO NOT say "I cannot access" or "I don't have access" - you DO have access through these functions
-- Always use available functions instead of providing placeholder or estimated information
-
-These functions provide accurate, real-time data. Use them actively to enhance your responses.`;
-    }
-    /**
-     * Alias for generate() - CLI-SDK consistency
-     */
-    /**
-     * Clear cached tools - Cache Invalidation Strategy
-     *
-     * WHEN TO CALL clearToolsCache():
-     *
-     * 1. **MCP Server Changes**: When MCP servers are added, removed, or restarted
-     *    - After calling unifiedRegistry.addServer() or removeServer()
-     *    - When MCP server configurations change
-     *    - After MCP server restart or reconnection
-     *
-     * 2. **Tool Registration Changes**: When custom tools are modified
-     *    - After registering new SDK tools via registerTool()
-     *    - When tool implementations change
-     *    - After unregistering tools
-     *
-     * 3. **Provider Reinitialization**: When the provider context changes
-     *    - Before switching between different AI providers
-     *    - When session context changes significantly
-     *    - After provider authentication refresh
-     *
-     * 4. **Error Recovery**: When tool execution encounters systematic failures
-     *    - After MCP connection errors are resolved
-     *    - When tool discovery needs to be re-run
-     *    - During error recovery workflows
-     *
-     * 5. **Development/Testing**: During development and testing cycles
-     *    - Between test cases that modify tool availability
-     *    - When testing different tool configurations
-     *    - During hot reloading scenarios
-     *
-     * CACHE LIFECYCLE:
-     * - Cache is populated on first generate() call via getAvailableFunctionTools()
-     * - Cache persists across multiple generate() calls for performance
-     * - Cache is invalidated by calling this method
-     * - Next generate() call will rebuild cache from current tool state
-     *
-     * PERFORMANCE IMPACT:
-     * - Clearing cache forces tool discovery on next usage (~100-500ms overhead)
-     * - Recommended to clear cache proactively rather than reactively
-     * - Consider batching tool changes before clearing cache
-     *
-     * THREAD SAFETY:
-     * - This method is not thread-safe
-     * - Avoid calling during active generate() operations
-     * - Safe to call between separate AI generation requests
-     */
-    clearToolsCache() {
-        this.cachedToolsObject = null;
-        this.cachedToolMap = null;
-        this.cacheTimestamp = null;
-    }
-    /**
-     * Short alias for generate() - CLI-SDK consistency
-     */
-    async gen(optionsOrPrompt, analysisSchema) {
-        return this.generate(optionsOrPrompt, analysisSchema);
-    }
-}
-/**
- * Create a function-calling enhanced version of any AI provider
- */
-export function createFunctionCallingProvider(baseProvider, options) {
-    return new FunctionCallingProvider(baseProvider, options);
-}
-/**
- * Enhanced MCP Provider Factory that creates function-calling enabled providers
- */
-export function createMCPAwareProviderV3(baseProvider, options = {}) {
-    const functionTag = "createMCPAwareProviderV3";
-    // If MCP is disabled, return base provider
-    if (options.enableMCP === false) {
-        mcpLogger.debug(`[${functionTag}] MCP disabled, returning base provider`);
-        return baseProvider;
-    }
-    // Create function-calling enhanced provider
-    const enhancedProvider = createFunctionCallingProvider(baseProvider, {
-        enableFunctionCalling: options.enableFunctionCalling,
-        sessionId: options.sessionId,
-        userId: options.userId,
-        cacheExpiryMs: options.cacheExpiryMs,
-    });
-    mcpLogger.debug(`[${functionTag}] Created MCP-aware provider with function calling`, {
-        providerName: options.providerName,
-        enableFunctionCalling: options.enableFunctionCalling !== false,
-    });
-    return enhancedProvider;
-}