@dexto/orchestration 1.5.8

package/dist/tools/index.cjs

@@ -0,0 +1,51 @@
+"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 tools_exports = {};
+__export(tools_exports, {
+  CheckTaskInputSchema: () => import_check_task2.CheckTaskInputSchema,
+  ListTasksInputSchema: () => import_list_tasks2.ListTasksInputSchema,
+  StartTaskInputSchema: () => import_start_task2.StartTaskInputSchema,
+  WaitForInputSchema: () => import_wait_for2.WaitForInputSchema,
+  createCheckTaskTool: () => import_check_task.createCheckTaskTool,
+  createGenericTaskStarter: () => import_start_task.createGenericTaskStarter,
+  createListTasksTool: () => import_list_tasks.createListTasksTool,
+  createStartTaskTool: () => import_start_task.createStartTaskTool,
+  createWaitForTool: () => import_wait_for.createWaitForTool
+});
+module.exports = __toCommonJS(tools_exports);
+var import_start_task = require("./start-task.js");
+var import_start_task2 = require("./start-task.js");
+var import_wait_for = require("./wait-for.js");
+var import_wait_for2 = require("./wait-for.js");
+var import_check_task = require("./check-task.js");
+var import_check_task2 = require("./check-task.js");
+var import_list_tasks = require("./list-tasks.js");
+var import_list_tasks2 = require("./list-tasks.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CheckTaskInputSchema,
+  ListTasksInputSchema,
+  StartTaskInputSchema,
+  WaitForInputSchema,
+  createCheckTaskTool,
+  createGenericTaskStarter,
+  createListTasksTool,
+  createStartTaskTool,
+  createWaitForTool
+});

package/dist/tools/index.d.cts

@@ -0,0 +1,10 @@
+export { StartTaskInput, StartTaskInputSchema, StartTaskOutput, TaskStarter, createGenericTaskStarter, createStartTaskTool } from './start-task.cjs';
+export { WaitForInput, WaitForInputSchema, WaitForOutput, createWaitForTool } from './wait-for.cjs';
+export { CheckTaskInput, CheckTaskInputSchema, CheckTaskOutput, createCheckTaskTool } from './check-task.cjs';
+export { ListTasksInput, ListTasksInputSchema, ListTasksOutput, TaskListItem, createListTasksTool } from './list-tasks.cjs';
+export { OrchestrationTool, OrchestrationToolContext } from './types.cjs';
+import 'zod';
+import '../types.cjs';
+import '../task-registry.cjs';
+import '../signal-bus.cjs';
+import '../condition-engine.cjs';

package/dist/tools/index.d.ts

@@ -0,0 +1,10 @@
+export { StartTaskInput, StartTaskInputSchema, StartTaskOutput, TaskStarter, createGenericTaskStarter, createStartTaskTool } from './start-task.js';
+export { WaitForInput, WaitForInputSchema, WaitForOutput, createWaitForTool } from './wait-for.js';
+export { CheckTaskInput, CheckTaskInputSchema, CheckTaskOutput, createCheckTaskTool } from './check-task.js';
+export { ListTasksInput, ListTasksInputSchema, ListTasksOutput, TaskListItem, createListTasksTool } from './list-tasks.js';
+export { OrchestrationTool, OrchestrationToolContext } from './types.js';
+import 'zod';
+import '../types.js';
+import '../task-registry.js';
+import '../signal-bus.js';
+import '../condition-engine.js';

package/dist/tools/index.js

@@ -0,0 +1,19 @@
+import { createStartTaskTool, createGenericTaskStarter } from "./start-task.js";
+import { StartTaskInputSchema } from "./start-task.js";
+import { createWaitForTool } from "./wait-for.js";
+import { WaitForInputSchema } from "./wait-for.js";
+import { createCheckTaskTool } from "./check-task.js";
+import { CheckTaskInputSchema } from "./check-task.js";
+import { createListTasksTool } from "./list-tasks.js";
+import { ListTasksInputSchema } from "./list-tasks.js";
+export {
+  CheckTaskInputSchema,
+  ListTasksInputSchema,
+  StartTaskInputSchema,
+  WaitForInputSchema,
+  createCheckTaskTool,
+  createGenericTaskStarter,
+  createListTasksTool,
+  createStartTaskTool,
+  createWaitForTool
+};

