import { Agent, type AgentOptions, type AgentEvent, type AgentMessage } from "@earendil-works/pi-agent-core";
import type { ImageContent, Models } from "@earendil-works/pi-ai";
import { type Storage } from "@earendil-works/pi-durable";
type Listener = (event: AgentEvent, signal: AbortSignal) => void | Promise<void>;
/** A public-API Agent facade over restartable pi-durable tasks. */
export declare class DurableAgent extends Agent {
    private readonly durableOptions;
    private readonly observers;
    private readonly registry;
    private engine?;
    private root?;
    private opening?;
    private releaseStartup;
    private readonly startup;
    /** Reconcile committed history without replaying events, before any recovered task runs. */
    recoverHistory?: (messages: AgentMessage[]) => void | Promise<void>;
    private delivery;
    private admission;
    private running;
    private controller;
    private requestId;
    private firstRequest;
    private closing;
    private closeRequested;
    private closed?;
    private active;
    private partial;
    private failure;
    private readonly pending;
    private emitted;
    private restored;
    private resetPending;
    private queuePreview;
    private readonly transient;
    private transientSequence;
    private requestScope;
    private readonly toolTask;
    private readonly runTask;
    /** `fabricJournalDirectory` lets an interrupted fabric_exec resume from a crash journal. */
    constructor(options: AgentOptions & {
        models: Models;
        storage: Storage;
        runId: string;
        fabricJournalDirectory?: string;
    });
    private scopedTask;
    private failureMessage;
    private context;
    private executionContext;
    private canonicalToolResults;
    private lastAssistant;
    private event;
    /** Commit an ordered, slim marker for a streaming update; its payload stays in memory until delivery. */
    private transientEvent;
    /** Restore a committed streaming marker to the full event; undefined when its payload is not in this process. */
    private rehydrate;
    private message;
    private expose;
    private open;
    /** Resolves only after all controls accepted so far have committed. */
    awaitControls(): Promise<void>;
    /**
     * A phase's wait for accepted controls. abort() chains the engine abort onto admission, and that abort joins the
     * running invocation, so a phase that kept waiting on admission after its abort signal would wait on itself. The
     * phase's next commit then rejects on the durable abort mark and the abort handler settles the task.
     */
    private admit;
    setRequestId(id: string): void;
    subscribe(listener: Listener): () => void;
    get signal(): AbortSignal | undefined;
    waitForIdle(): Promise<void>;
    abort(): void;
    prompt(message: AgentMessage | AgentMessage[]): Promise<void>;
    prompt(input: string, images?: ImageContent[]): Promise<void>;
    continue(): Promise<void>;
    private start;
    private enqueue;
    steer(message: AgentMessage): void;
    followUp(message: AgentMessage): void;
    private clear;
    clearSteeringQueue(): void;
    clearFollowUpQueue(): void;
    clearAllQueues(): void;
    hasQueuedMessages(): boolean;
    peekQueuedMessages(): AgentMessage[];
    reset(): void;
    /** Close cancels invocations, NOT durable tasks. A new Harness resumes their checkpoints. */
    close(): Promise<void>;
}
export {};
//# sourceMappingURL=agent.d.ts.map