@juspay/neurolink 5.2.0 → 5.3.0

package/CHANGELOG.md

@@ -1,9 +1,15 @@
-# [5.2.0](https://github.com/juspay/neurolink/compare/v5.1.0...v5.2.0) (2025-07-22)
+# [5.3.0](https://github.com/juspay/neurolink/compare/v5.2.0...v5.3.0) (2025-07-23)
+
+
+### Features
+
+* **mcp:** enhance MCP integration with comprehensive testing infrastructure and tool ecosystem improvements ([a38d845](https://github.com/juspay/neurolink/commit/a38d845032133eee098de10b966cbdd3a329fdfd))
 
+# [5.2.0](https://github.com/juspay/neurolink/compare/v5.1.0...v5.2.0) (2025-07-22)
 
 ### Features
 
-* **core:** implement comprehensive factory pattern architecture with full MCP integration and provider unification ([b13963a](https://github.com/juspay/neurolink/commit/b13963aaf6f95233be8b1e9bdc69ce1b65604cdf))
+- **core:** implement comprehensive factory pattern architecture with full MCP integration and provider unification ([b13963a](https://github.com/juspay/neurolink/commit/b13963aaf6f95233be8b1e9bdc69ce1b65604cdf))
 
 # [5.1.0](https://github.com/juspay/neurolink/compare/v5.0.0...v5.1.0) (2025-07-13)
 

package/dist/cli/factories/command-factory.js

@@ -1,6 +1,7 @@
 import { NeuroLink } from "../../lib/neurolink.js";
 import ora from "ora";
 import chalk from "chalk";
+import { logger } from "../../lib/utils/logger.js";
 /**
  * CLI Command Factory for generate commands
  */
@@ -161,14 +162,14 @@ export class CLICommandFactory {
                 console.log(result.content);
             }
             if (argv.debug) {
-                console.log("\n" + chalk.yellow("Debug Information:"));
-                console.log("Provider:", result.provider);
-                console.log("Model:", result.model);
+                logger.debug("\n" + chalk.yellow("Debug Information:"));
+                logger.debug("Provider:", result.provider);
+                logger.debug("Model:", result.model);
                 if (result.analytics) {
-                    console.log("Analytics:", JSON.stringify(result.analytics, null, 2));
+                    logger.debug("Analytics:", JSON.stringify(result.analytics, null, 2));
                 }
                 if (result.evaluation) {
-                    console.log("Evaluation:", JSON.stringify(result.evaluation, null, 2));
+                    logger.debug("Evaluation:", JSON.stringify(result.evaluation, null, 2));
                 }
             }
             // Exit successfully

package/dist/core/base-provider.js

@@ -4,6 +4,18 @@ import { directAgentTools } from "../agent/direct-tools.js";
 // import { evaluateResponse } from "../core/evaluation.js";
 // import { getAvailableFunctionTools } from "../mcp/function-calling.js";
 // Analytics helper will be dynamically imported when needed
+/**
+ * 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 &&
+        typeof result === "object" &&
+        result.toolsObject &&
+        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
@@ -170,16 +182,16 @@ export class BaseProvider {
         const tools = {
             ...this.directTools, // Always include direct tools
         };
-        logger.info(`[BaseProvider] getAllTools called, SDK available: ${!!this.sdk}, type: ${typeof this.sdk}`);
-        console.log(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
+        logger.debug(`[BaseProvider] getAllTools called, SDK available: ${!!this.sdk}, type: ${typeof this.sdk}`);
+        logger.debug(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
         // Add custom tools from SDK if available
-        console.log(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
+        logger.debug(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
         if (this.sdk &&
             typeof this.sdk.getInMemoryServers === "function") {
-            console.log(`[BaseProvider] SDK check passed, loading custom tools`);
+            logger.debug(`[BaseProvider] SDK check passed, loading custom tools`);
             try {
                 const inMemoryServers = this.sdk.getInMemoryServers();
-                console.log(`[BaseProvider] Got servers:`, inMemoryServers.size);
+                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
@@ -192,7 +204,7 @@ export class BaseProvider {
                                 : Object.entries(server.tools || {});
                             for (const [toolName, toolInfo] of toolEntries) {
                                 if (toolInfo && typeof toolInfo.execute === "function") {
-                                    console.log(`[BaseProvider] Converting custom tool: ${toolName}`);
+                                    logger.debug(`[BaseProvider] Converting custom tool: ${toolName}`);
                                     // Convert to AI SDK tool format
                                     const { tool: createAISDKTool } = await import("ai");
                                     const { z } = await import("zod");
@@ -233,12 +245,11 @@ export class BaseProvider {
             try {
                 const { getAvailableFunctionTools } = await import("../mcp/function-calling.js");
                 const result = await getAvailableFunctionTools();
-                if (result.tools && result.tools.length > 0) {
-                    this.mcpTools = {};
-                    for (const tool of result.tools) {
-                        const toolName = tool.name || "unknown";
-                        this.mcpTools[toolName] = tool;
-                    }
+                if (isValidToolsObject(result)) {
+                    this.mcpTools = result.toolsObject;
+                }
+                else {
+                    logger.debug(`Invalid or empty toolsObject for ${this.providerName}: Expected an object with at least one key, but got ${typeof result.toolsObject} with ${result.toolsObject ? Object.keys(result.toolsObject).length : 0} keys. Full result:`, result);
                 }
             }
             catch (error) {
@@ -250,7 +261,7 @@ export class BaseProvider {
         if (this.mcpTools) {
             Object.assign(tools, this.mcpTools);
         }
-        console.log(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
+        logger.debug(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
         return tools;
     }
     /**

package/dist/core/constants.d.ts

@@ -5,6 +5,7 @@
 export declare const DEFAULT_MAX_TOKENS = 8192;
 export declare const DEFAULT_TEMPERATURE = 0.7;
 export declare const DEFAULT_TIMEOUT = 30000;
+export declare const DEFAULT_MAX_STEPS = 5;
 export declare const DEFAULT_EVALUATION_MAX_TOKENS = 500;
 export declare const DEFAULT_ANALYSIS_MAX_TOKENS = 800;
 export declare const DEFAULT_DOCUMENTATION_MAX_TOKENS = 12000;

package/dist/core/constants.js

@@ -6,6 +6,7 @@
 export const DEFAULT_MAX_TOKENS = 8192; // Changed from 10000 to fix Anthropic error
 export const DEFAULT_TEMPERATURE = 0.7;
 export const DEFAULT_TIMEOUT = 30000;
+export const DEFAULT_MAX_STEPS = 5; // Default multi-turn tool execution steps
 // Specialized Use Case Defaults
 export const DEFAULT_EVALUATION_MAX_TOKENS = 500; // Keep evaluation fast
 export const DEFAULT_ANALYSIS_MAX_TOKENS = 800; // For analysis tools

package/dist/lib/core/base-provider.js

@@ -4,6 +4,18 @@ import { directAgentTools } from "../agent/direct-tools.js";
 // import { evaluateResponse } from "../core/evaluation.js";
 // import { getAvailableFunctionTools } from "../mcp/function-calling.js";
 // Analytics helper will be dynamically imported when needed
+/**
+ * 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 &&
+        typeof result === "object" &&
+        result.toolsObject &&
+        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
@@ -170,16 +182,16 @@ export class BaseProvider {
         const tools = {
             ...this.directTools, // Always include direct tools
         };
-        logger.info(`[BaseProvider] getAllTools called, SDK available: ${!!this.sdk}, type: ${typeof this.sdk}`);
-        console.log(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
+        logger.debug(`[BaseProvider] getAllTools called, SDK available: ${!!this.sdk}, type: ${typeof this.sdk}`);
+        logger.debug(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
         // Add custom tools from SDK if available
-        console.log(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
+        logger.debug(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
         if (this.sdk &&
             typeof this.sdk.getInMemoryServers === "function") {
-            console.log(`[BaseProvider] SDK check passed, loading custom tools`);
+            logger.debug(`[BaseProvider] SDK check passed, loading custom tools`);
             try {
                 const inMemoryServers = this.sdk.getInMemoryServers();
-                console.log(`[BaseProvider] Got servers:`, inMemoryServers.size);
+                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
@@ -192,7 +204,7 @@ export class BaseProvider {
                                 : Object.entries(server.tools || {});
                             for (const [toolName, toolInfo] of toolEntries) {
                                 if (toolInfo && typeof toolInfo.execute === "function") {
-                                    console.log(`[BaseProvider] Converting custom tool: ${toolName}`);
+                                    logger.debug(`[BaseProvider] Converting custom tool: ${toolName}`);
                                     // Convert to AI SDK tool format
                                     const { tool: createAISDKTool } = await import("ai");
                                     const { z } = await import("zod");
@@ -233,12 +245,11 @@ export class BaseProvider {
             try {
                 const { getAvailableFunctionTools } = await import("../mcp/function-calling.js");
                 const result = await getAvailableFunctionTools();
-                if (result.tools && result.tools.length > 0) {
-                    this.mcpTools = {};
-                    for (const tool of result.tools) {
-                        const toolName = tool.name || "unknown";
-                        this.mcpTools[toolName] = tool;
-                    }
+                if (isValidToolsObject(result)) {
+                    this.mcpTools = result.toolsObject;
+                }
+                else {
+                    logger.debug(`Invalid or empty toolsObject for ${this.providerName}: Expected an object with at least one key, but got ${typeof result.toolsObject} with ${result.toolsObject ? Object.keys(result.toolsObject).length : 0} keys. Full result:`, result);
                 }
             }
             catch (error) {
@@ -250,7 +261,7 @@ export class BaseProvider {
         if (this.mcpTools) {
             Object.assign(tools, this.mcpTools);
         }
-        console.log(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
+        logger.debug(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
         return tools;
     }
     /**

package/dist/lib/core/constants.d.ts

@@ -5,6 +5,7 @@
 export declare const DEFAULT_MAX_TOKENS = 8192;
 export declare const DEFAULT_TEMPERATURE = 0.7;
 export declare const DEFAULT_TIMEOUT = 30000;
+export declare const DEFAULT_MAX_STEPS = 5;
 export declare const DEFAULT_EVALUATION_MAX_TOKENS = 500;
 export declare const DEFAULT_ANALYSIS_MAX_TOKENS = 800;
 export declare const DEFAULT_DOCUMENTATION_MAX_TOKENS = 12000;

package/dist/lib/core/constants.js

@@ -6,6 +6,7 @@
 export const DEFAULT_MAX_TOKENS = 8192; // Changed from 10000 to fix Anthropic error
 export const DEFAULT_TEMPERATURE = 0.7;
 export const DEFAULT_TIMEOUT = 30000;
+export const DEFAULT_MAX_STEPS = 5; // Default multi-turn tool execution steps
 // Specialized Use Case Defaults
 export const DEFAULT_EVALUATION_MAX_TOKENS = 500; // Keep evaluation fast
 export const DEFAULT_ANALYSIS_MAX_TOKENS = 800; // For analysis tools

package/dist/lib/mcp/client.d.ts

@@ -33,6 +33,7 @@ export declare class NeuroLinkMCPClient extends EventEmitter {
      * Get all registered tools
      */
     getTools(): Record<string, {
+        name: string;
         description?: string;
         inputSchema?: unknown;
     }>;

package/dist/lib/mcp/client.js

@@ -130,6 +130,7 @@ export class NeuroLinkMCPClient extends EventEmitter {
         const tools = {};
         for (const [name, tool] of this.tools) {
             tools[name] = {
+                name: name, // Include the tool name as a property
                 description: tool.description,
                 inputSchema: tool.inputSchema,
             };

package/dist/lib/mcp/context-manager.d.ts

@@ -29,6 +29,7 @@ export interface ContextRequest {
 export declare class ContextManager {
     private sessionCounter;
     private activeContexts;
+    private static cachedLogger;
     /**
      * Create a new execution context with rich information
      *

package/dist/lib/mcp/context-manager.js

@@ -10,6 +10,7 @@
 export class ContextManager {
     sessionCounter = 0;
     activeContexts = new Map();
+    static cachedLogger = null;
     /**
      * Create a new execution context with rich information
      *
@@ -64,6 +65,7 @@ export class ContextManager {
             },
             path: {
                 join: (...paths) => {
+                    // Use dynamic require for synchronous path operations
                     const path = require("path");
                     return path.join(...paths);
                 },
@@ -85,11 +87,13 @@ export class ContextManager {
                 },
             },
             grantedPermissions: request.permissions || [],
-            log: (level, message, data) => {
-                // Use logger if available, otherwise console
+            log: async (level, message, data) => {
+                // Use cached logger if available, otherwise import and cache
                 try {
-                    const { logger } = require("../utils/logger.js");
-                    logger[level](message, data);
+                    if (!ContextManager.cachedLogger) {
+                        ContextManager.cachedLogger = await import("../utils/logger.js").then(({ logger }) => logger);
+                    }
+                    ContextManager.cachedLogger[level](message, data);
                 }
                 catch {
                     console[level === "debug" ? "log" : level](message, data);

package/dist/lib/mcp/function-calling.d.ts

@@ -14,6 +14,7 @@ export declare function mcpToolToAISDKTool(tool: NeuroLinkMCPTool, serverId: str
  */
 export declare function getAvailableFunctionTools(): Promise<{
     tools: Tool[];
+    toolsObject: Record<string, Tool>;
     toolMap: Map<string, {
         serverId: string;
         toolName: string;
@@ -49,3 +50,15 @@ export declare function getFunctionToolsForCategory(category?: string, maxTools?
  * Check if function calling is available
  */
 export declare function isFunctionCallingAvailable(): Promise<boolean>;
+/**
+ * Utility function to create a named tool object for debugging
+ */
+export declare function createNamedTool(name: string, toolDef: any): any & {
+    name: string;
+};
+/**
+ * Get tools with proper name properties for debugging
+ */
+export declare function getToolsWithNames(): Promise<Record<string, any & {
+    name: string;
+}>>;

package/dist/lib/mcp/function-calling.js

@@ -8,6 +8,100 @@ import { z } from "zod";
 import { unifiedRegistry } from "./unified-registry.js";
 import { createExecutionContext } from "./context-manager.js";
 import { mcpLogger } from "./logging.js";
+/**
+ * Parses neurolink-specific function name patterns to extract the server ID and tool name.
+ *
+ * @param {string[]} parts - An array of strings representing parts of a function name,
+ * typically obtained by splitting the function name on underscores.
+ * @returns {{ serverId: string; toolName: string } | null} An object containing the `serverId`
+ * and `toolName` if the input matches a neurolink-specific pattern, or `null` if no match is found.
+ *
+ * @example
+ * // Returns { serverId: "neurolink_ai_core", toolName: "generate" }
+ * parseNeuroLinkPattern(["neurolink", "ai", "core", "generate"]);
+ *
+ * @example
+ * // Returns { serverId: "neurolink_utility", toolName: "format_number" }
+ * parseNeuroLinkPattern(["neurolink", "utility", "format_number"]);
+ *
+ * @example
+ * // Returns null
+ * parseNeuroLinkPattern(["other", "pattern"]);
+ */
+function parseNeuroLinkPattern(parts) {
+    if (parts.length >= 3 &&
+        parts[0] === "neurolink" &&
+        (parts[1] === "ai" || parts[1] === "utility")) {
+        // neurolink_ai_core_generate -> serverId: "neurolink_ai_core", toolName: "generate"
+        // neurolink_utility_format_number -> serverId: "neurolink_utility", toolName: "format_number"
+        if (parts[1] === "ai" && parts[2] === "core") {
+            return {
+                serverId: "neurolink_ai_core",
+                toolName: parts.slice(3).join("_"),
+            };
+        }
+        else if (parts[1] === "utility") {
+            return {
+                serverId: "neurolink_utility",
+                toolName: parts.slice(2).join("_"),
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Parse underscore-separated function name format
+ */
+function parseUnderscoreFormat(functionName) {
+    const parts = functionName.split("_");
+    if (parts.length >= 2) {
+        // Try neurolink-specific patterns first
+        const neurolinkResult = parseNeuroLinkPattern(parts);
+        if (neurolinkResult) {
+            return neurolinkResult;
+        }
+        // Default underscore parsing
+        return {
+            serverId: parts[0],
+            toolName: parts.slice(1).join("_"),
+        };
+    }
+    return null;
+}
+/**
+ * Parse dot-separated function name format (legacy support)
+ */
+function parseDotFormat(functionName) {
+    const parts = functionName.split(".");
+    if (parts.length >= 2) {
+        return {
+            serverId: parts[0],
+            toolName: parts.slice(1).join("."),
+        };
+    }
+    return null;
+}
+/**
+ * Parse function name to extract server ID and tool name
+ * Handles various naming patterns including neurolink server patterns
+ */
+function parseFunctionName(functionName) {
+    // Try underscore format first (most common)
+    const underscoreResult = parseUnderscoreFormat(functionName);
+    if (underscoreResult) {
+        return underscoreResult;
+    }
+    // Fallback to dot format for backward compatibility
+    const dotResult = parseDotFormat(functionName);
+    if (dotResult) {
+        return dotResult;
+    }
+    // Final fallback - return as-is with unknown server
+    return {
+        serverId: "unknown",
+        toolName: functionName,
+    };
+}
 /**
  * Convert MCP tool to AI SDK function definition
  */
@@ -55,6 +149,7 @@ export function mcpToolToAISDKTool(tool, serverId) {
 export async function getAvailableFunctionTools() {
     const functionTag = "getAvailableFunctionTools";
     const tools = [];
+    const toolsObject = {};
     const toolMap = new Map();
     try {
         // Add overall timeout for the entire function
@@ -281,6 +376,8 @@ export async function getAvailableFunctionTools() {
                             },
                         });
                         tools.push(aiTool);
+                        // Store tool with proper name association
+                        toolsObject[functionName] = aiTool;
                         // Store mapping for execution - CRITICAL: Use sanitized functionName as key
                         toolMap.set(functionName, {
                             serverId: typeof toolInfo.serverId === "string"
@@ -302,7 +399,7 @@ export async function getAvailableFunctionTools() {
                 if (overallTimeoutId) {
                     clearTimeout(overallTimeoutId);
                 }
-                return { tools, toolMap };
+                return { tools, toolsObject, toolMap };
             }
             catch (error) {
                 if (overallTimeoutId) {
@@ -315,7 +412,7 @@ export async function getAvailableFunctionTools() {
     }
     catch (error) {
         mcpLogger.error(`[${functionTag}] Error getting function tools:`, error);
-        return { tools: [], toolMap: new Map() };
+        return { tools: [], toolsObject: {}, toolMap: new Map() };
     }
 }
 /**
@@ -345,38 +442,12 @@ export async function executeFunctionCall(functionName, parameters, context) {
             });
         }
         // Parse server and tool name from function name
-        // First try underscore format (sanitized), then fallback to dot format
-        let parts = functionName.split("_");
-        let serverId = "unknown";
-        let toolName = functionName;
-        if (parts.length >= 2) {
-            // Handle underscore format (sanitized names)
-            const firstPart = parts[0];
-            if (firstPart && typeof firstPart === "string" && firstPart.length > 0) {
-                serverId = firstPart;
-            }
-            else {
-                serverId = "unknown";
-            }
-            toolName = parts.slice(1).join("_"); // Rejoin in case tool name had underscores
-        }
-        else {
-            // Fallback to dot format for backward compatibility
-            parts = functionName.split(".");
-            if (parts.length === 2) {
-                const parsedServerId = parts[0];
-                const parsedToolName = parts[1];
-                if (parsedServerId && parsedToolName) {
-                    serverId = parsedServerId;
-                    toolName = parsedToolName;
-                }
-            }
-            else {
-                // Can't parse - try executing as-is through unified registry
-                mcpLogger.debug(`[${functionTag}] Cannot parse function name format: ${functionName}, trying unified registry`);
-                const result = await unifiedRegistry.executeTool(functionName, actualParameters, finalContext);
-                return result;
-            }
+        const { serverId, toolName } = parseFunctionName(functionName);
+        if (serverId === "unknown") {
+            // Can't parse - try executing as-is through unified registry
+            mcpLogger.debug(`[${functionTag}] Cannot parse function name format: ${functionName}, trying unified registry`);
+            const result = await unifiedRegistry.executeTool(functionName, actualParameters, finalContext);
+            return result;
         }
         // Handle built-in NeuroLink servers directly
         if (serverId === "neurolink-utility" ||
@@ -541,3 +612,31 @@ export async function isFunctionCallingAvailable() {
         return false;
     }
 }
+/**
+ * Utility function to create a named tool object for debugging
+ */
+export function createNamedTool(name, toolDef) {
+    return {
+        name,
+        description: toolDef.description,
+        parameters: toolDef.parameters,
+        execute: toolDef.execute,
+    };
+}
+/**
+ * Get tools with proper name properties for debugging
+ */
+export async function getToolsWithNames() {
+    try {
+        const { toolsObject } = await getAvailableFunctionTools();
+        const namedTools = {};
+        for (const [name, tool] of Object.entries(toolsObject)) {
+            namedTools[name] = createNamedTool(name, tool);
+        }
+        return namedTools;
+    }
+    catch (error) {
+        mcpLogger.warn("[getToolsWithNames] Failed to get tools with names:", error);
+        return {};
+    }
+}

package/dist/lib/mcp/neurolink-mcp-client.d.ts

@@ -70,6 +70,7 @@ export declare class NeuroLinkMCPClient extends EventEmitter {
      * Get registered tools
      */
     getTools(): Record<string, {
+        name: string;
         description?: string;
         inputSchema?: unknown;
     }>;

package/dist/lib/mcp/neurolink-mcp-client.js

@@ -244,11 +244,26 @@ Response (JSON array only):`;
                     exists: async () => false,
                 },
                 path: {
-                    join: (...paths) => require("path").join(...paths),
-                    resolve: (...paths) => require("path").resolve(...paths),
-                    relative: (from, to) => require("path").relative(from, to),
-                    dirname: (path) => require("path").dirname(path),
-                    basename: (path, ext) => require("path").basename(path, ext),
+                    join: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.join(...paths);
+                    },
+                    resolve: (...paths) => {
+                        const pathModule = require("path");
+                        return pathModule.resolve(...paths);
+                    },
+                    relative: (from, to) => {
+                        const pathModule = require("path");
+                        return pathModule.relative(from, to);
+                    },
+                    dirname: (pathArg) => {
+                        const pathModule = require("path");
+                        return pathModule.dirname(pathArg);
+                    },
+                    basename: (pathArg, ext) => {
+                        const pathModule = require("path");
+                        return pathModule.basename(pathArg, ext);
+                    },
                 },
                 grantedPermissions: [],
                 log: console.log,
@@ -409,6 +424,7 @@ Please provide a natural response based on the tool results.`;
         const tools = {};
         for (const [name, tool] of this.tools) {
             tools[name] = {
+                name: name, // Include the tool name as a property
                 description: tool.description,
                 inputSchema: tool.inputSchema,
             };