@dexto/core 1.1.4 → 1.1.6

package/dist/tools/schemas.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schemas_exports = {};
+__export(schemas_exports, {
+  InternalToolsSchema: () => InternalToolsSchema,
+  ToolConfirmationConfigSchema: () => ToolConfirmationConfigSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var import_registry = require("./internal-tools/registry.js");
+const InternalToolsSchema = import_zod.z.array(import_zod.z.enum(import_registry.INTERNAL_TOOL_NAMES).describe("Available internal tool names")).default([]).describe(
+  `Array of internal tool names to enable. Empty array = disabled. Available tools: ${import_registry.INTERNAL_TOOL_NAMES.join(", ")}`
+);
+const ToolConfirmationConfigSchema = import_zod.z.object({
+  mode: import_zod.z.enum(["event-based", "auto-approve", "auto-deny"]).default("event-based").describe(
+    "Tool confirmation mode: event-based (interactive), auto-approve (all tools), auto-deny (no tools)"
+  ),
+  timeout: import_zod.z.number().int().positive().default(12e4).describe(
+    "Timeout for tool confirmation requests in milliseconds, defaults to 120000ms (2 mins)"
+  ),
+  allowedToolsStorage: import_zod.z.enum(["memory", "storage"]).default("storage").describe(
+    "Storage type for remembered tool approvals: memory (session-only) or storage (persistent)"
+  )
+}).strict().describe("Tool confirmation and approval configuration");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalToolsSchema,
+  ToolConfirmationConfigSchema
+});

package/dist/tools/schemas.d.cts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+declare const InternalToolsSchema: z.ZodDefault<z.ZodArray<z.ZodEnum<["search_history"]>, "many">>;
+type InternalToolsConfig = z.output<typeof InternalToolsSchema>;
+declare const ToolConfirmationConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<["event-based", "auto-approve", "auto-deny"]>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    allowedToolsStorage: z.ZodDefault<z.ZodEnum<["memory", "storage"]>>;
+}, "strict", z.ZodTypeAny, {
+    timeout: number;
+    mode: "event-based" | "auto-approve" | "auto-deny";
+    allowedToolsStorage: "storage" | "memory";
+}, {
+    timeout?: number | undefined;
+    mode?: "event-based" | "auto-approve" | "auto-deny" | undefined;
+    allowedToolsStorage?: "storage" | "memory" | undefined;
+}>;
+type ToolConfirmationConfig = z.input<typeof ToolConfirmationConfigSchema>;
+type ValidatedToolConfirmationConfig = z.output<typeof ToolConfirmationConfigSchema>;
+
+export { type InternalToolsConfig, InternalToolsSchema, type ToolConfirmationConfig, ToolConfirmationConfigSchema, type ValidatedToolConfirmationConfig };

package/dist/tools/schemas.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+declare const InternalToolsSchema: z.ZodDefault<z.ZodArray<z.ZodEnum<["search_history"]>, "many">>;
+type InternalToolsConfig = z.output<typeof InternalToolsSchema>;
+declare const ToolConfirmationConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<["event-based", "auto-approve", "auto-deny"]>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    allowedToolsStorage: z.ZodDefault<z.ZodEnum<["memory", "storage"]>>;
+}, "strict", z.ZodTypeAny, {
+    timeout: number;
+    mode: "event-based" | "auto-approve" | "auto-deny";
+    allowedToolsStorage: "storage" | "memory";
+}, {
+    timeout?: number | undefined;
+    mode?: "event-based" | "auto-approve" | "auto-deny" | undefined;
+    allowedToolsStorage?: "storage" | "memory" | undefined;
+}>;
+type ToolConfirmationConfig = z.input<typeof ToolConfirmationConfigSchema>;
+type ValidatedToolConfirmationConfig = z.output<typeof ToolConfirmationConfigSchema>;
+
+export { type InternalToolsConfig, InternalToolsSchema, type ToolConfirmationConfig, ToolConfirmationConfigSchema, type ValidatedToolConfirmationConfig };

