@dexto/core 1.4.0 → 1.5.0

package/dist/tools/internal-tools/provider.cjs

@@ -24,31 +24,59 @@ module.exports = __toCommonJS(provider_exports);
 var import_errors = require("../errors.js");
 var import_schema = require("../../utils/schema.js");
 var import_registry = require("./registry.js");
+var import_custom_tool_registry = require("../custom-tool-registry.js");
+var import_DextoRuntimeError = require("../../errors/DextoRuntimeError.js");
+var import_error_codes = require("../error-codes.js");
 class InternalToolsProvider {
   services;
-  tools = /* @__PURE__ */ new Map();
-  // ← Store original InternalTool
+  internalTools = /* @__PURE__ */ new Map();
+  // Built-in internal tools
+  customTools = /* @__PURE__ */ new Map();
+  // Custom tool provider tools
   config;
+  customToolConfigs;
   logger;
-  constructor(services, config = [], logger) {
+  agent;
+  // Set after construction to avoid circular dependency
+  constructor(services, config = [], customToolConfigs = [], logger) {
     this.services = services;
     this.config = config;
+    this.customToolConfigs = customToolConfigs;
     this.logger = logger;
-    this.logger.debug("InternalToolsProvider initialized with config:", { config });
+    this.logger.debug("InternalToolsProvider initialized with config:", {
+      config,
+      customToolConfigs
+    });
+  }
+  /**
+   * Set agent reference after construction (avoids circular dependency)
+   * Must be called before initialize() if custom tools need agent access
+   */
+  setAgent(agent) {
+    this.agent = agent;
   }
   /**
    * Initialize the internal tools provider by registering all available internal tools
+   * and custom tools from the registry
    */
   async initialize() {
     this.logger.info("Initializing InternalToolsProvider...");
     try {
-      if (this.config.length === 0) {
+      if (this.config.length > 0) {
+        this.registerInternalTools();
+      } else {
         this.logger.info("No internal tools enabled by configuration");
-        return;
       }
-      this.registerInternalTools();
-      const toolCount = this.tools.size;
-      this.logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
+      if (this.customToolConfigs.length > 0) {
+        this.registerCustomTools();
+      } else {
+        this.logger.debug("No custom tool providers configured");
+      }
+      const internalCount = this.internalTools.size;
+      const customCount = this.customTools.size;
+      this.logger.info(
+        `InternalToolsProvider initialized with ${internalCount + customCount} tools (${internalCount} internal, ${customCount} custom)`
+      );
     } catch (error) {
       this.logger.error(
         `Failed to initialize InternalToolsProvider: ${error instanceof Error ? error.message : String(error)}`
@@ -86,7 +114,7 @@ class InternalToolsProvider {
       }
       try {
         const tool = toolInfo.factory(this.services);
-        this.tools.set(toolName, tool);
+        this.internalTools.set(toolName, tool);
         this.logger.debug(`Registered ${toolName} internal tool`);
       } catch (error) {
         this.logger.error(
@@ -96,27 +124,89 @@ class InternalToolsProvider {
     }
   }
   /**
-   * Check if a tool exists
+   * Register custom tools from the custom tool registry.
+   * Tools are stored by their original ID - prefixing is handled by ToolManager.
+   */
+  registerCustomTools() {
+    if (!this.agent) {
+      throw import_errors.ToolError.configInvalid(
+        "Agent reference not set. Call setAgent() before initialize() when using custom tools."
+      );
+    }
+    const context = {
+      logger: this.logger,
+      agent: this.agent,
+      services: this.services
+      // Includes approvalManager for tools that need approval flows
+    };
+    for (const toolConfig of this.customToolConfigs) {
+      try {
+        const validatedConfig = import_custom_tool_registry.customToolRegistry.validateConfig(toolConfig);
+        const provider = import_custom_tool_registry.customToolRegistry.get(validatedConfig.type);
+        if (!provider) {
+          const availableTypes = import_custom_tool_registry.customToolRegistry.getTypes();
+          throw import_errors.ToolError.unknownCustomToolProvider(validatedConfig.type, availableTypes);
+        }
+        const tools = provider.create(validatedConfig, context);
+        for (const tool of tools) {
+          if (this.customTools.has(tool.id)) {
+            this.logger.warn(
+              `Custom tool '${tool.id}' conflicts with existing custom tool. Skipping.`
+            );
+            continue;
+          }
+          this.customTools.set(tool.id, tool);
+          this.logger.debug(
+            `Registered custom tool: ${tool.id} from provider '${provider.metadata?.displayName || validatedConfig.type}'`
+          );
+        }
+      } catch (error) {
+        if (error instanceof import_DextoRuntimeError.DextoRuntimeError && error.code === import_error_codes.ToolErrorCode.CUSTOM_TOOL_PROVIDER_UNKNOWN) {
+          throw error;
+        }
+        this.logger.error(
+          `Failed to register custom tool provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /**
+   * Check if a tool exists (checks both internal and custom tools)
    */
   hasTool(toolName) {
-    return this.tools.has(toolName);
+    return this.internalTools.has(toolName) || this.customTools.has(toolName);
+  }
+  /**
+   * Check if an internal tool exists
+   */
+  hasInternalTool(toolName) {
+    return this.internalTools.has(toolName);
+  }
+  /**
+   * Check if a custom tool exists
+   */
+  hasCustomTool(toolName) {
+    return this.customTools.has(toolName);
   }
   /**
    * Get an internal tool by name
    * Returns undefined if tool doesn't exist
    */
   getTool(toolName) {
-    return this.tools.get(toolName);
+    return this.internalTools.get(toolName) || this.customTools.get(toolName);
   }
   /**
    * Execute an internal tool - confirmation is handled by ToolManager
    */
   async executeTool(toolName, args, sessionId, abortSignal) {
-    const tool = this.tools.get(toolName);
+    const tool = this.internalTools.get(toolName) || this.customTools.get(toolName);
     if (!tool) {
-      this.logger.error(`\u274C No internal tool found: ${toolName}`);
+      this.logger.error(`\u274C No tool found: ${toolName}`);
+      this.logger.debug(
+        `Available internal tools: ${Array.from(this.internalTools.keys()).join(", ")}`
+      );
       this.logger.debug(
-        `Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`
+        `Available custom tools: ${Array.from(this.customTools.keys()).join(", ")}`
       );
       throw import_errors.ToolError.notFound(toolName);
     }
@@ -145,31 +235,68 @@ class InternalToolsProvider {
     }
   }
   /**
-   * Get all tools in ToolSet format with on-demand JSON Schema conversion
+   * Get internal tools in ToolSet format (excludes custom tools)
+   */
+  getInternalTools() {
+    const toolSet = {};
+    for (const [name, tool] of this.internalTools) {
+      toolSet[name] = {
+        name: tool.id,
+        description: tool.description,
+        parameters: (0, import_schema.convertZodSchemaToJsonSchema)(tool.inputSchema, this.logger)
+      };
+    }
+    return toolSet;
+  }
+  /**
+   * Get custom tools in ToolSet format (excludes internal tools)
    */
-  getAllTools() {
+  getCustomTools() {
     const toolSet = {};
-    for (const [name, tool] of this.tools) {
+    for (const [name, tool] of this.customTools) {
       toolSet[name] = {
         name: tool.id,
         description: tool.description,
         parameters: (0, import_schema.convertZodSchemaToJsonSchema)(tool.inputSchema, this.logger)
-        // ← Convert on-demand
       };
     }
     return toolSet;
   }
   /**
-   * Get tool names
+   * Get internal tool names
+   */
+  getInternalToolNames() {
+    return Array.from(this.internalTools.keys());
+  }
+  /**
+   * Get custom tool names
+   */
+  getCustomToolNames() {
+    return Array.from(this.customTools.keys());
+  }
+  /**
+   * Get all tool names (internal + custom)
    */
   getToolNames() {
-    return Array.from(this.tools.keys());
+    return [...this.internalTools.keys(), ...this.customTools.keys()];
   }
   /**
    * Get tool count
    */
   getToolCount() {
-    return this.tools.size;
+    return this.internalTools.size + this.customTools.size;
+  }
+  /**
+   * Get internal tool count
+   */
+  getInternalToolCount() {
+    return this.internalTools.size;
+  }
+  /**
+   * Get custom tool count
+   */
+  getCustomToolCount() {
+    return this.customTools.size;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/tools/internal-tools/provider.d.ts

@@ -1,27 +1,39 @@
 import { ToolSet, InternalTool } from '../types.js';
 import type { IDextoLogger } from '../../logger/v2/types.js';
+import type { DextoAgent } from '../../agent/DextoAgent.js';
 import { InternalToolsServices } from './registry.js';
-import type { InternalToolsConfig } from '../schemas.js';
+import type { InternalToolsConfig, CustomToolsConfig } from '../schemas.js';
 /**
- * Provider for built-in internal tools that are part of the core system
+ * Provider for built-in internal tools and custom tool providers
  *
- * This provider manages internal tools that are shipped with the core system
- * and need access to core services like SearchService, SessionManager, etc.
+ * This provider manages:
+ * 1. Built-in internal tools that are shipped with the core system
+ * 2. Custom tools registered via the customToolRegistry
  *
  * Benefits:
  * - Clean separation: ToolManager doesn't need to know about specific services
  * - Easy to extend: Just add new tools and services as needed
  * - Lightweight: Direct tool management without complex infrastructure
  * - No unnecessary ProcessedInternalTool wrapper - uses InternalTool directly
+ * - Custom tools follow the same provider pattern as blob storage
  */
 export declare class InternalToolsProvider {
     private services;
-    private tools;
+    private internalTools;
+    private customTools;
     private config;
+    private customToolConfigs;
     private logger;
-    constructor(services: InternalToolsServices, config: InternalToolsConfig | undefined, logger: IDextoLogger);
+    private agent?;
+    constructor(services: InternalToolsServices, config: InternalToolsConfig | undefined, customToolConfigs: CustomToolsConfig | undefined, logger: IDextoLogger);
+    /**
+     * Set agent reference after construction (avoids circular dependency)
+     * Must be called before initialize() if custom tools need agent access
+     */
+    setAgent(agent: DextoAgent): void;
     /**
      * Initialize the internal tools provider by registering all available internal tools
+     * and custom tools from the registry
      */
     initialize(): Promise<void>;
     /**
@@ -29,9 +41,22 @@ export declare class InternalToolsProvider {
      */
     private registerInternalTools;
     /**
-     * Check if a tool exists
+     * Register custom tools from the custom tool registry.
+     * Tools are stored by their original ID - prefixing is handled by ToolManager.
+     */
+    private registerCustomTools;
+    /**
+     * Check if a tool exists (checks both internal and custom tools)
      */
     hasTool(toolName: string): boolean;
+    /**
+     * Check if an internal tool exists
+     */
+    hasInternalTool(toolName: string): boolean;
+    /**
+     * Check if a custom tool exists
+     */
+    hasCustomTool(toolName: string): boolean;
     /**
      * Get an internal tool by name
      * Returns undefined if tool doesn't exist
@@ -42,16 +67,36 @@ export declare class InternalToolsProvider {
      */
     executeTool(toolName: string, args: Record<string, unknown>, sessionId?: string, abortSignal?: AbortSignal): Promise<unknown>;
     /**
-     * Get all tools in ToolSet format with on-demand JSON Schema conversion
+     * Get internal tools in ToolSet format (excludes custom tools)
+     */
+    getInternalTools(): ToolSet;
+    /**
+     * Get custom tools in ToolSet format (excludes internal tools)
+     */
+    getCustomTools(): ToolSet;
+    /**
+     * Get internal tool names
+     */
+    getInternalToolNames(): string[];
+    /**
+     * Get custom tool names
      */
-    getAllTools(): ToolSet;
+    getCustomToolNames(): string[];
     /**
-     * Get tool names
+     * Get all tool names (internal + custom)
      */
     getToolNames(): string[];
     /**
      * Get tool count
      */
     getToolCount(): number;
+    /**
+     * Get internal tool count
+     */
+    getInternalToolCount(): number;
+    /**
+     * Get custom tool count
+     */
+    getCustomToolCount(): number;
 }
 //# sourceMappingURL=provider.d.ts.map

package/dist/tools/internal-tools/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D,OAAO,EAAE,qBAAqB,EAA0C,MAAM,eAAe,CAAC;AAC9F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,KAAK,CAAwC;IACrD,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,MAAM,CAAe;gBAGzB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,mBAAmB,YAAK,EAChC,MAAM,EAAE,YAAY;IAQxB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgD7B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlC;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAInD;;OAEG;IACG,WAAW,CACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,WAAW,GAC1B,OAAO,CAAC,OAAO,CAAC;IAqCnB;;OAEG;IACH,WAAW,IAAI,OAAO;IActB;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,YAAY,IAAI,MAAM;CAGzB"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/tools/internal-tools/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAG5D,OAAO,EAAE,qBAAqB,EAA0C,MAAM,eAAe,CAAC;AAC9F,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAK5E;;;;;;;;;;;;;GAaG;AACH,qBAAa,qBAAqB;IAC9B,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,aAAa,CAAwC;IAC7D,OAAO,CAAC,WAAW,CAAwC;IAC3D,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,KAAK,CAAC,CAAa;gBAGvB,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,mBAAmB,YAAK,EAChC,iBAAiB,EAAE,iBAAiB,YAAK,EACzC,MAAM,EAAE,YAAY;IAYxB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAIjC;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BjC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgD7B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IA4D3B;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIlC;;OAEG;IACH,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI1C;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAIxC;;;OAGG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAInD;;OAEG;IACG,WAAW,CACb,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,WAAW,GAC1B,OAAO,CAAC,OAAO,CAAC;IAyCnB;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAc3B;;OAEG;IACH,cAAc,IAAI,OAAO;IAczB;;OAEG;IACH,oBAAoB,IAAI,MAAM,EAAE;IAIhC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,YAAY,IAAI,MAAM,EAAE;IAIxB;;OAEG;IACH,YAAY,IAAI,MAAM;IAItB;;OAEG;IACH,oBAAoB,IAAI,MAAM;IAI9B;;OAEG;IACH,kBAAkB,IAAI,MAAM;CAG/B"}

package/dist/tools/internal-tools/provider.js

@@ -2,31 +2,59 @@ import "../../chunk-PTJYTZNU.js";
 import { ToolError } from "../errors.js";
 import { convertZodSchemaToJsonSchema } from "../../utils/schema.js";
 import { getInternalToolInfo } from "./registry.js";
+import { customToolRegistry } from "../custom-tool-registry.js";
+import { DextoRuntimeError } from "../../errors/DextoRuntimeError.js";
+import { ToolErrorCode } from "../error-codes.js";
 class InternalToolsProvider {
   services;
-  tools = /* @__PURE__ */ new Map();
-  // ← Store original InternalTool
+  internalTools = /* @__PURE__ */ new Map();
+  // Built-in internal tools
+  customTools = /* @__PURE__ */ new Map();
+  // Custom tool provider tools
   config;
+  customToolConfigs;
   logger;
-  constructor(services, config = [], logger) {
+  agent;
+  // Set after construction to avoid circular dependency
+  constructor(services, config = [], customToolConfigs = [], logger) {
     this.services = services;
     this.config = config;
+    this.customToolConfigs = customToolConfigs;
     this.logger = logger;
-    this.logger.debug("InternalToolsProvider initialized with config:", { config });
+    this.logger.debug("InternalToolsProvider initialized with config:", {
+      config,
+      customToolConfigs
+    });
+  }
+  /**
+   * Set agent reference after construction (avoids circular dependency)
+   * Must be called before initialize() if custom tools need agent access
+   */
+  setAgent(agent) {
+    this.agent = agent;
   }
   /**
    * Initialize the internal tools provider by registering all available internal tools
+   * and custom tools from the registry
    */
   async initialize() {
     this.logger.info("Initializing InternalToolsProvider...");
     try {
-      if (this.config.length === 0) {
+      if (this.config.length > 0) {
+        this.registerInternalTools();
+      } else {
         this.logger.info("No internal tools enabled by configuration");
-        return;
       }
-      this.registerInternalTools();
-      const toolCount = this.tools.size;
-      this.logger.info(`InternalToolsProvider initialized with ${toolCount} internal tools`);
+      if (this.customToolConfigs.length > 0) {
+        this.registerCustomTools();
+      } else {
+        this.logger.debug("No custom tool providers configured");
+      }
+      const internalCount = this.internalTools.size;
+      const customCount = this.customTools.size;
+      this.logger.info(
+        `InternalToolsProvider initialized with ${internalCount + customCount} tools (${internalCount} internal, ${customCount} custom)`
+      );
     } catch (error) {
       this.logger.error(
         `Failed to initialize InternalToolsProvider: ${error instanceof Error ? error.message : String(error)}`
@@ -64,7 +92,7 @@ class InternalToolsProvider {
       }
       try {
         const tool = toolInfo.factory(this.services);
-        this.tools.set(toolName, tool);
+        this.internalTools.set(toolName, tool);
         this.logger.debug(`Registered ${toolName} internal tool`);
       } catch (error) {
         this.logger.error(
@@ -74,27 +102,89 @@ class InternalToolsProvider {
     }
   }
   /**
-   * Check if a tool exists
+   * Register custom tools from the custom tool registry.
+   * Tools are stored by their original ID - prefixing is handled by ToolManager.
+   */
+  registerCustomTools() {
+    if (!this.agent) {
+      throw ToolError.configInvalid(
+        "Agent reference not set. Call setAgent() before initialize() when using custom tools."
+      );
+    }
+    const context = {
+      logger: this.logger,
+      agent: this.agent,
+      services: this.services
+      // Includes approvalManager for tools that need approval flows
+    };
+    for (const toolConfig of this.customToolConfigs) {
+      try {
+        const validatedConfig = customToolRegistry.validateConfig(toolConfig);
+        const provider = customToolRegistry.get(validatedConfig.type);
+        if (!provider) {
+          const availableTypes = customToolRegistry.getTypes();
+          throw ToolError.unknownCustomToolProvider(validatedConfig.type, availableTypes);
+        }
+        const tools = provider.create(validatedConfig, context);
+        for (const tool of tools) {
+          if (this.customTools.has(tool.id)) {
+            this.logger.warn(
+              `Custom tool '${tool.id}' conflicts with existing custom tool. Skipping.`
+            );
+            continue;
+          }
+          this.customTools.set(tool.id, tool);
+          this.logger.debug(
+            `Registered custom tool: ${tool.id} from provider '${provider.metadata?.displayName || validatedConfig.type}'`
+          );
+        }
+      } catch (error) {
+        if (error instanceof DextoRuntimeError && error.code === ToolErrorCode.CUSTOM_TOOL_PROVIDER_UNKNOWN) {
+          throw error;
+        }
+        this.logger.error(
+          `Failed to register custom tool provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  }
+  /**
+   * Check if a tool exists (checks both internal and custom tools)
    */
   hasTool(toolName) {
-    return this.tools.has(toolName);
+    return this.internalTools.has(toolName) || this.customTools.has(toolName);
+  }
+  /**
+   * Check if an internal tool exists
+   */
+  hasInternalTool(toolName) {
+    return this.internalTools.has(toolName);
+  }
+  /**
+   * Check if a custom tool exists
+   */
+  hasCustomTool(toolName) {
+    return this.customTools.has(toolName);
   }
   /**
    * Get an internal tool by name
    * Returns undefined if tool doesn't exist
    */
   getTool(toolName) {
-    return this.tools.get(toolName);
+    return this.internalTools.get(toolName) || this.customTools.get(toolName);
   }
   /**
    * Execute an internal tool - confirmation is handled by ToolManager
    */
   async executeTool(toolName, args, sessionId, abortSignal) {
-    const tool = this.tools.get(toolName);
+    const tool = this.internalTools.get(toolName) || this.customTools.get(toolName);
     if (!tool) {
-      this.logger.error(`\u274C No internal tool found: ${toolName}`);
+      this.logger.error(`\u274C No tool found: ${toolName}`);
+      this.logger.debug(
+        `Available internal tools: ${Array.from(this.internalTools.keys()).join(", ")}`
+      );
       this.logger.debug(
-        `Available internal tools: ${Array.from(this.tools.keys()).join(", ")}`
+        `Available custom tools: ${Array.from(this.customTools.keys()).join(", ")}`
       );
       throw ToolError.notFound(toolName);
     }
@@ -123,31 +213,68 @@ class InternalToolsProvider {
     }
   }
   /**
-   * Get all tools in ToolSet format with on-demand JSON Schema conversion
+   * Get internal tools in ToolSet format (excludes custom tools)
+   */
+  getInternalTools() {
+    const toolSet = {};
+    for (const [name, tool] of this.internalTools) {
+      toolSet[name] = {
+        name: tool.id,
+        description: tool.description,
+        parameters: convertZodSchemaToJsonSchema(tool.inputSchema, this.logger)
+      };
+    }
+    return toolSet;
+  }
+  /**
+   * Get custom tools in ToolSet format (excludes internal tools)
    */
-  getAllTools() {
+  getCustomTools() {
     const toolSet = {};
-    for (const [name, tool] of this.tools) {
+    for (const [name, tool] of this.customTools) {
       toolSet[name] = {
         name: tool.id,
         description: tool.description,
         parameters: convertZodSchemaToJsonSchema(tool.inputSchema, this.logger)
-        // ← Convert on-demand
       };
     }
     return toolSet;
   }
   /**
-   * Get tool names
+   * Get internal tool names
+   */
+  getInternalToolNames() {
+    return Array.from(this.internalTools.keys());
+  }
+  /**
+   * Get custom tool names
+   */
+  getCustomToolNames() {
+    return Array.from(this.customTools.keys());
+  }
+  /**
+   * Get all tool names (internal + custom)
    */
   getToolNames() {
-    return Array.from(this.tools.keys());
+    return [...this.internalTools.keys(), ...this.customTools.keys()];
   }
   /**
    * Get tool count
    */
   getToolCount() {
-    return this.tools.size;
+    return this.internalTools.size + this.customTools.size;
+  }
+  /**
+   * Get internal tool count
+   */
+  getInternalToolCount() {
+    return this.internalTools.size;
+  }
+  /**
+   * Get custom tool count
+   */
+  getCustomToolCount() {
+    return this.customTools.size;
   }
 }
 export {