@dexto/core 1.1.4 → 1.1.6

package/dist/tools/tool-manager.js

@@ -0,0 +1,251 @@
+import { InternalToolsProvider } from "./internal-tools/provider.js";
+import { ToolError } from "./errors.js";
+import { logger } from "../logger/index.js";
+class ToolManager {
+  mcpManager;
+  internalToolsProvider;
+  confirmationProvider;
+  // Tool source prefixing - ALL tools get prefixed by source
+  static MCP_TOOL_PREFIX = "mcp--";
+  static INTERNAL_TOOL_PREFIX = "internal--";
+  // Tool caching for performance
+  toolsCache = {};
+  cacheValid = false;
+  constructor(mcpManager, confirmationProvider, options) {
+    this.mcpManager = mcpManager;
+    this.confirmationProvider = confirmationProvider;
+    if (options?.internalToolsConfig && options.internalToolsConfig.length > 0) {
+      this.internalToolsProvider = new InternalToolsProvider(
+        options.internalToolsServices || {},
+        confirmationProvider,
+        options.internalToolsConfig
+      );
+    }
+    logger.debug("ToolManager initialized");
+  }
+  /**
+   * Initialize the ToolManager and its components
+   */
+  async initialize() {
+    if (this.internalToolsProvider) {
+      await this.internalToolsProvider.initialize();
+    }
+    logger.debug("ToolManager initialization complete");
+  }
+  /**
+   * Invalidate the tools cache when tool sources change
+   */
+  invalidateCache() {
+    this.cacheValid = false;
+    this.toolsCache = {};
+  }
+  getMcpManager() {
+    return this.mcpManager;
+  }
+  /**
+   * Get all MCP tools (delegates to mcpManager.getAllTools())
+   * This provides access to MCP tools while maintaining separation of concerns
+   */
+  async getMcpTools() {
+    return await this.mcpManager.getAllTools();
+  }
+  /**
+   * Build all tools from sources with universal prefixing
+   * ALL tools get prefixed by their source - no exceptions
+   */
+  async buildAllTools() {
+    const allTools = {};
+    let mcpTools = {};
+    let internalTools = {};
+    try {
+      mcpTools = await this.mcpManager.getAllTools();
+    } catch (error) {
+      logger.error(
+        `Failed to get MCP tools: ${error instanceof Error ? error.message : String(error)}`
+      );
+      mcpTools = {};
+    }
+    try {
+      internalTools = this.internalToolsProvider?.getAllTools() || {};
+    } catch (error) {
+      logger.error(
+        `Failed to get internal tools: ${error instanceof Error ? error.message : String(error)}`
+      );
+      internalTools = {};
+    }
+    for (const [toolName, toolDef] of Object.entries(internalTools)) {
+      const qualifiedName = `${ToolManager.INTERNAL_TOOL_PREFIX}${toolName}`;
+      allTools[qualifiedName] = {
+        ...toolDef,
+        name: qualifiedName,
+        description: `${toolDef.description || "No description provided"} (internal tool)`
+      };
+    }
+    for (const [toolName, toolDef] of Object.entries(mcpTools)) {
+      const qualifiedName = `${ToolManager.MCP_TOOL_PREFIX}${toolName}`;
+      allTools[qualifiedName] = {
+        ...toolDef,
+        name: qualifiedName,
+        description: `${toolDef.description || "No description provided"} (via MCP servers)`
+      };
+    }
+    const totalTools = Object.keys(allTools).length;
+    const mcpCount = Object.keys(mcpTools).length;
+    const internalCount = Object.keys(internalTools).length;
+    logger.debug(
+      `\u{1F527} Unified tool discovery: ${totalTools} total tools (${mcpCount} MCP \u2192 ${ToolManager.MCP_TOOL_PREFIX}*, ${internalCount} internal \u2192 ${ToolManager.INTERNAL_TOOL_PREFIX}*)`
+    );
+    return allTools;
+  }
+  /**
+   * Get all available tools from all sources with conflict resolution
+   * This is the single interface the LLM uses to discover tools
+   * Uses caching to avoid rebuilding on every call
+   */
+  async getAllTools() {
+    if (this.cacheValid) {
+      return this.toolsCache;
+    }
+    this.toolsCache = await this.buildAllTools();
+    this.cacheValid = true;
+    return this.toolsCache;
+  }
+  /**
+   * Execute a tool by routing based on universal prefix
+   * ALL tools must have source prefix - no exceptions
+   */
+  async executeTool(toolName, args, sessionId) {
+    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);
+    }
+    logger.debug(`\u2705 Tool execution approved: ${toolName}`);
+    logger.info(
+      `\u{1F527} Tool execution started for ${toolName}, sessionId: ${sessionId ?? "global"}`
+    );
+    const startTime = Date.now();
+    try {
+      let result;
+      if (toolName.startsWith(ToolManager.MCP_TOOL_PREFIX)) {
+        logger.debug(`\u{1F527} Detected MCP tool: '${toolName}'`);
+        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)) {
+        logger.debug(`\u{1F527} Detected internal tool: '${toolName}'`);
+        const actualToolName = toolName.substring(ToolManager.INTERNAL_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);
+        }
+        logger.debug(`\u{1F3AF} Internal routing: '${toolName}' -> '${actualToolName}'`);
+        result = await this.internalToolsProvider.executeTool(
+          actualToolName,
+          args,
+          sessionId
+        );
+      } else {
+        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}*')`
+        );
+        logger.debug(`Available: ${stats.mcp} MCP tools, ${stats.internal} internal tools`);
+        throw ToolError.notFound(toolName);
+      }
+      const duration = Date.now() - startTime;
+      logger.debug(`\u{1F3AF} Tool execution completed in ${duration}ms: '${toolName}'`);
+      logger.info(
+        `\u2705 Tool execution completed successfully for ${toolName} in ${duration}ms, sessionId: ${sessionId ?? "global"}`
+      );
+      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)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Check if a tool exists (must have proper source prefix)
+   */
+  async hasTool(toolName) {
+    if (toolName.startsWith(ToolManager.MCP_TOOL_PREFIX)) {
+      const actualToolName = toolName.substring(ToolManager.MCP_TOOL_PREFIX.length);
+      return this.mcpManager.getToolClient(actualToolName) !== void 0;
+    }
+    if (toolName.startsWith(ToolManager.INTERNAL_TOOL_PREFIX)) {
+      const actualToolName = toolName.substring(ToolManager.INTERNAL_TOOL_PREFIX.length);
+      return this.internalToolsProvider?.hasTool(actualToolName) ?? false;
+    }
+    return false;
+  }
+  /**
+   * Get tool statistics across all sources
+   */
+  async getToolStats() {
+    let mcpTools = {};
+    let internalTools = {};
+    try {
+      mcpTools = await this.mcpManager.getAllTools();
+    } catch (error) {
+      logger.error(
+        `Failed to get MCP tools for stats: ${error instanceof Error ? error.message : String(error)}`
+      );
+      mcpTools = {};
+    }
+    try {
+      internalTools = this.internalToolsProvider?.getAllTools() || {};
+    } catch (error) {
+      logger.error(
+        `Failed to get internal tools for stats: ${error instanceof Error ? error.message : String(error)}`
+      );
+      internalTools = {};
+    }
+    const mcpCount = Object.keys(mcpTools).length;
+    const internalCount = Object.keys(internalTools).length;
+    return {
+      total: mcpCount + internalCount,
+      // No conflicts with universal prefixing
+      mcp: mcpCount,
+      internal: internalCount
+    };
+  }
+  /**
+   * Get the source of a tool (mcp, internal, or unknown)
+   * @param toolName The name of the tool to check
+   * @returns The source of the tool
+   */
+  getToolSource(toolName) {
+    if (toolName.startsWith(ToolManager.MCP_TOOL_PREFIX) && toolName.length > ToolManager.MCP_TOOL_PREFIX.length) {
+      return "mcp";
+    }
+    if (toolName.startsWith(ToolManager.INTERNAL_TOOL_PREFIX) && toolName.length > ToolManager.INTERNAL_TOOL_PREFIX.length) {
+      return "internal";
+    }
+    return "unknown";
+  }
+  /**
+   * Refresh tool discovery (call when MCP servers change)
+   */
+  async refresh() {
+    this.invalidateCache();
+    logger.debug("ToolManager refreshed");
+  }
+}
+export {
+  ToolManager
+};

