@oh-my-pi/pi-coding-agent 15.12.3 → 15.12.4

package/dist/types/session/agent-session.d.ts

@@ -357,16 +357,6 @@ export declare class AgentSession {
     /** Unconditionally clear the silent-abort flag. Idempotent: safe when the
      *  flag was never set OR was already consumed by `#handleAgentEvent`. */
     clearPlanCompactAbortPending(): void;
-    /** Register a compact display string for a custom message that the caller is
-     *  about to dispatch via `promptCustomMessage` / `sendCustomMessage`.
-     *  Returns a stable tag the caller MUST embed in
-     *  `CustomMessage.details.__pendingDisplayTag` so the agent-side
-     *  `message_start` handler can remove the matching display entry when the
-     *  queued message is consumed.
-     *
-     *  Does NOT push to the agent's steering/followUp queue — that happens
-     *  separately inside `sendCustomMessage`. */
-    enqueueCustomMessageDisplay(text: string, mode: "steer" | "followUp"): string;
     getAsyncJobSnapshot(options?: {
         recentLimit?: number;
     }): AsyncJobSnapshot | null;
@@ -421,6 +411,7 @@ export declare class AgentSession {
     get serviceTier(): ServiceTier | undefined;
     /** Whether agent is currently streaming a response */
     get isStreaming(): boolean;
+    get isAborting(): boolean;
     /** Wait until streaming and deferred recovery work are fully settled. */
     waitForIdle(): Promise<void>;
     drainAsyncJobDeliveriesForAcp(options?: {
@@ -595,7 +586,9 @@ export declare class AgentSession {
      * the ACP agent) use this to know whether to expect an `agent_end` event.
      */
     prompt(text: string, options?: PromptOptions): Promise<boolean>;
-    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice">): Promise<void>;
+    promptCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: Pick<PromptOptions, "streamingBehavior" | "toolChoice"> & {
+        queueChipText?: string;
+    }): Promise<void>;
     /**
      * Queue a steering message to interrupt the agent mid-run.
      */
@@ -616,6 +609,7 @@ export declare class AgentSession {
     sendCustomMessage<T = unknown>(message: Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">, options?: {
         triggerTurn?: boolean;
         deliverAs?: "steer" | "followUp" | "nextTurn";
+        queueChipText?: string;
     }): Promise<void>;
     /**
      * Send a user message to the agent.
@@ -627,22 +621,13 @@ export declare class AgentSession {
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";
     }): Promise<void>;
-    /**
-     * Clear queued messages and return them (text plus any attached images).
-     * Useful for restoring to editor when user aborts. The internal entry
-     * arrays are handed out as-is — a `tag` (if any) is inert once the record
-     * leaves the queue.
-     */
+    /** Clear queued messages and return them (text plus any attached images). */
     clearQueue(): {
         steering: RestoredQueuedMessage[];
         followUp: RestoredQueuedMessage[];
     };
-    /** Number of pending messages (includes steering, follow-up, and next-turn messages) */
+    /** Number of pending displayable messages (includes steering, follow-up, and next-turn messages) */
     get queuedMessageCount(): number;
-    /** Get pending messages (read-only). Returns the public text-only view;
-     *  internal `{text, tag?}` records are mapped to `.text` so callers
-     *  (`updatePendingMessagesDisplay`, `restoreQueuedMessagesToEditor`) see
-     *  the unchanged historical shape. */
     getQueuedMessages(): {
         steering: readonly string[];
         followUp: readonly string[];
@@ -650,8 +635,6 @@ export declare class AgentSession {
     /**
      * Pop the last queued message (steering first, then follow-up).
      * Used by dequeue keybinding to restore messages to editor one at a time.
-     * Returns the popped entry's text and images; the tag (if any) dies with
-     * the record — no orphan state can outlive the queue entry.
      */
     popLastQueuedMessage(): RestoredQueuedMessage | undefined;
     get skillsSettings(): SkillsSettings | undefined;
@@ -673,13 +656,6 @@ export declare class AgentSession {
         goalReason?: "interrupted" | "internal";
         reason?: string;
     }): Promise<void>;
-    /**
-     * Abort active work, then immediately resume the agent so queued steer/follow-up
-     * messages drain instead of waiting for another natural turn boundary.
-     */
-    interruptAndFlushQueuedMessages(options?: {
-        reason?: string;
-    }): Promise<void>;
     /**
      * Start a new session, optionally with initial messages and parent tracking.
      * Clears all messages and starts a new session.
@@ -701,7 +677,10 @@ export declare class AgentSession {
     fork(): Promise<boolean>;
     /**
      * Set model directly.
-     * Validates API key and saves to the active session. Persists settings only when requested.
+     * Validates that a credential source is configured (synchronously, without
+     * refreshing OAuth or running command-backed key programs) and saves to the
+     * active session. Persists settings only when requested. The concrete key is
+     * resolved lazily per request, so switching never blocks the event loop.
      * @throws Error if no API key available for the model
      */
     setModel(model: Model, role?: string, options?: {
@@ -711,7 +690,9 @@ export declare class AgentSession {
     }): Promise<void>;
     /**
      * Set model temporarily (for this session only).
-     * Validates API key, saves to session log but NOT to settings.
+     * Validates that a credential source is configured (synchronously, without
+     * refreshing OAuth or running command-backed key programs), saves to session
+     * log but NOT to settings.
      * @throws Error if no API key available for the model
      */
     setModelTemporary(model: Model, thinkingLevel?: ThinkingLevel, options?: {

package/dist/types/session/agent-storage.d.ts

@@ -10,7 +10,8 @@ export declare class AgentStorage {
     private constructor();
     /**
      * Returns singleton instance for the given database path, creating if needed.
-     * Retries on SQLITE_BUSY with exponential backoff.
+     * Retries on the `SQLITE_BUSY` family (including `SQLITE_BUSY_RECOVERY`) with
+     * exponential backoff. See issue #2421.
      * @param dbPath - Path to the SQLite database file (defaults to config path)
      * @returns AgentStorage instance for the given path
      */

package/dist/types/session/indexed-session-storage.d.ts

@@ -53,6 +53,7 @@ declare class IndexedSessionStorageWriter implements SessionStorageWriter {
     writeLine(line: string): Promise<void>;
     flush(): Promise<void>;
     fsync(): Promise<void>;
+    fsyncSync(): void;
     close(): Promise<void>;
     getError(): Error | undefined;
 }

package/dist/types/session/messages.d.ts

@@ -16,13 +16,11 @@ export interface SkillPromptDetails {
     path: string;
     args?: string;
     lineCount: number;
-    /** Internal: tag used by AgentSession to remove the pending-display chip
-     *  from `#steeringMessages` / `#followUpMessages` when the agent consumes
-     *  this message. Not surfaced to renderers; the `__` prefix signals
-     *  "private". Optional — non-streaming skill prompts never set it. Stripped
-     *  from persisted `details` by `SessionManager.appendCustomMessageEntry`
-     *  via the `INTERNAL_DETAILS_FIELDS` allowlist below. */
-    __pendingDisplayTag?: string;
+    /** Internal: compact label shown for a queued custom message. Optional —
+     *  non-streaming skill prompts never set it. Stripped from persisted
+     *  `details` by `SessionManager.appendCustomMessageEntry` via the
+     *  `INTERNAL_DETAILS_FIELDS` allowlist below. */
+    __queueChipText?: string;
 }
 /** Sentinel value for `AssistantMessage.errorMessage` indicating that the abort
  *  was an *expected internal transition* (plan-mode → execution compaction)
@@ -55,16 +53,16 @@ export declare function shouldRenderAbortReason(errorMessage: string | undefined
  *  `shouldRenderAbortReason` before rendering when user interrupts should stay
  *  visually quiet. */
 export declare function resolveAbortLabel(errorMessage: string | undefined, retryAttempt?: number): string;
-/** Extract the optional `__pendingDisplayTag` field from a CustomMessage's
+/** Extract the optional `__queueChipText` field from a CustomMessage's
  *  `details` blob. Safe over `unknown`; returns undefined when the field is
  *  absent or non-string. */
-export declare function readPendingDisplayTag(details: unknown): string | undefined;
+export declare function readQueueChipText(details: unknown): string | undefined;
 /** Explicit allowlist of `details` field names that are AgentSession-internal
  *  transient bookkeeping and MUST be removed before SessionManager persists
  *  the CustomMessageEntry to disk. Scoped intentionally narrow: only fields
  *  declared here are stripped. Adding a new entry is a deliberate, reviewed
  *  change — unrelated future payload fields are never silently dropped. */
-export declare const INTERNAL_DETAILS_FIELDS: readonly ["__pendingDisplayTag"];
+export declare const INTERNAL_DETAILS_FIELDS: readonly ["__queueChipText"];
 /** Return a `details` copy with every key in `INTERNAL_DETAILS_FIELDS`
  *  removed. Returns the input unchanged when there is nothing to strip
  *  (null/non-object, or no listed fields present) so callers don't pay a

package/dist/types/session/session-manager.d.ts

@@ -353,6 +353,21 @@ export declare class SessionManager {
     ensureOnDisk(): Promise<void>;
     /** Flush pending writes to disk. Call before switching sessions or on shutdown. */
     flush(): Promise<void>;
+    /**
+     * Synchronously flush all in-memory entries to disk and fsync.
+     * Use when the process may exit before an async flush settles (e.g. Ctrl+C
+     * in the TUI, where raw mode consumes the keystroke so postmortem's SIGINT
+     * handler never fires).
+     *
+     * Hot path: the persist writer is open and flushed, so a single fsyncSync
+     * pushes the page-cache data to physical disk.
+     *
+     * Cold path: entries are only in memory (session just started, or a rewrite
+     * is pending). Writes all entries to a temp file, fsyncs, and atomically
+     * renames over the session file — then re-opens an append writer so the
+     * hot path resumes on subsequent `_persist` calls.
+     */
+    flushSync(): void;
     /** Close the persistent writer after flushing all pending data. */
     close(): Promise<void>;
     getCwd(): string;

package/dist/types/session/session-storage.d.ts

@@ -15,6 +15,11 @@ export interface SessionStorageWriter {
     writeLineSync(line: string): void;
     flush(): Promise<void>;
     fsync(): Promise<void>;
+    /**
+     * Synchronously fsync the underlying file descriptor. Returns once the data
+     * is on the physical disk. Throws synchronously on I/O error.
+     */
+    fsyncSync(): void;
     close(): Promise<void>;
     getError(): Error | undefined;
 }

package/dist/types/slash-commands/helpers/logout.d.ts

@@ -0,0 +1,15 @@
+import type { OAuthAccountIdentity, StoredAuthCredential } from "../../session/auth-storage";
+export interface LogoutAccount {
+    credentialId: number;
+    provider: string;
+    label: string;
+    detail: string;
+    type: "api_key" | "oauth";
+    active: boolean;
+}
+interface LogoutAccountOptions {
+    activeIdentity?: OAuthAccountIdentity;
+    activeApiKey?: boolean;
+}
+export declare function toLogoutAccounts(provider: string, credentials: StoredAuthCredential[], options?: LogoutAccountOptions): LogoutAccount[];
+export {};

package/dist/types/task/types.d.ts

@@ -1,6 +1,6 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { AgentSessionEvent } from "../session/agent-session";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */

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

@@ -16,7 +16,7 @@
  */
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type Component } from "@oh-my-pi/pi-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 ".";

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-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 ".";

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-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 ".";

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

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-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 ".";

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?: {
@@ -41,3 +53,4 @@ 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 `OMP_NO_WEBP`. */
+    excludeWebP?: boolean;
 }
 export type WorkerInitPayload = {
     mode: "headless";