@dexto/orchestration 1.5.8 → 1.6.1

package/dist/condition-engine.d.ts

@@ -1,21 +1,19 @@
-import { WaitCondition, WaitResult } from './types.js';
-import { SignalBus } from './signal-bus.js';
-import { TaskRegistry } from './task-registry.js';
-
 /**
  * ConditionEngine
  *
  * Evaluates wait conditions and resolves when met.
  * Supports single task, any/all of multiple tasks, timeouts, and races.
  */
-
+import type { WaitCondition, WaitResult } from './types.js';
+import type { SignalBus } from './signal-bus.js';
+import type { TaskRegistry } from './task-registry.js';
 type LoggerLike = {
     debug: (message: string) => void;
 };
 /**
  * ConditionEngine - Evaluates composable wait conditions
  */
-declare class ConditionEngine {
+export declare class ConditionEngine {
     private taskRegistry;
     private signalBus;
     private logger?;
@@ -83,5 +81,5 @@ declare class ConditionEngine {
      */
     static createAllTasks(taskIds: string[]): WaitCondition;
 }
-
-export { ConditionEngine };
+export {};
+//# sourceMappingURL=condition-engine.d.ts.map

package/dist/condition-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition-engine.d.ts","sourceRoot":"","sources":["../src/condition-engine.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAU,UAAU,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,KAAK,UAAU,GAAG;IACd,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC,CAAC;AAEF;;GAEG;AACH,qBAAa,eAAe;IAEpB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,MAAM,CAAC;gBAFP,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,SAAS,EACpB,MAAM,CAAC,EAAE,UAAU,YAAA;IAG/B;;;;OAIG;IACG,IAAI,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC;IAWzD;;;OAGG;IACH,KAAK,CAAC,SAAS,EAAE,aAAa,GAAG,UAAU,GAAG,IAAI;IAqBlD;;OAEG;IACH,OAAO,CAAC,SAAS;IAuCjB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAUhB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAsBhB;;OAEG;YACW,QAAQ;IAmBtB;;;;;OAKG;YACW,YAAY;IA0C1B;;OAEG;YACW,WAAW;IAgBzB;;OAEG;YACW,WAAW;IAsBzB;;OAEG;YACW,eAAe;IAc7B;;OAEG;YACW,YAAY;IAmB1B;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,aAAa;IAY9E;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,aAAa;IAOtD;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,aAAa;CAM1D"}

package/dist/index.cjs

@@ -18,22 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 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");
@@ -41,17 +36,13 @@ 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

@@ -1,11 +1,615 @@
-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';
+import { z } from 'zod';
+import { Tool } from '@dexto/core';
+
+/**
+ * Orchestration Types
+ *
+ * Core type definitions for the agent orchestration layer.
+ * Defines tasks, signals, wait conditions, and agent states.
+ */
+/**
+ * Task result from agent or process execution
+ */
+interface TaskResult {
+    success: boolean;
+    response?: string;
+    error?: string;
+    agentId?: string;
+    tokenUsage?: {
+        input: number;
+        output: number;
+        total: number;
+    };
+}
+/**
+ * Process result from shell command execution
+ */
+interface ProcessResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    duration?: number;
+}
+/**
+ * Task types - discriminated union of different background task kinds
+ */
+type Task = {
+    type: 'agent';
+    taskId: string;
+    agentId: string;
+    taskDescription: string;
+    promise: Promise<TaskResult>;
+} | {
+    type: 'process';
+    taskId: string;
+    processId: string;
+    command: string;
+    promise: Promise<ProcessResult>;
+} | {
+    type: 'generic';
+    taskId: string;
+    description: string;
+    promise: Promise<unknown>;
+};
+/**
+ * Task lifecycle status
+ */
+type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Entry in the task registry tracking a background task
+ */
+interface TaskEntry {
+    task: Task;
+    status: TaskStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    result?: unknown;
+    error?: string;
+    /** If true, auto-trigger agent turn on completion */
+    notify?: boolean;
+    /** Timeout handle for this task (if set) */
+    timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+}
+/**
+ * Signal types - events that trigger state transitions
+ */
+type Signal = {
+    type: 'task:completed';
+    taskId: string;
+    result: unknown;
+} | {
+    type: 'task:failed';
+    taskId: string;
+    error: string;
+} | {
+    type: 'task:cancelled';
+    taskId: string;
+} | {
+    type: 'timeout';
+    conditionId: string;
+} | {
+    type: 'user:input';
+    content: string;
+    sessionId: string;
+} | {
+    type: 'external';
+    source: string;
+    data: unknown;
+};
+/**
+ * Extract signal type string
+ */
+type SignalType = Signal['type'];
+/**
+ * Wait conditions - composable conditions for suspension
+ */
+type WaitCondition = {
+    type: 'task';
+    taskId: string;
+} | {
+    type: 'any';
+    conditions: WaitCondition[];
+} | {
+    type: 'all';
+    conditions: WaitCondition[];
+} | {
+    type: 'timeout';
+    ms: number;
+    conditionId: string;
+} | {
+    type: 'race';
+    task: WaitCondition;
+    timeout: WaitCondition;
+};
+/**
+ * Agent loop states
+ */
+type AgentState = 'idle' | 'processing' | 'waiting';
+/**
+ * Task info returned by list/check operations (without internal promise)
+ */
+interface TaskInfo {
+    taskId: string;
+    type: Task['type'];
+    status: TaskStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    duration?: number;
+    description?: string;
+    result?: unknown;
+    error?: string;
+    cancelReason?: string;
+}
+/**
+ * Filter options for listing tasks
+ */
+interface TaskFilter {
+    status?: TaskStatus | TaskStatus[];
+    type?: Task['type'];
+}
+/**
+ * Result from waiting on a condition
+ */
+interface WaitResult {
+    signal: Signal;
+    /** For 'all' conditions, contains all signals */
+    allSignals?: Signal[];
+}
+/**
+ * Options for registering a task
+ */
+interface RegisterTaskOptions {
+    /** Auto-trigger agent turn on completion */
+    notify?: boolean;
+    /** Timeout in milliseconds */
+    timeout?: number;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * wait_for Tool
+ *
+ * Suspends agent execution until condition is met using a blocking promise.
+ * TurnExecutor naturally awaits tool execution, so this works seamlessly.
+ */
+
+/**
+ * Input schema for wait_for tool
+ */
+declare const WaitForInputSchema: z.ZodEffects<z.ZodObject<{
+    /** Wait for a single task */
+    taskId: z.ZodOptional<z.ZodString>;
+    /** Wait for multiple tasks */
+    taskIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Mode for multiple tasks: any = first to complete, all = wait for all */
+    mode: z.ZodDefault<z.ZodOptional<z.ZodEnum<["any", "all"]>>>;
+    /** Timeout in milliseconds */
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    mode: "any" | "all";
+    timeout?: number | undefined;
+    taskId?: string | undefined;
+    taskIds?: string[] | undefined;
+}, {
+    timeout?: number | undefined;
+    taskId?: string | undefined;
+    taskIds?: string[] | undefined;
+    mode?: "any" | "all" | undefined;
+}>, {
+    mode: "any" | "all";
+    timeout?: number | undefined;
+    taskId?: string | undefined;
+    taskIds?: string[] | undefined;
+}, {
+    timeout?: number | undefined;
+    taskId?: string | undefined;
+    taskIds?: string[] | undefined;
+    mode?: "any" | "all" | undefined;
+}>;
+type WaitForInput = z.output<typeof WaitForInputSchema>;
+/**
+ * Output from wait_for tool
+ */
+interface WaitForOutput {
+    /** Task ID that triggered the return (for 'any' mode) */
+    taskId: string;
+    /** Final status */
+    status: 'completed' | 'failed' | 'cancelled' | 'timeout';
+    /** Result if completed */
+    result?: unknown;
+    /** Error if failed */
+    error?: string;
+    /** All results for 'all' mode */
+    allResults?: Array<{
+        taskId: string;
+        status: 'completed' | 'failed' | 'cancelled';
+        result?: unknown;
+        error?: string;
+    }>;
+}
+/**
+ * Create the wait_for tool
+ */
+declare function createWaitForTool(conditionEngine: ConditionEngine): Tool<typeof WaitForInputSchema>;
+
+/**
+ * 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(taskRegistry: TaskRegistry): Tool<typeof CheckTaskInputSchema>;
+
+/**
+ * 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(taskRegistry: TaskRegistry): Tool<typeof ListTasksInputSchema>;
+
+export { type AgentState, type CheckTaskInput, CheckTaskInputSchema, type CheckTaskOutput, ConditionEngine, type ListTasksInput, ListTasksInputSchema, type ListTasksOutput, type ProcessResult, type RegisterTaskOptions, type Signal, SignalBus, type SignalHandler, type SignalPredicate, type SignalType, type Task, type TaskEntry, type TaskFilter, type TaskInfo, type TaskListItem, TaskRegistry, type TaskRegistryConfig, type TaskResult, type TaskStatus, type WaitCondition, type WaitForInput, WaitForInputSchema, type WaitForOutput, type WaitResult, createCheckTaskTool, createListTasksTool, createWaitForTool };