package/dist/tools/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/tools/types.d.cts

@@ -0,0 +1,66 @@
+import { JSONSchema7 } from 'json-schema';
+import { ZodSchema } from 'zod';
+
+/**
+ * Context passed to tool execution
+ */
+interface ToolExecutionContext {
+    /** Session ID if available */
+    sessionId?: string | undefined;
+}
+/**
+ * Internal tool interface - for tools implemented within Dexto
+ */
+interface InternalTool {
+    /** Unique identifier for the tool */
+    id: string;
+    /** Human-readable description of what the tool does */
+    description: string;
+    /** Zod schema defining the input parameters */
+    inputSchema: ZodSchema;
+    /** The actual function that executes the tool - input is validated by Zod before execution */
+    execute: (input: unknown, context?: ToolExecutionContext) => Promise<unknown> | unknown;
+}
+/**
+ * Standard tool set interface - used by AI/LLM services
+ * Each tool entry contains JSON Schema parameters
+ */
+interface ToolSet {
+    [key: string]: {
+        name?: string;
+        description?: string;
+        parameters: JSONSchema7;
+    };
+}
+/**
+ * Tool execution result
+ */
+interface ToolResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    metadata?: {
+        type: string;
+        mimeType?: string;
+    };
+}
+/**
+ * Tool call representation
+ */
+interface ToolCall {
+    id: string;
+    toolName: string;
+    input: any;
+    output?: any;
+    error?: string;
+    duration?: number;
+}
+/**
+ * Interface for any provider of tools
+ */
+interface ToolProvider {
+    getTools(): Promise<ToolSet>;
+    callTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
+}
+
+export type { InternalTool, ToolCall, ToolExecutionContext, ToolProvider, ToolResult, ToolSet };

