import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
import type { CaptureRegion, DesktopCapabilities, DesktopScreenState } from "@oh-my-pi/pi-natives";
export { COMPUTER_WORKER_ARG } from "../../cli/worker-selectors.js";
/** Frozen run settings transferred from the host session to the worker. */
export interface ComputerSessionSnapshot {
    cwd: string;
    sessionId: string;
    captureMaxWidth: number;
    captureMaxHeight: number;
    display: string;
    readOnly: boolean;
    /** `computer.backgroundFallback`: what a refused background input call does. */
    backgroundFallback: "takeover" | "refuse";
    /**
     * The agent turn the run belongs to, if any: once it acts, the display stays awake until that turn's
     * `release-display` rather than for the native grace period after its last request.
     */
    displayTurn?: number;
}
/** Reply envelope for a session tool invoked by desktop JavaScript. */
export type ToolReply = {
    ok: true;
    value: unknown;
} | {
    ok: false;
    error: RunErrorPayload;
};
/**
 * The host's answer to a `control.acquire` confirmation: the user, or their `tools.approval["computer.control"]`
 * policy, approved or declined, nobody could be asked because the session has no interactive UI (a subagent,
 * print mode or another headless run), or nobody answered before the confirmation's `timeoutMs` closed it.
 */
export type ControlVerdict = "approved" | "denied" | "no-ui" | "unanswered";
/** Where the native session counts the user's Escape stops, and how many the user's latest message acknowledged. */
export interface ComputerEscapeScope {
    key: string;
    acknowledged: number;
}
/** Commands accepted by the persistent computer worker. */
export type ComputerWorkerInbound = {
    type: "ping";
    id: string;
} | {
    type: "run";
    id: string;
    code: string;
    timeoutMs: number;
    session: ComputerSessionSnapshot;
    escape: ComputerEscapeScope;
} | {
    type: "capabilities";
    id: string;
    session: ComputerSessionSnapshot;
    escape: ComputerEscapeScope;
} | {
    type: "abort";
    id: string;
} | {
    type: "revoke-control";
    id: string;
}
/** Agent turn `turn` ended: let the display sleep now, keeping every other piece of session state. */
 | {
    type: "release-display";
    turn: number;
}
/**
 * Turn `from` stopped for a dialog and went on as turn `turn`: the run of turn `from` still active holds the display
 * again, until turn `turn` ends.
 */
 | {
    type: "resume-display";
    from: number;
    turn: number;
} | {
    type: "tool-reply";
    id: string;
    reply: ToolReply;
} | {
    type: "close";
};
/** Successful computer run output returned to the host supervisor. */
export interface ComputerRunOk {
    displays: Array<TextContent | ImageContent>;
    returnValue: unknown;
    screenshots: ComputerScreenshot[];
    capabilities?: DesktopCapabilities;
}
/** Result of a computer call the user stopped with physical Escape during takeover input. */
export declare const ESCAPE_STOPPED_MESSAGE: string;
/** Result of a computer call that finished, its input out, before the user's Escape stopped computer use. */
export declare const ESCAPE_AFTER_CALL_MESSAGE: string;
/** Refusal of every later computer call until the user's next message acknowledges their Escape stop. */
export declare const ESCAPE_REFUSED_MESSAGE: string;
/** Appended to a screenshot taken while the macOS lock screen is up. */
export declare const SCREEN_LOCKED_CAPTURE_NOTE: string;
/**
 * Tells the model a run ended with the macOS screen locked or the session's
 * display asleep, so lock-screen pixels and failed captures are not taken
 * for the app's state. Input is never refused because of it.
 */
export declare function screenStateNotice(state: DesktopScreenState | undefined): string | undefined;
/** Screenshot or zoom emitted during one computer run, with its full input coordinate frame. */
export interface ComputerScreenshot {
    path: string;
    width: number;
    height: number;
    coordinateWidth: number;
    coordinateHeight: number;
    region?: CaptureRegion;
    sourceWidth?: number;
    sourceHeight?: number;
    target: string;
    /** The macOS lock screen was up: a display capture shows it, a window capture shows the window's last frame. */
    screenLocked?: true;
}
/** Clone-safe error metadata returned across the worker boundary. */
export interface RunErrorPayload {
    name: string;
    message: string;
    stack?: string;
    isToolError: boolean;
    isAbort: boolean;
}
/** Events emitted by the persistent computer worker. */
export type ComputerWorkerOutbound = {
    type: "ready";
} | {
    type: "control-revoked";
    id: string;
} | {
    type: "pong";
    id: string;
} | {
    type: "result";
    id: string;
    ok: true;
    payload: ComputerRunOk;
} | {
    type: "result";
    id: string;
    ok: false;
    error: RunErrorPayload;
} | {
    type: "capabilities";
    id: string;
    ok: true;
    capabilities: DesktopCapabilities;
} | {
    type: "capabilities";
    id: string;
    ok: false;
    error: RunErrorPayload;
} | {
    type: "tool-call";
    id: string;
    runId: string;
    name: string;
    args: unknown;
} | {
    type: "control-request";
    id: string;
    runId: string;
    reason: string;
    timeoutMs: number;
} | {
    type: "closed";
};
/** Transport used by the worker core in Bun workers and tests. */
export interface ComputerWorkerTransport {
    send(message: ComputerWorkerOutbound, transfer?: Bun.Transferable[]): void;
    onMessage(handler: (message: ComputerWorkerInbound) => void): () => void;
    close(): void;
}