@dexto/orchestration 1.5.8 → 1.6.0

package/dist/agent-controller.d.ts

@@ -1,116 +0,0 @@
-import { Signal, AgentState } from './types.js';
-import { SignalBus } from './signal-bus.js';
-import { TaskRegistryConfig, TaskRegistry } from './task-registry.js';
-import { ConditionEngine } from './condition-engine.js';
-
-/**
- * AgentController
- *
- * Wraps DextoAgent and manages orchestration state.
- * Handles background task execution, state transitions, and context injection.
- */
-
-type AgentLike = {
-    generate: (content: string, sessionId?: string) => Promise<{
-        content: string;
-    }>;
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
-};
-type LoggerLike = {
-    debug: (message: string) => void;
-    error?: (message: string) => void;
-};
-/**
- * Configuration for AgentController
- */
-interface AgentControllerConfig {
-    /** The agent to wrap */
-    agent: AgentLike;
-    /** Optional logger instance */
-    logger?: LoggerLike;
-    /** Task registry configuration */
-    taskRegistry?: TaskRegistryConfig;
-    /** Session ID to use (defaults to a generated one) */
-    sessionId?: string;
-}
-/**
- * AgentController - Orchestration wrapper for DextoAgent
- */
-declare class AgentController {
-    private agent;
-    private logger?;
-    private state;
-    private sessionId;
-    /** Signal bus for event routing */
-    readonly signalBus: SignalBus;
-    /** Task registry for tracking background tasks */
-    readonly taskRegistry: TaskRegistry;
-    /** Condition engine for evaluating wait conditions */
-    readonly conditionEngine: ConditionEngine;
-    /** Signals that arrived while agent was busy */
-    private pendingSignals;
-    /** Unsubscribe function for notify listener */
-    private notifyUnsubscribe?;
-    constructor(config: AgentControllerConfig);
-    /**
-     * Set up listener for tasks with notify=true
-     */
-    private setupNotifyListener;
-    /**
-     * Process an auto-notify task completion
-     */
-    private processNotify;
-    /**
-     * Build context message for auto-notify
-     */
-    private buildNotifyContext;
-    /**
-     * Process any pending signals
-     */
-    private processPendingSignals;
-    /**
-     * Process user input and generate response
-     * @param content User message content
-     * @returns Agent response
-     */
-    process(content: string): Promise<string>;
-    /**
-     * Process a signal trigger (e.g., from external source)
-     */
-    processSignal(signal: Signal): Promise<void>;
-    /**
-     * Build context about pending/completed tasks
-     */
-    private buildTaskContext;
-    /**
-     * Get current agent state
-     */
-    getState(): AgentState;
-    /**
-     * Get the wrapped agent
-     */
-    getAgent(): AgentLike;
-    /**
-     * Get session ID
-     */
-    getSessionId(): string;
-    /**
-     * Inject a signal for processing
-     */
-    injectSignal(signal: Signal): void;
-    /**
-     * Clean up resources
-     */
-    cleanup(): void;
-    /**
-     * Start the agent (delegates to wrapped agent)
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the agent (delegates to wrapped agent)
-     */
-    stop(): Promise<void>;
-}
-
-export { AgentController, type AgentControllerConfig };

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/tools/start-task.cjs

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

@@ -1,102 +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';
-
-/**
- * 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 };