@dexto/orchestration 1.5.8

package/dist/condition-engine.js

@@ -0,0 +1,252 @@
+import { randomUUID } from "crypto";
+class ConditionEngine {
+  constructor(taskRegistry, signalBus, logger) {
+    this.taskRegistry = taskRegistry;
+    this.signalBus = signalBus;
+    this.logger = logger;
+  }
+  /**
+   * Wait for a condition to be met
+   * @param condition Wait condition to evaluate
+   * @returns Promise resolving to the signal(s) that satisfied the condition
+   */
+  async wait(condition) {
+    const immediate = this.check(condition);
+    if (immediate) {
+      return immediate;
+    }
+    return this.evaluate(condition);
+  }
+  /**
+   * Check if a condition is already satisfied (non-blocking)
+   * @returns WaitResult if satisfied, null if not
+   */
+  check(condition) {
+    switch (condition.type) {
+      case "task":
+        return this.checkTask(condition.taskId);
+      case "any":
+        return this.checkAny(condition.conditions);
+      case "all":
+        return this.checkAll(condition.conditions);
+      case "timeout":
+        return null;
+      case "race":
+        return this.check(condition.task);
+    }
+  }
+  /**
+   * Check if a single task is completed
+   */
+  checkTask(taskId) {
+    const result = this.taskRegistry.getResult(taskId);
+    if (!result) {
+      return null;
+    }
+    if (result.status === "completed") {
+      return {
+        signal: {
+          type: "task:completed",
+          taskId,
+          result: result.result
+        }
+      };
+    }
+    if (result.status === "failed") {
+      return {
+        signal: {
+          type: "task:failed",
+          taskId,
+          error: result.error ?? "Unknown error"
+        }
+      };
+    }
+    if (result.status === "cancelled") {
+      return {
+        signal: {
+          type: "task:cancelled",
+          taskId
+        }
+      };
+    }
+    return null;
+  }
+  /**
+   * Check if any of the conditions is satisfied
+   */
+  checkAny(conditions) {
+    for (const condition of conditions) {
+      const result = this.check(condition);
+      if (result) {
+        return result;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if all conditions are satisfied
+   */
+  checkAll(conditions) {
+    const signals = [];
+    for (const condition of conditions) {
+      const result = this.check(condition);
+      if (!result) {
+        return null;
+      }
+      signals.push(result.signal);
+    }
+    const primarySignal = signals[0];
+    if (!primarySignal) {
+      throw new Error("Internal error: no signals in checkAll result");
+    }
+    return {
+      signal: primarySignal,
+      allSignals: signals
+    };
+  }
+  /**
+   * Evaluate a condition asynchronously
+   */
+  async evaluate(condition) {
+    switch (condition.type) {
+      case "task":
+        return this.evaluateTask(condition.taskId);
+      case "any":
+        return this.evaluateAny(condition.conditions);
+      case "all":
+        return this.evaluateAll(condition.conditions);
+      case "timeout":
+        return this.evaluateTimeout(condition.ms, condition.conditionId);
+      case "race":
+        return this.evaluateRace(condition.task, condition.timeout);
+    }
+  }
+  /**
+   * Wait for a single task to complete
+   *
+   * Uses subscribe-then-check pattern to avoid race conditions where
+   * the task completes between checking and subscribing.
+   */
+  async evaluateTask(taskId) {
+    this.logger?.debug(`[ConditionEngine] evaluateTask called for taskId=${taskId}`);
+    return new Promise((resolve) => {
+      let unsubscribe;
+      const handler = (signal) => {
+        this.logger?.debug(
+          `[ConditionEngine] Received signal: type=${signal.type}, taskId=${"taskId" in signal ? signal.taskId : "N/A"}`
+        );
+        if ((signal.type === "task:completed" || signal.type === "task:failed" || signal.type === "task:cancelled") && signal.taskId === taskId) {
+          this.logger?.debug(
+            `[ConditionEngine] Signal matches taskId=${taskId}, resolving`
+          );
+          if (unsubscribe) {
+            unsubscribe();
+          }
+          resolve({ signal });
+        }
+      };
+      unsubscribe = this.signalBus.onAny(handler);
+      this.logger?.debug(`[ConditionEngine] Subscribed to signals for taskId=${taskId}`);
+      const immediate = this.checkTask(taskId);
+      this.logger?.debug(
+        `[ConditionEngine] checkTask(${taskId}) returned: ${immediate ? "found" : "null"}`
+      );
+      if (immediate) {
+        unsubscribe();
+        resolve(immediate);
+      }
+    });
+  }
+  /**
+   * Wait for any of the conditions to be satisfied
+   */
+  async evaluateAny(conditions) {
+    const immediate = this.checkAny(conditions);
+    if (immediate) {
+      return immediate;
+    }
+    const promises = conditions.map((c) => this.evaluate(c));
+    const result = await Promise.race(promises);
+    return result;
+  }
+  /**
+   * Wait for all conditions to be satisfied
+   */
+  async evaluateAll(conditions) {
+    const immediate = this.checkAll(conditions);
+    if (immediate) {
+      return immediate;
+    }
+    const results = await Promise.all(conditions.map((c) => this.evaluate(c)));
+    const signals = results.map((r) => r.signal);
+    const primarySignal = signals[0];
+    if (!primarySignal) {
+      throw new Error("Internal error: no signals in evaluateAll result");
+    }
+    return {
+      signal: primarySignal,
+      allSignals: signals
+    };
+  }
+  /**
+   * Wait for a timeout
+   */
+  async evaluateTimeout(ms, conditionId) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    const signal = {
+      type: "timeout",
+      conditionId
+    };
+    this.signalBus.emit(signal);
+    return { signal };
+  }
+  /**
+   * Race a task condition against a timeout
+   */
+  async evaluateRace(taskCondition, timeoutCondition) {
+    const immediate = this.check(taskCondition);
+    if (immediate) {
+      return immediate;
+    }
+    const result = await Promise.race([
+      this.evaluate(taskCondition),
+      this.evaluate(timeoutCondition)
+    ]);
+    return result;
+  }
+  /**
+   * Helper to create a race condition with timeout
+   */
+  static createRaceWithTimeout(taskId, timeoutMs) {
+    return {
+      type: "race",
+      task: { type: "task", taskId },
+      timeout: {
+        type: "timeout",
+        ms: timeoutMs,
+        conditionId: `timeout-${randomUUID().slice(0, 8)}`
+      }
+    };
+  }
+  /**
+   * Helper to create an 'any' condition from task IDs
+   */
+  static createAnyTask(taskIds) {
+    return {
+      type: "any",
+      conditions: taskIds.map((taskId) => ({ type: "task", taskId }))
+    };
+  }
+  /**
+   * Helper to create an 'all' condition from task IDs
+   */
+  static createAllTasks(taskIds) {
+    return {
+      type: "all",
+      conditions: taskIds.map((taskId) => ({ type: "task", taskId }))
+    };
+  }
+}
+export {
+  ConditionEngine
+};

package/dist/index.cjs

@@ -0,0 +1,57 @@
+"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 index_exports = {};
+__export(index_exports, {
+  AgentController: () => import_agent_controller.AgentController,
+  CheckTaskInputSchema: () => import_tools2.CheckTaskInputSchema,
+  ConditionEngine: () => import_condition_engine.ConditionEngine,
+  ListTasksInputSchema: () => import_tools2.ListTasksInputSchema,
+  SignalBus: () => import_signal_bus.SignalBus,
+  StartTaskInputSchema: () => import_tools2.StartTaskInputSchema,
+  TaskRegistry: () => import_task_registry.TaskRegistry,
+  WaitForInputSchema: () => import_tools2.WaitForInputSchema,
+  createCheckTaskTool: () => import_tools.createCheckTaskTool,
+  createGenericTaskStarter: () => import_tools.createGenericTaskStarter,
+  createListTasksTool: () => import_tools.createListTasksTool,
+  createStartTaskTool: () => import_tools.createStartTaskTool,
+  createWaitForTool: () => import_tools.createWaitForTool
+});
+module.exports = __toCommonJS(index_exports);
+var import_agent_controller = require("./agent-controller.js");
+var import_signal_bus = require("./signal-bus.js");
+var import_task_registry = require("./task-registry.js");
+var import_condition_engine = require("./condition-engine.js");
+var import_tools = require("./tools/index.js");
+var import_tools2 = require("./tools/index.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentController,
+  CheckTaskInputSchema,
+  ConditionEngine,
+  ListTasksInputSchema,
+  SignalBus,
+  StartTaskInputSchema,
+  TaskRegistry,
+  WaitForInputSchema,
+  createCheckTaskTool,
+  createGenericTaskStarter,
+  createListTasksTool,
+  createStartTaskTool,
+  createWaitForTool
+});

package/dist/index.d.cts

@@ -0,0 +1,11 @@
+export { AgentController, AgentControllerConfig } from './agent-controller.cjs';
+export { SignalBus, SignalHandler, SignalPredicate } from './signal-bus.cjs';
+export { TaskRegistry, TaskRegistryConfig } from './task-registry.cjs';
+export { ConditionEngine } from './condition-engine.cjs';
+export { AgentState, ProcessResult, RegisterTaskOptions, Signal, SignalType, Task, TaskEntry, TaskFilter, TaskInfo, TaskResult, TaskStatus, WaitCondition, WaitResult } from './types.cjs';
+export { StartTaskInput, StartTaskInputSchema, StartTaskOutput, TaskStarter, createGenericTaskStarter, createStartTaskTool } from './tools/start-task.cjs';
+export { WaitForInput, WaitForInputSchema, WaitForOutput, createWaitForTool } from './tools/wait-for.cjs';
+export { CheckTaskInput, CheckTaskInputSchema, CheckTaskOutput, createCheckTaskTool } from './tools/check-task.cjs';
+export { ListTasksInput, ListTasksInputSchema, ListTasksOutput, TaskListItem, createListTasksTool } from './tools/list-tasks.cjs';
+export { OrchestrationTool, OrchestrationToolContext } from './tools/types.cjs';
+import 'zod';

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { AgentController, AgentControllerConfig } from './agent-controller.js';
+export { SignalBus, SignalHandler, SignalPredicate } from './signal-bus.js';
+export { TaskRegistry, TaskRegistryConfig } from './task-registry.js';
+export { ConditionEngine } from './condition-engine.js';
+export { AgentState, ProcessResult, RegisterTaskOptions, Signal, SignalType, Task, TaskEntry, TaskFilter, TaskInfo, TaskResult, TaskStatus, WaitCondition, WaitResult } from './types.js';
+export { StartTaskInput, StartTaskInputSchema, StartTaskOutput, TaskStarter, createGenericTaskStarter, createStartTaskTool } from './tools/start-task.js';
+export { WaitForInput, WaitForInputSchema, WaitForOutput, createWaitForTool } from './tools/wait-for.js';
+export { CheckTaskInput, CheckTaskInputSchema, CheckTaskOutput, createCheckTaskTool } from './tools/check-task.js';
+export { ListTasksInput, ListTasksInputSchema, ListTasksOutput, TaskListItem, createListTasksTool } from './tools/list-tasks.js';
+export { OrchestrationTool, OrchestrationToolContext } from './tools/types.js';
+import 'zod';

package/dist/index.js

@@ -0,0 +1,32 @@
+import { AgentController } from "./agent-controller.js";
+import { SignalBus } from "./signal-bus.js";
+import { TaskRegistry } from "./task-registry.js";
+import { ConditionEngine } from "./condition-engine.js";
+import {
+  createStartTaskTool,
+  createWaitForTool,
+  createCheckTaskTool,
+  createListTasksTool,
+  createGenericTaskStarter
+} from "./tools/index.js";
+import {
+  StartTaskInputSchema,
+  WaitForInputSchema,
+  CheckTaskInputSchema,
+  ListTasksInputSchema
+} from "./tools/index.js";
+export {
+  AgentController,
+  CheckTaskInputSchema,
+  ConditionEngine,
+  ListTasksInputSchema,
+  SignalBus,
+  StartTaskInputSchema,
+  TaskRegistry,
+  WaitForInputSchema,
+  createCheckTaskTool,
+  createGenericTaskStarter,
+  createListTasksTool,
+  createStartTaskTool,
+  createWaitForTool
+};

package/dist/signal-bus.cjs

@@ -0,0 +1,186 @@
+"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 signal_bus_exports = {};
+__export(signal_bus_exports, {
+  SignalBus: () => SignalBus
+});
+module.exports = __toCommonJS(signal_bus_exports);
+var import_events = require("events");
+class SignalBus {
+  emitter = new import_events.EventEmitter();
+  constructor() {
+    this.emitter.setMaxListeners(100);
+  }
+  /**
+   * Emit a signal to all subscribers
+   */
+  emit(signal) {
+    this.emitter.emit(signal.type, signal);
+    this.emitter.emit("*", signal);
+  }
+  /**
+   * Subscribe to signals of a specific type
+   * @returns Unsubscribe function
+   */
+  on(type, handler) {
+    this.emitter.on(type, handler);
+    return () => this.emitter.off(type, handler);
+  }
+  /**
+   * Subscribe to all signals
+   * @returns Unsubscribe function
+   */
+  onAny(handler) {
+    this.emitter.on("*", handler);
+    return () => this.emitter.off("*", handler);
+  }
+  /**
+   * Subscribe to a signal type once
+   */
+  once(type, handler) {
+    this.emitter.once(type, handler);
+  }
+  /**
+   * Remove a specific handler
+   */
+  off(type, handler) {
+    this.emitter.off(type, handler);
+  }
+  /**
+   * Wait for a signal matching the predicate
+   * @param predicate Function to test signals
+   * @param timeout Optional timeout in milliseconds
+   * @returns Promise that resolves with the matching signal
+   */
+  waitFor(predicate, timeout) {
+    return new Promise((resolve, reject) => {
+      let timeoutId;
+      let unsubscribe;
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        if (unsubscribe) {
+          unsubscribe();
+        }
+      };
+      const handler = (signal) => {
+        if (predicate(signal)) {
+          cleanup();
+          resolve(signal);
+        }
+      };
+      unsubscribe = this.onAny(handler);
+      if (timeout !== void 0 && timeout > 0) {
+        timeoutId = setTimeout(() => {
+          cleanup();
+          reject(new Error(`Signal wait timed out after ${timeout}ms`));
+        }, timeout);
+      }
+    });
+  }
+  /**
+   * Wait for a signal for a specific task
+   */
+  waitForTask(taskId, timeout) {
+    return this.waitFor(
+      (signal) => (signal.type === "task:completed" || signal.type === "task:failed" || signal.type === "task:cancelled") && signal.taskId === taskId,
+      timeout
+    );
+  }
+  /**
+   * Wait for any of multiple tasks to complete
+   */
+  waitForAnyTask(taskIds, timeout) {
+    if (taskIds.length === 0) {
+      return Promise.reject(new Error("taskIds must not be empty"));
+    }
+    const taskIdSet = new Set(taskIds);
+    return this.waitFor(
+      (signal) => (signal.type === "task:completed" || signal.type === "task:failed" || signal.type === "task:cancelled") && taskIdSet.has(signal.taskId),
+      timeout
+    );
+  }
+  /**
+   * Wait for all tasks to complete
+   * @returns Promise that resolves with all signals
+   */
+  async waitForAllTasks(taskIds, timeout, resolveInitial) {
+    if (taskIds.length === 0) {
+      return [];
+    }
+    const remaining = new Set(taskIds);
+    const signals = [];
+    if (resolveInitial) {
+      for (const taskId of taskIds) {
+        const signal = resolveInitial(taskId);
+        if (signal) {
+          remaining.delete(taskId);
+          signals.push(signal);
+        }
+      }
+    }
+    if (remaining.size === 0) {
+      return signals;
+    }
+    return new Promise((resolve, reject) => {
+      let timeoutId;
+      let unsubscribe;
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        if (unsubscribe) {
+          unsubscribe();
+        }
+      };
+      const handler = (signal) => {
+        if ((signal.type === "task:completed" || signal.type === "task:failed" || signal.type === "task:cancelled") && remaining.has(signal.taskId)) {
+          remaining.delete(signal.taskId);
+          signals.push(signal);
+          if (remaining.size === 0) {
+            cleanup();
+            resolve(signals);
+          }
+        }
+      };
+      unsubscribe = this.onAny(handler);
+      if (timeout !== void 0 && timeout > 0) {
+        timeoutId = setTimeout(() => {
+          cleanup();
+          reject(
+            new Error(
+              `Waiting for all tasks timed out after ${timeout}ms. Remaining tasks: ${Array.from(remaining).join(", ")}`
+            )
+          );
+        }, timeout);
+      }
+    });
+  }
+  /**
+   * Remove all listeners
+   */
+  clear() {
+    this.emitter.removeAllListeners();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SignalBus
+});

