@dexto/agent-management 1.5.6 → 1.5.8

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;AAYpE,OAAO,EAA4B,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAmBjF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,yBAAyB,EAAE,kBAAkB,CAAC,eAAe,EAAE,kBAAkB,CAsM7F,CAAC"}

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

@@ -1,13 +1,173 @@
+import {
+  ConditionEngine,
+  SignalBus,
+  TaskRegistry,
+  createCheckTaskTool,
+  createListTasksTool,
+  createWaitForTool
+} from "@dexto/orchestration";
 import { AgentSpawnerConfigSchema } from "./schemas.js";
 import { RuntimeService } from "./runtime-service.js";
 import { createSpawnAgentTool } from "./spawn-agent-tool.js";
+function bindOrchestrationTool(tool, context) {
+  return {
+    id: tool.id,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    execute: (input) => tool.execute(input, context)
+  };
+}
 const agentSpawnerToolsProvider = {
   type: "agent-spawner",
   configSchema: AgentSpawnerConfigSchema,
   create: (config, context) => {
     const { logger, agent } = context;
+    const signalBus = new SignalBus();
+    const taskRegistry = new TaskRegistry(signalBus);
+    const conditionEngine = new ConditionEngine(taskRegistry, signalBus, logger);
+    const toolContext = {
+      taskRegistry,
+      conditionEngine,
+      signalBus
+    };
     const service = new RuntimeService(agent, config, logger);
-    return [createSpawnAgentTool(service)];
+    agent.toolManager.setTaskForker(service);
+    logger.debug("RuntimeService wired as taskForker for context:fork skill support");
+    const taskSessions = /* @__PURE__ */ new Map();
+    const emitTasksUpdate = (sessionId) => {
+      const tasks = taskRegistry.list({
+        status: ["running", "completed", "failed", "cancelled"]
+      });
+      const scopedTasks = sessionId ? tasks.filter((task) => taskSessions.get(task.taskId) === sessionId) : tasks;
+      const runningCount = scopedTasks.filter((task) => task.status === "running").length;
+      agent.agentEventBus.emit("service:event", {
+        service: "orchestration",
+        event: "tasks-updated",
+        sessionId: sessionId ?? "",
+        data: {
+          runningCount,
+          tasks: scopedTasks.map((task) => ({
+            taskId: task.taskId,
+            status: task.status,
+            ...task.description !== void 0 && { description: task.description }
+          }))
+        }
+      });
+    };
+    const triggerBackgroundCompletion = (taskId, sessionId) => {
+      if (!sessionId) {
+        return;
+      }
+      agent.agentEventBus.emit("tool:background-completed", {
+        toolCallId: taskId,
+        sessionId
+      });
+      const taskInfo = taskRegistry.getInfo(taskId);
+      const resultText = (() => {
+        if (taskInfo?.status === "failed") {
+          return taskInfo.error ?? "Unknown error.";
+        }
+        if (taskInfo?.result !== void 0) {
+          if (typeof taskInfo.result === "string") {
+            return taskInfo.result;
+          }
+          try {
+            return JSON.stringify(taskInfo.result, null, 2);
+          } catch {
+            return String(taskInfo.result ?? "<unserializable result>");
+          }
+        }
+        return "No result available.";
+      })();
+      const sanitizeCdata = (value) => value.replace(/\]\]>/g, "]]]]><![CDATA[>");
+      const safeDescription = taskInfo?.description ? sanitizeCdata(taskInfo.description) : null;
+      const safeResultText = sanitizeCdata(resultText);
+      const descriptionTag = safeDescription ? `  <description><![CDATA[${safeDescription}]]></description>
+` : "";
+      const statusTag = taskInfo?.status ? `  <status>${taskInfo.status}</status>
+` : "";
+      const content = [
+        {
+          type: "text",
+          text: `<background-task-completion>
+  <origin>task</origin>
+  <note>The following response was reported by the background task (not user input).</note>
+  <taskId>${taskId}</taskId>
+` + statusTag + descriptionTag + `  <result><![CDATA[${safeResultText}]]></result>
+</background-task-completion>`
+        }
+      ];
+      agent.isSessionBusy(sessionId).then((isBusy) => {
+        if (isBusy) {
+          agent.queueMessage(sessionId, {
+            content,
+            kind: "background"
+          }).catch(() => void 0);
+        } else {
+          agent.agentEventBus.emit("run:invoke", {
+            sessionId,
+            content,
+            source: "external",
+            metadata: { taskId }
+          });
+          agent.generate(content, sessionId).catch(() => void 0);
+        }
+      }).catch(() => {
+      });
+    };
+    const handleBackground = (event) => {
+      const taskId = event.toolCallId;
+      if (taskRegistry.has(taskId)) {
+        return;
+      }
+      if (event.sessionId) {
+        taskSessions.set(taskId, event.sessionId);
+      }
+      try {
+        taskRegistry.register(
+          {
+            type: "generic",
+            taskId,
+            description: event.description ?? `Tool ${event.toolName}`,
+            promise: event.promise
+          },
+          {
+            ...event.timeoutMs !== void 0 && { timeout: event.timeoutMs },
+            ...event.notifyOnComplete !== void 0 && {
+              notify: event.notifyOnComplete
+            }
+          }
+        );
+      } catch (error) {
+        taskSessions.delete(taskId);
+        event.promise.catch(() => void 0);
+        logger.warn(
+          `Failed to register background task ${taskId}: ${error instanceof Error ? error.message : String(error)}`,
+          { color: "yellow" }
+        );
+        return;
+      }
+      emitTasksUpdate(event.sessionId);
+      event.promise.finally(() => {
+        taskSessions.delete(taskId);
+        emitTasksUpdate(event.sessionId);
+        triggerBackgroundCompletion(taskId, event.sessionId);
+      });
+    };
+    const backgroundAbortController = new AbortController();
+    agent.agentEventBus.on("tool:background", handleBackground, {
+      signal: backgroundAbortController.signal
+    });
+    agent.agentEventBus.on("agent:stopped", () => {
+      backgroundAbortController.abort();
+    });
+    const tool = createSpawnAgentTool(service);
+    return [
+      tool,
+      bindOrchestrationTool(createWaitForTool(), toolContext),
+      bindOrchestrationTool(createCheckTaskTool(), toolContext),
+      bindOrchestrationTool(createListTasksTool(), toolContext)
+    ];
   },
   metadata: {
     displayName: "Agent Spawner",

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-nova": ["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-nova": ["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,32 @@
+"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() {
+  const flag = process.env.DEXTO_FEATURE_AUTH;
+  if (flag === void 0) return true;
+  return flag === "true";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isDextoAuthEnabled
+});

