@dexto/core 1.5.7 → 1.6.0

package/dist/tools/tool-manager.cjs

@@ -66,40 +66,41 @@ __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_error_codes = require("./error-codes.js");
 var import_errors2 = require("../errors/index.js");
 var import_types2 = require("../logger/v2/types.js");
+var import_schema = require("../utils/schema.js");
 var import_types3 = require("../approval/types.js");
 var import_decorators = require("../telemetry/decorators.js");
-var import_bash_pattern_utils = require("./bash-pattern-utils.js");
+var import_tool_call_metadata = require("./tool-call-metadata.js");
+var import_env = require("../utils/env.js");
 var _ToolManager_decorators, _init;
 _ToolManager_decorators = [(0, import_decorators.InstrumentClass)({
   prefix: "tool",
-  excludeMethods: [
-    "setPluginManager",
-    "setStateManager",
-    "getApprovalManager",
-    "getAllowedToolsProvider"
-  ]
+  excludeMethods: ["setHookSupport", "getApprovalManager", "getAllowedToolsProvider"]
 })];
 let _ToolManager = class _ToolManager {
   mcpManager;
-  internalToolsProvider;
+  agentTools = /* @__PURE__ */ new Map();
   approvalManager;
   allowedToolsProvider;
   approvalMode;
   agentEventBus;
   toolPolicies;
-  // Plugin support - set after construction to avoid circular dependencies
-  pluginManager;
+  toolExecutionContextFactory;
+  // Hook support - set after construction to avoid circular dependencies
+  hookManager;
   sessionManager;
   stateManager;
-  // Tool source prefixing - ALL tools get prefixed by source
+  workspaceManager;
+  currentWorkspace;
+  workspaceListenerAttached = false;
+  workspaceListenerAbort = new AbortController();
+  // Tool naming:
+  // - MCP tools are prefixed with `mcp--` for disambiguation.
+  // - Local tools use their `Tool.id` as-is (no internal/custom prefixing).
   static MCP_TOOL_PREFIX = "mcp--";
-  static INTERNAL_TOOL_PREFIX = "internal--";
-  static CUSTOM_TOOL_PREFIX = "custom--";
   // Tool caching for performance
   toolsCache = {};
   cacheValid = false;
@@ -108,7 +109,33 @@ let _ToolManager = class _ToolManager {
   // When a skill with allowedTools is invoked, those tools are auto-approved (skip confirmation)
   // This is ADDITIVE - other tools are NOT blocked, they just go through normal approval flow
   sessionAutoApproveTools = /* @__PURE__ */ new Map();
-  constructor(mcpManager, approvalManager, allowedToolsProvider, approvalMode, agentEventBus, toolPolicies, options, logger) {
+  // Session-level auto-approve tools set by users (UI)
+  sessionUserAutoApproveTools = /* @__PURE__ */ new Map();
+  sessionDisabledTools = /* @__PURE__ */ new Map();
+  globalDisabledTools = [];
+  cleanupHandlers = /* @__PURE__ */ new Set();
+  cleanupStarted = false;
+  resolveLocalToolIdOrAlias(name) {
+    const direct = this.agentTools.get(name);
+    if (direct) return direct.id;
+    const lower = name.toLowerCase();
+    for (const tool of this.agentTools.values()) {
+      if (tool.id.toLowerCase() === lower) {
+        return tool.id;
+      }
+      if (tool.aliases?.some((alias) => alias.toLowerCase() === lower)) {
+        return tool.id;
+      }
+    }
+    return null;
+  }
+  normalizeToolPolicyPattern(pattern) {
+    if (pattern.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
+      return pattern;
+    }
+    return this.resolveLocalToolIdOrAlias(pattern) ?? pattern;
+  }
+  constructor(mcpManager, approvalManager, allowedToolsProvider, approvalMode, agentEventBus, toolPolicies, tools, logger) {
     this.mcpManager = mcpManager;
     this.approvalManager = approvalManager;
     this.allowedToolsProvider = allowedToolsProvider;
@@ -116,18 +143,12 @@ let _ToolManager = class _ToolManager {
     this.agentEventBus = agentEventBus;
     this.toolPolicies = toolPolicies;
     this.logger = logger.createChild(import_types2.DextoLogComponent.TOOLS);
-    if (options?.internalToolsConfig && options.internalToolsConfig.length > 0 || options?.customToolsConfig && options.customToolsConfig.length > 0) {
-      const internalToolsServices = {
-        ...options.internalToolsServices,
-        approvalManager
-      };
-      this.internalToolsProvider = new import_provider.InternalToolsProvider(
-        internalToolsServices,
-        options.internalToolsConfig || [],
-        options.customToolsConfig || [],
-        this.logger
+    this.setTools(tools);
+    this.toolExecutionContextFactory = () => {
+      throw import_errors.ToolError.configInvalid(
+        "ToolExecutionContextFactory not configured. DextoAgent.start() must configure tool execution context before tools can run."
       );
-    }
+    };
     this.setupNotificationListeners();
     this.logger.debug("ToolManager initialized");
   }
@@ -135,50 +156,78 @@ let _ToolManager = class _ToolManager {
    * Initialize the ToolManager and its components
    */
   async initialize() {
-    if (this.internalToolsProvider) {
-      await this.internalToolsProvider.initialize();
-    }
     this.logger.debug("ToolManager initialization complete");
   }
+  setTools(tools) {
+    this.agentTools.clear();
+    for (const tool of tools) {
+      this.agentTools.set(tool.id, tool);
+    }
+    this.invalidateCache();
+  }
+  setToolExecutionContextFactory(factory) {
+    this.toolExecutionContextFactory = factory;
+  }
+  registerCleanup(handler) {
+    this.cleanupHandlers.add(handler);
+  }
+  async cleanup() {
+    if (this.cleanupStarted) {
+      return;
+    }
+    this.cleanupStarted = true;
+    for (const handler of this.cleanupHandlers) {
+      try {
+        await handler();
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        this.logger.warn(`ToolManager cleanup handler failed: ${err.message}`, {
+          color: "yellow"
+        });
+      }
+    }
+  }
   /**
-   * Set plugin support services (called after construction to avoid circular dependencies)
+   * Set hook support services (called after construction to avoid circular dependencies)
    */
-  setPluginSupport(pluginManager, sessionManager, stateManager) {
-    this.pluginManager = pluginManager;
+  setHookSupport(hookManager, sessionManager, stateManager) {
+    this.hookManager = hookManager;
     this.sessionManager = sessionManager;
     this.stateManager = stateManager;
-    this.logger.debug("Plugin support configured for ToolManager");
+    this.logger.debug("Hook support configured for ToolManager");
   }
   /**
-   * Set agent reference for custom tools (called after construction to avoid circular dependencies)
-   * Must be called before initialize() if custom tools are configured
+   * Set workspace manager for tool execution context propagation.
    */
-  setAgent(agent) {
-    if (this.internalToolsProvider) {
-      this.internalToolsProvider.setAgent(agent);
-      this.logger.debug("Agent reference configured for custom tools");
+  setWorkspaceManager(workspaceManager) {
+    this.workspaceManager = workspaceManager;
+    void this.refreshWorkspace();
+    if (!this.workspaceListenerAttached) {
+      this.workspaceListenerAttached = true;
+      this.agentEventBus.on(
+        "workspace:changed",
+        (payload) => {
+          this.currentWorkspace = payload.workspace ?? void 0;
+        },
+        { signal: this.workspaceListenerAbort.signal }
+      );
+      this.registerCleanup(() => {
+        if (!this.workspaceListenerAbort.signal.aborted) {
+          this.workspaceListenerAbort.abort();
+        }
+      });
     }
+    this.logger.debug("WorkspaceManager reference configured for ToolManager");
   }
-  /**
-   * Set prompt manager for invoke_skill tool (called after construction to avoid circular dependencies)
-   * Must be called before initialize() if invoke_skill tool is enabled
-   */
-  setPromptManager(promptManager) {
-    if (this.internalToolsProvider) {
-      this.internalToolsProvider.setPromptManager(promptManager);
-      this.logger.debug("PromptManager reference configured for invoke_skill tool");
+  async refreshWorkspace() {
+    if (!this.workspaceManager) {
+      return;
     }
-  }
-  /**
-   * Set task forker for context:fork skill execution (late-binding)
-   * Called by agent-spawner custom tool provider after RuntimeService is created.
-   * This enables invoke_skill to fork execution to an isolated subagent.
-   */
-  setTaskForker(taskForker) {
-    if (this.internalToolsProvider) {
-      this.internalToolsProvider.setTaskForker(taskForker);
+    try {
+      this.currentWorkspace = await this.workspaceManager.getWorkspace();
+    } catch (error) {
       this.logger.debug(
-        "TaskForker reference configured for invoke_skill (context:fork support)"
+        `Failed to refresh workspace context: ${error instanceof Error ? error.message : String(error)}`
       );
     }
   }
@@ -189,18 +238,48 @@ let _ToolManager = class _ToolManager {
    * This is ADDITIVE - other tools are NOT blocked, they just go through normal approval flow.
    *
    * @param sessionId The session ID
-   * @param autoApproveTools Array of tool names to auto-approve (e.g., ['custom--bash_exec', 'custom--read_file'])
+   * @param autoApproveTools Array of tool names to auto-approve (e.g., ['bash_exec', 'mcp--read_file'])
    */
   setSessionAutoApproveTools(sessionId, autoApproveTools) {
     if (autoApproveTools.length === 0) {
       this.clearSessionAutoApproveTools(sessionId);
       return;
     }
-    this.sessionAutoApproveTools.set(sessionId, autoApproveTools);
+    const normalized = autoApproveTools.map(
+      (pattern) => this.normalizeToolPolicyPattern(pattern)
+    );
+    this.sessionAutoApproveTools.set(sessionId, normalized);
     this.logger.info(
       `Session auto-approve tools set for '${sessionId}': ${autoApproveTools.length} tools`
     );
-    this.logger.debug(`Auto-approve tools: ${autoApproveTools.join(", ")}`);
+    this.logger.debug(`Auto-approve tools: ${normalized.join(", ")}`);
+  }
+  /**
+   * Set session-level auto-approve tools chosen by the user.
+   */
+  setSessionUserAutoApproveTools(sessionId, autoApproveTools) {
+    if (autoApproveTools.length === 0) {
+      this.clearSessionUserAutoApproveTools(sessionId);
+      return;
+    }
+    const normalized = autoApproveTools.map(
+      (pattern) => this.normalizeToolPolicyPattern(pattern)
+    );
+    this.sessionUserAutoApproveTools.set(sessionId, normalized);
+    this.logger.info(
+      `Session user auto-approve tools set for '${sessionId}': ${autoApproveTools.length} tools`
+    );
+    this.logger.debug(`User auto-approve tools: ${normalized.join(", ")}`);
+  }
+  /**
+   * Clear session-level auto-approve tools chosen by the user.
+   */
+  clearSessionUserAutoApproveTools(sessionId) {
+    const hadAutoApprove = this.sessionUserAutoApproveTools.has(sessionId);
+    this.sessionUserAutoApproveTools.delete(sessionId);
+    if (hadAutoApprove) {
+      this.logger.info(`Session user auto-approve tools cleared for '${sessionId}'`);
+    }
   }
   /**
    * Clear session-level auto-approve tools.
@@ -215,6 +294,76 @@ let _ToolManager = class _ToolManager {
       this.logger.info(`Session auto-approve tools cleared for '${sessionId}'`);
     }
   }
+  hasSessionUserAutoApproveTools(sessionId) {
+    return this.sessionUserAutoApproveTools.has(sessionId);
+  }
+  // ============= ENABLED/DISABLED TOOLS =============
+  /**
+   * Set global disabled tools (agent-level preferences).
+   */
+  setGlobalDisabledTools(toolNames) {
+    this.globalDisabledTools = [...toolNames];
+    this.logger.info("Global disabled tools updated", {
+      count: toolNames.length
+    });
+    this.agentEventBus.emit("tools:enabled-updated", {
+      scope: "global",
+      disabledTools: [...this.globalDisabledTools]
+    });
+  }
+  getGlobalDisabledTools() {
+    return [...this.globalDisabledTools];
+  }
+  /**
+   * Set session-level disabled tools (overrides global list).
+   */
+  setSessionDisabledTools(sessionId, toolNames) {
+    if (toolNames.length === 0) {
+      this.clearSessionDisabledTools(sessionId);
+      return;
+    }
+    this.sessionDisabledTools.set(sessionId, [...toolNames]);
+    this.logger.info("Session disabled tools updated", {
+      sessionId,
+      count: toolNames.length
+    });
+    this.agentEventBus.emit("tools:enabled-updated", {
+      scope: "session",
+      sessionId,
+      disabledTools: [...toolNames]
+    });
+  }
+  /**
+   * Clear session-level disabled tools.
+   */
+  clearSessionDisabledTools(sessionId) {
+    const hadOverrides = this.sessionDisabledTools.has(sessionId);
+    this.sessionDisabledTools.delete(sessionId);
+    if (hadOverrides) {
+      this.logger.info("Session disabled tools cleared", { sessionId });
+    }
+  }
+  /**
+   * Get disabled tools for a session (session override wins).
+   */
+  getDisabledTools(sessionId) {
+    if (sessionId && this.sessionDisabledTools.has(sessionId)) {
+      return this.sessionDisabledTools.get(sessionId) ?? [];
+    }
+    return this.globalDisabledTools;
+  }
+  /**
+   * Filter a tool set based on disabled tools for a session.
+   */
+  filterToolsForSession(toolSet, sessionId) {
+    const disabled = new Set(this.getDisabledTools(sessionId));
+    if (disabled.size === 0) {
+      return toolSet;
+    }
+    return Object.fromEntries(
+      Object.entries(toolSet).filter(([toolName]) => !disabled.has(toolName))
+    );
+  }
   /**
    * Check if a session has auto-approve tools set.
    *
@@ -225,7 +374,7 @@ let _ToolManager = class _ToolManager {
     return this.sessionAutoApproveTools.has(sessionId);
   }
   /**
-   * Get the auto-approve tools for a session.
+   * Get the auto-approve tools for a session (skill-provided list).
    *
    * @param sessionId The session ID to check
    * @returns Array of auto-approve tool names, or undefined if none set
@@ -233,6 +382,21 @@ let _ToolManager = class _ToolManager {
   getSessionAutoApproveTools(sessionId) {
     return this.sessionAutoApproveTools.get(sessionId);
   }
+  /**
+   * Get the user auto-approve tools for a session.
+   */
+  getSessionUserAutoApproveTools(sessionId) {
+    return this.sessionUserAutoApproveTools.get(sessionId);
+  }
+  /**
+   * Combined auto-approve list for a session.
+   */
+  getCombinedSessionAutoApproveTools(sessionId) {
+    return [
+      ...this.sessionAutoApproveTools.get(sessionId) ?? [],
+      ...this.sessionUserAutoApproveTools.get(sessionId) ?? []
+    ];
+  }
   /**
    * Check if a tool should be auto-approved for a session.
    * Returns true if the tool is in the session's auto-approve list.
@@ -242,8 +406,8 @@ let _ToolManager = class _ToolManager {
    * @returns true if the tool should be auto-approved
    */
   isToolAutoApprovedForSession(sessionId, toolName) {
-    const autoApproveTools = this.sessionAutoApproveTools.get(sessionId);
-    if (!autoApproveTools) {
+    const autoApproveTools = this.getCombinedSessionAutoApproveTools(sessionId);
+    if (autoApproveTools.length === 0) {
       return false;
     }
     return autoApproveTools.some((pattern) => this.matchesToolPolicy(toolName, pattern));
@@ -282,39 +446,44 @@ let _ToolManager = class _ToolManager {
       }
     });
   }
-  // ==================== Bash Pattern Approval Helpers ====================
-  /**
-   * Check if a tool name represents a bash execution tool
-   */
-  isBashTool(toolName) {
-    return toolName === "bash_exec" || toolName === "internal--bash_exec" || toolName === "custom--bash_exec";
+  // ==================== Pattern Approval Helpers ====================
+  getToolPatternKey(toolName, args) {
+    if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
+      return null;
+    }
+    const tool = this.agentTools.get(toolName);
+    if (!tool?.getApprovalPatternKey) {
+      return null;
+    }
+    try {
+      return tool.getApprovalPatternKey(args);
+    } catch (error) {
+      this.logger.debug(
+        `Pattern key generation failed for '${toolName}': ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
   }
-  /**
-   * Check if a bash command is covered by any approved pattern.
-   * Generates a pattern key from the command, then checks if it's covered by stored patterns.
-   *
-   * Returns approval info if covered, or pattern suggestions if not.
-   */
-  checkBashPatternApproval(command) {
-    const patternKey = (0, import_bash_pattern_utils.generateBashPatternKey)(command);
-    if (!patternKey) {
-      if ((0, import_bash_pattern_utils.isDangerousCommand)(command)) {
-        this.logger.debug(
-          `Skipping pattern generation for dangerous command: ${command.split(/\s+/)[0]}`
-        );
-      }
-      return { approved: false, suggestedPatterns: [] };
+  getToolSuggestedPatterns(toolName, args) {
+    if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
+      return void 0;
     }
-    if (this.approvalManager.matchesBashPattern(patternKey)) {
-      return { approved: true };
+    const tool = this.agentTools.get(toolName);
+    if (!tool?.suggestApprovalPatterns) {
+      return void 0;
+    }
+    try {
+      const patterns = tool.suggestApprovalPatterns(args);
+      return patterns.length > 0 ? patterns : void 0;
+    } catch (error) {
+      this.logger.debug(
+        `Pattern suggestion failed for '${toolName}': ${error instanceof Error ? error.message : String(error)}`
+      );
+      return void 0;
     }
-    return {
-      approved: false,
-      suggestedPatterns: (0, import_bash_pattern_utils.generateBashPatternSuggestions)(command)
-    };
   }
   /**
-   * Auto-approve pending tool confirmation requests for the same tool.
+   * Auto-approve pending tool approval requests for the same tool.
    * Called after a user selects "remember choice" for a tool.
    * This handles the case where parallel tool calls come in before the first one is approved.
    *
@@ -324,7 +493,7 @@ let _ToolManager = class _ToolManager {
   autoApprovePendingToolRequests(toolName, sessionId) {
     const count = this.approvalManager.autoApprovePendingRequests(
       (request) => {
-        if (request.type !== import_types3.ApprovalType.TOOL_CONFIRMATION) {
+        if (request.type !== import_types3.ApprovalType.TOOL_APPROVAL) {
           return false;
         }
         if (request.sessionId !== sessionId) {
@@ -343,42 +512,86 @@ let _ToolManager = class _ToolManager {
     }
   }
   /**
-   * Auto-approve pending bash command requests that match a pattern.
-   * Called after a user selects "remember pattern" for a bash command.
-   * This handles the case where parallel bash commands come in before the first one is approved.
-   *
-   * @param pattern The bash pattern that was just remembered
-   * @param sessionId The session ID for context
+   * Auto-approve pending tool approval requests that are now covered by a remembered pattern.
+   * Called after a user selects "remember pattern" for a tool.
    */
-  autoApprovePendingBashRequests(pattern, sessionId) {
+  autoApprovePendingPatternRequests(toolName, sessionId) {
+    if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
+      return;
+    }
+    const tool = this.agentTools.get(toolName);
+    const getPatternKey = tool?.getApprovalPatternKey;
+    if (!getPatternKey) {
+      return;
+    }
     const count = this.approvalManager.autoApprovePendingRequests(
       (request) => {
-        if (request.type !== import_types3.ApprovalType.TOOL_CONFIRMATION) {
+        if (request.type !== import_types3.ApprovalType.TOOL_APPROVAL) {
           return false;
         }
         if (request.sessionId !== sessionId) {
           return false;
         }
         const metadata = request.metadata;
-        if (!this.isBashTool(metadata.toolName)) {
+        if (metadata.toolName !== toolName) {
           return false;
         }
-        const command = metadata.args?.command;
-        if (!command) {
+        const args = metadata.args;
+        if (typeof args !== "object" || args === null) {
           return false;
         }
-        const patternKey = (0, import_bash_pattern_utils.generateBashPatternKey)(command);
-        if (!patternKey) {
+        let patternKey;
+        try {
+          patternKey = getPatternKey(args);
+        } catch (error) {
+          this.logger.debug(
+            `Pattern key generation failed for '${toolName}': ${error instanceof Error ? error.message : String(error)}`
+          );
           return false;
         }
-        return this.approvalManager.matchesBashPattern(patternKey);
+        if (!patternKey) return false;
+        return this.approvalManager.matchesPattern(toolName, patternKey);
       },
       { rememberPattern: void 0 }
-      // Don't propagate pattern to auto-approved requests
+      // Don't propagate pattern choice to auto-approved requests
     );
     if (count > 0) {
       this.logger.info(
-        `Auto-approved ${count} parallel bash command(s) matching pattern '${pattern}'`
+        `Auto-approved ${count} parallel request(s) for tool '${toolName}' after user selected "remember pattern"`
+      );
+    }
+  }
+  /**
+   * Auto-approve pending directory access requests that match a newly approved directory access request.
+   *
+   * This handles the case where parallel file operations request directory approval concurrently.
+   */
+  autoApprovePendingDirectoryAccessRequests(options) {
+    const count = this.approvalManager.autoApprovePendingRequests(
+      (request) => {
+        if (request.type !== import_types3.ApprovalType.DIRECTORY_ACCESS) {
+          return false;
+        }
+        if (request.sessionId !== options.sessionId) {
+          return false;
+        }
+        const metadata = request.metadata;
+        if (typeof metadata?.parentDir !== "string" || metadata.parentDir !== options.parentDir) {
+          return false;
+        }
+        if (options.rememberDirectory) {
+          return true;
+        }
+        if (typeof metadata?.operation !== "string" || typeof metadata?.toolName !== "string") {
+          return false;
+        }
+        return metadata.operation === options.operation && metadata.toolName === options.toolName;
+      },
+      { rememberDirectory: false }
+    );
+    if (count > 0) {
+      this.logger.info(
+        `Auto-approved ${count} parallel request(s) for directory '${options.parentDir}' after directory access was approved`
       );
     }
   }
@@ -392,11 +605,66 @@ let _ToolManager = class _ToolManager {
   async getMcpTools() {
     return await this.mcpManager.getAllTools();
   }
+  buildToolExecutionContext(options) {
+    const workspace = this.currentWorkspace;
+    const baseContext = {
+      sessionId: options.sessionId,
+      workspaceId: workspace?.id,
+      workspace,
+      abortSignal: options.abortSignal,
+      toolCallId: options.toolCallId,
+      logger: this.logger
+    };
+    return this.toolExecutionContextFactory(baseContext);
+  }
+  validateLocalToolArgsOrThrow(toolName, args) {
+    if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
+      return args;
+    }
+    const tool = this.agentTools.get(toolName);
+    if (!tool) {
+      return args;
+    }
+    const validationResult = tool.inputSchema.safeParse(args);
+    if (!validationResult.success) {
+      this.logger.error(
+        `\u274C Invalid arguments for tool ${toolName}: ${validationResult.error.message}`
+      );
+      throw import_errors.ToolError.validationFailed(
+        toolName,
+        `Invalid arguments: ${validationResult.error.message}`
+      );
+    }
+    const validated = validationResult.data;
+    if (typeof validated !== "object" || validated === null || Array.isArray(validated)) {
+      throw import_errors.ToolError.validationFailed(toolName, "Invalid arguments: expected an object");
+    }
+    return validated;
+  }
+  async executeLocalTool(toolName, args, sessionId, abortSignal, toolCallId) {
+    const tool = this.agentTools.get(toolName);
+    if (!tool) {
+      this.logger.error(`\u274C No local tool found: ${toolName}`);
+      this.logger.debug(
+        `Available local tools: ${Array.from(this.agentTools.keys()).join(", ")}`
+      );
+      throw import_errors.ToolError.notFound(toolName);
+    }
+    try {
+      const context = this.buildToolExecutionContext({ sessionId, abortSignal, toolCallId });
+      const result = await tool.execute(args, context);
+      return result;
+    } catch (error) {
+      this.logger.error(`\u274C Local tool execution failed: ${toolName}`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
   /**
-   * Build all tools from sources with universal prefixing
-   * ALL tools get prefixed by their source - no exceptions
+   * Build all tools from sources.
    *
-   * TODO: Rethink tool naming convention for more consistency
+   * TODO: Rethink MCP tool naming convention for more consistency.
    * Current issue: MCP tools have dynamic naming based on conflicts:
    * - No conflict: mcp--toolName
    * - With conflict: mcp--serverName--toolName
@@ -409,8 +677,6 @@ let _ToolManager = class _ToolManager {
   async buildAllTools() {
     const allTools = {};
     let mcpTools = {};
-    let internalTools = {};
-    let customTools = {};
     try {
       mcpTools = await this.mcpManager.getAllTools();
     } catch (error) {
@@ -419,36 +685,13 @@ let _ToolManager = class _ToolManager {
       );
       mcpTools = {};
     }
-    try {
-      internalTools = this.internalToolsProvider?.getInternalTools() || {};
-    } catch (error) {
-      this.logger.error(
-        `Failed to get internal tools: ${error instanceof Error ? error.message : String(error)}`
-      );
-      internalTools = {};
-    }
-    try {
-      customTools = this.internalToolsProvider?.getCustomTools() || {};
-    } catch (error) {
-      this.logger.error(
-        `Failed to get custom tools: ${error instanceof Error ? error.message : String(error)}`
-      );
-      customTools = {};
-    }
-    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(customTools)) {
-      const qualifiedName = `${_ToolManager.CUSTOM_TOOL_PREFIX}${toolName}`;
-      allTools[qualifiedName] = {
-        ...toolDef,
-        name: qualifiedName,
-        description: `${toolDef.description || "No description provided"} (custom tool)`
+    for (const [toolName, tool] of this.agentTools) {
+      allTools[toolName] = {
+        name: toolName,
+        description: tool.description || "No description provided",
+        parameters: (0, import_tool_call_metadata.wrapToolParametersSchema)(
+          (0, import_schema.convertZodSchemaToJsonSchema)(tool.inputSchema, this.logger)
+        )
       };
     }
     for (const [toolName, toolDef] of Object.entries(mcpTools)) {
@@ -456,15 +699,15 @@ let _ToolManager = class _ToolManager {
       allTools[qualifiedName] = {
         ...toolDef,
         name: qualifiedName,
-        description: `${toolDef.description || "No description provided"} (via MCP servers)`
+        description: `${toolDef.description || "No description provided"} (via MCP servers)`,
+        parameters: (0, import_tool_call_metadata.wrapToolParametersSchema)(toolDef.parameters)
       };
     }
     const totalTools = Object.keys(allTools).length;
     const mcpCount = Object.keys(mcpTools).length;
-    const internalCount = Object.keys(internalTools).length;
-    const customCount = Object.keys(customTools).length;
+    const localCount = this.agentTools.size;
     this.logger.debug(
-      `\u{1F527} Unified tool discovery: ${totalTools} total tools (${mcpCount} MCP, ${internalCount} internal, ${customCount} custom)`
+      `\u{1F527} Unified tool discovery: ${totalTools} total tools (${mcpCount} MCP, ${localCount} local)`
     );
     return allTools;
   }
@@ -482,32 +725,44 @@ let _ToolManager = class _ToolManager {
     return this.toolsCache;
   }
   /**
-   * Execute a tool by routing based on universal prefix
-   * ALL tools must have source prefix - no exceptions
+   * Execute a tool by routing based on prefix:
+   * - MCP tools: `mcp--...`
+   * - Local tools: `Tool.id`
    *
-   * @param toolName The fully qualified tool name (e.g., "internal--edit_file")
+   * @param toolName Tool name (e.g., "edit_file", "mcp--filesystem--read_file")
    * @param args The arguments for the tool
    * @param toolCallId The unique tool call ID for tracking (from LLM or generated for direct calls)
    * @param sessionId Optional session ID for context
    * @param abortSignal Optional abort signal for cancellation support
    */
   async executeTool(toolName, args, toolCallId, sessionId, abortSignal) {
+    const { toolArgs: rawToolArgs, meta } = (0, import_tool_call_metadata.extractToolCallMeta)(args);
+    let toolArgs = rawToolArgs;
+    const backgroundTasksEnabled = (0, import_env.isBackgroundTasksEnabled)();
+    const toolDisplayName = this.agentTools.get(toolName)?.displayName;
     this.logger.debug(`\u{1F527} Tool execution requested: '${toolName}' (toolCallId: ${toolCallId})`);
-    this.logger.debug(`Tool args: ${JSON.stringify(args, null, 2)}`);
+    this.logger.debug(`Tool args: ${JSON.stringify(toolArgs, null, 2)}`);
     if (sessionId) {
       this.agentEventBus.emit("llm:tool-call", {
         toolName,
-        args,
+        ...toolDisplayName !== void 0 && { toolDisplayName },
+        args: toolArgs,
         callId: toolCallId,
         sessionId
       });
     }
-    const { requireApproval, approvalStatus } = await this.handleToolApproval(
+    const {
+      requireApproval,
+      approvalStatus,
+      args: validatedToolArgs
+    } = await this.handleToolApproval(
       toolName,
-      args,
+      toolArgs,
       toolCallId,
-      sessionId
+      sessionId,
+      meta.callDescription
     );
+    toolArgs = validatedToolArgs;
     this.logger.debug(`\u2705 Tool execution approved: ${toolName}`);
     this.logger.info(
       `\u{1F527} Tool execution started for ${toolName}, sessionId: ${sessionId ?? "global"}`
@@ -520,13 +775,13 @@ let _ToolManager = class _ToolManager {
       });
     }
     const startTime = Date.now();
-    if (this.pluginManager && this.sessionManager && this.stateManager) {
+    if (this.hookManager && this.sessionManager && this.stateManager) {
       const beforePayload = {
         toolName,
-        args,
+        args: toolArgs,
         ...sessionId !== void 0 && { sessionId }
       };
-      const modifiedPayload = await this.pluginManager.executePlugins(
+      const modifiedPayload = await this.hookManager.executeHooks(
         "beforeToolCall",
         beforePayload,
         {
@@ -537,10 +792,29 @@ let _ToolManager = class _ToolManager {
           ...sessionId !== void 0 && { sessionId }
         }
       );
-      args = modifiedPayload.args;
+      toolArgs = modifiedPayload.args;
+      try {
+        toolArgs = this.validateLocalToolArgsOrThrow(toolName, toolArgs);
+      } catch (error) {
+        this.logger.error(
+          `Post-hook validation failed for tool '${toolName}': a beforeToolCall hook may have set invalid args`
+        );
+        throw error;
+      }
     }
     try {
       let result;
+      const registerBackgroundTask = (promise, description) => {
+        const fallbackId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        return {
+          result: {
+            taskId: toolCallId ?? fallbackId,
+            status: "running",
+            description
+          },
+          promise
+        };
+      };
       if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
         this.logger.debug(`\u{1F527} Detected MCP tool: '${toolName}'`);
         const actualToolName = toolName.substring(_ToolManager.MCP_TOOL_PREFIX.length);
@@ -548,65 +822,89 @@ let _ToolManager = class _ToolManager {
           throw import_errors.ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
         }
         this.logger.debug(`\u{1F3AF} MCP routing: '${toolName}' -> '${actualToolName}'`);
-        result = await this.mcpManager.executeTool(actualToolName, args, sessionId);
-      } else if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX)) {
-        this.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");
+        const runInBackground = backgroundTasksEnabled && meta.runInBackground === true && sessionId !== void 0;
+        if (meta.runInBackground === true && !backgroundTasksEnabled) {
+          this.logger.debug(
+            "Background tool execution disabled; running synchronously instead.",
+            { toolName }
+          );
         }
-        if (!this.internalToolsProvider) {
-          throw import_errors.ToolError.internalToolsNotInitialized(toolName);
+        if (runInBackground) {
+          const backgroundSessionId = sessionId;
+          const { result: backgroundResult, promise } = registerBackgroundTask(
+            this.mcpManager.executeTool(actualToolName, toolArgs, backgroundSessionId),
+            `MCP tool ${actualToolName}`
+          );
+          this.agentEventBus.emit("tool:background", {
+            toolName,
+            toolCallId: backgroundResult.taskId,
+            sessionId: backgroundSessionId,
+            description: backgroundResult.description,
+            promise,
+            ...meta.timeoutMs !== void 0 && { timeoutMs: meta.timeoutMs },
+            ...meta.notifyOnComplete !== void 0 && {
+              notifyOnComplete: meta.notifyOnComplete
+            }
+          });
+          result = backgroundResult;
+        } else {
+          result = await this.mcpManager.executeTool(actualToolName, toolArgs, sessionId);
         }
-        this.logger.debug(`\u{1F3AF} Internal routing: '${toolName}' -> '${actualToolName}'`);
-        result = await this.internalToolsProvider.executeTool(
-          actualToolName,
-          args,
-          sessionId,
-          abortSignal,
-          toolCallId
-        );
-      } else if (toolName.startsWith(_ToolManager.CUSTOM_TOOL_PREFIX)) {
-        this.logger.debug(`\u{1F527} Detected custom tool: '${toolName}'`);
-        const actualToolName = toolName.substring(_ToolManager.CUSTOM_TOOL_PREFIX.length);
-        if (actualToolName.length === 0) {
-          throw import_errors.ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
+      } else {
+        const runInBackground = backgroundTasksEnabled && meta.runInBackground === true && sessionId !== void 0;
+        if (meta.runInBackground === true && !backgroundTasksEnabled) {
+          this.logger.debug(
+            "Background tool execution disabled; running synchronously instead.",
+            { toolName }
+          );
         }
-        if (!this.internalToolsProvider) {
-          throw import_errors.ToolError.internalToolsNotInitialized(toolName);
+        if (runInBackground) {
+          const backgroundSessionId = sessionId;
+          const { result: backgroundResult, promise } = registerBackgroundTask(
+            this.executeLocalTool(
+              toolName,
+              toolArgs,
+              backgroundSessionId,
+              abortSignal,
+              toolCallId
+            ),
+            `Tool ${toolName}`
+          );
+          this.agentEventBus.emit("tool:background", {
+            toolName,
+            toolCallId: backgroundResult.taskId,
+            sessionId: backgroundSessionId,
+            description: backgroundResult.description,
+            promise,
+            ...meta.timeoutMs !== void 0 && { timeoutMs: meta.timeoutMs },
+            ...meta.notifyOnComplete !== void 0 && {
+              notifyOnComplete: meta.notifyOnComplete
+            }
+          });
+          result = backgroundResult;
+        } else {
+          result = await this.executeLocalTool(
+            toolName,
+            toolArgs,
+            sessionId,
+            abortSignal,
+            toolCallId
+          );
         }
-        this.logger.debug(`\u{1F3AF} Custom routing: '${toolName}' -> '${actualToolName}'`);
-        result = await this.internalToolsProvider.executeTool(
-          actualToolName,
-          args,
-          sessionId,
-          abortSignal,
-          toolCallId
-        );
-      } else {
-        this.logger.debug(`\u{1F527} Detected tool without proper prefix: '${toolName}'`);
-        const stats = await this.getToolStats();
-        this.logger.error(
-          `\u274C Tool missing source prefix: '${toolName}' (expected '${_ToolManager.MCP_TOOL_PREFIX}*', '${_ToolManager.INTERNAL_TOOL_PREFIX}*', or '${_ToolManager.CUSTOM_TOOL_PREFIX}*')`
-        );
-        this.logger.debug(
-          `Available: ${stats.mcp} MCP, ${stats.internal} internal, ${stats.custom} custom tools`
-        );
-        throw import_errors.ToolError.notFound(toolName);
       }
       const duration = Date.now() - startTime;
       this.logger.debug(`\u{1F3AF} Tool execution completed in ${duration}ms: '${toolName}'`);
       this.logger.info(
         `\u2705 Tool execution completed successfully for ${toolName} in ${duration}ms, sessionId: ${sessionId ?? "global"}`
       );
-      if (this.pluginManager && this.sessionManager && this.stateManager) {
+      if (this.hookManager && this.sessionManager && this.stateManager) {
         const afterPayload = {
           toolName,
           result,
           success: true,
           ...sessionId !== void 0 && { sessionId }
         };
-        const modifiedPayload = await this.pluginManager.executePlugins(
+        const modifiedPayload = await this.hookManager.executeHooks(
           "afterToolResult",
           afterPayload,
           {
@@ -621,6 +919,7 @@ let _ToolManager = class _ToolManager {
       }
       return {
         result,
+        ...toolDisplayName !== void 0 && { toolDisplayName },
         ...requireApproval && { requireApproval, approvalStatus }
       };
     } catch (error) {
@@ -628,14 +927,14 @@ let _ToolManager = class _ToolManager {
       this.logger.error(
         `\u274C Tool execution failed for ${toolName} after ${duration}ms, sessionId: ${sessionId ?? "global"}: ${error instanceof Error ? error.message : String(error)}`
       );
-      if (this.pluginManager && this.sessionManager && this.stateManager) {
+      if (this.hookManager && this.sessionManager && this.stateManager) {
         const afterPayload = {
           toolName,
           result: error instanceof Error ? error.message : String(error),
           success: false,
           ...sessionId !== void 0 && { sessionId }
         };
-        await this.pluginManager.executePlugins("afterToolResult", afterPayload, {
+        await this.hookManager.executeHooks("afterToolResult", afterPayload, {
           sessionManager: this.sessionManager,
           mcpManager: this.mcpManager,
           toolManager: this,
@@ -647,30 +946,20 @@ let _ToolManager = class _ToolManager {
     }
   }
   /**
-   * Check if a tool exists (must have proper source prefix)
+   * Check if a tool exists.
    */
   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?.hasInternalTool(actualToolName) ?? false;
-    }
-    if (toolName.startsWith(_ToolManager.CUSTOM_TOOL_PREFIX)) {
-      const actualToolName = toolName.substring(_ToolManager.CUSTOM_TOOL_PREFIX.length);
-      return this.internalToolsProvider?.hasCustomTool(actualToolName) ?? false;
-    }
-    return false;
+    return this.agentTools.has(toolName);
   }
   /**
    * Get tool statistics across all sources
    */
   async getToolStats() {
     let mcpTools = {};
-    let internalTools = {};
-    let customTools = {};
     try {
       mcpTools = await this.mcpManager.getAllTools();
     } catch (error) {
@@ -679,34 +968,16 @@ let _ToolManager = class _ToolManager {
       );
       mcpTools = {};
     }
-    try {
-      internalTools = this.internalToolsProvider?.getInternalTools() || {};
-    } catch (error) {
-      this.logger.error(
-        `Failed to get internal tools for stats: ${error instanceof Error ? error.message : String(error)}`
-      );
-      internalTools = {};
-    }
-    try {
-      customTools = this.internalToolsProvider?.getCustomTools() || {};
-    } catch (error) {
-      this.logger.error(
-        `Failed to get custom tools for stats: ${error instanceof Error ? error.message : String(error)}`
-      );
-      customTools = {};
-    }
     const mcpCount = Object.keys(mcpTools).length;
-    const internalCount = Object.keys(internalTools).length;
-    const customCount = Object.keys(customTools).length;
+    const localCount = this.agentTools.size;
     return {
-      total: mcpCount + internalCount + customCount,
+      total: mcpCount + localCount,
       mcp: mcpCount,
-      internal: internalCount,
-      custom: customCount
+      local: localCount
     };
   }
   /**
-   * Get the source of a tool (mcp, internal, custom, or unknown)
+   * Get the source of a tool (mcp, local, or unknown).
    * @param toolName The name of the tool to check
    * @returns The source of the tool
    */
@@ -714,11 +985,8 @@ let _ToolManager = class _ToolManager {
     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";
-    }
-    if (toolName.startsWith(_ToolManager.CUSTOM_TOOL_PREFIX) && toolName.length > _ToolManager.CUSTOM_TOOL_PREFIX.length) {
-      return "custom";
+    if (this.agentTools.has(toolName)) {
+      return "local";
     }
     return "unknown";
   }
@@ -729,7 +997,7 @@ let _ToolManager = class _ToolManager {
    * Examples:
    * - Policy "mcp--read_file" matches "mcp--read_file" (exact)
    * - Policy "mcp--read_file" matches "mcp--filesystem--read_file" (suffix)
-   * - Policy "internal--ask_user" matches "internal--ask_user" (exact only)
+   * - Policy "read_file" matches "read_file" (local tool exact only)
    *
    * @param toolName The fully qualified tool name (e.g., "mcp--filesystem--read_file")
    * @param policyPattern The policy pattern to match against (e.g., "mcp--read_file")
@@ -780,26 +1048,21 @@ let _ToolManager = class _ToolManager {
    * Tools can implement getApprovalOverride() to request specialized approval flows
    * (e.g., directory access approval for file tools) instead of default tool confirmation.
    *
-   * @param toolName The fully qualified tool name
+   * @param toolName Tool name
    * @param args The tool arguments
    * @param sessionId Optional session ID
    * @returns { handled: true } if custom approval was processed, { handled: false } to continue normal flow
    */
-  async checkCustomApprovalOverride(toolName, args, sessionId) {
-    let actualToolName;
-    if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX)) {
-      actualToolName = toolName.substring(_ToolManager.INTERNAL_TOOL_PREFIX.length);
-    } else if (toolName.startsWith(_ToolManager.CUSTOM_TOOL_PREFIX)) {
-      actualToolName = toolName.substring(_ToolManager.CUSTOM_TOOL_PREFIX.length);
-    }
-    if (!actualToolName || !this.internalToolsProvider) {
+  async checkCustomApprovalOverride(toolName, args, toolCallId, sessionId) {
+    if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
       return { handled: false };
     }
-    const tool = this.internalToolsProvider.getTool(actualToolName);
+    const tool = this.agentTools.get(toolName);
     if (!tool?.getApprovalOverride) {
       return { handled: false };
     }
-    const approvalRequest = await tool.getApprovalOverride(args);
+    const context = this.buildToolExecutionContext({ sessionId, toolCallId });
+    const approvalRequest = await tool.getApprovalOverride(args, context);
     if (!approvalRequest) {
       return { handled: false };
     }
@@ -812,7 +1075,23 @@ let _ToolManager = class _ToolManager {
     const response = await this.approvalManager.requestApproval(approvalRequest);
     if (response.status === import_types3.ApprovalStatus.APPROVED) {
       if (tool.onApprovalGranted) {
-        tool.onApprovalGranted(response);
+        tool.onApprovalGranted(response, context, approvalRequest);
+      }
+      if (approvalRequest.type === import_types3.ApprovalType.DIRECTORY_ACCESS) {
+        const metadata = approvalRequest.metadata;
+        const parentDir = typeof metadata?.parentDir === "string" ? metadata.parentDir : null;
+        const operation = typeof metadata?.operation === "string" ? metadata.operation : null;
+        if (parentDir && operation) {
+          const data = response.data;
+          const rememberDirectory = data?.rememberDirectory ?? false;
+          this.autoApprovePendingDirectoryAccessRequests({
+            parentDir,
+            operation,
+            sessionId,
+            toolName,
+            rememberDirectory
+          });
+        }
       }
       this.logger.info(
         `Custom approval granted for '${toolName}', type=${approvalRequest.type}, session=${sessionId ?? "global"}`
@@ -835,12 +1114,25 @@ let _ToolManager = class _ToolManager {
    * Handle tool approval flow. Checks various precedence levels to determine
    * if a tool should be auto-approved, denied, or requires manual approval.
    */
-  async handleToolApproval(toolName, args, toolCallId, sessionId) {
-    const quickResult = await this.tryQuickApprovalResolution(toolName, args, sessionId);
+  async handleToolApproval(toolName, args, toolCallId, sessionId, callDescription) {
+    const validatedArgs = this.validateLocalToolArgsOrThrow(toolName, args);
+    const quickResult = await this.tryQuickApprovalResolution(
+      toolName,
+      validatedArgs,
+      toolCallId,
+      sessionId
+    );
     if (quickResult !== null) {
-      return quickResult;
+      return { ...quickResult, args: validatedArgs };
     }
-    return this.requestManualApproval(toolName, args, toolCallId, sessionId);
+    const manualResult = await this.requestManualApproval(
+      toolName,
+      validatedArgs,
+      toolCallId,
+      sessionId,
+      callDescription
+    );
+    return { ...manualResult, args: validatedArgs };
   }
   /**
    * Try to resolve tool approval quickly based on policies and cached permissions.
@@ -852,10 +1144,10 @@ let _ToolManager = class _ToolManager {
    * 3. Session auto-approve (skill allowed-tools)
    * 4. Static allow list
    * 5. Dynamic "remembered" allowed list
-   * 6. Bash command patterns
+   * 6. Tool approval patterns
    * 7. Approval mode (auto-approve/auto-deny)
    */
-  async tryQuickApprovalResolution(toolName, args, sessionId) {
+  async tryQuickApprovalResolution(toolName, args, toolCallId, sessionId) {
     if (this.isInAlwaysDenyList(toolName)) {
       this.logger.info(
         `Tool '${toolName}' is in static deny list \u2013 blocking execution (session: ${sessionId ?? "global"})`
@@ -865,6 +1157,7 @@ let _ToolManager = class _ToolManager {
     const customApprovalResult = await this.checkCustomApprovalOverride(
       toolName,
       args,
+      toolCallId,
       sessionId
     );
     if (customApprovalResult.handled) {
@@ -888,17 +1181,12 @@ let _ToolManager = class _ToolManager {
       );
       return { requireApproval: false };
     }
-    if (this.isBashTool(toolName)) {
-      const command = args.command;
-      if (command) {
-        const bashResult = this.checkBashPatternApproval(command);
-        if (bashResult.approved) {
-          this.logger.info(
-            `Bash command '${command}' matched approved pattern \u2013 skipping confirmation.`
-          );
-          return { requireApproval: false };
-        }
-      }
+    const patternKey = this.getToolPatternKey(toolName, args);
+    if (patternKey && this.approvalManager.matchesPattern(toolName, patternKey)) {
+      this.logger.info(
+        `Tool '${toolName}' matched approved pattern key '${patternKey}' \u2013 skipping confirmation.`
+      );
+      return { requireApproval: false };
     }
     if (this.approvalMode === "auto-approve") {
       this.logger.debug(`\u{1F7E2} Auto-approving tool execution: ${toolName}`);
@@ -914,22 +1202,25 @@ let _ToolManager = class _ToolManager {
    * Request manual approval from the user for a tool execution.
    * Generates preview, sends approval request, and handles the response.
    */
-  async requestManualApproval(toolName, args, toolCallId, sessionId) {
+  async requestManualApproval(toolName, args, toolCallId, sessionId, callDescription) {
     this.logger.info(
-      `Tool confirmation requested for ${toolName}, sessionId: ${sessionId ?? "global"}`
+      `Tool approval requested for ${toolName}, sessionId: ${sessionId ?? "global"}`
     );
     try {
+      const toolDisplayName = this.agentTools.get(toolName)?.displayName;
       const displayPreview = await this.generateToolPreview(
         toolName,
         args,
         toolCallId,
         sessionId
       );
-      const suggestedPatterns = this.getBashSuggestedPatterns(toolName, args);
-      const response = await this.approvalManager.requestToolConfirmation({
+      const suggestedPatterns = this.getToolSuggestedPatterns(toolName, args);
+      const response = await this.approvalManager.requestToolApproval({
         toolName,
+        ...toolDisplayName !== void 0 && { toolDisplayName },
         toolCallId,
         args,
+        ...callDescription !== void 0 && { description: callDescription },
         ...sessionId !== void 0 && { sessionId },
         ...displayPreview !== void 0 && { displayPreview },
         ...suggestedPatterns !== void 0 && { suggestedPatterns }
@@ -941,12 +1232,12 @@ let _ToolManager = class _ToolManager {
         this.handleApprovalDenied(toolName, response, sessionId);
       }
       this.logger.info(
-        `Tool confirmation approved for ${toolName}, sessionId: ${sessionId ?? "global"}`
+        `Tool approval approved for ${toolName}, sessionId: ${sessionId ?? "global"}`
       );
       return { requireApproval: true, approvalStatus: "approved" };
     } catch (error) {
       this.logger.error(
-        `Tool confirmation error for ${toolName}: ${error instanceof Error ? error.message : String(error)}`
+        `Tool approval error for ${toolName}: ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
     }
@@ -955,14 +1246,13 @@ let _ToolManager = class _ToolManager {
    * Generate a preview for the tool approval UI if the tool supports it.
    */
   async generateToolPreview(toolName, args, toolCallId, sessionId) {
-    const actualToolName = toolName.replace(/^internal--/, "").replace(/^custom--/, "");
-    const internalTool = this.internalToolsProvider?.getTool(actualToolName);
-    if (!internalTool?.generatePreview) {
+    const tool = this.agentTools.get(toolName);
+    if (!tool?.generatePreview) {
       return void 0;
     }
     try {
-      const context = { sessionId, toolCallId };
-      const preview = await internalTool.generatePreview(args, context);
+      const context = this.buildToolExecutionContext({ sessionId, toolCallId });
+      const preview = await tool.generatePreview(args, context);
       this.logger.debug(`Generated preview for ${toolName}`);
       return preview ?? void 0;
     } catch (previewError) {
@@ -976,20 +1266,6 @@ let _ToolManager = class _ToolManager {
       return void 0;
     }
   }
-  /**
-   * Get suggested bash patterns for the approval UI.
-   */
-  getBashSuggestedPatterns(toolName, args) {
-    if (!this.isBashTool(toolName)) {
-      return void 0;
-    }
-    const command = args.command;
-    if (!command) {
-      return void 0;
-    }
-    const result = this.checkBashPatternApproval(command);
-    return result.suggestedPatterns?.length ? result.suggestedPatterns : void 0;
-  }
   /**
    * Handle "remember choice" or "remember pattern" when user approves a tool.
    */
@@ -1005,10 +1281,10 @@ let _ToolManager = class _ToolManager {
         `Tool '${toolName}' added to allowed tools for session '${allowSessionId ?? "global"}' (remember choice selected)`
       );
       this.autoApprovePendingToolRequests(toolName, allowSessionId);
-    } else if (rememberPattern && this.isBashTool(toolName)) {
-      this.approvalManager.addBashPattern(rememberPattern);
-      this.logger.info(`Bash pattern '${rememberPattern}' added for session approval`);
-      this.autoApprovePendingBashRequests(rememberPattern, sessionId);
+    } else if (rememberPattern && this.agentTools.get(toolName)?.getApprovalPatternKey) {
+      this.approvalManager.addPattern(toolName, rememberPattern);
+      this.logger.info(`Pattern '${rememberPattern}' added for tool '${toolName}' approval`);
+      this.autoApprovePendingPatternRequests(toolName, sessionId);
     }
   }
   /**