package/dist/tools/types.d.ts

@@ -0,0 +1,66 @@
+import { JSONSchema7 } from 'json-schema';
+import { ZodSchema } from 'zod';
+
+/**
+ * Context passed to tool execution
+ */
+interface ToolExecutionContext {
+    /** Session ID if available */
+    sessionId?: string | undefined;
+}
+/**
+ * Internal tool interface - for tools implemented within Dexto
+ */
+interface InternalTool {
+    /** Unique identifier for the tool */
+    id: string;
+    /** Human-readable description of what the tool does */
+    description: string;
+    /** Zod schema defining the input parameters */
+    inputSchema: ZodSchema;
+    /** The actual function that executes the tool - input is validated by Zod before execution */
+    execute: (input: unknown, context?: ToolExecutionContext) => Promise<unknown> | unknown;
+}
+/**
+ * Standard tool set interface - used by AI/LLM services
+ * Each tool entry contains JSON Schema parameters
+ */
+interface ToolSet {
+    [key: string]: {
+        name?: string;
+        description?: string;
+        parameters: JSONSchema7;
+    };
+}
+/**
+ * Tool execution result
+ */
+interface ToolResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    metadata?: {
+        type: string;
+        mimeType?: string;
+    };
+}
+/**
+ * Tool call representation
+ */
+interface ToolCall {
+    id: string;
+    toolName: string;
+    input: any;
+    output?: any;
+    error?: string;
+    duration?: number;
+}
+/**
+ * Interface for any provider of tools
+ */
+interface ToolProvider {
+    getTools(): Promise<ToolSet>;
+    callTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
+}
+
+export type { InternalTool, ToolCall, ToolExecutionContext, ToolProvider, ToolResult, ToolSet };

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