package/dist/utils/feature-flags.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Feature flags for Dexto
+ *
+ * These flags control the availability of features that are in development
+ * or being rolled out gradually.
+ */
+/**
+ * Check if Dexto authentication/provider is enabled.
+ *
+ * When disabled (set DEXTO_FEATURE_AUTH=false), the Dexto provider option is hidden from:
+ * - Onboarding/setup wizard
+ * - Model selectors (CLI and WebUI)
+ * - LLM catalog API responses
+ *
+ * The underlying auth commands (dexto login, logout, billing) remain functional
+ * for users who need to manage their account.
+ *
+ * Enabled by default. Set DEXTO_FEATURE_AUTH=false to disable.
+ */
+export declare function isDextoAuthEnabled(): boolean;
+//# sourceMappingURL=feature-flags.d.ts.map

package/dist/utils/feature-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../src/utils/feature-flags.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAI5C"}

package/dist/utils/feature-flags.js

@@ -0,0 +1,8 @@
+function isDextoAuthEnabled() {
+  const flag = process.env.DEXTO_FEATURE_AUTH;
+  if (flag === void 0) return true;
+  return flag === "true";
+}
+export {
+  isDextoAuthEnabled
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/agent-management",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -16,7 +16,8 @@
   "dependencies": {
     "yaml": "^2.7.1",
     "zod": "^3.25.0",
-    "@dexto/core": "1.5.6"
+    "@dexto/core": "1.5.8",
+    "@dexto/orchestration": "1.5.8"
   },
   "devDependencies": {
     "@types/node": "^22.13.5"