@dexto/agent-management 1.5.5 → 1.5.7

package/dist/tool-provider/runtime-service.d.ts

@@ -10,11 +10,11 @@
  * - Enforces per-parent agent limits
  * - Always cleans up agents after task completion (synchronous model)
  */
-import type { DextoAgent, IDextoLogger } from '@dexto/core';
+import type { DextoAgent, IDextoLogger, TaskForker } from '@dexto/core';
 import type { AgentRegistryEntry } from '../registry/types.js';
 import type { AgentSpawnerConfig } from './schemas.js';
 import type { SpawnAgentOutput } from './types.js';
-export declare class RuntimeService {
+export declare class RuntimeService implements TaskForker {
     private runtime;
     private parentId;
     private parentAgent;
@@ -39,6 +39,7 @@ export declare class RuntimeService {
      * @param input.task - Short task description (for logging/UI)
      * @param input.instructions - Full prompt sent to sub-agent
      * @param input.agentId - Optional agent ID from registry
+     * @param input.autoApprove - Optional override for auto-approve (used by fork skills)
      * @param input.timeout - Optional task timeout in milliseconds
      * @param input.toolCallId - Optional tool call ID for progress events
      * @param input.sessionId - Optional session ID for progress events
@@ -47,10 +48,34 @@ export declare class RuntimeService {
         task: string;
         instructions: string;
         agentId?: string;
+        autoApprove?: boolean;
         timeout?: number;
         toolCallId?: string;
         sessionId?: string;
     }): Promise<SpawnAgentOutput>;
+    /**
+     * Fork execution to an isolated subagent.
+     * Implements TaskForker interface for use by invoke_skill when context: fork is set.
+     *
+     * @param options.task - Short description for UI/logs
+     * @param options.instructions - Full instructions for the subagent
+     * @param options.agentId - Optional agent ID from registry to use for execution
+     * @param options.autoApprove - Auto-approve tool calls (default: true for fork skills)
+     * @param options.toolCallId - Optional tool call ID for progress events
+     * @param options.sessionId - Optional session ID for progress events
+     */
+    fork(options: {
+        task: string;
+        instructions: string;
+        agentId?: string;
+        autoApprove?: boolean;
+        toolCallId?: string;
+        sessionId?: string;
+    }): Promise<{
+        success: boolean;
+        response?: string;
+        error?: string;
+    }>;
     /**
      * Set up progress event emission for a sub-agent.
      * Subscribes to llm:tool-call and llm:response events and emits service:event with progress data.
@@ -58,6 +83,10 @@ export declare class RuntimeService {
      * @returns Cleanup function to unsubscribe from events
      */
     private setupProgressTracking;
+    /**
+     * Check if an error is LLM-related (API errors, credit issues, model not found, etc.)
+     */
+    private isLLMError;
     /**
      * Try to spawn agent, falling back to parent's LLM config if the sub-agent's config fails
      */
@@ -68,6 +97,7 @@ export declare class RuntimeService {
      * @param options.agentId - Agent ID from registry
      * @param options.inheritLlm - Use parent's LLM config instead of sub-agent's
      * @param options.autoApprove - Auto-approve all tool calls
+     * @param sessionId - Optional session ID to get session-specific LLM config
      */
     private buildSubAgentConfig;
     /**

package/dist/tool-provider/runtime-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-service.d.ts","sourceRoot":"","sources":["../../src/tool-provider/runtime-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAe,MAAM,aAAa,CAAC;AAKzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,qBAAa,cAAc;IACvB,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,MAAM,CAAe;gBAEjB,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,YAAY;IAuBrF;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAIhB;;;;;;;;;;;;;OAaG;IACG,eAAe,CAAC,KAAK,EAAE;QACzB,IAAI,EAAE,MAAM,CAAC;QACb,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA8C7B;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAiH7B;;OAEG;YACW,oBAAoB;IAgKlC;;;;;;OAMG;YACW,mBAAmB;IAuEjC;;;OAGG;IACH,kBAAkB,IAAI,kBAAkB,EAAE;IAoB1C;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAIjC"}
+{"version":3,"file":"runtime-service.d.ts","sourceRoot":"","sources":["../../src/tool-provider/runtime-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAe,UAAU,EAAE,MAAM,aAAa,CAAC;AAMrF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGnD,qBAAa,cAAe,YAAW,UAAU;IAC7C,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,MAAM,CAAe;gBAEjB,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,YAAY;IAuBrF;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAIhB;;;;;;;;;;;;;;OAcG;IACG,eAAe,CAAC,KAAK,EAAE;QACzB,IAAI,EAAE,MAAM,CAAC;QACb,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA8C7B;;;;;;;;;;OAUG;IACG,IAAI,CAAC,OAAO,EAAE;QAChB,IAAI,EAAE,MAAM,CAAC;QACb,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IA6BpE;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAiH7B;;OAEG;IACH,OAAO,CAAC,UAAU;IAsBlB;;OAEG;YACW,oBAAoB;IAyPlC;;;;;;;OAOG;YACW,mBAAmB;IA2GjC;;;OAGG;IACH,kBAAkB,IAAI,kBAAkB,EAAE;IAoB1C;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAIjC"}

package/dist/tool-provider/runtime-service.js

@@ -1,7 +1,9 @@
+import { DextoRuntimeError, ErrorType } from "@dexto/core";
 import { AgentRuntime } from "../runtime/AgentRuntime.js";
 import { createDelegatingApprovalHandler } from "../runtime/approval-delegation.js";
 import { loadAgentConfig } from "../config/loader.js";
 import { getAgentRegistry } from "../registry/registry.js";
+import { resolveSubAgentLLM } from "./llm-resolution.js";
 class RuntimeService {
   runtime;
   parentId;
@@ -46,6 +48,7 @@ class RuntimeService {
    * @param input.task - Short task description (for logging/UI)
    * @param input.instructions - Full prompt sent to sub-agent
    * @param input.agentId - Optional agent ID from registry
+   * @param input.autoApprove - Optional override for auto-approve (used by fork skills)
    * @param input.timeout - Optional task timeout in milliseconds
    * @param input.toolCallId - Optional tool call ID for progress events
    * @param input.sessionId - Optional session ID for progress events
@@ -72,10 +75,7 @@ class RuntimeService {
       }
     }
     const timeout = input.timeout ?? this.config.defaultTimeout;
-    let autoApprove = false;
-    if (input.agentId && this.config.autoApproveAgents) {
-      autoApprove = this.config.autoApproveAgents.includes(input.agentId);
-    }
+    const autoApprove = input.autoApprove !== void 0 ? input.autoApprove : !!(input.agentId && this.config.autoApproveAgents?.includes(input.agentId));
     const result = await this.trySpawnWithFallback(
       input,
       timeout,
@@ -85,6 +85,36 @@ class RuntimeService {
     );
     return result;
   }
+  /**
+   * Fork execution to an isolated subagent.
+   * Implements TaskForker interface for use by invoke_skill when context: fork is set.
+   *
+   * @param options.task - Short description for UI/logs
+   * @param options.instructions - Full instructions for the subagent
+   * @param options.agentId - Optional agent ID from registry to use for execution
+   * @param options.autoApprove - Auto-approve tool calls (default: true for fork skills)
+   * @param options.toolCallId - Optional tool call ID for progress events
+   * @param options.sessionId - Optional session ID for progress events
+   */
+  async fork(options) {
+    const spawnOptions = {
+      task: options.task,
+      instructions: options.instructions
+    };
+    if (options.agentId) {
+      spawnOptions.agentId = options.agentId;
+    }
+    if (options.autoApprove !== void 0) {
+      spawnOptions.autoApprove = options.autoApprove;
+    }
+    if (options.toolCallId) {
+      spawnOptions.toolCallId = options.toolCallId;
+    }
+    if (options.sessionId) {
+      spawnOptions.sessionId = options.sessionId;
+    }
+    return this.spawnAndExecute(spawnOptions);
+  }
   /**
    * Set up progress event emission for a sub-agent.
    * Subscribes to llm:tool-call and llm:response events and emits service:event with progress data.
@@ -160,12 +190,25 @@ class RuntimeService {
       subAgentBus.off("llm:response", responseHandler);
     };
   }
+  /**
+   * Check if an error is LLM-related (API errors, credit issues, model not found, etc.)
+   */
+  isLLMError(error) {
+    if (error instanceof DextoRuntimeError) {
+      if (error.scope === "llm") return true;
+      if (error.type === ErrorType.PAYMENT_REQUIRED || error.type === ErrorType.FORBIDDEN) {
+        return true;
+      }
+    }
+    const msg = error instanceof Error ? error.message : String(error);
+    return msg.includes("model") || msg.includes("provider") || msg.includes("rate limit") || msg.includes("quota");
+  }
   /**
    * Try to spawn agent, falling back to parent's LLM config if the sub-agent's config fails
    */
   async trySpawnWithFallback(input, timeout, autoApprove, toolCallId, sessionId) {
     let spawnedAgentId;
-    let usedFallback = false;
+    let llmMode = "subagent";
     let cleanupProgressTracking;
     try {
       const buildOptions = {};
@@ -175,7 +218,7 @@ class RuntimeService {
       if (autoApprove) {
         buildOptions.autoApprove = autoApprove;
       }
-      let subAgentConfig = await this.buildSubAgentConfig(buildOptions);
+      let subAgentConfig = await this.buildSubAgentConfig(buildOptions, sessionId);
       let handle;
       try {
         handle = await this.runtime.spawnAgent({
@@ -201,15 +244,15 @@ class RuntimeService {
         });
         spawnedAgentId = handle.agentId;
       } catch (spawnError) {
-        const errorMsg = spawnError instanceof Error ? spawnError.message : String(spawnError);
-        const isLlmError = errorMsg.includes("Model") || errorMsg.includes("model") || errorMsg.includes("API") || errorMsg.includes("apiKey") || errorMsg.includes("provider");
-        if (isLlmError && input.agentId) {
+        const isLlmError = this.isLLMError(spawnError);
+        if (isLlmError && input.agentId && llmMode === "subagent") {
+          const errorMsg = spawnError instanceof Error ? spawnError.message : String(spawnError);
           this.logger.warn(
-            `Sub-agent LLM config failed: ${errorMsg}. Falling back to parent's LLM config.`
+            `Sub-agent '${input.agentId}' LLM config failed: ${errorMsg}. Falling back to parent's full LLM config.`
           );
-          usedFallback = true;
+          llmMode = "parent";
           buildOptions.inheritLlm = true;
-          subAgentConfig = await this.buildSubAgentConfig(buildOptions);
+          subAgentConfig = await this.buildSubAgentConfig(buildOptions, sessionId);
           handle = await this.runtime.spawnAgent({
             agentConfig: subAgentConfig,
             ephemeral: true,
@@ -218,7 +261,8 @@ class RuntimeService {
               parentId: this.parentId,
               task: input.task,
               autoApprove,
-              usedLlmFallback: true,
+              llmMode: "parent",
+              fallbackStage: "spawn",
               spawnedAt: (/* @__PURE__ */ new Date()).toISOString()
             },
             onBeforeStart: (agent) => {
@@ -238,7 +282,7 @@ class RuntimeService {
         }
       }
       this.logger.info(
-        `Spawned sub-agent '${spawnedAgentId}' for task: ${input.task}${autoApprove ? " (auto-approve)" : ""}${usedFallback ? " (using parent LLM)" : ""}`
+        `Spawned sub-agent '${spawnedAgentId}' for task: ${input.task}${autoApprove ? " (auto-approve)" : ""}${llmMode === "parent" ? " (using parent LLM)" : ""}`
       );
       cleanupProgressTracking = this.setupProgressTracking(
         handle,
@@ -246,11 +290,74 @@ class RuntimeService {
         toolCallId,
         sessionId
       );
-      const result = await this.runtime.executeTask(
-        spawnedAgentId,
-        input.instructions,
-        timeout
-      );
+      let result;
+      try {
+        result = await this.runtime.executeTask(
+          spawnedAgentId,
+          input.instructions,
+          timeout
+        );
+      } catch (execError) {
+        const isLlmExecError = this.isLLMError(execError);
+        if (llmMode === "parent") {
+          throw execError;
+        }
+        if (isLlmExecError && input.agentId && llmMode === "subagent") {
+          this.logger.warn(
+            `Sub-agent '${input.agentId}' LLM error during execution: ${execError instanceof Error ? execError.message : String(execError)}. Retrying with parent's full LLM config.`
+          );
+          try {
+            await this.runtime.stopAgent(spawnedAgentId);
+          } catch {
+          }
+          if (cleanupProgressTracking) {
+            cleanupProgressTracking();
+          }
+          llmMode = "parent";
+          buildOptions.inheritLlm = true;
+          subAgentConfig = await this.buildSubAgentConfig(buildOptions, sessionId);
+          handle = await this.runtime.spawnAgent({
+            agentConfig: subAgentConfig,
+            ephemeral: true,
+            group: this.parentId,
+            metadata: {
+              parentId: this.parentId,
+              task: input.task,
+              autoApprove,
+              llmMode: "parent",
+              fallbackStage: "execution",
+              spawnedAt: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            onBeforeStart: (agent) => {
+              if (!autoApprove) {
+                const delegatingHandler = createDelegatingApprovalHandler(
+                  this.parentAgent.services.approvalManager,
+                  agent.config.agentId ?? "unknown",
+                  this.logger
+                );
+                agent.setApprovalHandler(delegatingHandler);
+              }
+            }
+          });
+          spawnedAgentId = handle.agentId;
+          this.logger.info(
+            `Re-spawned sub-agent '${spawnedAgentId}' for task: ${input.task} (using parent LLM)`
+          );
+          cleanupProgressTracking = this.setupProgressTracking(
+            handle,
+            input,
+            toolCallId,
+            sessionId
+          );
+          result = await this.runtime.executeTask(
+            spawnedAgentId,
+            input.instructions,
+            timeout
+          );
+        } else {
+          throw execError;
+        }
+      }
       const output = {
         success: result.success
       };
@@ -260,6 +367,9 @@ class RuntimeService {
       if (result.error !== void 0) {
         output.error = result.error;
       }
+      if (llmMode === "parent") {
+        output.warning = `Sub-agent '${input.agentId}' used fallback LLM (parent's full config) due to an error with its configured model.`;
+      }
       return output;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -286,10 +396,15 @@ class RuntimeService {
    * @param options.agentId - Agent ID from registry
    * @param options.inheritLlm - Use parent's LLM config instead of sub-agent's
    * @param options.autoApprove - Auto-approve all tool calls
+   * @param sessionId - Optional session ID to get session-specific LLM config
    */
-  async buildSubAgentConfig(options) {
+  async buildSubAgentConfig(options, sessionId) {
     const { agentId, inheritLlm, autoApprove } = options;
     const parentConfig = this.parentAgent.config;
+    const currentParentLLM = this.parentAgent.getCurrentLLMConfig(sessionId);
+    this.logger.debug(
+      `[RuntimeService] Building sub-agent config with LLM: ${currentParentLLM.provider}/${currentParentLLM.model}` + (sessionId ? ` (sessionId: ${sessionId})` : " (no sessionId)")
+    );
     const toolConfirmationMode = autoApprove ? "auto-approve" : "manual";
     if (agentId) {
       const registry = getAgentRegistry();
@@ -301,8 +416,18 @@ class RuntimeService {
         const loadedConfig = await loadAgentConfig(configPath, this.logger);
         let llmConfig = loadedConfig.llm;
         if (inheritLlm) {
-          this.logger.debug("Using parent LLM config (inheritLlm=true)");
-          llmConfig = { ...parentConfig.llm };
+          this.logger.debug(
+            `Sub-agent '${agentId}' using parent LLM config (inheritLlm=true)`
+          );
+          llmConfig = { ...currentParentLLM };
+        } else {
+          const resolution = resolveSubAgentLLM({
+            subAgentLLM: loadedConfig.llm,
+            parentLLM: currentParentLLM,
+            subAgentId: agentId
+          });
+          this.logger.debug(`Sub-agent LLM resolution: ${resolution.reason}`);
+          llmConfig = resolution.llm;
         }
         return {
           ...loadedConfig,
@@ -320,12 +445,22 @@ class RuntimeService {
       }
     }
     const config = {
-      llm: { ...parentConfig.llm },
+      llm: { ...currentParentLLM },
       // Default system prompt for sub-agents
       systemPrompt: "You are a helpful sub-agent. Complete the task given to you efficiently and concisely.",
       toolConfirmation: {
         mode: toolConfirmationMode
       },
+      // Inherit MCP servers from parent so subagent has tool access
+      mcpServers: parentConfig.mcpServers ? { ...parentConfig.mcpServers } : {},
+      // Inherit internal tools from parent, excluding tools that don't work in subagent context
+      // - ask_user: Subagents can't interact with the user directly
+      // - invoke_skill: Avoid nested skill invocations for simplicity
+      internalTools: parentConfig.internalTools ? parentConfig.internalTools.filter(
+        (tool) => tool !== "ask_user" && tool !== "invoke_skill"
+      ) : [],
+      // Inherit custom tools from parent
+      customTools: parentConfig.customTools ? [...parentConfig.customTools] : [],
       // Suppress sub-agent console logs entirely using silent transport
       logger: {
         level: "error",

package/dist/tool-provider/tool-provider.cjs

@@ -30,6 +30,8 @@ const agentSpawnerToolsProvider = {
   create: (config, context) => {
     const { logger, agent } = context;
     const service = new import_runtime_service.RuntimeService(agent, config, logger);
+    agent.toolManager.setTaskForker(service);
+    logger.debug("RuntimeService wired as taskForker for context:fork skill support");
     return [(0, import_spawn_agent_tool.createSpawnAgentTool)(service)];
   },
   metadata: {

package/dist/tool-provider/tool-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-provider.d.ts","sourceRoot":"","sources":["../../src/tool-provider/tool-provider.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAgB,MAAM,aAAa,CAAC;AACpE,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAIjF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,yBAAyB,EAAE,kBAAkB,CAAC,eAAe,EAAE,kBAAkB,CAmB7F,CAAC"}
+{"version":3,"file":"tool-provider.d.ts","sourceRoot":"","sources":["../../src/tool-provider/tool-provider.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAgB,MAAM,aAAa,CAAC;AACpE,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAIjF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,yBAAyB,EAAE,kBAAkB,CAAC,eAAe,EAAE,kBAAkB,CAwB7F,CAAC"}

package/dist/tool-provider/tool-provider.js

@@ -7,6 +7,8 @@ const agentSpawnerToolsProvider = {
   create: (config, context) => {
     const { logger, agent } = context;
     const service = new RuntimeService(agent, config, logger);
+    agent.toolManager.setTaskForker(service);
+    logger.debug("RuntimeService wired as taskForker for context:fork skill support");
     return [createSpawnAgentTool(service)];
   },
   metadata: {

package/dist/tool-provider/types.d.ts

@@ -13,5 +13,7 @@ export interface SpawnAgentOutput {
     response?: string;
     /** Error message if the task failed */
     error?: string;
+    /** Warning message (e.g., when fallback LLM was used) */
+    warning?: string;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/tool-provider/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tool-provider/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAC;IAEjB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tool-provider/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAC;IAEjB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB"}

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

@@ -32,6 +32,8 @@ const PROVIDER_API_KEY_MAP = {
   groq: ["GROQ_API_KEY"],
   cohere: ["COHERE_API_KEY"],
   xai: ["XAI_API_KEY", "X_AI_API_KEY"],
+  minimax: ["MINIMAX_API_KEY"],
+  glm: ["ZHIPU_API_KEY", "ZHIPUAI_API_KEY"],
   openrouter: ["OPENROUTER_API_KEY"],
   litellm: ["LITELLM_API_KEY", "LITELLM_KEY"],
   glama: ["GLAMA_API_KEY"],
@@ -47,9 +49,10 @@ const PROVIDER_API_KEY_MAP = {
   // Local providers don't require API keys
   local: [],
   // Native node-llama-cpp execution
-  ollama: []
+  ollama: [],
   // Ollama server (may optionally use OLLAMA_API_KEY for remote servers)
-  // TODO: dexto: ['DEXTO_API_KEY'],
+  // Dexto gateway - requires key from `dexto login`
+  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,aAAa,CAAC;AAE/C;;;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"}
+{"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,aAAa,CAAC;AAE/C;;;GAGG;AAGH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,CA+B9D,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

@@ -7,6 +7,8 @@ const PROVIDER_API_KEY_MAP = {
   groq: ["GROQ_API_KEY"],
   cohere: ["COHERE_API_KEY"],
   xai: ["XAI_API_KEY", "X_AI_API_KEY"],
+  minimax: ["MINIMAX_API_KEY"],
+  glm: ["ZHIPU_API_KEY", "ZHIPUAI_API_KEY"],
   openrouter: ["OPENROUTER_API_KEY"],
   litellm: ["LITELLM_API_KEY", "LITELLM_KEY"],
   glama: ["GLAMA_API_KEY"],
@@ -22,9 +24,10 @@ const PROVIDER_API_KEY_MAP = {
   // Local providers don't require API keys
   local: [],
   // Native node-llama-cpp execution
-  ollama: []
+  ollama: [],
   // Ollama server (may optionally use OLLAMA_API_KEY for remote servers)
-  // TODO: dexto: ['DEXTO_API_KEY'],
+  // Dexto gateway - requires key from `dexto login`
+  dexto: ["DEXTO_API_KEY"]
   // perplexity: ['PERPLEXITY_API_KEY'],
   // together: ['TOGETHER_API_KEY'],
   // fireworks: ['FIREWORKS_API_KEY'],

package/dist/utils/dexto-auth.cjs

@@ -0,0 +1,83 @@
+"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 dexto_auth_exports = {};
+__export(dexto_auth_exports, {
+  canUseDextoProvider: () => canUseDextoProvider,
+  getDextoApiKeyFromAuth: () => getDextoApiKeyFromAuth,
+  isDextoAuthenticated: () => isDextoAuthenticated
+});
+module.exports = __toCommonJS(dexto_auth_exports);
+var import_fs = require("fs");
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+const AUTH_CONFIG_FILE = "auth.json";
+const AuthConfigSchema = import_zod.z.object({
+  token: import_zod.z.string().min(1),
+  expiresAt: import_zod.z.number().optional(),
+  dextoApiKey: import_zod.z.string().optional()
+});
+async function isDextoAuthenticated() {
+  const authPath = (0, import_core.getDextoGlobalPath)("", AUTH_CONFIG_FILE);
+  if (!(0, import_fs.existsSync)(authPath)) {
+    return false;
+  }
+  try {
+    const content = await import_fs.promises.readFile(authPath, "utf-8");
+    const config = JSON.parse(content);
+    const validated = AuthConfigSchema.safeParse(config);
+    if (!validated.success) {
+      return false;
+    }
+    if (validated.data.expiresAt && validated.data.expiresAt < Date.now()) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDextoApiKeyFromAuth() {
+  if (process.env.DEXTO_API_KEY) {
+    return process.env.DEXTO_API_KEY;
+  }
+  const authPath = (0, import_core.getDextoGlobalPath)("", AUTH_CONFIG_FILE);
+  if (!(0, import_fs.existsSync)(authPath)) {
+    return null;
+  }
+  try {
+    const content = await import_fs.promises.readFile(authPath, "utf-8");
+    const config = JSON.parse(content);
+    return config.dextoApiKey || null;
+  } catch {
+    return null;
+  }
+}
+async function canUseDextoProvider() {
+  const authenticated = await isDextoAuthenticated();
+  if (!authenticated) return false;
+  const apiKey = await getDextoApiKeyFromAuth();
+  if (!apiKey) return false;
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  canUseDextoProvider,
+  getDextoApiKeyFromAuth,
+  isDextoAuthenticated
+});

package/dist/utils/dexto-auth.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Dexto Authentication Utilities
+ *
+ * Provides functions to check dexto authentication status.
+ * Used by both CLI and server to determine if user can use dexto features.
+ */
+/**
+ * Check if user is authenticated with Dexto.
+ * Returns true if auth.json exists with valid (non-expired) token.
+ */
+export declare function isDextoAuthenticated(): Promise<boolean>;
+/**
+ * Get the dexto API key from auth config or environment.
+ */
+export declare function getDextoApiKeyFromAuth(): Promise<string | null>;
+/**
+ * Check if user can use Dexto provider.
+ * Requires BOTH:
+ * 1. User is authenticated (valid auth token)
+ * 2. Has DEXTO_API_KEY (from auth config or environment)
+ */
+export declare function canUseDextoProvider(): Promise<boolean>;
+//# sourceMappingURL=dexto-auth.d.ts.map

package/dist/utils/dexto-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dexto-auth.d.ts","sourceRoot":"","sources":["../../src/utils/dexto-auth.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAkBH;;;GAGG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,OAAO,CAAC,CAyB7D;AAED;;GAEG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAoBrE;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,OAAO,CAAC,CAQ5D"}

package/dist/utils/dexto-auth.js

@@ -0,0 +1,57 @@
+import { existsSync, promises as fs } from "fs";
+import { z } from "zod";
+import { getDextoGlobalPath } from "@dexto/core";
+const AUTH_CONFIG_FILE = "auth.json";
+const AuthConfigSchema = z.object({
+  token: z.string().min(1),
+  expiresAt: z.number().optional(),
+  dextoApiKey: z.string().optional()
+});
+async function isDextoAuthenticated() {
+  const authPath = getDextoGlobalPath("", AUTH_CONFIG_FILE);
+  if (!existsSync(authPath)) {
+    return false;
+  }
+  try {
+    const content = await fs.readFile(authPath, "utf-8");
+    const config = JSON.parse(content);
+    const validated = AuthConfigSchema.safeParse(config);
+    if (!validated.success) {
+      return false;
+    }
+    if (validated.data.expiresAt && validated.data.expiresAt < Date.now()) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDextoApiKeyFromAuth() {
+  if (process.env.DEXTO_API_KEY) {
+    return process.env.DEXTO_API_KEY;
+  }
+  const authPath = getDextoGlobalPath("", AUTH_CONFIG_FILE);
+  if (!existsSync(authPath)) {
+    return null;
+  }
+  try {
+    const content = await fs.readFile(authPath, "utf-8");
+    const config = JSON.parse(content);
+    return config.dextoApiKey || null;
+  } catch {
+    return null;
+  }
+}
+async function canUseDextoProvider() {
+  const authenticated = await isDextoAuthenticated();
+  if (!authenticated) return false;
+  const apiKey = await getDextoApiKeyFromAuth();
+  if (!apiKey) return false;
+  return true;
+}
+export {
+  canUseDextoProvider,
+  getDextoApiKeyFromAuth,
+  isDextoAuthenticated
+};

package/dist/utils/feature-flags.cjs

@@ -0,0 +1,30 @@
+"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 feature_flags_exports = {};
+__export(feature_flags_exports, {
+  isDextoAuthEnabled: () => isDextoAuthEnabled
+});
+module.exports = __toCommonJS(feature_flags_exports);
+function isDextoAuthEnabled() {
+  return process.env.DEXTO_FEATURE_AUTH === "true";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isDextoAuthEnabled
+});