@juspay/neurolink 7.13.0 → 7.14.1

package/dist/cli/factories/commandFactory.js

@@ -288,7 +288,7 @@ export class CLICommandFactory {
         let analyticsText = "\n\n📊 Analytics:\n";
         // Provider and model info
         analyticsText += `   Provider: ${analytics.provider}`;
-        // Check for model in multiple locations: result.model, analytics.model, or any model property
+        // Check for model in multiple locations: result.model, analytics.model, or available model property
         const modelName = result.model ||
             analytics.model ||
             analytics.modelName;
@@ -703,6 +703,12 @@ export class CLICommandFactory {
                 return;
             }
             const sdk = new NeuroLink();
+            if (options.debug) {
+                logger.debug("CLI Tools configuration:", {
+                    disableTools: options.disableTools,
+                    toolsEnabled: !options.disableTools,
+                });
+            }
             const result = await sdk.generate({
                 input: { text: inputText },
                 provider: options.provider,

package/dist/cli/utils/interactiveSetup.js

@@ -146,7 +146,7 @@ export const PROVIDER_CONFIGS = [
             },
             {
                 key: "LITELLM_API_KEY",
-                prompt: "LiteLLM API Key (or any value)",
+                prompt: "LiteLLM API Key (or random value)",
                 default: "sk-anything",
                 secure: false,
                 optional: true,

package/dist/config/conversationMemoryConfig.js

@@ -34,6 +34,7 @@ export function getConversationMemoryDefaults() {
     return {
         enabled: process.env.NEUROLINK_MEMORY_ENABLED === "true",
         maxSessions: Number(process.env.NEUROLINK_MEMORY_MAX_SESSIONS) || DEFAULT_MAX_SESSIONS,
-        maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) || DEFAULT_MAX_TURNS_PER_SESSION,
+        maxTurnsPerSession: Number(process.env.NEUROLINK_MEMORY_MAX_TURNS_PER_SESSION) ||
+            DEFAULT_MAX_TURNS_PER_SESSION,
     };
 }

package/dist/context/ContextManager.js

@@ -14,7 +14,10 @@ export class ContextManager {
     constructor(generatorFunction, config, initialContext = "This is the start of the conversation.") {
         this.internalGenerator = generatorFunction;
         this.config = config;
-        const initialMessage = { role: "system", content: initialContext };
+        const initialMessage = {
+            role: "system",
+            content: initialContext,
+        };
         initialMessage.wordCount = this.config.estimateWordCount([initialMessage]);
         this.history = [initialMessage];
         this.wordCount = initialMessage.wordCount;
@@ -55,7 +58,9 @@ export class ContextManager {
             const result = await this.internalGenerator(textOptions);
             if (typeof result.content === "string" && result.content.length > 0) {
                 // Replace the history with a single system message containing the summary
-                const newHistory = [{ role: "system", content: result.content }];
+                const newHistory = [
+                    { role: "system", content: result.content },
+                ];
                 this.history = newHistory;
                 this.wordCount = this.config.estimateWordCount(this.history);
                 logger.info(`[ContextManager] Summarization complete. New history length: ${this.wordCount} words.`);
@@ -63,7 +68,10 @@ export class ContextManager {
             else {
                 logger.warn("[ContextManager] Summarization returned empty or non-string content; truncating history as a fallback.");
                 this._truncateHistory(this.config.lowWaterMarkWords);
-                this.history.unshift({ role: "system", content: ContextManager.SUMMARIZATION_EMPTY_WARNING });
+                this.history.unshift({
+                    role: "system",
+                    content: ContextManager.SUMMARIZATION_EMPTY_WARNING,
+                });
                 this.wordCount = this.config.estimateWordCount(this.history);
             }
             logger.debug(`[ContextManager] New history: ${JSON.stringify(this.history)}`);
@@ -72,7 +80,10 @@ export class ContextManager {
             logger.error("Context summarization failed:", { error });
             // Fallback strategy: truncate the history to the target word count.
             this._truncateHistory(this.config.lowWaterMarkWords);
-            this.history.unshift({ role: "system", content: ContextManager.SUMMARIZATION_FAILED_WARNING });
+            this.history.unshift({
+                role: "system",
+                content: ContextManager.SUMMARIZATION_FAILED_WARNING,
+            });
             this.wordCount = this.config.estimateWordCount(this.history);
         }
     }

package/dist/context/config.js

@@ -6,7 +6,11 @@ function estimateWordCount(history) {
     if (!history || history.length === 0) {
         return 0;
     }
-    return history.reduce((acc, msg) => acc + (msg.content.trim().split(/\s+/).filter(word => word.length > 0).length || 0), 0);
+    return history.reduce((acc, msg) => acc +
+        (msg.content
+            .trim()
+            .split(/\s+/)
+            .filter((word) => word.length > 0).length || 0), 0);
 }
 /**
  * Generates the default prompt for summarization.

package/dist/context/utils.js

@@ -4,5 +4,5 @@
  * @returns A formatted string representing the conversation.
  */
 export function formatHistoryToString(history) {
-    return history.map(msg => `${msg.role}: ${msg.content}`).join('\n\n');
+    return history.map((msg) => `${msg.role}: ${msg.content}`).join("\n\n");
 }

package/dist/core/baseProvider.d.ts

@@ -3,33 +3,8 @@ import type { Schema } from "ai";
 import type { Tool, LanguageModelV1 } from "ai";
 import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName, EvaluationData } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
-import type { JsonValue, UnknownRecord } from "../types/common.js";
-import type { ToolResult } from "../types/tools.js";
-/**
- * Interface for SDK with in-memory MCP servers
- */
-export interface NeuroLinkSDK {
-    getInMemoryServers?: () => Map<string, {
-        server: {
-            title?: string;
-            description?: string;
-            tools?: Map<string, ToolInfo> | Record<string, ToolInfo>;
-        };
-        category?: string;
-        metadata?: UnknownRecord;
-    }>;
-}
-/**
- * Interface for tool information in MCP servers
- */
-interface ToolInfo {
-    description?: string;
-    inputSchema?: ZodType<JsonValue>;
-    parameters?: ZodType<JsonValue>;
-    execute: (args: JsonValue) => Promise<JsonValue | ToolResult> | JsonValue | ToolResult;
-    isImplemented?: boolean;
-    metadata?: UnknownRecord;
-}
+import type { UnknownRecord } from "../types/common.js";
+import type { NeuroLink } from "../neurolink.js";
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -40,10 +15,12 @@ export declare abstract class BaseProvider implements AIProvider {
     protected readonly defaultTimeout: number;
     protected readonly directTools: {};
     protected mcpTools?: Record<string, Tool>;
+    protected customTools?: Map<string, unknown>;
+    protected toolExecutor?: (toolName: string, params: unknown) => Promise<unknown>;
     protected sessionId?: string;
     protected userId?: string;
-    protected sdk?: NeuroLinkSDK;
-    constructor(modelName?: string, providerName?: AIProviderName, sdk?: NeuroLinkSDK);
+    protected neurolink?: NeuroLink;
+    constructor(modelName?: string, providerName?: AIProviderName, neurolink?: NeuroLink);
     /**
      * Check if this provider supports tool/function calling
      * Override in subclasses to disable tools for specific providers or models
@@ -86,6 +63,11 @@ export declare abstract class BaseProvider implements AIProvider {
      * MCP tools are added when available (without blocking)
      */
     protected getAllTools(): Promise<Record<string, Tool>>;
+    /**
+     * Convert MCP JSON Schema to Zod schema for AI SDK tools
+     * Handles common MCP schema patterns safely
+     */
+    private convertMCPSchemaToZod;
     /**
      * Set session context for MCP tools
      */
@@ -161,4 +143,3 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     static chunkPrompt(prompt: string, maxChunkSize?: number, overlap?: number): string[];
 }
-export {};

package/dist/core/baseProvider.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { SYSTEM_LIMITS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { directAgentTools } from "../agent/directTools.js";
@@ -5,19 +6,6 @@ import { getSafeMaxTokens } from "../utils/tokenLimits.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
-/**
- * Validates if a result contains a valid toolsObject structure
- * @param result - The result object to validate
- * @returns true if the result contains a valid toolsObject, false otherwise
- */
-function isValidToolsObject(result) {
-    return (result !== null &&
-        typeof result === "object" &&
-        "toolsObject" in result &&
-        result.toolsObject !== null &&
-        typeof result.toolsObject === "object" &&
-        Object.keys(result.toolsObject).length > 0);
-}
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -31,13 +19,15 @@ export class BaseProvider {
         ? {}
         : directAgentTools;
     mcpTools; // MCP tools loaded dynamically when available
+    customTools; // Custom tools from registerTool()
+    toolExecutor; // Tool executor from setupToolExecutor
     sessionId;
     userId;
-    sdk; // Reference to NeuroLink SDK instance for custom tools
-    constructor(modelName, providerName, sdk) {
+    neurolink; // Reference to actual NeuroLink instance for MCP tools
+    constructor(modelName, providerName, neurolink) {
         this.modelName = modelName || this.getDefaultModel();
         this.providerName = providerName || this.getProviderName();
-        this.sdk = sdk;
+        this.neurolink = neurolink;
     }
     /**
      * Check if this provider supports tool/function calling
@@ -106,7 +96,7 @@ export class BaseProvider {
                                         await new Promise((resolve) => setTimeout(resolve, Math.random() * 9 + 1));
                                     }
                                 }
-                                // Yield any remaining content
+                                // Yield all remaining content
                                 if (buffer.trim()) {
                                     yield { content: buffer };
                                 }
@@ -157,10 +147,20 @@ export class BaseProvider {
         try {
             // Import generateText dynamically to avoid circular dependencies
             const { generateText } = await import("ai");
-            // Get ALL available tools (direct + MCP when available)
+            // Get ALL available tools (direct + MCP + external from options)
             const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools ? await this.getAllTools() : {};
-            logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}: ${Object.keys(tools).join(", ")}`);
+            const baseTools = shouldUseTools ? await this.getAllTools() : {};
+            const tools = shouldUseTools
+                ? {
+                    ...baseTools,
+                    ...(options.tools || {}), // Include external tools passed from NeuroLink
+                }
+                : {};
+            logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}:`, {
+                directTools: Object.keys(baseTools),
+                externalTools: Object.keys(options.tools || {}),
+                totalTools: Object.keys(tools),
+            });
             // EVERY provider uses Vercel AI SDK - no exceptions
             const model = await this.getAISDKModel(); // This method is now REQUIRED
             // Build proper message array with conversation history
@@ -201,22 +201,66 @@ export class BaseProvider {
             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
+            const toolCallArgsMap = new Map();
             // Extract tool executions from AI SDK result steps
-            // Extract tool executions from steps (where tool results are stored)
             if (result.steps &&
                 Array.isArray(result.steps)) {
                 for (const step of result.steps ||
                     []) {
-                    // Focus only on tool results (which have complete execution data)
-                    // Tool calls are just the requests, tool results contain the actual execution data
+                    // 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
+                        }
+                    }
+                    // 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: trRecord.toolName || "unknown",
-                                input: trRecord.args || {},
+                                name: toolName,
+                                input: toolArgs,
                                 output: trRecord.result || "success",
-                                duration: 0, // AI SDK doesn't track duration
                             });
                         }
                     }
@@ -248,6 +292,12 @@ export class BaseProvider {
                 toolResults: result.toolResults,
                 toolsUsed: uniqueToolsUsed,
                 toolExecutions, // ✅ Add extracted tool executions
+                availableTools: Object.keys(tools).map((name) => ({
+                    name,
+                    description: tools[name].description || "No description available",
+                    parameters: tools[name].parameters || {},
+                    server: tools[name].serverId || "direct",
+                })),
             };
             // Enhanced result with analytics and evaluation
             return await this.enhanceResult(enhancedResult, options, startTime);
@@ -274,37 +324,88 @@ export class BaseProvider {
         const tools = {
             ...this.directTools, // Always include direct tools
         };
-        logger.debug(`[BaseProvider] getAllTools called, SDK available: ${!!this.sdk}, type: ${typeof this.sdk}`);
+        logger.debug(`[BaseProvider] getAllTools called for ${this.providerName}`, {
+            neurolinkAvailable: !!this.neurolink,
+            neurolinkType: typeof this.neurolink,
+            directToolsCount: Object.keys(this.directTools).length,
+        });
         logger.debug(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
-        // Add custom tools from SDK if available
-        logger.debug(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
-        if (this.sdk && typeof this.sdk.getInMemoryServers === "function") {
-            logger.debug(`[BaseProvider] SDK check passed, loading custom tools`);
+        // Add custom tools from setupToolExecutor if available
+        if (this.customTools && this.customTools.size > 0) {
+            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}`, {
+                    toolDef: typeof toolDef,
+                    hasExecute: toolDef && typeof toolDef === "object" && "execute" in toolDef,
+                    hasName: toolDef && typeof toolDef === "object" && "name" in toolDef,
+                });
+                if (toolDef &&
+                    typeof toolDef === "object" &&
+                    "execute" in toolDef &&
+                    typeof toolDef.execute === "function") {
+                    try {
+                        const { tool: createAISDKTool } = await import("ai");
+                        const typedToolDef = toolDef;
+                        tools[toolName] = createAISDKTool({
+                            description: typedToolDef.description || `Custom tool ${toolName}`,
+                            parameters: z.object({}), // Use empty schema for custom tools
+                            execute: async (args) => {
+                                logger.debug(`[BaseProvider] Executing custom tool: ${toolName}`, { args });
+                                // Use the tool executor if available (from setupToolExecutor)
+                                if (this.toolExecutor) {
+                                    return await this.toolExecutor(toolName, args);
+                                }
+                                else {
+                                    return await typedToolDef.execute(args);
+                                }
+                            },
+                        });
+                        logger.debug(`[BaseProvider] Successfully added custom tool: ${toolName}`);
+                    }
+                    catch (error) {
+                        logger.error(`[BaseProvider] Failed to add custom tool: ${toolName}`, error);
+                    }
+                }
+                else {
+                    logger.warn(`[BaseProvider] Invalid custom tool format: ${toolName}`, {
+                        toolDef: typeof toolDef,
+                        hasExecute: toolDef && typeof toolDef === "object" && "execute" in toolDef,
+                        executeType: toolDef && typeof toolDef === "object" && "execute" in toolDef
+                            ? typeof toolDef.execute
+                            : "N/A",
+                    });
+                }
+            }
+        }
+        // Add custom tools from NeuroLink if available
+        logger.debug(`[BaseProvider] Checking NeuroLink: ${!!this.neurolink}, has getInMemoryServers: ${this.neurolink && typeof this.neurolink.getInMemoryServers}`);
+        if (this.neurolink &&
+            typeof this.neurolink.getInMemoryServers === "function") {
+            logger.debug(`[BaseProvider] NeuroLink check passed, loading custom tools`);
             try {
-                const inMemoryServers = this.sdk.getInMemoryServers();
+                const inMemoryServers = this.neurolink.getInMemoryServers();
                 logger.debug(`[BaseProvider] Got servers:`, inMemoryServers.size);
                 logger.debug(`[BaseProvider] Loading custom tools from SDK, found ${inMemoryServers.size} servers`);
                 if (inMemoryServers && inMemoryServers.size > 0) {
                     // Convert in-memory server tools to AI SDK format
                     for (const [serverId, serverConfig] of inMemoryServers) {
-                        const server = serverConfig.server;
-                        if (server && server.tools) {
-                            // Handle both Map and object formats
-                            const toolEntries = server.tools instanceof Map
-                                ? Array.from(server.tools.entries())
-                                : Object.entries(server.tools || {});
+                        if (serverConfig && serverConfig.tools) {
+                            // Handle tools array from MCPServerInfo
+                            const toolEntries = serverConfig.tools.map((tool) => [
+                                tool.name,
+                                tool,
+                            ]);
                             for (const [toolName, toolInfo] of toolEntries) {
                                 if (toolInfo && typeof toolInfo.execute === "function") {
                                     logger.debug(`[BaseProvider] Converting custom tool: ${toolName}`);
                                     try {
                                         // Convert to AI SDK tool format
                                         const { tool: createAISDKTool } = await import("ai");
-                                        const { z } = await import("zod");
                                         tools[toolName] = createAISDKTool({
                                             description: toolInfo.description || `Tool ${toolName}`,
-                                            parameters: toolInfo.inputSchema ||
-                                                toolInfo.parameters ||
-                                                z.object({}),
+                                            parameters: toolInfo.parameters instanceof z.ZodType
+                                                ? toolInfo.parameters
+                                                : z.object({}),
                                             execute: async (args) => {
                                                 const result = await toolInfo.execute(args);
                                                 // Handle MCP-style results
@@ -339,6 +440,54 @@ export class BaseProvider {
                 // Not an error - custom tools are optional
             }
         }
+        if (this.neurolink &&
+            typeof this.neurolink.getExternalMCPTools === "function") {
+            try {
+                logger.debug(`[BaseProvider] Loading external MCP tools from NeuroLink via direct tool access`);
+                const externalTools = this.neurolink.getExternalMCPTools() || [];
+                logger.debug(`[BaseProvider] Found ${externalTools.length} external MCP tools`);
+                for (const tool of externalTools) {
+                    logger.debug(`[BaseProvider] Converting external MCP tool: ${tool.name}`);
+                    try {
+                        // Convert to AI SDK tool format
+                        const { tool: createAISDKTool } = await import("ai");
+                        tools[tool.name] = createAISDKTool({
+                            description: tool.description || `External MCP tool ${tool.name}`,
+                            parameters: await this.convertMCPSchemaToZod(tool.inputSchema),
+                            execute: async (args) => {
+                                logger.debug(`[BaseProvider] Executing external MCP tool: ${tool.name}`, { args });
+                                // 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, args);
+                                }
+                                else {
+                                    throw new Error(`Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`);
+                                }
+                            },
+                        });
+                        logger.debug(`[BaseProvider] Successfully added external MCP tool: ${tool.name}`);
+                    }
+                    catch (toolCreationError) {
+                        logger.error(`Failed to create external MCP tool: ${tool.name}`, toolCreationError);
+                    }
+                }
+                logger.debug(`[BaseProvider] External MCP tools loading complete`, {
+                    totalToolsAdded: externalTools.length,
+                });
+            }
+            catch (error) {
+                logger.error(`[BaseProvider] Failed to load external MCP tools for ${this.providerName}:`, error);
+                // Not an error - external tools are optional
+            }
+        }
+        else {
+            logger.debug(`[BaseProvider] No external MCP tool interface available`, {
+                hasNeuroLink: !!this.neurolink,
+                hasGetExternalMCPTools: this.neurolink &&
+                    typeof this.neurolink.getExternalMCPTools === "function",
+            });
+        }
         // MCP tools loading simplified - removed functionCalling dependency
         if (!this.mcpTools) {
             // Set empty tools object - MCP tools are handled at a higher level
@@ -351,6 +500,80 @@ export class BaseProvider {
         logger.debug(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
         return tools;
     }
+    /**
+     * Convert MCP JSON Schema to Zod schema for AI SDK tools
+     * Handles common MCP schema patterns safely
+     */
+    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) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "number":
+                        case "integer":
+                            zodType = z.number();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "boolean":
+                            zodType = z.boolean();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "array":
+                            zodType = z.array(z.unknown());
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "object":
+                            zodType = z.object({});
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        default:
+                            // Unknown type, use string as fallback
+                            zodType = z.string();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                    }
+                    // Make optional if not required
+                    if (!required.has(propName)) {
+                        zodType = zodType.optional();
+                    }
+                    zodFields[propName] = zodType;
+                }
+            }
+            return Object.keys(zodFields).length > 0
+                ? z.object(zodFields)
+                : z.object({});
+        }
+        catch (error) {
+            logger.warn(`Failed to convert MCP schema to Zod, using empty schema:`, error);
+            return z.object({});
+        }
+    }
     /**
      * Set session context for MCP tools
      */
@@ -490,6 +713,9 @@ export class BaseProvider {
             });
             return;
         }
+        // Store custom tools for use in getAllTools()
+        this.customTools = sdk.customTools;
+        this.toolExecutor = sdk.executeTool;
         logger.debug(`[${functionTag}] Setting up tool executor for provider`, {
             providerType: this.constructor.name,
             availableCustomTools: sdk.customTools.size,

package/dist/core/conversationMemoryManager.js

@@ -3,7 +3,7 @@
  * Handles in-memory conversation storage, session management, and context injection
  */
 import { ConversationMemoryError } from "../types/conversationTypes.js";
-import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN } from "../config/conversationMemoryConfig.js";
+import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemoryConfig.js";
 import { logger } from "../utils/logger.js";
 export class ConversationMemoryManager {
     sessions = new Map();
@@ -49,7 +49,8 @@ export class ConversationMemoryManager {
             session.messages.push({ role: "user", content: userMessage }, { role: "assistant", content: aiResponse });
             session.lastActivity = Date.now();
             // Enforce per-session turn limit (each turn = MESSAGES_PER_TURN messages: user + assistant)
-            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) * MESSAGES_PER_TURN;
+            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) *
+                MESSAGES_PER_TURN;
             if (session.messages.length > maxMessages) {
                 session.messages = session.messages.slice(-maxMessages);
             }