@dexto/core 1.1.10 → 1.2.0

package/dist/tools/tool-manager.js

@@ -1,26 +1,56 @@
+import {
+  __decorateElement,
+  __decoratorStart,
+  __runInitializers
+} from "../chunk-C6A6W6XS.js";
+var _ToolManager_decorators, _init;
 import { InternalToolsProvider } from "./internal-tools/provider.js";
 import { ToolError } from "./errors.js";
 import { logger } from "../logger/index.js";
-class ToolManager {
+import { ApprovalStatus } from "../approval/types.js";
+import { InstrumentClass } from "../telemetry/decorators.js";
+_ToolManager_decorators = [InstrumentClass({
+  prefix: "tool",
+  excludeMethods: [
+    "setPluginManager",
+    "setStateManager",
+    "getApprovalManager",
+    "getAllowedToolsProvider"
+  ]
+})];
+let _ToolManager = class _ToolManager {
   mcpManager;
   internalToolsProvider;
-  confirmationProvider;
+  approvalManager;
+  allowedToolsProvider;
+  approvalMode;
+  agentEventBus;
+  toolPolicies;
+  // Plugin support - set after construction to avoid circular dependencies
+  pluginManager;
+  sessionManager;
+  stateManager;
   // 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) {
+  constructor(mcpManager, approvalManager, allowedToolsProvider, approvalMode, agentEventBus, toolPolicies, options) {
     this.mcpManager = mcpManager;
-    this.confirmationProvider = confirmationProvider;
+    this.approvalManager = approvalManager;
+    this.allowedToolsProvider = allowedToolsProvider;
+    this.approvalMode = approvalMode;
+    this.agentEventBus = agentEventBus;
+    this.toolPolicies = toolPolicies;
     if (options?.internalToolsConfig && options.internalToolsConfig.length > 0) {
       this.internalToolsProvider = new InternalToolsProvider(
         options.internalToolsServices || {},
-        confirmationProvider,
+        approvalManager,
         options.internalToolsConfig
       );
     }
+    this.setupNotificationListeners();
     logger.debug("ToolManager initialized");
   }
   /**
@@ -32,6 +62,15 @@ class ToolManager {
     }
     logger.debug("ToolManager initialization complete");
   }
+  /**
+   * Set plugin support services (called after construction to avoid circular dependencies)
+   */
+  setPluginSupport(pluginManager, sessionManager, stateManager) {
+    this.pluginManager = pluginManager;
+    this.sessionManager = sessionManager;
+    this.stateManager = stateManager;
+    logger.debug("Plugin support configured for ToolManager");
+  }
   /**
    * Invalidate the tools cache when tool sources change
    */
@@ -39,6 +78,21 @@ class ToolManager {
     this.cacheValid = false;
     this.toolsCache = {};
   }
+  /**
+   * Set up listeners for MCP notifications to invalidate cache on changes
+   */
+  setupNotificationListeners() {
+    this.agentEventBus.on("dexto:mcpServerConnected", async (payload) => {
+      if (payload.success) {
+        logger.debug(`\u{1F504} MCP server connected, invalidating tool cache: ${payload.name}`);
+        this.invalidateCache();
+      }
+    });
+    this.agentEventBus.on("dexto:mcpServerRemoved", async (payload) => {
+      logger.debug(`\u{1F504} MCP server removed: ${payload.serverName}, invalidating tool cache`);
+      this.invalidateCache();
+    });
+  }
   getMcpManager() {
     return this.mcpManager;
   }
@@ -52,6 +106,16 @@ class ToolManager {
   /**
    * Build all tools from sources with universal prefixing
    * ALL tools get prefixed by their source - no exceptions
+   *
+   * TODO: Rethink 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
+   * This makes policy configuration fragile. Consider:
+   * 1. Always including server name: mcp--serverName--toolName (breaking change)
+   * 2. Using a different delimiter pattern that's more predictable
+   * 3. Providing a tool discovery command to help users find exact names
+   * Related: Tool policies now support dual matching (exact + suffix) as a workaround
    */
   async buildAllTools() {
     const allTools = {};
@@ -74,7 +138,7 @@ class ToolManager {
       internalTools = {};
     }
     for (const [toolName, toolDef] of Object.entries(internalTools)) {
-      const qualifiedName = `${ToolManager.INTERNAL_TOOL_PREFIX}${toolName}`;
+      const qualifiedName = `${_ToolManager.INTERNAL_TOOL_PREFIX}${toolName}`;
       allTools[qualifiedName] = {
         ...toolDef,
         name: qualifiedName,
@@ -82,7 +146,7 @@ class ToolManager {
       };
     }
     for (const [toolName, toolDef] of Object.entries(mcpTools)) {
-      const qualifiedName = `${ToolManager.MCP_TOOL_PREFIX}${toolName}`;
+      const qualifiedName = `${_ToolManager.MCP_TOOL_PREFIX}${toolName}`;
       allTools[qualifiedName] = {
         ...toolDef,
         name: qualifiedName,
@@ -93,7 +157,7 @@ class ToolManager {
     const mcpCount = Object.keys(mcpTools).length;
     const internalCount = Object.keys(internalTools).length;
     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 \u2192 ${_ToolManager.MCP_TOOL_PREFIX}*, ${internalCount} internal \u2192 ${_ToolManager.INTERNAL_TOOL_PREFIX}*)`
     );
     return allTools;
   }
@@ -117,33 +181,44 @@ class ToolManager {
   async executeTool(toolName, args, sessionId) {
     logger.debug(`\u{1F527} Tool execution requested: '${toolName}'`);
     logger.debug(`Tool args: ${JSON.stringify(args, null, 2)}`);
-    const approved = await this.confirmationProvider.requestConfirmation({
-      toolName,
-      args,
-      ...sessionId && { sessionId }
-    });
-    if (!approved) {
-      logger.debug(`\u{1F6AB} Tool execution denied: ${toolName}`);
-      throw ToolError.executionDenied(toolName, sessionId);
-    }
+    await this.handleToolApproval(toolName, args, sessionId);
     logger.debug(`\u2705 Tool execution approved: ${toolName}`);
     logger.info(
       `\u{1F527} Tool execution started for ${toolName}, sessionId: ${sessionId ?? "global"}`
     );
     const startTime = Date.now();
+    if (this.pluginManager && this.sessionManager && this.stateManager) {
+      const beforePayload = {
+        toolName,
+        args,
+        ...sessionId !== void 0 && { sessionId }
+      };
+      const modifiedPayload = await this.pluginManager.executePlugins(
+        "beforeToolCall",
+        beforePayload,
+        {
+          sessionManager: this.sessionManager,
+          mcpManager: this.mcpManager,
+          toolManager: this,
+          stateManager: this.stateManager,
+          ...sessionId !== void 0 && { sessionId }
+        }
+      );
+      args = modifiedPayload.args;
+    }
     try {
       let result;
-      if (toolName.startsWith(ToolManager.MCP_TOOL_PREFIX)) {
+      if (toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
         logger.debug(`\u{1F527} Detected MCP tool: '${toolName}'`);
-        const actualToolName = toolName.substring(ToolManager.MCP_TOOL_PREFIX.length);
+        const actualToolName = toolName.substring(_ToolManager.MCP_TOOL_PREFIX.length);
         if (actualToolName.length === 0) {
           throw ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
         }
         logger.debug(`\u{1F3AF} MCP routing: '${toolName}' -> '${actualToolName}'`);
         result = await this.mcpManager.executeTool(actualToolName, args, sessionId);
-      } else if (toolName.startsWith(ToolManager.INTERNAL_TOOL_PREFIX)) {
+      } else if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX)) {
         logger.debug(`\u{1F527} Detected internal tool: '${toolName}'`);
-        const actualToolName = toolName.substring(ToolManager.INTERNAL_TOOL_PREFIX.length);
+        const actualToolName = toolName.substring(_ToolManager.INTERNAL_TOOL_PREFIX.length);
         if (actualToolName.length === 0) {
           throw ToolError.invalidName(toolName, "tool name cannot be empty after prefix");
         }
@@ -160,7 +235,7 @@ class ToolManager {
         logger.debug(`\u{1F527} Detected tool without proper prefix: '${toolName}'`);
         const stats = await this.getToolStats();
         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}*' or '${_ToolManager.INTERNAL_TOOL_PREFIX}*')`
         );
         logger.debug(`Available: ${stats.mcp} MCP tools, ${stats.internal} internal tools`);
         throw ToolError.notFound(toolName);
@@ -170,12 +245,47 @@ class ToolManager {
       logger.info(
         `\u2705 Tool execution completed successfully for ${toolName} in ${duration}ms, sessionId: ${sessionId ?? "global"}`
       );
+      if (this.pluginManager && this.sessionManager && this.stateManager) {
+        const afterPayload = {
+          toolName,
+          result,
+          success: true,
+          ...sessionId !== void 0 && { sessionId }
+        };
+        const modifiedPayload = await this.pluginManager.executePlugins(
+          "afterToolResult",
+          afterPayload,
+          {
+            sessionManager: this.sessionManager,
+            mcpManager: this.mcpManager,
+            toolManager: this,
+            stateManager: this.stateManager,
+            ...sessionId !== void 0 && { sessionId }
+          }
+        );
+        result = modifiedPayload.result;
+      }
       return result;
     } catch (error) {
       const duration = Date.now() - startTime;
       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) {
+        const afterPayload = {
+          toolName,
+          result: error instanceof Error ? error.message : String(error),
+          success: false,
+          ...sessionId !== void 0 && { sessionId }
+        };
+        await this.pluginManager.executePlugins("afterToolResult", afterPayload, {
+          sessionManager: this.sessionManager,
+          mcpManager: this.mcpManager,
+          toolManager: this,
+          stateManager: this.stateManager,
+          ...sessionId !== void 0 && { sessionId }
+        });
+      }
       throw error;
     }
   }
@@ -183,12 +293,12 @@ class ToolManager {
    * 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);
+    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);
+    if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX)) {
+      const actualToolName = toolName.substring(_ToolManager.INTERNAL_TOOL_PREFIX.length);
       return this.internalToolsProvider?.hasTool(actualToolName) ?? false;
     }
     return false;
@@ -230,22 +340,171 @@ class ToolManager {
    * @returns The source of the tool
    */
   getToolSource(toolName) {
-    if (toolName.startsWith(ToolManager.MCP_TOOL_PREFIX) && toolName.length > ToolManager.MCP_TOOL_PREFIX.length) {
+    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) {
+    if (toolName.startsWith(_ToolManager.INTERNAL_TOOL_PREFIX) && toolName.length > _ToolManager.INTERNAL_TOOL_PREFIX.length) {
       return "internal";
     }
     return "unknown";
   }
+  /**
+   * Check if a tool matches a policy pattern
+   * Supports both exact matching and suffix matching for MCP tools with server prefixes
+   *
+   * 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)
+   *
+   * @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")
+   * @returns true if the tool matches the policy pattern
+   */
+  matchesToolPolicy(toolName, policyPattern) {
+    if (toolName === policyPattern) {
+      return true;
+    }
+    if (policyPattern.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
+      const baseName = policyPattern.substring(_ToolManager.MCP_TOOL_PREFIX.length);
+      if (toolName.endsWith(`--${baseName}`) && toolName.startsWith(_ToolManager.MCP_TOOL_PREFIX)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a tool is in the static alwaysDeny list
+   * Supports both exact and suffix matching (e.g., "mcp--read_file" matches "mcp--server--read_file")
+   * @param toolName The fully qualified tool name to check
+   * @returns true if the tool is in the deny list
+   */
+  isInAlwaysDenyList(toolName) {
+    if (!this.toolPolicies?.alwaysDeny) {
+      return false;
+    }
+    return this.toolPolicies.alwaysDeny.some(
+      (pattern) => this.matchesToolPolicy(toolName, pattern)
+    );
+  }
+  /**
+   * Check if a tool is in the static alwaysAllow list
+   * Supports both exact and suffix matching (e.g., "mcp--read_file" matches "mcp--server--read_file")
+   * @param toolName The fully qualified tool name to check
+   * @returns true if the tool is in the allow list
+   */
+  isInAlwaysAllowList(toolName) {
+    if (!this.toolPolicies?.alwaysAllow) {
+      return false;
+    }
+    return this.toolPolicies.alwaysAllow.some(
+      (pattern) => this.matchesToolPolicy(toolName, pattern)
+    );
+  }
+  /**
+   * Handle tool approval/confirmation flow
+   * Checks allowed list, manages approval modes (event-based, auto-approve, auto-deny),
+   * and handles remember choice logic
+   */
+  async handleToolApproval(toolName, args, sessionId) {
+    if (this.isInAlwaysDenyList(toolName)) {
+      logger.info(
+        `Tool '${toolName}' is in static deny list \u2013 blocking execution (session: ${sessionId ?? "global"})`
+      );
+      logger.debug(`\u{1F6AB} Tool execution blocked by policy: ${toolName}`);
+      throw ToolError.executionDenied(toolName, sessionId);
+    }
+    if (this.isInAlwaysAllowList(toolName)) {
+      logger.info(
+        `Tool '${toolName}' is in static allow list \u2013 skipping confirmation (session: ${sessionId ?? "global"})`
+      );
+      return;
+    }
+    const isAllowed = await this.allowedToolsProvider.isToolAllowed(toolName, sessionId);
+    if (isAllowed) {
+      logger.info(
+        `Tool '${toolName}' already allowed for session '${sessionId ?? "global"}' \u2013 skipping confirmation.`
+      );
+      return;
+    }
+    if (this.approvalMode === "auto-approve") {
+      logger.debug(`\u{1F7E2} Auto-approving tool execution: ${toolName}`);
+      return;
+    }
+    if (this.approvalMode === "auto-deny") {
+      logger.debug(`\u{1F6AB} Auto-denying tool execution: ${toolName}`);
+      throw ToolError.executionDenied(toolName, sessionId);
+    }
+    logger.info(
+      `Tool confirmation requested for ${toolName}, sessionId: ${sessionId ?? "global"}`
+    );
+    try {
+      const requestData = {
+        toolName,
+        args
+      };
+      if (sessionId !== void 0) {
+        requestData.sessionId = sessionId;
+      }
+      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);
+        logger.info(
+          `Tool '${toolName}' added to allowed tools for session '${allowSessionId ?? "global"}' (remember choice selected)`
+        );
+      }
+      const approved = response.status === ApprovalStatus.APPROVED;
+      if (!approved) {
+        logger.info(
+          `Tool confirmation denied for ${toolName}, sessionId: ${sessionId ?? "global"}`
+        );
+        logger.debug(`\u{1F6AB} Tool execution denied: ${toolName}`);
+        throw ToolError.executionDenied(toolName, sessionId);
+      }
+      logger.info(
+        `Tool confirmation approved for ${toolName}, sessionId: ${sessionId ?? "global"}`
+      );
+    } catch (error) {
+      logger.error(
+        `Tool confirmation error for ${toolName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
   /**
    * Refresh tool discovery (call when MCP servers change)
+   * Refreshes both MCPManager's cache (server capabilities) and ToolManager's cache (combined tools)
    */
   async refresh() {
+    await this.mcpManager.refresh();
     this.invalidateCache();
-    logger.debug("ToolManager refreshed");
+    logger.debug("ToolManager refreshed (including MCP server capabilities)");
   }
-}
+  /**
+   * Get list of pending confirmation requests
+   */
+  getPendingConfirmations() {
+    return this.approvalManager.getPendingApprovals();
+  }
+  /**
+   * Cancel a pending confirmation request
+   */
+  cancelConfirmation(approvalId) {
+    this.approvalManager.cancelApproval(approvalId);
+  }
+  /**
+   * Cancel all pending confirmation requests
+   */
+  cancelAllConfirmations() {
+    this.approvalManager.cancelAllApprovals();
+  }
+};
+_init = __decoratorStart(null);
+_ToolManager = __decorateElement(_init, 0, "ToolManager", _ToolManager_decorators, _ToolManager);
+__runInitializers(_init, 1, _ToolManager);
+let ToolManager = _ToolManager;
 export {
   ToolManager
 };

package/dist/tools/types.d.ts

@@ -1,17 +1,16 @@
-import { JSONSchema7 } from 'json-schema';
-import { ZodSchema } from 'zod';
-
+import type { JSONSchema7 } from 'json-schema';
+import type { ZodSchema } from 'zod';
 /**
  * Context passed to tool execution
  */
-interface ToolExecutionContext {
+export interface ToolExecutionContext {
     /** Session ID if available */
     sessionId?: string | undefined;
 }
 /**
  * Internal tool interface - for tools implemented within Dexto
  */
-interface InternalTool {
+export interface InternalTool {
     /** Unique identifier for the tool */
     id: string;
     /** Human-readable description of what the tool does */
@@ -25,7 +24,7 @@ interface InternalTool {
  * Standard tool set interface - used by AI/LLM services
  * Each tool entry contains JSON Schema parameters
  */
-interface ToolSet {
+export interface ToolSet {
     [key: string]: {
         name?: string;
         description?: string;
@@ -35,7 +34,7 @@ interface ToolSet {
 /**
  * Tool execution result
  */
-interface ToolResult {
+export interface ToolResult {
     success: boolean;
     data?: any;
     error?: string;
@@ -47,7 +46,7 @@ interface ToolResult {
 /**
  * Tool call representation
  */
-interface ToolCall {
+export interface ToolCall {
     id: string;
     toolName: string;
     input: any;
@@ -58,9 +57,8 @@ interface ToolCall {
 /**
  * Interface for any provider of tools
  */
-interface ToolProvider {
+export interface ToolProvider {
     getTools(): Promise<ToolSet>;
     callTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
 }
-
-export type { InternalTool, ToolCall, ToolExecutionContext, ToolProvider, ToolResult, ToolSet };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +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;IACf,QAAQ,CAAC,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACL;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,GAAG,CAAC;IACX,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;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.d.ts

@@ -1,23 +1,21 @@
-import { LLMProvider } from '../llm/types.js';
-
+import type { LLMProvider } from '../llm/types.js';
 /**
  * Utility for resolving API keys from environment variables.
  * This consolidates the API key resolution logic used across CLI and core components.
  */
-declare const PROVIDER_API_KEY_MAP: Record<LLMProvider, string[]>;
+export declare const PROVIDER_API_KEY_MAP: Record<LLMProvider, string[]>;
 /**
  * Resolves API key for a given provider from environment variables.
  *
  * @param provider The LLM provider
  * @returns Resolved API key or undefined if not found
  */
-declare function resolveApiKeyForProvider(provider: LLMProvider): string | undefined;
+export declare function resolveApiKeyForProvider(provider: LLMProvider): string | undefined;
 /**
  * Gets the primary environment variable name for a provider (for display/error messages).
  *
  * @param provider The LLM provider
  * @returns Primary environment variable name
  */
-declare function getPrimaryApiKeyEnvVar(provider: LLMProvider): string;
-
-export { PROVIDER_API_KEY_MAP, getPrimaryApiKeyEnvVar, resolveApiKeyForProvider };
+export declare function getPrimaryApiKeyEnvVar(provider: LLMProvider): string;
+//# sourceMappingURL=api-key-resolver.d.ts.map

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

@@ -0,0 +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"}

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

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 const PROVIDER_API_KEY_MAP = {
   openai: ["OPENAI_API_KEY", "OPENAI_KEY"],
   "openai-compatible": ["OPENAI_API_KEY", "OPENAI_KEY"],

package/dist/utils/api-key-store.d.ts

@@ -1,26 +1,24 @@
-import { LLMProvider } from '../llm/types.js';
-
+import type { LLMProvider } from '../llm/types.js';
 /**
  * Save provider API key to the correct .env and make it immediately available in-process.
  * Never returns the key; only metadata for callers to display.
  */
-declare function saveProviderApiKey(provider: LLMProvider, apiKey: string, startPath?: string): Promise<{
+export declare function saveProviderApiKey(provider: LLMProvider, apiKey: string, startPath?: string): Promise<{
     envVar: string;
     targetEnvPath: string;
 }>;
 /**
  * Get key presence and primary env var name for a provider.
  */
-declare function getProviderKeyStatus(provider: LLMProvider): {
+export declare function getProviderKeyStatus(provider: LLMProvider): {
     hasApiKey: boolean;
     envVar: string;
 };
 /**
  * List key presence across all known providers.
  */
-declare function listProviderKeyStatus(): Record<string, {
+export declare function listProviderKeyStatus(): Record<string, {
     hasApiKey: boolean;
     envVar: string;
 }>;
-
-export { getProviderKeyStatus, listProviderKeyStatus, saveProviderApiKey };
+//# sourceMappingURL=api-key-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api-key-store.d.ts","sourceRoot":"","sources":["../../src/utils/api-key-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAMnD;;;GAGG;AACH,wBAAsB,kBAAkB,CACpC,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAapD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,WAAW,GAAG;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAClB,CAIA;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAM9F"}

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

@@ -1,3 +1,4 @@
+import "../chunk-C6A6W6XS.js";
 import { LLM_PROVIDERS } from "../llm/types.js";
 import { getPrimaryApiKeyEnvVar, resolveApiKeyForProvider } from "./api-key-resolver.js";
 import { updateEnvFile } from "./env.js";

package/dist/utils/async-context.cjs

@@ -0,0 +1,51 @@
+"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 async_context_exports = {};
+__export(async_context_exports, {
+  getContext: () => getContext,
+  isAsyncContextAvailable: () => isAsyncContextAvailable,
+  runWithContext: () => runWithContext,
+  setContext: () => setContext
+});
+module.exports = __toCommonJS(async_context_exports);
+var import_async_hooks = require("async_hooks");
+const asyncContext = new import_async_hooks.AsyncLocalStorage();
+function setContext(ctx) {
+  asyncContext.enterWith(ctx);
+}
+function getContext() {
+  return asyncContext.getStore();
+}
+async function runWithContext(ctx, fn) {
+  return asyncContext.run(ctx, fn);
+}
+function isAsyncContextAvailable() {
+  try {
+    return typeof import_async_hooks.AsyncLocalStorage !== "undefined";
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getContext,
+  isAsyncContextAvailable,
+  runWithContext,
+  setContext
+});