@dexto/orchestration 1.5.8 → 1.6.1

package/dist/agent-controller.js

@@ -1,241 +0,0 @@
-import { SignalBus } from "./signal-bus.js";
-import { TaskRegistry } from "./task-registry.js";
-import { ConditionEngine } from "./condition-engine.js";
-class AgentController {
-  agent;
-  logger;
-  state = "idle";
-  sessionId;
-  /** Signal bus for event routing */
-  signalBus;
-  /** Task registry for tracking background tasks */
-  taskRegistry;
-  /** Condition engine for evaluating wait conditions */
-  conditionEngine;
-  /** Signals that arrived while agent was busy */
-  pendingSignals = [];
-  /** Unsubscribe function for notify listener */
-  notifyUnsubscribe;
-  constructor(config) {
-    this.agent = config.agent;
-    if (config.logger) {
-      this.logger = config.logger;
-    }
-    this.sessionId = config.sessionId ?? `session-${Date.now()}`;
-    this.signalBus = new SignalBus();
-    this.taskRegistry = new TaskRegistry(this.signalBus, config.taskRegistry);
-    this.conditionEngine = new ConditionEngine(this.taskRegistry, this.signalBus, this.logger);
-    this.setupNotifyListener();
-  }
-  /**
-   * Set up listener for tasks with notify=true
-   */
-  setupNotifyListener() {
-    this.notifyUnsubscribe = this.signalBus.onAny((signal) => {
-      if (signal.type === "task:completed" || signal.type === "task:failed" || signal.type === "task:cancelled") {
-        const entry = this.taskRegistry.get(signal.taskId);
-        if (entry?.notify) {
-          if (this.state === "idle") {
-            this.logger?.debug(`Auto-notify triggered for task ${signal.taskId}`);
-            void this.processNotify(signal).catch((error) => {
-              const message = error instanceof Error ? error.message : String(error);
-              const signalContext = `signal.type=${signal.type} taskId=${signal.taskId}`;
-              this.logger?.error?.(
-                `AgentController.processNotify failed for ${signalContext}: ${message}`
-              );
-            });
-          } else {
-            this.pendingSignals.push(signal);
-          }
-        }
-      }
-    });
-  }
-  /**
-   * Process an auto-notify task completion
-   */
-  async processNotify(signal) {
-    if (this.state !== "idle") {
-      this.pendingSignals.push(signal);
-      return;
-    }
-    try {
-      this.state = "processing";
-      const taskInfo = signal.type === "task:completed" || signal.type === "task:failed" || signal.type === "task:cancelled" ? this.taskRegistry.getInfo(signal.taskId) : void 0;
-      const contextMessage = this.buildNotifyContext(signal, taskInfo);
-      await this.agent.generate(contextMessage, this.sessionId);
-      if (taskInfo) {
-        this.taskRegistry.acknowledgeNotify([taskInfo.taskId]);
-      }
-    } finally {
-      this.state = "idle";
-      this.processPendingSignals();
-    }
-  }
-  /**
-   * Build context message for auto-notify
-   */
-  buildNotifyContext(signal, taskInfo) {
-    if (signal.type === "task:completed" && taskInfo) {
-      const resultStr = typeof taskInfo.result === "string" ? taskInfo.result : JSON.stringify(taskInfo.result, null, 2);
-      const durationLine = taskInfo.duration !== void 0 ? `Duration: ${taskInfo.duration}ms
-` : "";
-      return `[Background Task Completed]
-Task ID: ${taskInfo.taskId}
-Type: ${taskInfo.type}
-Description: ${taskInfo.description}
-` + durationLine + `Result:
-${resultStr}`;
-    }
-    if (signal.type === "task:failed" && taskInfo) {
-      return `[Background Task Failed]
-Task ID: ${taskInfo.taskId}
-Type: ${taskInfo.type}
-Description: ${taskInfo.description}
-Error: ${taskInfo.error}`;
-    }
-    if (signal.type === "task:cancelled" && taskInfo) {
-      const cancelReason = taskInfo.error ?? "Cancelled";
-      return `[Background Task Cancelled]
-Task ID: ${taskInfo.taskId}
-Type: ${taskInfo.type}
-Description: ${taskInfo.description}
-Reason: ${cancelReason}`;
-    }
-    return `[Background Signal]
-${JSON.stringify(signal, null, 2)}`;
-  }
-  /**
-   * Process any pending signals
-   */
-  processPendingSignals() {
-    while (this.pendingSignals.length > 0 && this.state === "idle") {
-      const signal = this.pendingSignals.shift();
-      if (signal) {
-        void this.processNotify(signal).catch((error) => {
-          const message = error instanceof Error ? error.message : String(error);
-          const signalContext = signal.type === "task:completed" || signal.type === "task:failed" || signal.type === "task:cancelled" ? `signal.type=${signal.type} taskId=${signal.taskId}` : `signal.type=${signal.type}`;
-          this.logger?.error?.(
-            `AgentController.processNotify failed for ${signalContext}: ${message}`
-          );
-        });
-      }
-    }
-  }
-  /**
-   * Process user input and generate response
-   * @param content User message content
-   * @returns Agent response
-   */
-  async process(content) {
-    if (this.state !== "idle") {
-      throw new Error(`Cannot process while agent is ${this.state}`);
-    }
-    try {
-      this.state = "processing";
-      const { contextPrefix, notifyTaskIds } = this.buildTaskContext();
-      const fullContent = contextPrefix ? `${contextPrefix}
-
-${content}` : content;
-      const response = await this.agent.generate(fullContent, this.sessionId);
-      if (notifyTaskIds.length > 0) {
-        this.taskRegistry.acknowledgeNotify(notifyTaskIds);
-      }
-      return response.content;
-    } finally {
-      this.state = "idle";
-      this.processPendingSignals();
-    }
-  }
-  /**
-   * Process a signal trigger (e.g., from external source)
-   */
-  async processSignal(signal) {
-    if (this.state !== "idle") {
-      this.pendingSignals.push(signal);
-      return;
-    }
-    await this.processNotify(signal);
-  }
-  /**
-   * Build context about pending/completed tasks
-   */
-  buildTaskContext() {
-    const running = this.taskRegistry.list({ status: "running" });
-    const notifyPending = this.taskRegistry.getNotifyPending();
-    if (running.length === 0 && notifyPending.length === 0) {
-      return { contextPrefix: "", notifyTaskIds: [] };
-    }
-    const parts = [];
-    if (running.length > 0) {
-      parts.push(
-        `[Background Tasks Running: ${running.length}]
-` + running.map((t) => `- ${t.taskId}: ${t.description}`).join("\n")
-      );
-    }
-    if (notifyPending.length > 0) {
-      parts.push(
-        `[Background Tasks Completed: ${notifyPending.length}]
-` + notifyPending.map((t) => {
-          const status = t.error ? `FAILED: ${t.error}` : t.status === "cancelled" ? "CANCELLED" : "SUCCESS";
-          return `- ${t.taskId}: ${t.description} [${status}]`;
-        }).join("\n")
-      );
-    }
-    return {
-      contextPrefix: parts.join("\n\n"),
-      notifyTaskIds: notifyPending.map((task) => task.taskId)
-    };
-  }
-  /**
-   * Get current agent state
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * Get the wrapped agent
-   */
-  getAgent() {
-    return this.agent;
-  }
-  /**
-   * Get session ID
-   */
-  getSessionId() {
-    return this.sessionId;
-  }
-  /**
-   * Inject a signal for processing
-   */
-  injectSignal(signal) {
-    this.signalBus.emit(signal);
-  }
-  /**
-   * Clean up resources
-   */
-  cleanup() {
-    if (this.notifyUnsubscribe) {
-      this.notifyUnsubscribe();
-    }
-    this.pendingSignals = [];
-    this.signalBus.clear();
-    this.taskRegistry.clear();
-  }
-  /**
-   * Start the agent (delegates to wrapped agent)
-   */
-  async start() {
-    await this.agent.start();
-  }
-  /**
-   * Stop the agent (delegates to wrapped agent)
-   */
-  async stop() {
-    this.cleanup();
-    await this.agent.stop();
-  }
-}
-export {
-  AgentController
-};