package/dist/tools/schemas.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { INTERNAL_TOOL_NAMES } from "./internal-tools/registry.js";
+const InternalToolsSchema = z.array(z.enum(INTERNAL_TOOL_NAMES).describe("Available internal tool names")).default([]).describe(
+  `Array of internal tool names to enable. Empty array = disabled. Available tools: ${INTERNAL_TOOL_NAMES.join(", ")}`
+);
+const ToolConfirmationConfigSchema = z.object({
+  mode: z.enum(["event-based", "auto-approve", "auto-deny"]).default("event-based").describe(
+    "Tool confirmation mode: event-based (interactive), auto-approve (all tools), auto-deny (no tools)"
+  ),
+  timeout: z.number().int().positive().default(12e4).describe(
+    "Timeout for tool confirmation requests in milliseconds, defaults to 120000ms (2 mins)"
+  ),
+  allowedToolsStorage: z.enum(["memory", "storage"]).default("storage").describe(
+    "Storage type for remembered tool approvals: memory (session-only) or storage (persistent)"
+  )
+}).strict().describe("Tool confirmation and approval configuration");
+export {
+  InternalToolsSchema,
+  ToolConfirmationConfigSchema
+};

package/dist/tools/tool-manager.cjs

@@ -0,0 +1,275 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_manager_exports = {};
+__export(tool_manager_exports, {
+  ToolManager: () => ToolManager
+});
+module.exports = __toCommonJS(tool_manager_exports);
+var import_provider = require("./internal-tools/provider.js");
+var import_errors = require("./errors.js");
+var import_logger = require("../logger/index.js");
+class ToolManager {
+  mcpManager;
+  internalToolsProvider;
+  confirmationProvider;
+  // Tool source prefixing - ALL tools get prefixed by source
+  static MCP_TOOL_PREFIX = "mcp--";
+  static INTERNAL_TOOL_PREFIX = "internal--";
+  // Tool caching for performance
+  toolsCache = {};
+  cacheValid = false;
+  constructor(mcpManager, confirmationProvider, options) {
+    this.mcpManager = mcpManager;
+    this.confirmationProvider = confirmationProvider;
+    if (options?.internalToolsConfig && options.internalToolsConfig.length > 0) {
+      this.internalToolsProvider = new import_provider.InternalToolsProvider(
+        options.internalToolsServices || {},
+        confirmationProvider,
+        options.internalToolsConfig
+      );
+    }
+    import_logger.logger.debug("ToolManager initialized");
+  }
+  /**
+   * Initialize the ToolManager and its components
+   */
+  async initialize() {
+    if (this.internalToolsProvider) {
+      await this.internalToolsProvider.initialize();
+    }
+    import_logger.logger.debug("ToolManager initialization complete");
+  }
+  /**
+   * Invalidate the tools cache when tool sources change
+   */
+  invalidateCache() {
+    this.cacheValid = false;
+    this.toolsCache = {};
+  }
+  getMcpManager() {
+    return this.mcpManager;
+  }
+  /**
+   * Get all MCP tools (delegates to mcpManager.getAllTools())
+   * This provides access to MCP tools while maintaining separation of concerns
+   */
+  async getMcpTools() {
+    return await this.mcpManager.getAllTools();
+  }
+  /**
+   * Build all tools from sources with universal prefixing
+   * ALL tools get prefixed by their source - no exceptions
+   */
+  async buildAllTools() {
+    const allTools = {};
+    let mcpTools = {};
+    let internalTools = {};
+    try {
+      mcpTools = await this.mcpManager.getAllTools();
+    } catch (error) {
+      import_logger.logger.error(
+        `Failed to get MCP tools: ${error instanceof Error ? error.message : String(error)}`
+      );
+      mcpTools = {};
+    }
+    try {
+      internalTools = this.internalToolsProvider?.getAllTools() || {};
+    } catch (error) {
+      import_logger.logger.error(
+        `Failed to get internal tools: ${error instanceof Error ? error.message : String(error)}`
+      );
+      internalTools = {};
+    }
+    for (const [toolName, toolDef] of Object.entries(internalTools)) {
+      const qualifiedName = `${ToolManager.INTERNAL_TOOL_PREFIX}${toolName}`;
+      allTools[qualifiedName] = {
+        ...toolDef,
+        name: qualifiedName,
+        description: `${toolDef.description || "No description provided"} (internal tool)`
+      };
+    }
+    for (const [toolName, toolDef] of Object.entries(mcpTools)) {
+      const qualifiedName = `${ToolManager.MCP_TOOL_PREFIX}${toolName}`;
+      allTools[qualifiedName] = {
+        ...toolDef,
+        name: qualifiedName,
+        description: `${toolDef.description || "No description provided"} (via MCP servers)`
+      };
+    }
+    const totalTools = Object.keys(allTools).length;
+    const mcpCount = Object.keys(mcpTools).length;
+    const internalCount = Object.keys(internalTools).length;
+    import_logger.logger.debug(
+      `\u{1F527} Unified tool discovery: ${totalTools} total tools (${mcpCount} MCP \u2192 ${ToolManager.MCP_TOOL_PREFIX}*, ${internalCount} internal \u2192 ${ToolManager.INTERNAL_TOOL_PREFIX}*)`
+    );
+    return allTools;
+  }
+  /**
+   * Get all available tools from all sources with conflict resolution
+   * This is the single interface the LLM uses to discover tools
+   * Uses caching to avoid rebuilding on every call
+   */
+  async getAllTools() {
+    if (this.cacheValid) {
+      return this.toolsCache;
+    }
+    this.toolsCache = await this.buildAllTools();
+    this.cacheValid = true;
+    return this.toolsCache;
+  }
+  /**
+   * Execute a tool by routing based on universal prefix
+   * ALL tools must have source prefix - no exceptions
+   */
+  async executeTool(toolName, args, sessionId) {
+    import_logger.logger.debug(`\u{1F527} Tool execution requested: '${toolName}'`);
+    import_logger.logger.debug(`Tool args: ${JSON.stringify(args, null, 2)}`);
+    const approved = await this.confirmationProvider.requestConfirmation({
+      toolName,
+      args,
+      ...sessionId && { sessionId }
+    });
+    if (!approved) {
+      import_logger.logger.debug(`\u{1F6AB} Tool execution denied: ${toolName}`);
+      throw import_errors.ToolError.executionDenied(toolName, sessionId);
+    }
+    import_logger.logger.debug(`\u2705 Tool execution approved: ${toolName}`);
+    import_logger.logger.info(
+      `\u{1F527} Tool execution started for ${toolName}, sessionId: ${sessionId ?? "global"}`
+    );
+    const startTime = Date.now();
+    try {
+      let result;
+      if (toolName.startsWith(ToolManager.MCP_TOOL_PREFIX)) {
+        import_logger.logger.debug(`\u{1F527} Detected MCP tool: '${toolName}'`);
+        const actualToolName = toolName.substring(ToolManager.MCP_TOOL_PREFIX.length);
+        if (actualToolName.length === 0) {
+          throw import_errors.ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
+        }
+        import_logger.logger.debug(`\u{1F3AF} MCP routing: '${toolName}' -> '${actualToolName}'`);
+        result = await this.mcpManager.executeTool(actualToolName, args, sessionId);
+      } else if (toolName.startsWith(ToolManager.INTERNAL_TOOL_PREFIX)) {
+        import_logger.logger.debug(`\u{1F527} Detected internal tool: '${toolName}'`);
+        const actualToolName = toolName.substring(ToolManager.INTERNAL_TOOL_PREFIX.length);
+        if (actualToolName.length === 0) {
+          throw import_errors.ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
+        }
+        if (!this.internalToolsProvider) {
+          throw import_errors.ToolError.internalToolsNotInitialized(toolName);
+        }
+        import_logger.logger.debug(`\u{1F3AF} Internal routing: '${toolName}' -> '${actualToolName}'`);
+        result = await this.internalToolsProvider.executeTool(
+          actualToolName,
+          args,
+          sessionId
+        );
+      } else {
+        import_logger.logger.debug(`\u{1F527} Detected tool without proper prefix: '${toolName}'`);
+        const stats = await this.getToolStats();
+        import_logger.logger.error(
+          `\u274C Tool missing source prefix: '${toolName}' (expected '${ToolManager.MCP_TOOL_PREFIX}*' or '${ToolManager.INTERNAL_TOOL_PREFIX}*')`
+        );
+        import_logger.logger.debug(`Available: ${stats.mcp} MCP tools, ${stats.internal} internal tools`);
+        throw import_errors.ToolError.notFound(toolName);
+      }
+      const duration = Date.now() - startTime;
+      import_logger.logger.debug(`\u{1F3AF} Tool execution completed in ${duration}ms: '${toolName}'`);
+      import_logger.logger.info(
+        `\u2705 Tool execution completed successfully for ${toolName} in ${duration}ms, sessionId: ${sessionId ?? "global"}`
+      );
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      import_logger.logger.error(
+        `\u274C Tool execution failed for ${toolName} after ${duration}ms, sessionId: ${sessionId ?? "global"}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Check if a tool exists (must have proper source prefix)
+   */
+  async hasTool(toolName) {
+    if (toolName.startsWith(ToolManager.MCP_TOOL_PREFIX)) {
+      const actualToolName = toolName.substring(ToolManager.MCP_TOOL_PREFIX.length);
+      return this.mcpManager.getToolClient(actualToolName) !== void 0;
+    }
+    if (toolName.startsWith(ToolManager.INTERNAL_TOOL_PREFIX)) {
+      const actualToolName = toolName.substring(ToolManager.INTERNAL_TOOL_PREFIX.length);
+      return this.internalToolsProvider?.hasTool(actualToolName) ?? false;
+    }
+    return false;
+  }
+  /**
+   * Get tool statistics across all sources
+   */
+  async getToolStats() {
+    let mcpTools = {};
+    let internalTools = {};
+    try {
+      mcpTools = await this.mcpManager.getAllTools();
+    } catch (error) {
+      import_logger.logger.error(
+        `Failed to get MCP tools for stats: ${error instanceof Error ? error.message : String(error)}`
+      );
+      mcpTools = {};
+    }
+    try {
+      internalTools = this.internalToolsProvider?.getAllTools() || {};
+    } catch (error) {
+      import_logger.logger.error(
+        `Failed to get internal tools for stats: ${error instanceof Error ? error.message : String(error)}`
+      );
+      internalTools = {};
+    }
+    const mcpCount = Object.keys(mcpTools).length;
+    const internalCount = Object.keys(internalTools).length;
+    return {
+      total: mcpCount + internalCount,
+      // No conflicts with universal prefixing
+      mcp: mcpCount,
+      internal: internalCount
+    };
+  }
+  /**
+   * Get the source of a tool (mcp, internal, or unknown)
+   * @param toolName The name of the tool to check
+   * @returns The source of the tool
+   */
+  getToolSource(toolName) {
+    if (toolName.startsWith(ToolManager.MCP_TOOL_PREFIX) && toolName.length > ToolManager.MCP_TOOL_PREFIX.length) {
+      return "mcp";
+    }
+    if (toolName.startsWith(ToolManager.INTERNAL_TOOL_PREFIX) && toolName.length > ToolManager.INTERNAL_TOOL_PREFIX.length) {
+      return "internal";
+    }
+    return "unknown";
+  }
+  /**
+   * Refresh tool discovery (call when MCP servers change)
+   */
+  async refresh() {
+    this.invalidateCache();
+    import_logger.logger.debug("ToolManager refreshed");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ToolManager
+});

package/dist/tools/tool-manager.d.cts

@@ -0,0 +1,106 @@
+import { MCPManager } from '../mcp/manager.cjs';
+import { InternalToolsServices } from './internal-tools/registry.cjs';
+import { InternalToolsConfig } from './schemas.cjs';
+import { ToolSet } from './types.cjs';
+import { ToolConfirmationProvider } from './confirmation/types.cjs';
+import '../mcp/schemas.cjs';
+import 'zod';
+import '../mcp/types.cjs';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';
+import '../search/search-service.cjs';
+import '../storage/backend/database-backend.cjs';
+import '../search/types.cjs';
+import '../context/types.cjs';
+import '../llm/types.cjs';
+import 'json-schema';
+import './confirmation/allowed-tools-provider/types.cjs';
+
+/**
+ * Options for internal tools configuration in ToolManager
+ */
+interface InternalToolsOptions {
+    internalToolsServices?: InternalToolsServices;
+    internalToolsConfig?: InternalToolsConfig;
+}
+/**
+ * Unified Tool Manager - Single interface for all tool operations
+ *
+ * This class acts as the single point of contact between the LLM and all tool sources.
+ * It aggregates tools from MCP servers and internal tools, providing a unified interface
+ * for tool discovery, aggregation, and execution.
+ *
+ * Responsibilities:
+ * - Aggregate tools from MCP servers and internal tools with conflict resolution
+ * - Route tool execution to appropriate source (MCP vs Internal)
+ * - Provide unified tool interface to LLM
+ * - Manage tool confirmation and security
+ * - Handle cross-source naming conflicts (internal tools have precedence)
+ *
+ * Architecture:
+ * LLMService → ToolManager → [MCPManager, InternalToolsProvider]
+ */
+declare class ToolManager {
+    private mcpManager;
+    private internalToolsProvider?;
+    private confirmationProvider;
+    private static readonly MCP_TOOL_PREFIX;
+    private static readonly INTERNAL_TOOL_PREFIX;
+    private toolsCache;
+    private cacheValid;
+    constructor(mcpManager: MCPManager, confirmationProvider: ToolConfirmationProvider, options?: InternalToolsOptions);
+    /**
+     * Initialize the ToolManager and its components
+     */
+    initialize(): Promise<void>;
+    /**
+     * Invalidate the tools cache when tool sources change
+     */
+    private invalidateCache;
+    getMcpManager(): MCPManager;
+    /**
+     * Get all MCP tools (delegates to mcpManager.getAllTools())
+     * This provides access to MCP tools while maintaining separation of concerns
+     */
+    getMcpTools(): Promise<ToolSet>;
+    /**
+     * Build all tools from sources with universal prefixing
+     * ALL tools get prefixed by their source - no exceptions
+     */
+    private buildAllTools;
+    /**
+     * Get all available tools from all sources with conflict resolution
+     * This is the single interface the LLM uses to discover tools
+     * Uses caching to avoid rebuilding on every call
+     */
+    getAllTools(): Promise<ToolSet>;
+    /**
+     * Execute a tool by routing based on universal prefix
+     * ALL tools must have source prefix - no exceptions
+     */
+    executeTool(toolName: string, args: Record<string, unknown>, sessionId?: string): Promise<unknown>;
+    /**
+     * Check if a tool exists (must have proper source prefix)
+     */
+    hasTool(toolName: string): Promise<boolean>;
+    /**
+     * Get tool statistics across all sources
+     */
+    getToolStats(): Promise<{
+        total: number;
+        mcp: number;
+        internal: number;
+    }>;
+    /**
+     * Get the source of a tool (mcp, internal, or unknown)
+     * @param toolName The name of the tool to check
+     * @returns The source of the tool
+     */
+    getToolSource(toolName: string): 'mcp' | 'internal' | 'unknown';
+    /**
+     * Refresh tool discovery (call when MCP servers change)
+     */
+    refresh(): Promise<void>;
+}
+
+export { type InternalToolsOptions, ToolManager };

package/dist/tools/tool-manager.d.ts

@@ -0,0 +1,106 @@
+import { MCPManager } from '../mcp/manager.js';
+import { InternalToolsServices } from './internal-tools/registry.js';
+import { InternalToolsConfig } from './schemas.js';
+import { ToolSet } from './types.js';
+import { ToolConfirmationProvider } from './confirmation/types.js';
+import '../mcp/schemas.js';
+import 'zod';
+import '../mcp/types.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/types.js';
+import '../search/search-service.js';
+import '../storage/backend/database-backend.js';
+import '../search/types.js';
+import '../context/types.js';
+import '../llm/types.js';
+import 'json-schema';
+import './confirmation/allowed-tools-provider/types.js';
+
+/**
+ * Options for internal tools configuration in ToolManager
+ */
+interface InternalToolsOptions {
+    internalToolsServices?: InternalToolsServices;
+    internalToolsConfig?: InternalToolsConfig;
+}
+/**
+ * Unified Tool Manager - Single interface for all tool operations
+ *
+ * This class acts as the single point of contact between the LLM and all tool sources.
+ * It aggregates tools from MCP servers and internal tools, providing a unified interface
+ * for tool discovery, aggregation, and execution.
+ *
+ * Responsibilities:
+ * - Aggregate tools from MCP servers and internal tools with conflict resolution
+ * - Route tool execution to appropriate source (MCP vs Internal)
+ * - Provide unified tool interface to LLM
+ * - Manage tool confirmation and security
+ * - Handle cross-source naming conflicts (internal tools have precedence)
+ *
+ * Architecture:
+ * LLMService → ToolManager → [MCPManager, InternalToolsProvider]
+ */
+declare class ToolManager {
+    private mcpManager;
+    private internalToolsProvider?;
+    private confirmationProvider;
+    private static readonly MCP_TOOL_PREFIX;
+    private static readonly INTERNAL_TOOL_PREFIX;
+    private toolsCache;
+    private cacheValid;
+    constructor(mcpManager: MCPManager, confirmationProvider: ToolConfirmationProvider, options?: InternalToolsOptions);
+    /**
+     * Initialize the ToolManager and its components
+     */
+    initialize(): Promise<void>;
+    /**
+     * Invalidate the tools cache when tool sources change
+     */
+    private invalidateCache;
+    getMcpManager(): MCPManager;
+    /**
+     * Get all MCP tools (delegates to mcpManager.getAllTools())
+     * This provides access to MCP tools while maintaining separation of concerns
+     */
+    getMcpTools(): Promise<ToolSet>;
+    /**
+     * Build all tools from sources with universal prefixing
+     * ALL tools get prefixed by their source - no exceptions
+     */
+    private buildAllTools;
+    /**
+     * Get all available tools from all sources with conflict resolution
+     * This is the single interface the LLM uses to discover tools
+     * Uses caching to avoid rebuilding on every call
+     */
+    getAllTools(): Promise<ToolSet>;
+    /**
+     * Execute a tool by routing based on universal prefix
+     * ALL tools must have source prefix - no exceptions
+     */
+    executeTool(toolName: string, args: Record<string, unknown>, sessionId?: string): Promise<unknown>;
+    /**
+     * Check if a tool exists (must have proper source prefix)
+     */
+    hasTool(toolName: string): Promise<boolean>;
+    /**
+     * Get tool statistics across all sources
+     */
+    getToolStats(): Promise<{
+        total: number;
+        mcp: number;
+        internal: number;
+    }>;
+    /**
+     * Get the source of a tool (mcp, internal, or unknown)
+     * @param toolName The name of the tool to check
+     * @returns The source of the tool
+     */
+    getToolSource(toolName: string): 'mcp' | 'internal' | 'unknown';
+    /**
+     * Refresh tool discovery (call when MCP servers change)
+     */
+    refresh(): Promise<void>;
+}
+
+export { type InternalToolsOptions, ToolManager };