package/dist/tools/list-tasks.cjs

@@ -0,0 +1,80 @@
+"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 list_tasks_exports = {};
+__export(list_tasks_exports, {
+  ListTasksInputSchema: () => ListTasksInputSchema,
+  createListTasksTool: () => createListTasksTool
+});
+module.exports = __toCommonJS(list_tasks_exports);
+var import_zod = require("zod");
+const ListTasksInputSchema = import_zod.z.object({
+  /** Filter by status */
+  status: import_zod.z.enum(["pending", "running", "completed", "failed", "cancelled", "all"]).optional().default("all").describe("Filter tasks by status"),
+  /** Filter by type */
+  type: import_zod.z.enum(["agent", "process", "generic"]).optional().describe("Filter tasks by type")
+}).strict();
+function createListTasksTool() {
+  return {
+    id: "list_tasks",
+    description: "List all background tasks with optional filtering by status or type. Returns task information and counts.",
+    inputSchema: ListTasksInputSchema,
+    execute: async (rawInput, context) => {
+      const input = ListTasksInputSchema.parse(rawInput);
+      const filter = {};
+      if (input.status && input.status !== "all") {
+        filter.status = input.status;
+      }
+      if (input.type) {
+        filter.type = input.type;
+      }
+      const tasks = context.taskRegistry.list(filter);
+      const allTasks = context.taskRegistry.list();
+      const counts = {
+        running: 0,
+        completed: 0,
+        failed: 0,
+        cancelled: 0,
+        pending: 0
+      };
+      for (const task of allTasks) {
+        counts[task.status]++;
+      }
+      return {
+        tasks: tasks.map((t) => ({
+          taskId: t.taskId,
+          type: t.type,
+          status: t.status,
+          startedAt: t.startedAt.toISOString(),
+          ...t.description !== void 0 && { description: t.description },
+          ...t.completedAt !== void 0 && {
+            completedAt: t.completedAt.toISOString()
+          },
+          ...t.duration !== void 0 && { duration: t.duration }
+        })),
+        count: tasks.length,
+        counts
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ListTasksInputSchema,
+  createListTasksTool
+});

package/dist/tools/list-tasks.d.cts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { TaskStatus } from '../types.cjs';
+import { OrchestrationTool } from './types.cjs';
+import '../task-registry.cjs';
+import '../signal-bus.cjs';
+import '../condition-engine.cjs';
+
+/**
+ * list_tasks Tool
+ *
+ * List all tracked background tasks with optional filtering.
+ */
+
+/**
+ * Input schema for list_tasks tool
+ */
+declare const ListTasksInputSchema: z.ZodObject<{
+    /** Filter by status */
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<["pending", "running", "completed", "failed", "cancelled", "all"]>>>;
+    /** Filter by type */
+    type: z.ZodOptional<z.ZodEnum<["agent", "process", "generic"]>>;
+}, "strict", z.ZodTypeAny, {
+    status: "pending" | "running" | "completed" | "failed" | "cancelled" | "all";
+    type?: "agent" | "process" | "generic" | undefined;
+}, {
+    type?: "agent" | "process" | "generic" | undefined;
+    status?: "pending" | "running" | "completed" | "failed" | "cancelled" | "all" | undefined;
+}>;
+type ListTasksInput = z.output<typeof ListTasksInputSchema>;
+/**
+ * Task info in list output
+ */
+interface TaskListItem {
+    taskId: string;
+    type: 'agent' | 'process' | 'generic';
+    status: TaskStatus;
+    description?: string;
+    startedAt: string;
+    completedAt?: string;
+    duration?: number;
+}
+/**
+ * Output from list_tasks tool
+ */
+interface ListTasksOutput {
+    /** List of tasks matching filter */
+    tasks: TaskListItem[];
+    /** Total count */
+    count: number;
+    /** Counts by status */
+    counts: {
+        running: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+        pending: number;
+    };
+}
+/**
+ * Create the list_tasks tool
+ */
+declare function createListTasksTool(): OrchestrationTool;
+
+export { type ListTasksInput, ListTasksInputSchema, type ListTasksOutput, type TaskListItem, createListTasksTool };

package/dist/tools/list-tasks.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { TaskStatus } from '../types.js';
+import { OrchestrationTool } from './types.js';
+import '../task-registry.js';
+import '../signal-bus.js';
+import '../condition-engine.js';
+
+/**
+ * list_tasks Tool
+ *
+ * List all tracked background tasks with optional filtering.
+ */
+
+/**
+ * Input schema for list_tasks tool
+ */
+declare const ListTasksInputSchema: z.ZodObject<{
+    /** Filter by status */
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<["pending", "running", "completed", "failed", "cancelled", "all"]>>>;
+    /** Filter by type */
+    type: z.ZodOptional<z.ZodEnum<["agent", "process", "generic"]>>;
+}, "strict", z.ZodTypeAny, {
+    status: "pending" | "running" | "completed" | "failed" | "cancelled" | "all";
+    type?: "agent" | "process" | "generic" | undefined;
+}, {
+    type?: "agent" | "process" | "generic" | undefined;
+    status?: "pending" | "running" | "completed" | "failed" | "cancelled" | "all" | undefined;
+}>;
+type ListTasksInput = z.output<typeof ListTasksInputSchema>;
+/**
+ * Task info in list output
+ */
+interface TaskListItem {
+    taskId: string;
+    type: 'agent' | 'process' | 'generic';
+    status: TaskStatus;
+    description?: string;
+    startedAt: string;
+    completedAt?: string;
+    duration?: number;
+}
+/**
+ * Output from list_tasks tool
+ */
+interface ListTasksOutput {
+    /** List of tasks matching filter */
+    tasks: TaskListItem[];
+    /** Total count */
+    count: number;
+    /** Counts by status */
+    counts: {
+        running: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+        pending: number;
+    };
+}
+/**
+ * Create the list_tasks tool
+ */
+declare function createListTasksTool(): OrchestrationTool;
+
+export { type ListTasksInput, ListTasksInputSchema, type ListTasksOutput, type TaskListItem, createListTasksTool };

package/dist/tools/list-tasks.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+const ListTasksInputSchema = z.object({
+  /** Filter by status */
+  status: z.enum(["pending", "running", "completed", "failed", "cancelled", "all"]).optional().default("all").describe("Filter tasks by status"),
+  /** Filter by type */
+  type: z.enum(["agent", "process", "generic"]).optional().describe("Filter tasks by type")
+}).strict();
+function createListTasksTool() {
+  return {
+    id: "list_tasks",
+    description: "List all background tasks with optional filtering by status or type. Returns task information and counts.",
+    inputSchema: ListTasksInputSchema,
+    execute: async (rawInput, context) => {
+      const input = ListTasksInputSchema.parse(rawInput);
+      const filter = {};
+      if (input.status && input.status !== "all") {
+        filter.status = input.status;
+      }
+      if (input.type) {
+        filter.type = input.type;
+      }
+      const tasks = context.taskRegistry.list(filter);
+      const allTasks = context.taskRegistry.list();
+      const counts = {
+        running: 0,
+        completed: 0,
+        failed: 0,
+        cancelled: 0,
+        pending: 0
+      };
+      for (const task of allTasks) {
+        counts[task.status]++;
+      }
+      return {
+        tasks: tasks.map((t) => ({
+          taskId: t.taskId,
+          type: t.type,
+          status: t.status,
+          startedAt: t.startedAt.toISOString(),
+          ...t.description !== void 0 && { description: t.description },
+          ...t.completedAt !== void 0 && {
+            completedAt: t.completedAt.toISOString()
+          },
+          ...t.duration !== void 0 && { duration: t.duration }
+        })),
+        count: tasks.length,
+        counts
+      };
+    }
+  };
+}
+export {
+  ListTasksInputSchema,
+  createListTasksTool
+};

package/dist/tools/start-task.cjs

@@ -0,0 +1,149 @@
+"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 start_task_exports = {};
+__export(start_task_exports, {
+  StartTaskInputSchema: () => StartTaskInputSchema,
+  createGenericTaskStarter: () => createGenericTaskStarter,
+  createStartTaskTool: () => createStartTaskTool
+});
+module.exports = __toCommonJS(start_task_exports);
+var import_zod = require("zod");
+const StartTaskInputSchema = import_zod.z.object({
+  /** Task type to start */
+  type: import_zod.z.enum(["agent", "process", "generic"]).describe("Type of task to start"),
+  // Agent task options
+  /** Task description for agent (required for type='agent') */
+  task: import_zod.z.string().optional().describe("Task description for agent execution"),
+  /** Custom system prompt for agent */
+  systemPrompt: import_zod.z.string().optional().describe("Custom system prompt for the agent"),
+  // Process task options
+  /** Command to run (required for type='process') */
+  command: import_zod.z.string().optional().describe("Shell command to execute"),
+  // Generic task options
+  /** Description for generic task */
+  description: import_zod.z.string().optional().describe("Description of the task"),
+  // Common options
+  /** Timeout in milliseconds */
+  timeout: import_zod.z.number().positive().optional().describe("Task timeout in milliseconds"),
+  /** Auto-notify when complete (triggers agent turn) */
+  notify: import_zod.z.boolean().default(false).describe("Auto-notify when task completes")
+}).strict().superRefine((data, ctx) => {
+  if (data.type === "agent" && !data.task) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: 'task is required when type is "agent"',
+      path: ["task"]
+    });
+  }
+  if (data.type === "process" && !data.command) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: 'command is required when type is "process"',
+      path: ["command"]
+    });
+  }
+});
+function createStartTaskTool(starters) {
+  return {
+    id: "start_task",
+    description: "Start a background task without waiting for completion. Returns immediately with a task ID. Use wait_for or check_task to monitor progress.",
+    inputSchema: StartTaskInputSchema,
+    execute: async (rawInput, context) => {
+      const input = StartTaskInputSchema.parse(rawInput);
+      const starter = starters.get(input.type);
+      if (!starter) {
+        return {
+          success: false,
+          error: `No task starter registered for type '${input.type}'. Available types: ${Array.from(starters.keys()).join(", ") || "none"}`
+        };
+      }
+      try {
+        const { taskId, promise } = await starter.start(input);
+        const registerOptions = {
+          notify: input.notify,
+          ...input.timeout !== void 0 && { timeout: input.timeout }
+        };
+        if (input.type === "agent") {
+          context.taskRegistry.register(
+            {
+              type: "agent",
+              taskId,
+              agentId: taskId,
+              // Using taskId as agentId for now
+              taskDescription: input.task ?? "",
+              promise
+            },
+            registerOptions
+          );
+        } else if (input.type === "process") {
+          context.taskRegistry.register(
+            {
+              type: "process",
+              taskId,
+              processId: taskId,
+              command: input.command ?? "",
+              promise
+            },
+            registerOptions
+          );
+        } else {
+          context.taskRegistry.register(
+            {
+              type: "generic",
+              taskId,
+              description: input.description ?? "Generic task",
+              promise
+            },
+            registerOptions
+          );
+        }
+        return {
+          success: true,
+          taskId,
+          status: "running"
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
+  };
+}
+function createGenericTaskStarter() {
+  let taskCounter = 0;
+  return {
+    async start(input) {
+      const taskId = `generic-${++taskCounter}`;
+      const promise = new Promise((resolve) => {
+        setTimeout(() => {
+          resolve({ completed: true, description: input.description });
+        }, 1e3);
+      });
+      return { taskId, promise };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StartTaskInputSchema,
+  createGenericTaskStarter,
+  createStartTaskTool
+});

package/dist/tools/start-task.d.cts

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { OrchestrationTool } from './types.cjs';
+import '../task-registry.cjs';
+import '../types.cjs';
+import '../signal-bus.cjs';
+import '../condition-engine.cjs';
+
+/**
+ * start_task Tool
+ *
+ * Starts a background task without blocking.
+ * This is a higher-level tool that delegates to task-specific providers.
+ */
+
+/**
+ * Input schema for start_task tool
+ */
+declare const StartTaskInputSchema: z.ZodEffects<z.ZodObject<{
+    /** Task type to start */
+    type: z.ZodEnum<["agent", "process", "generic"]>;
+    /** Task description for agent (required for type='agent') */
+    task: z.ZodOptional<z.ZodString>;
+    /** Custom system prompt for agent */
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    /** Command to run (required for type='process') */
+    command: z.ZodOptional<z.ZodString>;
+    /** Description for generic task */
+    description: z.ZodOptional<z.ZodString>;
+    /** Timeout in milliseconds */
+    timeout: z.ZodOptional<z.ZodNumber>;
+    /** Auto-notify when complete (triggers agent turn) */
+    notify: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    type: "agent" | "process" | "generic";
+    notify: boolean;
+    timeout?: number | undefined;
+    task?: string | undefined;
+    command?: string | undefined;
+    description?: string | undefined;
+    systemPrompt?: string | undefined;
+}, {
+    type: "agent" | "process" | "generic";
+    timeout?: number | undefined;
+    task?: string | undefined;
+    command?: string | undefined;
+    description?: string | undefined;
+    systemPrompt?: string | undefined;
+    notify?: boolean | undefined;
+}>, {
+    type: "agent" | "process" | "generic";
+    notify: boolean;
+    timeout?: number | undefined;
+    task?: string | undefined;
+    command?: string | undefined;
+    description?: string | undefined;
+    systemPrompt?: string | undefined;
+}, {
+    type: "agent" | "process" | "generic";
+    timeout?: number | undefined;
+    task?: string | undefined;
+    command?: string | undefined;
+    description?: string | undefined;
+    systemPrompt?: string | undefined;
+    notify?: boolean | undefined;
+}>;
+type StartTaskInput = z.infer<typeof StartTaskInputSchema>;
+/**
+ * Output from start_task tool
+ */
+interface StartTaskOutput {
+    /** Whether task was started successfully */
+    success: boolean;
+    /** Task ID for tracking */
+    taskId?: string;
+    /** Error message if failed to start */
+    error?: string;
+    /** Status */
+    status?: 'running';
+}
+/**
+ * Task starter interface - implemented by agent-spawner, process-tools, etc.
+ */
+interface TaskStarter {
+    /** Start a task and return the promise */
+    start(input: StartTaskInput): Promise<{
+        taskId: string;
+        promise: Promise<unknown>;
+    }>;
+}
+/**
+ * Create the start_task tool
+ *
+ * Note: This tool requires task starters to be registered for each task type.
+ * Use `registerTaskStarter` to add support for agent/process/generic tasks.
+ */
+declare function createStartTaskTool(starters: Map<string, TaskStarter>): OrchestrationTool;
+/**
+ * Create a simple generic task starter for testing
+ */
+declare function createGenericTaskStarter(): TaskStarter;
+
+export { type StartTaskInput, StartTaskInputSchema, type StartTaskOutput, type TaskStarter, createGenericTaskStarter, createStartTaskTool };