@dexto/orchestration 1.6.0 → 1.6.2

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

@@ -1 +1 @@
-{"version":3,"file":"list-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/list-tasks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;GAEG;AACH,eAAO,MAAM,oBAAoB;IAEzB,uBAAuB;;IAOvB,qBAAqB;;;;;;;;EAGhB,CAAC;AAEd,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEnE;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;IACtC,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,oCAAoC;IACpC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,kBAAkB;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,MAAM,EAAE;QACJ,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACnB,CAAC;CACL;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC,OAAO,oBAAoB,CAAC,CA2DjG"}
+{"version":3,"file":"list-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/list-tasks.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;GAEG;AACH,eAAO,MAAM,oBAAoB;IAEzB,uBAAuB;;IAOvB,qBAAqB;;;;;;;;EAGhB,CAAC;AAEd,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEnE;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;IACtC,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,oCAAoC;IACpC,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,kBAAkB;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,MAAM,EAAE;QACJ,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACnB,CAAC;CACL;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAyEjG"}

package/dist/tools/list-tasks.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { createLocalToolCallHeader, truncateForHeader } from "@dexto/core";
 const ListTasksInputSchema = z.object({
   /** Filter by status */
   status: z.enum(["pending", "running", "completed", "failed", "cancelled", "all"]).optional().default("all").describe("Filter tasks by status"),
@@ -8,9 +9,20 @@ const ListTasksInputSchema = z.object({
 function createListTasksTool(taskRegistry) {
   return {
     id: "list_tasks",
-    displayName: "List Tasks",
     description: "List all background tasks with optional filtering by status or type. Returns task information and counts.",
     inputSchema: ListTasksInputSchema,
+    presentation: {
+      describeHeader: (input) => {
+        const bits = [];
+        if (input.status && input.status !== "all") bits.push(`status=${input.status}`);
+        if (input.type) bits.push(`type=${input.type}`);
+        const argsText = bits.length > 0 ? truncateForHeader(bits.join(", "), 120) : void 0;
+        return createLocalToolCallHeader({
+          title: "List Tasks",
+          ...argsText ? { argsText } : {}
+        });
+      }
+    },
     execute: async (input, _context) => {
       const filter = {};
       if (input.status && input.status !== "all") {

package/dist/tools/wait-for.cjs

@@ -25,6 +25,7 @@ module.exports = __toCommonJS(wait_for_exports);
 var import_zod = require("zod");
 var import_crypto = require("crypto");
 var import_condition_engine = require("../condition-engine.js");
+var import_core = require("@dexto/core");
 const WaitForInputSchema = import_zod.z.object({
   /** Wait for a single task */
   taskId: import_zod.z.string().optional().describe("Task ID to wait for"),
@@ -99,9 +100,17 @@ function formatOutput(signal, allSignals) {
 function createWaitForTool(conditionEngine) {
   return {
     id: "wait_for",
-    displayName: "Wait",
     description: "Wait for background task(s) to complete. Blocks execution until the condition is met. Use taskId for a single task, or taskIds with mode for multiple tasks.",
     inputSchema: WaitForInputSchema,
+    presentation: {
+      describeHeader: (input) => {
+        const argsText = input.taskId ? (0, import_core.truncateForHeader)(input.taskId, 80) : input.taskIds && input.taskIds.length > 0 ? (0, import_core.truncateForHeader)(`${input.taskIds.length} tasks`, 80) : void 0;
+        return (0, import_core.createLocalToolCallHeader)({
+          title: "Wait",
+          ...argsText ? { argsText } : {}
+        });
+      }
+    },
     execute: async (input, _context) => {
       const condition = buildCondition(input);
       const { signal, allSignals } = await conditionEngine.wait(condition);

package/dist/tools/wait-for.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wait-for.d.ts","sourceRoot":"","sources":["../../src/tools/wait-for.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAEvB,6BAA6B;;IAG7B,8BAA8B;;IAG9B,2EAA2E;;IAO3E,8BAA8B;;;;;;;;;;;;;;;;;;;;;;EAQjC,CAAC;AAEN,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB;IACnB,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,SAAS,CAAC;IACzD,0BAA0B;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sBAAsB;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,UAAU,CAAC,EAAE,KAAK,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;QAC7C,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACN;AAoFD;;GAEG;AACH,wBAAgB,iBAAiB,CAC7B,eAAe,EAAE,eAAe,GACjC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAkBjC"}
+{"version":3,"file":"wait-for.d.ts","sourceRoot":"","sources":["../../src/tools/wait-for.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAEvB,6BAA6B;;IAG7B,8BAA8B;;IAG9B,2EAA2E;;IAO3E,8BAA8B;;;;;;;;;;;;;;;;;;;;;;EAQjC,CAAC;AAEN,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB;IACnB,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,WAAW,GAAG,SAAS,CAAC;IACzD,0BAA0B;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sBAAsB;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,UAAU,CAAC,EAAE,KAAK,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;QAC7C,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACN;AAoFD;;GAEG;AACH,wBAAgB,iBAAiB,CAC7B,eAAe,EAAE,eAAe,GACjC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CA+BjC"}

package/dist/tools/wait-for.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { randomUUID } from "crypto";
 import { ConditionEngine } from "../condition-engine.js";
+import { createLocalToolCallHeader, truncateForHeader } from "@dexto/core";
 const WaitForInputSchema = z.object({
   /** Wait for a single task */
   taskId: z.string().optional().describe("Task ID to wait for"),
@@ -75,9 +76,17 @@ function formatOutput(signal, allSignals) {
 function createWaitForTool(conditionEngine) {
   return {
     id: "wait_for",
-    displayName: "Wait",
     description: "Wait for background task(s) to complete. Blocks execution until the condition is met. Use taskId for a single task, or taskIds with mode for multiple tasks.",
     inputSchema: WaitForInputSchema,
+    presentation: {
+      describeHeader: (input) => {
+        const argsText = input.taskId ? truncateForHeader(input.taskId, 80) : input.taskIds && input.taskIds.length > 0 ? truncateForHeader(`${input.taskIds.length} tasks`, 80) : void 0;
+        return createLocalToolCallHeader({
+          title: "Wait",
+          ...argsText ? { argsText } : {}
+        });
+      }
+    },
     execute: async (input, _context) => {
       const condition = buildCondition(input);
       const { signal, allSignals } = await conditionEngine.wait(condition);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/orchestration",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Agent orchestration layer for background task management, event-driven completion handling, and async workflows",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,7 +21,7 @@
   ],
   "dependencies": {
     "zod": "^3.25.0",
-    "@dexto/core": "1.6.0"
+    "@dexto/core": "1.6.2"
   },
   "devDependencies": {
     "tsup": "^8.0.0",
@@ -32,7 +32,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node ../../scripts/clean-tsbuildinfo.mjs && tsc -b tsconfig.json --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   }

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,55 +0,0 @@
-import { z } from 'zod';
-import { Tool } from '@dexto/core';
-import { TaskRegistry } from '../task-registry.cjs';
-import '../types.cjs';
-import '../signal-bus.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(taskRegistry: TaskRegistry): Tool<typeof CheckTaskInputSchema>;
-
-export { type CheckTaskInput, CheckTaskInputSchema, type CheckTaskOutput, createCheckTaskTool };

package/dist/tools/index.d.cts

@@ -1,9 +0,0 @@
-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';
-import '../signal-bus.cjs';
-import '../task-registry.cjs';
-import '../condition-engine.cjs';
-import '../types.cjs';
-import 'zod';
-import '@dexto/core';

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

@@ -1,63 +0,0 @@
-import { z } from 'zod';
-import { TaskStatus } from '../types.cjs';
-import { Tool } from '@dexto/core';
-import { TaskRegistry } from '../task-registry.cjs';
-import '../signal-bus.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(taskRegistry: TaskRegistry): Tool<typeof ListTasksInputSchema>;
-
-export { type ListTasksInput, ListTasksInputSchema, type ListTasksOutput, type TaskListItem, createListTasksTool };

package/dist/tools/wait-for.d.cts

@@ -1,74 +0,0 @@
-import { z } from 'zod';
-import { ConditionEngine } from '../condition-engine.cjs';
-import { Tool } from '@dexto/core';
-import '../types.cjs';
-import '../signal-bus.cjs';
-import '../task-registry.cjs';
-
-/**
- * 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>;
-
-export { type WaitForInput, WaitForInputSchema, type WaitForOutput, createWaitForTool };