package/dist/signal-bus.d.cts

@@ -0,0 +1,78 @@
+import { Signal, SignalType } from './types.cjs';
+
+/**
+ * SignalBus
+ *
+ * Event emitter for routing orchestration signals.
+ * Supports typed subscriptions and promise-based waiting.
+ */
+
+/**
+ * Handler function for signal subscriptions
+ */
+type SignalHandler<T extends Signal = Signal> = (signal: T) => void;
+/**
+ * Predicate function for filtering signals
+ */
+type SignalPredicate = (signal: Signal) => boolean;
+/**
+ * SignalBus - Routes signals between orchestration components
+ */
+declare class SignalBus {
+    private emitter;
+    constructor();
+    /**
+     * Emit a signal to all subscribers
+     */
+    emit(signal: Signal): void;
+    /**
+     * Subscribe to signals of a specific type
+     * @returns Unsubscribe function
+     */
+    on<T extends SignalType>(type: T, handler: SignalHandler<Extract<Signal, {
+        type: T;
+    }>>): () => void;
+    /**
+     * Subscribe to all signals
+     * @returns Unsubscribe function
+     */
+    onAny(handler: SignalHandler): () => void;
+    /**
+     * Subscribe to a signal type once
+     */
+    once<T extends SignalType>(type: T, handler: SignalHandler<Extract<Signal, {
+        type: T;
+    }>>): void;
+    /**
+     * Remove a specific handler
+     */
+    off<T extends SignalType>(type: T, handler: SignalHandler<Extract<Signal, {
+        type: T;
+    }>>): void;
+    /**
+     * Wait for a signal matching the predicate
+     * @param predicate Function to test signals
+     * @param timeout Optional timeout in milliseconds
+     * @returns Promise that resolves with the matching signal
+     */
+    waitFor(predicate: SignalPredicate, timeout?: number): Promise<Signal>;
+    /**
+     * Wait for a signal for a specific task
+     */
+    waitForTask(taskId: string, timeout?: number): Promise<Signal>;
+    /**
+     * Wait for any of multiple tasks to complete
+     */
+    waitForAnyTask(taskIds: string[], timeout?: number): Promise<Signal>;
+    /**
+     * Wait for all tasks to complete
+     * @returns Promise that resolves with all signals
+     */
+    waitForAllTasks(taskIds: string[], timeout?: number, resolveInitial?: (taskId: string) => Signal | undefined): Promise<Signal[]>;
+    /**
+     * Remove all listeners
+     */
+    clear(): void;
+}
+
+export { SignalBus, type SignalHandler, type SignalPredicate };