@@ -0,0 +1,62 @@
+"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 api_key_resolver_exports = {};
+__export(api_key_resolver_exports, {
+  PROVIDER_API_KEY_MAP: () => PROVIDER_API_KEY_MAP,
+  getPrimaryApiKeyEnvVar: () => getPrimaryApiKeyEnvVar,
+  resolveApiKeyForProvider: () => resolveApiKeyForProvider
+});
+module.exports = __toCommonJS(api_key_resolver_exports);
+const PROVIDER_API_KEY_MAP = {
+  openai: ["OPENAI_API_KEY", "OPENAI_KEY"],
+  "openai-compatible": ["OPENAI_API_KEY", "OPENAI_KEY"],
+  // Uses same keys as openai
+  anthropic: ["ANTHROPIC_API_KEY", "ANTHROPIC_KEY", "CLAUDE_API_KEY"],
+  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"]
+  // perplexity: ['PERPLEXITY_API_KEY'],
+  // together: ['TOGETHER_API_KEY'],
+  // fireworks: ['FIREWORKS_API_KEY'],
+  // deepseek: ['DEEPSEEK_API_KEY'],
+};
+function resolveApiKeyForProvider(provider) {
+  const envVars = PROVIDER_API_KEY_MAP[provider];
+  if (!envVars) {
+    return void 0;
+  }
+  for (const envVar of envVars) {
+    const value = process.env[envVar];
+    if (value && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function getPrimaryApiKeyEnvVar(provider) {
+  const envVars = PROVIDER_API_KEY_MAP[provider];
+  return envVars?.[0] || `${provider.toUpperCase()}_API_KEY`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROVIDER_API_KEY_MAP,
+  getPrimaryApiKeyEnvVar,
+  resolveApiKeyForProvider
+});

package/dist/utils/api-key-resolver.d.cts

@@ -0,0 +1,23 @@
+import { LLMProvider } from '../llm/types.cjs';
+
+/**
+ * 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[]>;
+/**
+ * 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;
+/**
+ * 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 };

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

@@ -0,0 +1,23 @@
+import { 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[]>;
+/**
+ * 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;
+/**
+ * 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 };

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

@@ -0,0 +1,36 @@
+const PROVIDER_API_KEY_MAP = {
+  openai: ["OPENAI_API_KEY", "OPENAI_KEY"],
+  "openai-compatible": ["OPENAI_API_KEY", "OPENAI_KEY"],
+  // Uses same keys as openai
+  anthropic: ["ANTHROPIC_API_KEY", "ANTHROPIC_KEY", "CLAUDE_API_KEY"],
+  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"]
+  // perplexity: ['PERPLEXITY_API_KEY'],
+  // together: ['TOGETHER_API_KEY'],
+  // fireworks: ['FIREWORKS_API_KEY'],
+  // deepseek: ['DEEPSEEK_API_KEY'],
+};
+function resolveApiKeyForProvider(provider) {
+  const envVars = PROVIDER_API_KEY_MAP[provider];
+  if (!envVars) {
+    return void 0;
+  }
+  for (const envVar of envVars) {
+    const value = process.env[envVar];
+    if (value && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function getPrimaryApiKeyEnvVar(provider) {
+  const envVars = PROVIDER_API_KEY_MAP[provider];
+  return envVars?.[0] || `${provider.toUpperCase()}_API_KEY`;
+}
+export {
+  PROVIDER_API_KEY_MAP,
+  getPrimaryApiKeyEnvVar,
+  resolveApiKeyForProvider
+};

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

@@ -0,0 +1,56 @@
+"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 api_key_store_exports = {};
+__export(api_key_store_exports, {
+  getProviderKeyStatus: () => getProviderKeyStatus,
+  listProviderKeyStatus: () => listProviderKeyStatus,
+  saveProviderApiKey: () => saveProviderApiKey
+});
+module.exports = __toCommonJS(api_key_store_exports);
+var import_types = require("../llm/types.js");
+var import_api_key_resolver = require("./api-key-resolver.js");
+var import_env = require("./env.js");
+var import_path = require("./path.js");
+async function saveProviderApiKey(provider, apiKey, startPath) {
+  if (!provider) throw new Error("provider is required");
+  if (!apiKey || !apiKey.trim()) throw new Error("apiKey is required");
+  const envVar = (0, import_api_key_resolver.getPrimaryApiKeyEnvVar)(provider);
+  const targetEnvPath = (0, import_path.getDextoEnvPath)(startPath);
+  await (0, import_env.updateEnvFile)(targetEnvPath, { [envVar]: apiKey });
+  process.env[envVar] = apiKey;
+  return { envVar, targetEnvPath };
+}
+function getProviderKeyStatus(provider) {
+  const envVar = (0, import_api_key_resolver.getPrimaryApiKeyEnvVar)(provider);
+  const key = (0, import_api_key_resolver.resolveApiKeyForProvider)(provider);
+  return { hasApiKey: Boolean(key && key.trim()), envVar };
+}
+function listProviderKeyStatus() {
+  const result = {};
+  for (const p of import_types.LLM_PROVIDERS) {
+    result[p] = getProviderKeyStatus(p);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getProviderKeyStatus,
+  listProviderKeyStatus,
+  saveProviderApiKey
+});

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

@@ -0,0 +1,26 @@
+import { LLMProvider } from '../llm/types.cjs';
+
+/**
+ * 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<{
+    envVar: string;
+    targetEnvPath: string;
+}>;
+/**
+ * Get key presence and primary env var name for a provider.
+ */
+declare function getProviderKeyStatus(provider: LLMProvider): {
+    hasApiKey: boolean;
+    envVar: string;
+};
+/**
+ * List key presence across all known providers.
+ */
+declare function listProviderKeyStatus(): Record<string, {
+    hasApiKey: boolean;
+    envVar: string;
+}>;
+
+export { getProviderKeyStatus, listProviderKeyStatus, saveProviderApiKey };

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

@@ -0,0 +1,26 @@
+import { 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<{
+    envVar: string;
+    targetEnvPath: string;
+}>;
+/**
+ * Get key presence and primary env var name for a provider.
+ */
+declare function getProviderKeyStatus(provider: LLMProvider): {
+    hasApiKey: boolean;
+    envVar: string;
+};
+/**
+ * List key presence across all known providers.
+ */
+declare function listProviderKeyStatus(): Record<string, {
+    hasApiKey: boolean;
+    envVar: string;
+}>;
+
+export { getProviderKeyStatus, listProviderKeyStatus, saveProviderApiKey };