trellis/dist/core/agents/worker-pool.d.ts

Agentic State Engine — event-sourced causal graph with branching, decision traces, and realtime sync for AI-native applications

/**
 * WorkerPool — Concurrent agent run execution with queue-based concurrency control.
 *
 * @module trellis/core/agents
 */
import type { TrellisKernel } from '../kernel/trellis-kernel.js';
import { AgentHarness } from './harness.js';
import type { RunTaskOptions } from './types.js';
export type WorkerTaskStatus = 'queued' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
export interface WorkerTask {
    id: string;
    agentId: string;
    runId: string;
    input: string;
    status: WorkerTaskStatus;
    queuedAt: string;
    startedAt?: string;
    completedAt?: string;
    error?: string;
}
export interface WorkerPoolConfig {
    /** Maximum concurrent agent runs (default 1). */
    concurrency: number;
    /** Interval in ms to poll for ready tasks (default 500). */
    pollIntervalMs: number;
    /** Persist queue state to the graph (survives restarts). */
    persistToGraph?: boolean;
    /** Simulate execution — complete tasks without LLM. Useful for testing and external executors. */
    simulate?: boolean;
}
export type WorkerPoolEvent = {
    type: 'task:queued';
    task: WorkerTask;
} | {
    type: 'task:started';
    task: WorkerTask;
} | {
    type: 'task:completed';
    task: WorkerTask;
} | {
    type: 'task:failed';
    task: WorkerTask;
    error: string;
} | {
    type: 'task:cancelled';
    task: WorkerTask;
} | {
    type: 'task:paused';
    task: WorkerTask;
} | {
    type: 'task:resumed';
    task: WorkerTask;
};
export type WorkerPoolListener = (event: WorkerPoolEvent) => void;
export interface PoolStatus {
    active: number;
    queued: number;
    maxConcurrency: number;
    running: boolean;
}
export type KernelFactory = () => TrellisKernel | Promise<TrellisKernel>;
export declare class WorkerPool {
    private kernel;
    private harness;
    private kernelFactory;
    private config;
    private queue;
    private active;
    private stopped;
    private pollTimer;
    private listeners;
    constructor(kernel: TrellisKernel | KernelFactory, harness?: AgentHarness, config?: Partial<WorkerPoolConfig>);
    /** Lazily resolve and expose the kernel (for DAGScheduler & consumers). */
    ensureKernel(): Promise<TrellisKernel>;
    private _ensureKernel;
    private _ensureHarness;
    start(): void;
    stop(): void;
    getStatus(): PoolStatus;
    on(listener: WorkerPoolListener): void;
    off(listener: WorkerPoolListener): void;
    private _emit;
    enqueue(agentId: string, input: string, opts?: RunTaskOptions, runId?: string): Promise<string>;
    cancel(runId: string): Promise<void>;
    pause(runId: string): Promise<void>;
    resume(runId: string): Promise<void>;
    getQueue(): WorkerTask[];
    getActiveJobs(): WorkerTask[];
    getTask(runId: string): WorkerTask | undefined;
    private _tick;
    private _execute;
    /** Restore queued/paused tasks from the graph. Call after construction. */
    restore(): Promise<void>;
    private _saveTask;
    private _updateTask;
}
//# sourceMappingURL=worker-pool.d.ts.map