package/dist/condition-engine.d.cts

@@ -1,87 +0,0 @@
-import { WaitCondition, WaitResult } from './types.cjs';
-import { SignalBus } from './signal-bus.cjs';
-import { TaskRegistry } from './task-registry.cjs';
-
-/**
- * ConditionEngine
- *
- * Evaluates wait conditions and resolves when met.
- * Supports single task, any/all of multiple tasks, timeouts, and races.
- */
-
-type LoggerLike = {
-    debug: (message: string) => void;
-};
-/**
- * ConditionEngine - Evaluates composable wait conditions
- */
-declare class ConditionEngine {
-    private taskRegistry;
-    private signalBus;
-    private logger?;
-    constructor(taskRegistry: TaskRegistry, signalBus: SignalBus, logger?: LoggerLike | undefined);
-    /**
-     * Wait for a condition to be met
-     * @param condition Wait condition to evaluate
-     * @returns Promise resolving to the signal(s) that satisfied the condition
-     */
-    wait(condition: WaitCondition): Promise<WaitResult>;
-    /**
-     * Check if a condition is already satisfied (non-blocking)
-     * @returns WaitResult if satisfied, null if not
-     */
-    check(condition: WaitCondition): WaitResult | null;
-    /**
-     * Check if a single task is completed
-     */
-    private checkTask;
-    /**
-     * Check if any of the conditions is satisfied
-     */
-    private checkAny;
-    /**
-     * Check if all conditions are satisfied
-     */
-    private checkAll;
-    /**
-     * Evaluate a condition asynchronously
-     */
-    private evaluate;
-    /**
-     * Wait for a single task to complete
-     *
-     * Uses subscribe-then-check pattern to avoid race conditions where
-     * the task completes between checking and subscribing.
-     */
-    private evaluateTask;
-    /**
-     * Wait for any of the conditions to be satisfied
-     */
-    private evaluateAny;
-    /**
-     * Wait for all conditions to be satisfied
-     */
-    private evaluateAll;
-    /**
-     * Wait for a timeout
-     */
-    private evaluateTimeout;
-    /**
-     * Race a task condition against a timeout
-     */
-    private evaluateRace;
-    /**
-     * Helper to create a race condition with timeout
-     */
-    static createRaceWithTimeout(taskId: string, timeoutMs: number): WaitCondition;
-    /**
-     * Helper to create an 'any' condition from task IDs
-     */
-    static createAnyTask(taskIds: string[]): WaitCondition;
-    /**
-     * Helper to create an 'all' condition from task IDs
-     */
-    static createAllTasks(taskIds: string[]): WaitCondition;
-}
-
-export { ConditionEngine };

