@dexto/core 1.3.0 → 1.5.0

package/dist/tools/tool-manager.js

@@ -2,13 +2,20 @@ import {
   __decorateElement,
   __decoratorStart,
   __runInitializers
-} from "../chunk-C6A6W6XS.js";
+} from "../chunk-PTJYTZNU.js";
 var _ToolManager_decorators, _init;
 import { InternalToolsProvider } from "./internal-tools/provider.js";
 import { ToolError } from "./errors.js";
+import { ToolErrorCode } from "./error-codes.js";
+import { DextoRuntimeError } from "../errors/index.js";
 import { DextoLogComponent } from "../logger/v2/types.js";
 import { ApprovalStatus } from "../approval/types.js";
 import { InstrumentClass } from "../telemetry/decorators.js";
+import {
+  generateBashPatternKey,
+  generateBashPatternSuggestions,
+  isDangerousCommand
+} from "./bash-pattern-utils.js";
 _ToolManager_decorators = [InstrumentClass({
   prefix: "tool",
   excludeMethods: [
@@ -33,6 +40,7 @@ let _ToolManager = class _ToolManager {
   // Tool source prefixing - ALL tools get prefixed by source
   static MCP_TOOL_PREFIX = "mcp--";
   static INTERNAL_TOOL_PREFIX = "internal--";
+  static CUSTOM_TOOL_PREFIX = "custom--";
   // Tool caching for performance
   toolsCache = {};
   cacheValid = false;
@@ -45,11 +53,15 @@ let _ToolManager = class _ToolManager {
     this.agentEventBus = agentEventBus;
     this.toolPolicies = toolPolicies;
     this.logger = logger.createChild(DextoLogComponent.TOOLS);
-    if (options?.internalToolsConfig && options.internalToolsConfig.length > 0) {
+    if (options?.internalToolsConfig && options.internalToolsConfig.length > 0 || options?.customToolsConfig && options.customToolsConfig.length > 0) {
+      const internalToolsServices = {
+        ...options.internalToolsServices,
+        approvalManager
+      };
       this.internalToolsProvider = new InternalToolsProvider(
-        options.internalToolsServices || {},
-        approvalManager,
-        options.internalToolsConfig,
+        internalToolsServices,
+        options.internalToolsConfig || [],
+        options.customToolsConfig || [],
         this.logger
       );
     }
@@ -74,6 +86,16 @@ let _ToolManager = class _ToolManager {
     this.stateManager = stateManager;
     this.logger.debug("Plugin 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
+   */
+  setAgent(agent) {
+    if (this.internalToolsProvider) {
+      this.internalToolsProvider.setAgent(agent);
+      this.logger.debug("Agent reference configured for custom tools");
+    }
+  }
   /**
    * Invalidate the tools cache when tool sources change
    */
@@ -100,6 +122,37 @@ let _ToolManager = class _ToolManager {
       this.invalidateCache();
     });
   }
+  // ==================== 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";
+  }
+  /**
+   * 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 = generateBashPatternKey(command);
+    if (!patternKey) {
+      if (isDangerousCommand(command)) {
+        this.logger.debug(
+          `Skipping pattern generation for dangerous command: ${command.split(/\s+/)[0]}`
+        );
+      }
+      return { approved: false, suggestedPatterns: [] };
+    }
+    if (this.approvalManager.matchesBashPattern(patternKey)) {
+      return { approved: true };
+    }
+    return {
+      approved: false,
+      suggestedPatterns: generateBashPatternSuggestions(command)
+    };
+  }
   getMcpManager() {
     return this.mcpManager;
   }
@@ -128,6 +181,7 @@ let _ToolManager = class _ToolManager {
     const allTools = {};
     let mcpTools = {};
     let internalTools = {};
+    let customTools = {};
     try {
       mcpTools = await this.mcpManager.getAllTools();
     } catch (error) {
@@ -137,13 +191,21 @@ let _ToolManager = class _ToolManager {
       mcpTools = {};
     }
     try {
-      internalTools = this.internalToolsProvider?.getAllTools() || {};
+      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] = {
@@ -152,6 +214,14 @@ let _ToolManager = class _ToolManager {
         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, toolDef] of Object.entries(mcpTools)) {
       const qualifiedName = `${_ToolManager.MCP_TOOL_PREFIX}${toolName}`;
       allTools[qualifiedName] = {
@@ -163,8 +233,9 @@ let _ToolManager = class _ToolManager {
     const totalTools = Object.keys(allTools).length;
     const mcpCount = Object.keys(mcpTools).length;
     const internalCount = Object.keys(internalTools).length;
+    const customCount = Object.keys(customTools).length;
     this.logger.debug(
-      `\u{1F527} Unified tool discovery: ${totalTools} total tools (${mcpCount} MCP \u2192 ${_ToolManager.MCP_TOOL_PREFIX}*, ${internalCount} internal \u2192 ${_ToolManager.INTERNAL_TOOL_PREFIX}*)`
+      `\u{1F527} Unified tool discovery: ${totalTools} total tools (${mcpCount} MCP, ${internalCount} internal, ${customCount} custom)`
     );
     return allTools;
   }
@@ -184,15 +255,41 @@ let _ToolManager = class _ToolManager {
   /**
    * Execute a tool by routing based on universal prefix
    * ALL tools must have source prefix - no exceptions
+   *
+   * @param toolName The fully qualified tool name (e.g., "internal--edit_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, sessionId) {
-    this.logger.debug(`\u{1F527} Tool execution requested: '${toolName}'`);
+  async executeTool(toolName, args, toolCallId, sessionId, abortSignal) {
+    this.logger.debug(`\u{1F527} Tool execution requested: '${toolName}' (toolCallId: ${toolCallId})`);
     this.logger.debug(`Tool args: ${JSON.stringify(args, null, 2)}`);
-    await this.handleToolApproval(toolName, args, sessionId);
+    if (sessionId) {
+      this.agentEventBus.emit("llm:tool-call", {
+        toolName,
+        args,
+        callId: toolCallId,
+        sessionId
+      });
+    }
+    const { requireApproval, approvalStatus } = await this.handleToolApproval(
+      toolName,
+      args,
+      toolCallId,
+      sessionId
+    );
     this.logger.debug(`\u2705 Tool execution approved: ${toolName}`);
     this.logger.info(
       `\u{1F527} Tool execution started for ${toolName}, sessionId: ${sessionId ?? "global"}`
     );
+    if (sessionId) {
+      this.agentEventBus.emit("tool:running", {
+        toolName,
+        toolCallId,
+        sessionId
+      });
+    }
     const startTime = Date.now();
     if (this.pluginManager && this.sessionManager && this.stateManager) {
       const beforePayload = {
@@ -236,16 +333,33 @@ let _ToolManager = class _ToolManager {
         result = await this.internalToolsProvider.executeTool(
           actualToolName,
           args,
-          sessionId
+          sessionId,
+          abortSignal
+        );
+      } 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 ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
+        }
+        if (!this.internalToolsProvider) {
+          throw ToolError.internalToolsNotInitialized(toolName);
+        }
+        this.logger.debug(`\u{1F3AF} Custom routing: '${toolName}' -> '${actualToolName}'`);
+        result = await this.internalToolsProvider.executeTool(
+          actualToolName,
+          args,
+          sessionId,
+          abortSignal
         );
       } 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}*' or '${_ToolManager.INTERNAL_TOOL_PREFIX}*')`
+          `\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 tools, ${stats.internal} internal tools`
+          `Available: ${stats.mcp} MCP, ${stats.internal} internal, ${stats.custom} custom tools`
         );
         throw ToolError.notFound(toolName);
       }
@@ -274,7 +388,10 @@ let _ToolManager = class _ToolManager {
         );
         result = modifiedPayload.result;
       }
-      return result;
+      return {
+        result,
+        ...requireApproval && { requireApproval, approvalStatus }
+      };
     } catch (error) {
       const duration = Date.now() - startTime;
       this.logger.error(
@@ -308,7 +425,11 @@ let _ToolManager = class _ToolManager {
     }
     if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX)) {
       const actualToolName = toolName.substring(_ToolManager.INTERNAL_TOOL_PREFIX.length);
-      return this.internalToolsProvider?.hasTool(actualToolName) ?? false;
+      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;
   }
@@ -318,6 +439,7 @@ let _ToolManager = class _ToolManager {
   async getToolStats() {
     let mcpTools = {};
     let internalTools = {};
+    let customTools = {};
     try {
       mcpTools = await this.mcpManager.getAllTools();
     } catch (error) {
@@ -327,24 +449,33 @@ let _ToolManager = class _ToolManager {
       mcpTools = {};
     }
     try {
-      internalTools = this.internalToolsProvider?.getAllTools() || {};
+      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;
     return {
-      total: mcpCount + internalCount,
-      // No conflicts with universal prefixing
+      total: mcpCount + internalCount + customCount,
       mcp: mcpCount,
-      internal: internalCount
+      internal: internalCount,
+      custom: customCount
     };
   }
   /**
-   * Get the source of a tool (mcp, internal, or unknown)
+   * Get the source of a tool (mcp, internal, custom, or unknown)
    * @param toolName The name of the tool to check
    * @returns The source of the tool
    */
@@ -355,6 +486,9 @@ let _ToolManager = class _ToolManager {
     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";
+    }
     return "unknown";
   }
   /**
@@ -410,12 +544,73 @@ let _ToolManager = class _ToolManager {
       (pattern) => this.matchesToolPolicy(toolName, pattern)
     );
   }
+  /**
+   * Check if a tool has a custom approval override and handle it.
+   * 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 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) {
+      return { handled: false };
+    }
+    const tool = this.internalToolsProvider.getTool(actualToolName);
+    if (!tool?.getApprovalOverride) {
+      return { handled: false };
+    }
+    const approvalRequest = tool.getApprovalOverride(args);
+    if (!approvalRequest) {
+      return { handled: false };
+    }
+    this.logger.debug(
+      `Tool '${toolName}' requested custom approval: type=${approvalRequest.type}`
+    );
+    if (sessionId && !approvalRequest.sessionId) {
+      approvalRequest.sessionId = sessionId;
+    }
+    const response = await this.approvalManager.requestApproval(approvalRequest);
+    if (response.status === ApprovalStatus.APPROVED) {
+      if (tool.onApprovalGranted) {
+        tool.onApprovalGranted(response);
+      }
+      this.logger.info(
+        `Custom approval granted for '${toolName}', type=${approvalRequest.type}, session=${sessionId ?? "global"}`
+      );
+      return { handled: true };
+    }
+    this.logger.info(
+      `Custom approval denied for '${toolName}', type=${approvalRequest.type}, reason=${response.reason ?? "unknown"}`
+    );
+    if (approvalRequest.type === "directory_access") {
+      const metadata = approvalRequest.metadata;
+      throw ToolError.directoryAccessDenied(
+        metadata?.parentDir ?? "unknown directory",
+        sessionId
+      );
+    }
+    throw ToolError.executionDenied(toolName, sessionId);
+  }
   /**
    * Handle tool approval/confirmation flow
    * Checks allowed list, manages approval modes (manual, auto-approve, auto-deny),
    * and handles remember choice logic
+   *
+   * @param toolName The fully qualified tool name
+   * @param args The arguments for the tool
+   * @param toolCallId The unique tool call ID for tracking parallel tool calls
+   * @param sessionId Optional session ID for context
    */
-  async handleToolApproval(toolName, args, sessionId) {
+  async handleToolApproval(toolName, args, toolCallId, sessionId) {
     if (this.isInAlwaysDenyList(toolName)) {
       this.logger.info(
         `Tool '${toolName}' is in static deny list \u2013 blocking execution (session: ${sessionId ?? "global"})`
@@ -423,22 +618,43 @@ let _ToolManager = class _ToolManager {
       this.logger.debug(`\u{1F6AB} Tool execution blocked by policy: ${toolName}`);
       throw ToolError.executionDenied(toolName, sessionId);
     }
+    const customApprovalResult = await this.checkCustomApprovalOverride(
+      toolName,
+      args,
+      sessionId
+    );
+    if (customApprovalResult.handled) {
+      return { requireApproval: true, approvalStatus: "approved" };
+    }
     if (this.isInAlwaysAllowList(toolName)) {
       this.logger.info(
         `Tool '${toolName}' is in static allow list \u2013 skipping confirmation (session: ${sessionId ?? "global"})`
       );
-      return;
+      return { requireApproval: false };
     }
     const isAllowed = await this.allowedToolsProvider.isToolAllowed(toolName, sessionId);
     if (isAllowed) {
       this.logger.info(
         `Tool '${toolName}' already allowed for session '${sessionId ?? "global"}' \u2013 skipping confirmation.`
       );
-      return;
+      return { requireApproval: false };
+    }
+    let bashPatternResult;
+    if (this.isBashTool(toolName)) {
+      const command = args.command;
+      if (command) {
+        bashPatternResult = this.checkBashPatternApproval(command);
+        if (bashPatternResult.approved) {
+          this.logger.info(
+            `Bash command '${command}' matched approved pattern \u2013 skipping confirmation.`
+          );
+          return { requireApproval: false };
+        }
+      }
     }
     if (this.approvalMode === "auto-approve") {
       this.logger.debug(`\u{1F7E2} Auto-approving tool execution: ${toolName}`);
-      return;
+      return { requireApproval: false };
     }
     if (this.approvalMode === "auto-deny") {
       this.logger.debug(`\u{1F6AB} Auto-denying tool execution: ${toolName}`);
@@ -448,21 +664,57 @@ let _ToolManager = class _ToolManager {
       `Tool confirmation requested for ${toolName}, sessionId: ${sessionId ?? "global"}`
     );
     try {
+      let displayPreview;
+      const actualToolName = toolName.replace(/^internal--/, "");
+      const internalTool = this.internalToolsProvider?.getTool(actualToolName);
+      if (internalTool?.generatePreview) {
+        try {
+          const context = { sessionId };
+          const preview = await internalTool.generatePreview(args, context);
+          displayPreview = preview ?? void 0;
+          this.logger.debug(`Generated preview for ${toolName}`);
+        } catch (previewError) {
+          if (previewError instanceof DextoRuntimeError && previewError.code === ToolErrorCode.VALIDATION_FAILED) {
+            this.logger.debug(
+              `Validation failed for ${toolName}: ${previewError.message}`
+            );
+            throw previewError;
+          }
+          this.logger.debug(
+            `Preview generation failed for ${toolName}: ${previewError instanceof Error ? previewError.message : String(previewError)}`
+          );
+        }
+      }
       const requestData = {
         toolName,
+        toolCallId,
         args
       };
       if (sessionId !== void 0) {
         requestData.sessionId = sessionId;
       }
+      if (displayPreview !== void 0) {
+        requestData.displayPreview = displayPreview;
+      }
+      if (bashPatternResult?.suggestedPatterns && bashPatternResult.suggestedPatterns.length > 0) {
+        requestData.suggestedPatterns = bashPatternResult.suggestedPatterns;
+      }
       const response = await this.approvalManager.requestToolConfirmation(requestData);
-      const rememberChoice = response.data && "rememberChoice" in response.data ? response.data.rememberChoice : false;
-      if (response.status === ApprovalStatus.APPROVED && rememberChoice) {
-        const allowSessionId = sessionId ?? response.sessionId;
-        await this.allowedToolsProvider.allowTool(toolName, allowSessionId);
-        this.logger.info(
-          `Tool '${toolName}' added to allowed tools for session '${allowSessionId ?? "global"}' (remember choice selected)`
-        );
+      if (response.status === ApprovalStatus.APPROVED && response.data) {
+        const rememberChoice = "rememberChoice" in response.data ? response.data.rememberChoice : false;
+        const rememberPattern = "rememberPattern" in response.data ? response.data.rememberPattern : void 0;
+        if (rememberChoice) {
+          const allowSessionId = sessionId ?? response.sessionId;
+          await this.allowedToolsProvider.allowTool(toolName, allowSessionId);
+          this.logger.info(
+            `Tool '${toolName}' added to allowed tools for session '${allowSessionId ?? "global"}' (remember choice selected)`
+          );
+        } else if (rememberPattern && typeof rememberPattern === "string" && this.isBashTool(toolName)) {
+          this.approvalManager.addBashPattern(rememberPattern);
+          this.logger.info(
+            `Bash pattern '${rememberPattern}' added for session approval`
+          );
+        }
       }
       const approved = response.status === ApprovalStatus.APPROVED;
       if (!approved) {
@@ -483,6 +735,7 @@ let _ToolManager = class _ToolManager {
       this.logger.info(
         `Tool confirmation 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)}`

package/dist/tools/types.d.ts

@@ -1,11 +1,26 @@
 import type { JSONSchema7 } from 'json-schema';
 import type { ZodSchema } from 'zod';
+import type { ToolDisplayData } from './display-types.js';
+import type { ApprovalRequestDetails, ApprovalResponse } from '../approval/types.js';
 /**
  * Context passed to tool execution
  */
 export interface ToolExecutionContext {
     /** Session ID if available */
     sessionId?: string | undefined;
+    /** Abort signal for cancellation support */
+    abortSignal?: AbortSignal | undefined;
+}
+/**
+ * Result of tool execution, including approval metadata
+ */
+export interface ToolExecutionResult {
+    /** The actual result data from tool execution */
+    result: unknown;
+    /** Whether this tool required user approval before execution */
+    requireApproval?: boolean;
+    /** The approval status (only present if requireApproval is true) */
+    approvalStatus?: 'approved' | 'rejected';
 }
 /**
  * Internal tool interface - for tools implemented within Dexto
@@ -19,6 +34,54 @@ export interface InternalTool {
     inputSchema: ZodSchema;
     /** The actual function that executes the tool - input is validated by Zod before execution */
     execute: (input: unknown, context?: ToolExecutionContext) => Promise<unknown> | unknown;
+    /**
+     * Optional preview generator for approval UI.
+     * Called before requesting user approval to generate display data (e.g., diff preview).
+     * Returns null if no preview is available.
+     */
+    generatePreview?: (input: unknown, context?: ToolExecutionContext) => Promise<ToolDisplayData | null>;
+    /**
+     * Optional custom approval override.
+     * If present and returns non-null, this approval request is used instead of
+     * the default tool confirmation. Allows tools to request specialized approval
+     * flows (e.g., directory access approval for file tools).
+     *
+     * @param args The validated input arguments for the tool
+     * @returns ApprovalRequestDetails for custom approval, or null to use default tool confirmation
+     *
+     * @example
+     * ```typescript
+     * // File tool requesting directory access approval for external paths
+     * getApprovalOverride: (args) => {
+     *   const filePath = (args as {file_path: string}).file_path;
+     *   if (!isPathWithinAllowed(filePath)) {
+     *     return {
+     *       type: ApprovalType.DIRECTORY_ACCESS,
+     *       metadata: { path: filePath, operation: 'read', ... }
+     *     };
+     *   }
+     *   return null; // Use default tool confirmation
+     * }
+     * ```
+     */
+    getApprovalOverride?: (args: unknown) => ApprovalRequestDetails | null;
+    /**
+     * Optional callback invoked when custom approval is granted.
+     * Allows tools to handle approval responses (e.g., remember approved directories).
+     * Only called when getApprovalOverride returned non-null and approval was granted.
+     *
+     * @param response The approval response from ApprovalManager
+     *
+     * @example
+     * ```typescript
+     * onApprovalGranted: (response) => {
+     *   if (response.data?.rememberDirectory) {
+     *     directoryApproval.addApproved(parentDir, 'session');
+     *   }
+     * }
+     * ```
+     */
+    onApprovalGranted?: (response: ApprovalResponse) => void;
 }
 /**
  * Standard tool set interface - used by AI/LLM services

package/dist/tools/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tools/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAErC;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,8BAA8B;IAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAMD;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,qCAAqC;IACrC,EAAE,EAAE,MAAM,CAAC;IAEX,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IAEpB,+CAA+C;IAC/C,WAAW,EAAE,SAAS,CAAC;IAEvB,8FAA8F;IAC9F,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC3F;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,WAAW,CAAC;KAC3B,CAAC;CACL;AAMD;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/E"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tools/types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAErF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,8BAA8B;IAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,4CAA4C;IAC5C,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,iDAAiD;IACjD,MAAM,EAAE,OAAO,CAAC;IAChB,gEAAgE;IAChE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,oEAAoE;IACpE,cAAc,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;CAC5C;AAMD;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,qCAAqC;IACrC,EAAE,EAAE,MAAM,CAAC;IAEX,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IAEpB,+CAA+C;IAC/C,WAAW,EAAE,SAAS,CAAC;IAEvB,8FAA8F;IAC9F,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAExF;;;;OAIG;IACH,eAAe,CAAC,EAAE,CACd,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,oBAAoB,KAC7B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,sBAAsB,GAAG,IAAI,CAAC;IAEvE;;;;;;;;;;;;;;;OAeG;IACH,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;CAC5D;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,EAAE,WAAW,CAAC;KAC3B,CAAC;CACL;AAMD;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/E"}

package/dist/utils/api-key-resolver.cjs

@@ -31,7 +31,25 @@ const PROVIDER_API_KEY_MAP = {
   google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY", "GEMINI_API_KEY"],
   groq: ["GROQ_API_KEY"],
   cohere: ["COHERE_API_KEY"],
-  xai: ["XAI_API_KEY", "X_AI_API_KEY"]
+  xai: ["XAI_API_KEY", "X_AI_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
+  litellm: ["LITELLM_API_KEY", "LITELLM_KEY"],
+  glama: ["GLAMA_API_KEY"],
+  // Vertex uses ADC (Application Default Credentials), not API keys
+  // GOOGLE_APPLICATION_CREDENTIALS points to service account JSON (optional)
+  // Primary config is GOOGLE_VERTEX_PROJECT (required) + GOOGLE_VERTEX_LOCATION (optional)
+  vertex: [],
+  // Bedrock supports two auth methods:
+  // 1. AWS_BEARER_TOKEN_BEDROCK - Bedrock API key (simplest)
+  // 2. AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY + AWS_REGION (IAM credentials)
+  // AWS_SESSION_TOKEN (optional, for temporary credentials)
+  bedrock: ["AWS_BEARER_TOKEN_BEDROCK"],
+  // Local providers don't require API keys
+  local: [],
+  // Native node-llama-cpp execution
+  ollama: []
+  // Ollama server (no authentication required)
+  // TODO: dexto: ['DEXTO_API_KEY'],
   // perplexity: ['PERPLEXITY_API_KEY'],
   // together: ['TOGETHER_API_KEY'],
   // fireworks: ['FIREWORKS_API_KEY'],

package/dist/utils/api-key-resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api-key-resolver.d.ts","sourceRoot":"","sources":["../../src/utils/api-key-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;GAGG;AAGH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,CAY9D,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAelF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAGpE"}
+{"version":3,"file":"api-key-resolver.d.ts","sourceRoot":"","sources":["../../src/utils/api-key-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;GAGG;AAGH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,CA4B9D,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAelF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,CAGpE"}

package/dist/utils/api-key-resolver.js

@@ -1,4 +1,4 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 const PROVIDER_API_KEY_MAP = {
   openai: ["OPENAI_API_KEY", "OPENAI_KEY"],
   "openai-compatible": ["OPENAI_API_KEY", "OPENAI_KEY"],
@@ -7,7 +7,25 @@ const PROVIDER_API_KEY_MAP = {
   google: ["GOOGLE_GENERATIVE_AI_API_KEY", "GOOGLE_API_KEY", "GEMINI_API_KEY"],
   groq: ["GROQ_API_KEY"],
   cohere: ["COHERE_API_KEY"],
-  xai: ["XAI_API_KEY", "X_AI_API_KEY"]
+  xai: ["XAI_API_KEY", "X_AI_API_KEY"],
+  openrouter: ["OPENROUTER_API_KEY"],
+  litellm: ["LITELLM_API_KEY", "LITELLM_KEY"],
+  glama: ["GLAMA_API_KEY"],
+  // Vertex uses ADC (Application Default Credentials), not API keys
+  // GOOGLE_APPLICATION_CREDENTIALS points to service account JSON (optional)
+  // Primary config is GOOGLE_VERTEX_PROJECT (required) + GOOGLE_VERTEX_LOCATION (optional)
+  vertex: [],
+  // Bedrock supports two auth methods:
+  // 1. AWS_BEARER_TOKEN_BEDROCK - Bedrock API key (simplest)
+  // 2. AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY + AWS_REGION (IAM credentials)
+  // AWS_SESSION_TOKEN (optional, for temporary credentials)
+  bedrock: ["AWS_BEARER_TOKEN_BEDROCK"],
+  // Local providers don't require API keys
+  local: [],
+  // Native node-llama-cpp execution
+  ollama: []
+  // Ollama server (no authentication required)
+  // TODO: dexto: ['DEXTO_API_KEY'],
   // perplexity: ['PERPLEXITY_API_KEY'],
   // together: ['TOGETHER_API_KEY'],
   // fireworks: ['FIREWORKS_API_KEY'],

package/dist/utils/async-context.js

@@ -1,4 +1,4 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { AsyncLocalStorage } from "async_hooks";
 const asyncContext = new AsyncLocalStorage();
 function setContext(ctx) {