@dexto/agent-management 1.5.8 → 1.6.0

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

@@ -1,180 +0,0 @@
-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");
-    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",
-    description: "Spawn sub-agents for task delegation",
-    category: "agents"
-  }
-};
-export {
-  agentSpawnerToolsProvider
-};

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

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