@prometheus-ai/agent 0.5.4 → 0.5.8

package/dist/types/tools/archive-reader.d.ts

@@ -31,6 +31,8 @@ type EntryStorage = TarStorage | ZipStorage;
 interface ArchiveIndexEntry extends ArchiveNode {
     storage?: EntryStorage;
 }
+export declare function formatArchiveEntryLines(entries: readonly ArchiveDirectoryEntry[]): string[];
+export declare function sniffArchiveFormat(bytes: Uint8Array): ArchiveFormat | undefined;
 export declare function parseArchivePathCandidates(filePath: string): ArchivePathCandidate[];
 export declare class ArchiveReader {
     #private;
@@ -41,4 +43,7 @@ export declare class ArchiveReader {
     readFile(subPath: string): Promise<ExtractedArchiveFile>;
 }
 export declare function openArchive(filePath: string): Promise<ArchiveReader>;
+export declare function listArchiveRoot(bytes: Uint8Array, format: ArchiveFormat, opts?: {
+    limit?: number;
+}): Promise<string>;
 export {};

package/dist/types/tools/ask.d.ts

@@ -16,7 +16,7 @@
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import { type Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
@@ -41,6 +41,8 @@ export interface QuestionResult {
     multi: boolean;
     selectedOptions: string[];
     customInput?: string;
+    /** True when the answer was auto-selected because the dialog timed out. */
+    timedOut?: boolean;
 }
 export interface AskToolDetails {
     question?: string;
@@ -48,6 +50,8 @@ export interface AskToolDetails {
     multi?: boolean;
     selectedOptions?: string[];
     customInput?: string;
+    /** True when the answer was auto-selected because the dialog timed out. */
+    timedOut?: boolean;
     /** Multi-part question mode */
     results?: QuestionResult[];
 }
@@ -79,6 +83,7 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
         }, z.core.$strip>>;
     }, z.core.$strip>;
     readonly strict = true;
+    readonly concurrency = "exclusive";
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
     static createIf(session: ToolSession): AskTool | null;

package/dist/types/tools/ast-edit.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
@@ -34,6 +34,9 @@ export interface AstEditToolDetails {
     /** Absolute base directory used during the edit. Used by the renderer to resolve
      * display-relative paths to absolute paths for OSC 8 hyperlinks. */
     searchPath?: string;
+    /** Session cwd at edit time. Display header paths are cwd-relative, so the
+     * renderer resolves them against this; `searchPath` is the scope target. */
+    cwd?: string;
 }
 export declare class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolDetails> {
     private readonly session;

package/dist/types/tools/ast-grep.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
@@ -31,6 +31,9 @@ export interface AstGrepToolDetails {
     /** Absolute base directory used during search. Used by the renderer to resolve
      * display-relative paths to absolute paths for OSC 8 hyperlinks. */
     searchPath?: string;
+    /** Session cwd at search time. Display header/match paths are cwd-relative, so
+     * the renderer resolves them against this; `searchPath` is the scope target. */
+    cwd?: string;
 }
 export declare class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolDetails> {
     private readonly session;

package/dist/types/tools/bash.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@prometheus-ai/agent-core";
 import type { Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
@@ -69,7 +69,7 @@ export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetai
     readonly loadMode = "essential";
     readonly description: string;
     readonly parameters: BashToolSchema;
-    readonly concurrency = "exclusive";
+    readonly concurrency: (args: Partial<BashToolInput>) => "shared" | "exclusive";
     readonly strict = true;
     constructor(session: ToolSession);
     execute(_toolCallId: string, { command: rawCommand, env: rawEnv, timeout: rawTimeout, cwd, async: asyncRequested, pty, }: BashToolInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<BashToolDetails>, ctx?: AgentToolContext): Promise<AgentToolResult<BashToolDetails>>;
@@ -99,6 +99,7 @@ export interface ShellRendererConfig<TArgs> {
     resolveCommand?: (args: TArgs | undefined) => string | undefined;
     resolveCwd?: (args: TArgs | undefined) => string | undefined;
     resolveEnv?: (args: TArgs | undefined) => Record<string, string> | undefined;
+    showHeader?: boolean;
 }
 export declare function getBashEnvForDisplay(args: BashRenderArgs): Record<string, string> | undefined;
 /**
@@ -123,6 +124,7 @@ export declare function createShellRenderer<TArgs>(config: ShellRendererConfig<T
     }, uiTheme: Theme, args?: TArgs): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
+    provisionalPendingPreview: string;
 };
 export declare const bashToolRenderer: {
     renderCall(args: BashRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component;
@@ -138,5 +140,6 @@ export declare const bashToolRenderer: {
     }, uiTheme: Theme, args?: BashRenderArgs | undefined): Component;
     mergeCallAndResult: boolean;
     inline: boolean;
+    provisionalPendingPreview: string;
 };
 export {};

package/dist/types/tools/browser/attach.d.ts

@@ -1,4 +1,4 @@
-import type { Browser, Page } from "puppeteer-core";
+import { type Browser, type Page } from "puppeteer-core";
 /**
  * Allocate an unused TCP port on 127.0.0.1 by binding to port 0 and reading
  * back the kernel-assigned port. There's a small race between close and the
@@ -17,9 +17,9 @@ export declare function findReusableCdp(exe: string, signal?: AbortSignal): Prom
     pid: number;
 } | null>;
 /**
- * Pick the best page target on an attached browser. Without a matcher, prefer
- * a page that doesn't look like a helper window (devtools, request handler,
- * background pages); with a matcher, return the first url+title substring hit.
+ * Pick the best page target on an attached browser. Prefer discoverable page
+ * targets first so Chromium/Edge attach flows that hide pages from
+ * `browser.pages()` can still return a usable tab.
  */
 export declare function pickElectronTarget(browser: Browser, matcher?: string): Promise<Page>;
 /**

package/dist/types/tools/browser/cmux/cmux-tab.d.ts

@@ -0,0 +1,202 @@
+import { JsRuntime } from "../../../eval/js/shared/runtime";
+import type { ToolSession } from "../../../sdk";
+import { type ReadableFormat } from "../readable";
+import type { Observation, ReadyInfo, RunResultOk, ScreenshotResult, SessionSnapshot } from "../tab-protocol";
+import type { CmuxSocketClient } from "./socket-client";
+interface ScreenshotOptions {
+    selector?: string;
+    fullPage?: boolean;
+    save?: string;
+    silent?: boolean;
+    encoding?: "base64" | "binary";
+}
+interface ObserveOptions {
+    includeAll?: boolean;
+    viewportOnly?: boolean;
+}
+interface RunContext {
+    session: SessionSnapshot;
+    displays: RunResultOk["displays"];
+    screenshots: ScreenshotResult[];
+    signal?: AbortSignal;
+    timeoutMs: number;
+}
+type WaitUntil = "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
+type DragTarget = string | {
+    readonly x: number;
+    readonly y: number;
+};
+interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface CmuxResponseRecord {
+    id: number;
+    url: string;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+}
+interface ViewportOptions {
+    width: number;
+    height: number;
+    deviceScaleFactor?: number;
+}
+export interface RunCmuxCodeOptions {
+    code: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    session: ToolSession;
+    snapshot: SessionSnapshot;
+}
+export declare class CmuxTab {
+    #private;
+    constructor(opts: {
+        client: CmuxSocketClient;
+        surfaceId: string;
+        url?: string;
+        title?: string;
+    });
+    get surfaceId(): string;
+    get page(): CmuxPageFacade;
+    get browser(): CmuxBrowserFacade;
+    viewport(): ReadyInfo["viewport"];
+    setViewport(viewport: ViewportOptions): Promise<void>;
+    url(): string;
+    title(): Promise<string>;
+    readyInfo(viewport?: ReadyInfo["viewport"]): Promise<ReadyInfo>;
+    setRunContext(context: RunContext): void;
+    clearRunContext(): void;
+    goto(url: string, opts?: {
+        waitUntil?: WaitUntil;
+        timeoutMs?: number;
+    }): Promise<void>;
+    observe(opts?: ObserveOptions): Promise<Observation>;
+    click(selector: string): Promise<void>;
+    dblclick(selector: string): Promise<void>;
+    hover(selector: string): Promise<void>;
+    focus(selector: string): Promise<void>;
+    check(selector: string): Promise<void>;
+    uncheck(selector: string): Promise<void>;
+    type(selector: string, text: string): Promise<void>;
+    fill(selector: string, value: string): Promise<void>;
+    press(key: string, opts?: {
+        selector?: string;
+    }): Promise<void>;
+    scroll(dx: number, dy: number): Promise<void>;
+    waitFor(selector: string, opts?: {
+        timeout?: number;
+    }): Promise<CmuxElementHandle>;
+    evaluate<TResult, TArgs extends unknown[]>(fn: string | ((...args: TArgs) => TResult | Promise<TResult>), ...args: TArgs): Promise<TResult>;
+    scrollIntoView(selector: string): Promise<void>;
+    select(selector: string, ...values: string[]): Promise<string[]>;
+    extract(format?: ReadableFormat): Promise<string>;
+    screenshot(opts?: ScreenshotOptions): Promise<ScreenshotResult>;
+    waitForUrl(pattern: string | RegExp, opts?: {
+        timeout?: number;
+    }): Promise<string>;
+    drag(from: DragTarget, to: DragTarget): Promise<void>;
+    uploadFile(selector: string, ...filePaths: string[]): Promise<void>;
+    waitForResponse(pattern: string | RegExp | ((response: CmuxResponse) => boolean | Promise<boolean>), opts?: {
+        timeout?: number;
+    }): Promise<CmuxResponse>;
+    id(id: number): Promise<CmuxElementHandle>;
+    ensureRuntime(session: SessionSnapshot): JsRuntime;
+    elementHandle(selector: string): CmuxElementHandle;
+    elementExists(selector: string): Promise<boolean>;
+    elementBox(selector: string): Promise<BoundingBox | null>;
+    evaluateOnSelector<TResult>(selector: string, source: string, args: unknown[]): Promise<TResult>;
+    pageContent(): Promise<string>;
+    pageScreenshot(opts?: ScreenshotOptions): Promise<Buffer | string>;
+    waitForFunction(fn: string | ((...args: unknown[]) => unknown | Promise<unknown>), opts: {
+        timeout?: number;
+        polling?: number;
+    } | undefined, ...args: unknown[]): Promise<unknown>;
+}
+declare class CmuxResponse {
+    #private;
+    constructor(record: CmuxResponseRecord);
+    url(): string;
+    status(): number;
+    statusText(): string;
+    headers(): Record<string, string>;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+}
+declare class CmuxElementHandle {
+    #private;
+    constructor(tab: CmuxTab, selector: string);
+    click(): Promise<void>;
+    type(text: string): Promise<void>;
+    fill(value: string): Promise<void>;
+    focus(): Promise<void>;
+    hover(): Promise<void>;
+    evaluate<TResult, TArgs extends unknown[]>(fn: (element: unknown, ...args: TArgs) => TResult | Promise<TResult>, ...args: TArgs): Promise<TResult>;
+    boundingBox(): Promise<BoundingBox | null>;
+    uploadFile(...paths: string[]): Promise<void>;
+    dispose(): Promise<void>;
+}
+declare class CmuxLocator {
+    #private;
+    constructor(tab: CmuxTab, selector: string);
+    setTimeout(timeoutMs: number): this;
+    click(): Promise<void>;
+    fill(value: string): Promise<void>;
+    waitHandle(): Promise<CmuxElementHandle>;
+}
+declare class CmuxPageFacade {
+    #private;
+    readonly keyboard: {
+        press: (key: string) => Promise<void>;
+    };
+    readonly mouse: {
+        wheel: (delta: {
+            deltaX?: number;
+            deltaY?: number;
+        }) => Promise<void>;
+        move: (x: number, y: number) => Promise<void>;
+        down: () => Promise<void>;
+        up: () => Promise<void>;
+    };
+    constructor(tab: CmuxTab);
+    url(): string;
+    title(): Promise<string>;
+    viewport(): ReadyInfo["viewport"];
+    setViewport(viewport: ViewportOptions): Promise<void>;
+    goto(url: string, opts?: {
+        waitUntil?: WaitUntil;
+        timeout?: number;
+    }): Promise<{
+        url: string;
+    }>;
+    evaluate<TResult, TArgs extends unknown[]>(fn: string | ((...args: TArgs) => TResult | Promise<TResult>), ...args: TArgs): Promise<TResult>;
+    content(): Promise<string>;
+    locator(selector: string): CmuxLocator;
+    $(selector: string): Promise<CmuxElementHandle | null>;
+    waitForSelector(selector: string, opts?: {
+        timeout?: number;
+    }): Promise<CmuxElementHandle>;
+    waitForFunction(fn: string | ((...args: unknown[]) => unknown | Promise<unknown>), opts?: {
+        timeout?: number;
+        polling?: number;
+    }, ...args: unknown[]): Promise<unknown>;
+    waitForResponse(pattern: string | RegExp | ((response: CmuxResponse) => boolean | Promise<boolean>), opts?: {
+        timeout?: number;
+    }): Promise<CmuxResponse>;
+    screenshot(opts?: ScreenshotOptions): Promise<Buffer | string>;
+}
+declare class CmuxBrowserFacade {
+    #private;
+    connected: boolean;
+    constructor(tab: CmuxTab);
+    pages(): Promise<CmuxPageFacade[]>;
+    version(): Promise<string>;
+    wsEndpoint(): string;
+    disconnect(): void;
+    close(): Promise<void>;
+}
+export declare function runCmuxCode(tab: CmuxTab, opts: RunCmuxCodeOptions): Promise<RunResultOk>;
+export {};

package/dist/types/tools/browser/cmux/rpc.d.ts

@@ -0,0 +1,70 @@
+import type { Observation } from "../tab-protocol";
+export interface CmuxKind {
+    kind: "cmux";
+    socketPath: string;
+    password?: string;
+    surface?: string;
+}
+export interface CmuxOpenSplitResult {
+    surface_id?: unknown;
+    url?: unknown;
+    workspace_id?: unknown;
+    created_split?: unknown;
+    placement_strategy?: unknown;
+}
+export interface CmuxSnapshotRef {
+    role?: unknown;
+    name?: unknown;
+}
+export interface CmuxSnapshotPage {
+    title?: unknown;
+    url?: unknown;
+    ready_state?: unknown;
+    text?: unknown;
+    html?: unknown;
+}
+export interface CmuxSnapshotResult {
+    snapshot?: unknown;
+    refs?: Record<string, CmuxSnapshotRef>;
+    page?: CmuxSnapshotPage;
+    url?: unknown;
+    title?: unknown;
+    ready_state?: unknown;
+    surface_id?: unknown;
+}
+export interface CmuxEvalResult {
+    value?: unknown;
+    surface_id?: unknown;
+    content_world?: unknown;
+}
+export interface CmuxUrlGetResult {
+    url?: unknown;
+    surface_id?: unknown;
+    workspace_id?: unknown;
+}
+export interface CmuxScreenshotResult {
+    png_base64?: unknown;
+    path?: unknown;
+    url?: unknown;
+    surface_id?: unknown;
+    width?: unknown;
+    height?: unknown;
+}
+export interface CmuxGeometry {
+    innerWidth: number;
+    innerHeight: number;
+    dpr: number;
+    scrollX: number;
+    scrollY: number;
+    scrollWidth: number;
+    scrollHeight: number;
+}
+export declare const GEOMETRY_SCRIPT = "(() => ({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, dpr: window.devicePixelRatio||1, scrollX: window.scrollX, scrollY: window.scrollY, scrollWidth: document.documentElement.scrollWidth, scrollHeight: document.documentElement.scrollHeight }))()";
+export declare function cmuxSnapshotToObservation(result: CmuxSnapshotResult, viewport: Observation["viewport"], geometry: CmuxGeometry): Observation;
+export declare function serializeEval(fn: string | ((...args: unknown[]) => unknown), args: unknown[]): string;
+export declare function mapWaitUntil(waitUntil: string | undefined): "interactive" | "complete";
+export interface ResolveCmuxKindOptions {
+    surface?: string;
+    settingEnabled?: boolean;
+}
+export declare function resolveCmuxKind(options?: ResolveCmuxKindOptions | null, env?: Record<string, string | undefined>): CmuxKind | null;

package/dist/types/tools/browser/cmux/socket-client.d.ts

@@ -0,0 +1,19 @@
+type CmuxErrorPayload = {
+    code?: unknown;
+    message?: unknown;
+    details?: unknown;
+};
+export declare function formatCmuxError(error: CmuxErrorPayload | undefined): string;
+export declare class CmuxSocketClient {
+    #private;
+    constructor(opts: {
+        socketPath: string;
+        password?: string;
+    });
+    connect(): Promise<void>;
+    request(method: string, params: Record<string, unknown>, opts?: {
+        timeoutMs?: number;
+    }): Promise<Record<string, unknown>>;
+    close(): void;
+}
+export {};

package/dist/types/tools/browser/registry.d.ts

@@ -1,7 +1,9 @@
 import type { Subprocess } from "bun";
 import type { Browser, CDPSession } from "puppeteer-core";
+import type { CmuxKind } from "./cmux/rpc";
+import { CmuxSocketClient } from "./cmux/socket-client";
 import { type UserAgentOverride } from "./launch";
-export type BrowserKind = {
+export type PuppeteerBrowserKind = {
     kind: "headless";
     headless: boolean;
 } | {
@@ -11,20 +13,30 @@ export type BrowserKind = {
     kind: "connected";
     cdpUrl: string;
 };
+export type BrowserKind = PuppeteerBrowserKind | CmuxKind;
 export type BrowserKindTag = BrowserKind["kind"];
-export interface BrowserHandle {
+interface BrowserHandleCommon {
     key: string;
     kind: BrowserKind;
+    refCount: number;
+}
+export interface PuppeteerBrowserHandle extends BrowserHandleCommon {
+    kind: PuppeteerBrowserKind;
     browser: Browser;
     cdpUrl?: string;
     pid?: number;
     subprocess?: Subprocess;
-    refCount: number;
     stealth: {
         browserSession: CDPSession | null;
         override: UserAgentOverride | null;
     };
 }
+export interface CmuxBrowserHandle extends BrowserHandleCommon {
+    kind: CmuxKind;
+    client: CmuxSocketClient;
+    surface?: string;
+}
+export type BrowserHandle = PuppeteerBrowserHandle | CmuxBrowserHandle;
 export interface AcquireBrowserOptions {
     cwd: string;
     viewport?: {
@@ -36,7 +48,9 @@ export interface AcquireBrowserOptions {
     signal?: AbortSignal;
 }
 export declare function acquireBrowser(kind: BrowserKind, opts: AcquireBrowserOptions): Promise<BrowserHandle>;
+export declare function normalizeConnectedCdpUrl(rawCdpUrl: string): string;
 export declare function holdBrowser(handle: BrowserHandle): void;
 export declare function releaseBrowser(handle: BrowserHandle, opts: {
     kill: boolean;
 }): Promise<void>;
+export {};

package/dist/types/tools/browser/render.d.ts

@@ -20,6 +20,8 @@ interface BrowserRenderArgs {
         path?: string;
         cdp_url?: string;
         target?: string;
+        cmux?: boolean;
+        surface?: string;
     };
     viewport?: {
         width: number;

package/dist/types/tools/browser/tab-protocol.d.ts

@@ -37,6 +37,8 @@ export interface ScreenshotResult {
 export interface SessionSnapshot {
     cwd: string;
     browserScreenshotDir?: string;
+    /** Force non-WebP screenshot encoding (e.g. for Ollama). Unset honors `PROMETHEUS_NO_WEBP`. */
+    excludeWebP?: boolean;
 }
 export type WorkerInitPayload = {
     mode: "headless";

package/dist/types/tools/browser/tab-supervisor.d.ts

@@ -1,5 +1,6 @@
 import type { ToolSession } from "../../sdk";
-import { type BrowserHandle, type BrowserKindTag } from "./registry";
+import { CmuxTab } from "./cmux/cmux-tab";
+import { type BrowserHandle, type BrowserKindTag, type CmuxBrowserHandle, type PuppeteerBrowserHandle } from "./registry";
 import type { ReadyInfo, RunResultOk, Transferable, WorkerInbound, WorkerInitPayload, WorkerOutbound } from "./tab-protocol";
 interface WorkerHandle {
     send(msg: WorkerInbound, transferList?: Transferable[]): void;
@@ -16,17 +17,27 @@ export interface PendingRun {
     signal?: AbortSignal;
     toolCalls: Map<string, AbortController>;
 }
-export interface TabSession {
+interface TabSessionBase<TBrowser extends BrowserHandle = BrowserHandle> {
     name: string;
-    browser: BrowserHandle;
+    browser: TBrowser;
     targetId: string;
-    worker: WorkerHandle;
     state: "alive" | "dead";
     info: ReadyInfo;
     pending: Map<string, PendingRun>;
     dialogPolicy?: DialogPolicy;
     kindTag: BrowserKindTag;
 }
+export interface WorkerTabSession extends TabSessionBase<PuppeteerBrowserHandle> {
+    backend: "worker";
+    worker: WorkerHandle;
+}
+export interface CmuxTabSession extends TabSessionBase<CmuxBrowserHandle> {
+    backend: "cmux";
+    cmuxTab: CmuxTab;
+    cmuxOwnsSurface: boolean;
+    cmuxAttachedSurface?: string;
+}
+export type TabSession = WorkerTabSession | CmuxTabSession;
 export interface AcquireTabOptions {
     url?: string;
     waitUntil?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
@@ -39,6 +50,7 @@ export interface AcquireTabOptions {
     signal?: AbortSignal;
     timeoutMs: number;
     dialogs?: DialogPolicy;
+    cmuxSurface?: string;
 }
 export interface AcquireTabResult {
     tab: TabSession;

package/dist/types/tools/browser/tab-worker.d.ts

@@ -1,5 +1,5 @@
 import type { HTMLElement } from "linkedom";
-import type { ElementHandle } from "puppeteer-core";
+import type { ElementHandle, ImageFormat } from "puppeteer-core";
 import type { Transport } from "./tab-protocol";
 declare global {
     interface Element extends HTMLElement {
@@ -11,9 +11,26 @@ declare global {
         elementFromPoint(x: number, y: number): Element | null;
     };
 }
+interface ScreenshotOptions {
+    selector?: string;
+    fullPage?: boolean;
+    save?: string;
+    silent?: boolean;
+}
+export interface InflightOp {
+    label: string;
+    startedAt: number;
+}
+/** Human-readable label for a screenshot op, used in op tracking + timeout errors. */
+export declare function describeScreenshot(opts?: ScreenshotOptions): string;
+/** Map an explicit save path's extension to a puppeteer capture format (default png). */
+export declare function imageFormatForPath(filePath: string): ImageFormat;
+/** Summarize still-running helpers (oldest first) so a cell timeout names what stalled. */
+export declare function describeInflight(inflight: Map<number, InflightOp>): string;
 export declare class WorkerCore {
     #private;
     constructor(transport: Transport);
     nextElementId(): number;
     cacheElement(id: number, handle: ElementHandle): void;
 }
+export {};

package/dist/types/tools/browser.d.ts

@@ -1,9 +1,11 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolSession } from "../sdk";
 import { type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
 import type { OutputMeta } from "./output-meta";
+export { cmuxSnapshotToObservation, mapWaitUntil, resolveCmuxKind, serializeEval } from "./browser/cmux/rpc";
+export { CmuxSocketClient } from "./browser/cmux/socket-client";
 export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } from "./browser/readable";
 export type { Observation, ObservationEntry } from "./browser/tab-protocol";
 declare const browserSchema: z.ZodObject<{

package/dist/types/tools/checkpoint.d.ts

@@ -1,5 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
 export interface CheckpointState {

package/dist/types/tools/conflict-detect.d.ts

@@ -128,6 +128,22 @@ export declare function parseConflictUri(raw: string): ParsedConflictUri | null;
  * has actually been altered or removed.
  */
 export declare function spliceConflict(originalText: string, entry: ConflictEntry, replacement: string): string;
+/**
+ * True when two registered blocks record the same marker-block content
+ * (labels and all sides). Out-of-band edits can shift a block's line
+ * numbers between reads, registering a fresh id while the stale one
+ * persists; callers use content identity to treat a locate-miss for the
+ * stale twin as "already resolved" instead of a hard failure.
+ */
+export declare function conflictRegionsEqual(a: ConflictBlock, b: ConflictBlock): boolean;
+/**
+ * True when the entry's recorded marker block still occurs in `content`
+ * (LF-normalized — recorded sections are stored LF). Distinguishes a stale
+ * re-registration of a just-resolved region (no longer present) from a
+ * DISTINCT conflict block that happens to be byte-identical (still present
+ * elsewhere in the file and must stay addressable).
+ */
+export declare function conflictRegionPresent(content: string, entry: ConflictBlock): boolean;
 /**
  * Expand `@ours` / `@theirs` / `@base` / `@both` line tokens against the
  * recorded sections of `entry`. A token only triggers when it is the

package/dist/types/tools/debug.d.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, RenderResultOptions, ToolApprovalDecision } from "@prometheus-ai/agent-core";
 import { type Component } from "@prometheus-ai/tui";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { type DapBreakpointRecord, type DapContinueOutcome, type DapDataBreakpointInfoResponse, type DapDataBreakpointRecord, type DapDisassembledInstruction, type DapEvaluateResponse, type DapFunctionBreakpointRecord, type DapInstructionBreakpointRecord, type DapModule, type DapScope, type DapSessionSummary, type DapSource, type DapStackFrame, type DapThread, type DapVariable } from "../dap";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";