package/dist/signal-bus.d.cts

@@ -1,78 +0,0 @@
-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 };

package/dist/task-registry.d.cts

@@ -1,124 +0,0 @@
-import { Task, RegisterTaskOptions, TaskEntry, TaskStatus, TaskInfo, TaskFilter } from './types.cjs';
-import { SignalBus } from './signal-bus.cjs';
-
-/**
- * TaskRegistry
- *
- * Tracks all background tasks and their results.
- * Emits signals on task completion for the ConditionEngine.
- */
-
-/**
- * Configuration for TaskRegistry
- */
-interface TaskRegistryConfig {
-    /** Maximum number of concurrent tasks (default: 20) */
-    maxTasks?: number;
-    /** TTL for completed task results in ms (default: 5 minutes) */
-    resultTTL?: number;
-}
-/**
- * TaskRegistry - Manages background task lifecycle
- */
-declare class TaskRegistry {
-    private tasks;
-    private signalBus;
-    private config;
-    constructor(signalBus: SignalBus, config?: TaskRegistryConfig);
-    /**
-     * Generate a unique task ID
-     */
-    private generateTaskId;
-    /**
-     * Get description from task for display
-     */
-    private getTaskDescription;
-    /**
-     * Register a new task and start tracking it
-     * @param task Task to register (must include promise)
-     * @param options Registration options
-     * @returns Task ID
-     */
-    register(task: Task, options?: RegisterTaskOptions): string;
-    /**
-     * Create and register an agent task
-     *
-     * Note: Uses agentId as the taskId so the caller can use the same ID
-     * for wait_for/check_task operations.
-     */
-    registerAgentTask(agentId: string, taskDescription: string, promise: Promise<unknown>, options?: RegisterTaskOptions): string;
-    /**
-     * Create and register a process task
-     */
-    registerProcessTask(processId: string, command: string, promise: Promise<unknown>, options?: RegisterTaskOptions): string;
-    /**
-     * Create and register a generic task
-     */
-    registerGenericTask(description: string, promise: Promise<unknown>, options?: RegisterTaskOptions): string;
-    /**
-     * Called when a task completes successfully
-     */
-    private onTaskComplete;
-    /**
-     * Called when a task fails
-     */
-    private onTaskFailed;
-    /**
-     * Cancel a running task
-     */
-    cancel(taskId: string): void;
-    /**
-     * Get task entry by ID
-     */
-    get(taskId: string): TaskEntry | undefined;
-    /**
-     * Get task status
-     */
-    getStatus(taskId: string): TaskStatus | undefined;
-    /**
-     * Get task result (if completed)
-     */
-    getResult(taskId: string): {
-        status: TaskStatus;
-        result?: unknown;
-        error?: string;
-    } | undefined;
-    /**
-     * Get task info (safe for serialization - no promise)
-     */
-    getInfo(taskId: string): TaskInfo | undefined;
-    /**
-     * List tasks matching filter
-     */
-    list(filter?: TaskFilter): TaskInfo[];
-    /**
-     * Get count of running tasks
-     */
-    getRunningCount(): number;
-    /**
-     * Get tasks that completed with notify=true and haven't been acknowledged
-     */
-    getNotifyPending(): TaskInfo[];
-    /**
-     * Mark notify tasks as acknowledged (clear notify flag)
-     */
-    acknowledgeNotify(taskIds: string[]): void;
-    /**
-     * Clean up old completed tasks
-     */
-    cleanup(olderThan?: Date): number;
-    /**
-     * Clear all tasks
-     */
-    clear(): void;
-    /**
-     * Check if a task exists
-     */
-    has(taskId: string): boolean;
-    /**
-     * Get total task count
-     */
-    get size(): number;
-}
-
-export { TaskRegistry, type TaskRegistryConfig };

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

