@dexto/agent-management 1.5.7 → 1.5.8

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

@@ -3,6 +3,9 @@ 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 { deriveDisplayName } from "../registry/types.js";
+import { resolveBundledScript } from "../utils/path.js";
+import * as path from "path";
 import { resolveSubAgentLLM } from "./llm-resolution.js";
 class RuntimeService {
   runtime;
@@ -10,6 +13,37 @@ class RuntimeService {
   parentAgent;
   config;
   logger;
+  resolveBundledAgentConfig(agentId) {
+    const baseDir = "agents";
+    const normalizedPath = path.relative(baseDir, path.join(baseDir, agentId));
+    if (normalizedPath.startsWith("..") || path.isAbsolute(normalizedPath)) {
+      return null;
+    }
+    const candidates = [
+      `agents/${agentId}/${agentId}.yml`,
+      `agents/${agentId}/${agentId}.yaml`,
+      `agents/${agentId}.yml`,
+      `agents/${agentId}.yaml`
+    ];
+    for (const candidate of candidates) {
+      try {
+        return resolveBundledScript(candidate);
+      } catch {
+      }
+    }
+    return null;
+  }
+  createFallbackRegistryEntry(agentId) {
+    return {
+      id: agentId,
+      name: deriveDisplayName(agentId),
+      description: "Agent specified in config (registry entry not found)",
+      author: "unknown",
+      tags: [],
+      source: agentId,
+      type: "custom"
+    };
+  }
   constructor(parentAgent, config, logger) {
     this.parentAgent = parentAgent;
     this.config = config;
@@ -407,12 +441,26 @@ class RuntimeService {
     );
     const toolConfirmationMode = autoApprove ? "auto-approve" : "manual";
     if (agentId) {
-      const registry = getAgentRegistry();
-      if (!registry.hasAgent(agentId)) {
-        this.logger.warn(`Agent '${agentId}' not found in registry. Using default config.`);
-      } else {
-        const configPath = await registry.resolveAgent(agentId);
-        this.logger.debug(`Loading agent config from registry: ${configPath}`);
+      let configPath = null;
+      try {
+        const registry = getAgentRegistry();
+        if (!registry.hasAgent(agentId)) {
+          this.logger.warn(
+            `Agent '${agentId}' not found in registry. Trying bundled config paths.`
+          );
+        } else {
+          configPath = await registry.resolveAgent(agentId);
+        }
+      } catch (error) {
+        this.logger.warn(
+          `Failed to load agent registry for '${agentId}'. Trying bundled config paths. (${error instanceof Error ? error.message : String(error)})`
+        );
+      }
+      if (!configPath) {
+        configPath = this.resolveBundledAgentConfig(agentId);
+      }
+      if (configPath) {
+        this.logger.debug(`Loading agent config from registry/bundled path: ${configPath}`);
         const loadedConfig = await loadAgentConfig(configPath, this.logger);
         let llmConfig = loadedConfig.llm;
         if (inheritLlm) {
@@ -429,6 +477,9 @@ class RuntimeService {
           this.logger.debug(`Sub-agent LLM resolution: ${resolution.reason}`);
           llmConfig = resolution.llm;
         }
+        const filteredCustomTools = loadedConfig.customTools ? loadedConfig.customTools.filter(
+          (tool) => typeof tool === "object" && tool !== null && "type" in tool && tool.type !== "agent-spawner"
+        ) : void 0;
         return {
           ...loadedConfig,
           llm: llmConfig,
@@ -436,6 +487,7 @@ class RuntimeService {
             ...loadedConfig.toolConfirmation,
             mode: toolConfirmationMode
           },
+          customTools: filteredCustomTools,
           // Suppress sub-agent console logs entirely using silent transport
           logger: {
             level: "error",
@@ -443,6 +495,9 @@ class RuntimeService {
           }
         };
       }
+      this.logger.warn(
+        `Agent '${agentId}' not found in registry or bundled paths. Using default config.`
+      );
     }
     const config = {
       llm: { ...currentParentLLM },
@@ -459,8 +514,11 @@ class RuntimeService {
       internalTools: parentConfig.internalTools ? parentConfig.internalTools.filter(
         (tool) => tool !== "ask_user" && tool !== "invoke_skill"
       ) : [],
-      // Inherit custom tools from parent
-      customTools: parentConfig.customTools ? [...parentConfig.customTools] : [],
+      // Inherit custom tools from parent, excluding agent-spawner to prevent nested spawning (depth=1 limit)
+      // - agent-spawner: Sub-agents should not spawn their own sub-agents
+      customTools: parentConfig.customTools ? parentConfig.customTools.filter(
+        (tool) => typeof tool === "object" && tool !== null && "type" in tool && tool.type !== "agent-spawner"
+      ) : [],
       // Suppress sub-agent console logs entirely using silent transport
       logger: {
         level: "error",
@@ -474,15 +532,24 @@ class RuntimeService {
    * Returns agent metadata from registry, filtered by allowedAgents if configured.
    */
   getAvailableAgents() {
-    const registry = getAgentRegistry();
-    const allAgents = registry.getAvailableAgents();
+    let allAgents;
+    try {
+      const registry = getAgentRegistry();
+      allAgents = registry.getAvailableAgents();
+    } catch (error) {
+      this.logger.warn(
+        `Failed to load agent registry for spawn_agent description: ${error instanceof Error ? error.message : String(error)}`
+      );
+      if (this.config.allowedAgents && this.config.allowedAgents.length > 0) {
+        return this.config.allowedAgents.map((id) => this.createFallbackRegistryEntry(id));
+      }
+      return [];
+    }
     if (this.config.allowedAgents && this.config.allowedAgents.length > 0) {
       const result = [];
       for (const id of this.config.allowedAgents) {
         const agent = allAgents[id];
-        if (agent) {
-          result.push(agent);
-        }
+        result.push(agent ?? this.createFallbackRegistryEntry(id));
       }
       return result;
     }

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

@@ -21,18 +21,169 @@ __export(tool_provider_exports, {
   agentSpawnerToolsProvider: () => agentSpawnerToolsProvider
 });
 module.exports = __toCommonJS(tool_provider_exports);
+var import_orchestration = require("@dexto/orchestration");
 var import_schemas = require("./schemas.js");
 var import_runtime_service = require("./runtime-service.js");
 var import_spawn_agent_tool = require("./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: import_schemas.AgentSpawnerConfigSchema,
   create: (config, context) => {
     const { logger, agent } = context;
+    const signalBus = new import_orchestration.SignalBus();
+    const taskRegistry = new import_orchestration.TaskRegistry(signalBus);
+    const conditionEngine = new import_orchestration.ConditionEngine(taskRegistry, signalBus, logger);
+    const toolContext = {
+      taskRegistry,
+      conditionEngine,
+      signalBus
+    };
     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)];
+    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 = (0, import_spawn_agent_tool.createSpawnAgentTool)(service);
+    return [
+      tool,
+      bindOrchestrationTool((0, import_orchestration.createWaitForTool)(), toolContext),
+      bindOrchestrationTool((0, import_orchestration.createCheckTaskTool)(), toolContext),
+      bindOrchestrationTool((0, import_orchestration.createListTasksTool)(), toolContext)
+    ];
   },
   metadata: {
     displayName: "Agent Spawner",

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

@@ -8,7 +8,13 @@ import { type AgentSpawnerConfig } from './schemas.js';
 /**
  * Agent Spawner Tools Provider
  *
- * Provides the spawn_agent tool for task delegation to sub-agents.
+ * Provides tools for spawning and managing sub-agents:
+ * - spawn_agent: Spawn a sub-agent to handle a task
+ *
+ * Orchestration tools (for background task management):
+ * - wait_for: Wait for background task(s) to complete
+ * - check_task: Check status of a background task
+ * - list_tasks: List all tracked background tasks
  *
  * Configuration:
  * ```yaml

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,CAwB7F,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,15 +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);
     agent.toolManager.setTaskForker(service);
     logger.debug("RuntimeService wired as taskForker for context:fork skill support");
-    return [createSpawnAgentTool(service)];
+    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/utils/api-key-resolver.cjs

@@ -52,7 +52,7 @@ const PROVIDER_API_KEY_MAP = {
   ollama: [],
   // Ollama server (may optionally use OLLAMA_API_KEY for remote servers)
   // Dexto gateway - requires key from `dexto login`
-  dexto: ["DEXTO_API_KEY"]
+  "dexto-nova": ["DEXTO_API_KEY"]
   // perplexity: ['PERPLEXITY_API_KEY'],
   // together: ['TOGETHER_API_KEY'],
   // fireworks: ['FIREWORKS_API_KEY'],

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

@@ -27,7 +27,7 @@ const PROVIDER_API_KEY_MAP = {
   ollama: [],
   // Ollama server (may optionally use OLLAMA_API_KEY for remote servers)
   // Dexto gateway - requires key from `dexto login`
-  dexto: ["DEXTO_API_KEY"]
+  "dexto-nova": ["DEXTO_API_KEY"]
   // perplexity: ['PERPLEXITY_API_KEY'],
   // together: ['TOGETHER_API_KEY'],
   // fireworks: ['FIREWORKS_API_KEY'],

package/dist/utils/feature-flags.cjs

@@ -22,7 +22,9 @@ __export(feature_flags_exports, {
 });
 module.exports = __toCommonJS(feature_flags_exports);
 function isDextoAuthEnabled() {
-  return process.env.DEXTO_FEATURE_AUTH === "true";
+  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 = {

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

@@ -7,7 +7,7 @@
 /**
  * Check if Dexto authentication/provider is enabled.
  *
- * When disabled (default), the Dexto provider option is hidden from:
+ * 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
@@ -15,7 +15,7 @@
  * The underlying auth commands (dexto login, logout, billing) remain functional
  * for users who need to manage their account.
  *
- * Enable by setting DEXTO_FEATURE_AUTH=true in environment.
+ * 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

@@ -1 +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,CAE5C"}
+{"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

@@ -1,5 +1,7 @@
 function isDextoAuthEnabled() {
-  return process.env.DEXTO_FEATURE_AUTH === "true";
+  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.7",
+  "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.7"
+    "@dexto/core": "1.5.8",
+    "@dexto/orchestration": "1.5.8"
   },
   "devDependencies": {
     "@types/node": "^22.13.5"