@@ -1,56 +0,0 @@
-import { z } from 'zod';
-import { OrchestrationTool } from './types.cjs';
-import '../task-registry.cjs';
-import '../types.cjs';
-import '../signal-bus.cjs';
-import '../condition-engine.cjs';
-
-/**
- * check_task Tool
- *
- * Non-blocking status check for a background task.
- */
-
-/**
- * Input schema for check_task tool
- */
-declare const CheckTaskInputSchema: z.ZodObject<{
-    /** Task ID to check */
-    taskId: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    taskId: string;
-}, {
-    taskId: string;
-}>;
-type CheckTaskInput = z.output<typeof CheckTaskInputSchema>;
-/**
- * Output from check_task tool
- */
-interface CheckTaskOutput {
-    /** Task ID */
-    taskId: string;
-    /** Whether task was found */
-    found: boolean;
-    /** Task type */
-    type?: 'agent' | 'process' | 'generic';
-    /** Current status */
-    status?: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
-    /** Description of what the task is doing */
-    description?: string;
-    /** When the task started */
-    startedAt?: string;
-    /** When the task completed (if done) */
-    completedAt?: string;
-    /** Duration in milliseconds (if completed) */
-    duration?: number;
-    /** Result (if completed successfully) */
-    result?: unknown;
-    /** Error message (if failed) */
-    error?: string;
-}
-/**
- * Create the check_task tool
- */
-declare function createCheckTaskTool(): OrchestrationTool;
-
-export { type CheckTaskInput, CheckTaskInputSchema, type CheckTaskOutput, createCheckTaskTool };

package/dist/tools/index.d.cts

@@ -1,10 +0,0 @@
-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/list-tasks.d.cts

@@ -1,64 +0,0 @@
-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 };