@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.1

package/dist/types/session/turn-recovery.d.ts

@@ -0,0 +1,225 @@
+import { type Agent, type AgentMessage, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage, CodexCompactionContext, Model, ToolChoice } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "../config/model-registry.js";
+import type { Settings } from "../config/settings.js";
+import type { ConfiguredThinkingLevel } from "../thinking.js";
+import type { AgentSessionEvent } from "./agent-session-events.js";
+import type { InitialRetryFallbackState } from "./agent-session-types.js";
+import { type RetryFallbackSelector } from "./retry-fallback-chains.js";
+import type { SessionManager } from "./session-manager.js";
+/** Result shape shared with automatic maintenance recovery. */
+export interface RecoveryCompactionResult {
+    deferredHandoff: boolean;
+    continuationScheduled: boolean;
+    automaticContinuationBlocked?: boolean;
+    historyRewritten?: boolean;
+}
+/** Capabilities borrowed from the owning AgentSession. */
+export interface TurnRecoveryHost {
+    agent: Agent;
+    sessionManager: SessionManager;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    configWarnings: string[];
+    model(): Model | undefined;
+    thinkingLevel(): ThinkingLevel | undefined;
+    configuredThinkingLevel(): ConfiguredThinkingLevel | undefined;
+    setThinkingLevel(level: ConfiguredThinkingLevel | undefined): void;
+    isDisposed(): boolean;
+    isStreaming(): boolean;
+    isCompacting(): boolean;
+    abortInProgress(): boolean;
+    streamingEditAbortTriggered(): boolean;
+    promptGeneration(): number;
+    sessionId(): string;
+    emitSessionEvent(event: AgentSessionEvent): Promise<void>;
+    scheduleAgentContinue(options: {
+        delayMs?: number;
+        generation?: number;
+    }): void;
+    waitForSessionMessagePersistence(message: AssistantMessage): Promise<void>;
+    appendSessionMessage(message: AssistantMessage): void;
+    sessionMessageAlreadyPersisted(message: AssistantMessage): boolean;
+    setModelWithProviderSessionReset(model: Model): void;
+    resetCurrentResponsesProviderSession(reason: string): void;
+    maybeAutoRedeemCodexReset(): Promise<boolean>;
+    runAutoCompaction(reason: "overflow" | "threshold" | "idle" | "incomplete", willRetry: boolean, deferred?: boolean, allowDefer?: boolean, options?: {
+        autoContinue?: boolean;
+        triggerContextTokens?: number;
+        suppressContinuation?: boolean;
+        suppressHandoff?: boolean;
+        phase?: CodexCompactionContext["phase"];
+        terminalTextAnswer?: boolean;
+    }): Promise<RecoveryCompactionResult>;
+    withBashBranchTransition<T>(operation: () => T): T;
+}
+/** Construction-time retry state restored from model selection. */
+export interface TurnRecoveryOptions {
+    initialRetryFallback?: InitialRetryFallbackState;
+}
+/** Owns terminal-stop recovery, automatic retries, and fallback routing. */
+export declare class TurnRecovery {
+    #private;
+    constructor(host: TurnRecoveryHost, options?: TurnRecoveryOptions);
+    /** Current automatic retry attempt. */
+    get attempt(): number;
+    /** Promise settled when the active retry saga finishes. */
+    get retryPromise(): Promise<void> | undefined;
+    /** Resolved selector while fallback routing owns the current model. */
+    get retryFallbackModel(): string | undefined;
+    /** Resets per-prompt recovery counters and terminal-stop acceptance. */
+    resetForNewPrompt(): void;
+    /** Sets whether one terminal empty stop is accepted for the current prompt. */
+    setAcceptTerminalEmptyStop(accept: boolean): void;
+    /** Closes a successful retry saga and annotates recovered persisted errors. */
+    onAssistantSettledSuccessfully(message: AssistantMessage): Promise<void>;
+    /** Closes a failed retry saga when no compaction continuation took ownership. */
+    onErrorSettledWithoutRetry(message: AssistantMessage, compaction: RecoveryCompactionResult): Promise<void>;
+    /** Persists an otherwise skipped terminal empty error turn. */
+    persistTerminalEmptyErrorTurn(message: AssistantMessage): Promise<void>;
+    /** Handles empty terminal assistant turns and schedules bounded recovery. */
+    handleEmptyAssistantStop(message: AssistantMessage): Promise<boolean>;
+    /** Classifies suspicious terminal stops and schedules bounded recovery. */
+    handleUnexpectedAssistantStop(message: AssistantMessage): Promise<boolean>;
+    /** Removes a persisted failed assistant turn after its persistence slot settles. */
+    dropPersistedAssistantTurn(message: AssistantMessage): Promise<void>;
+    /** Runs recovery compaction and restores the failed turn when no rewrite occurs. */
+    runRecoveryCompactionWithRollback(reason: "overflow" | "incomplete", message: AssistantMessage, allowDefer: boolean, options: {
+        autoContinue: boolean;
+        triggerContextTokens?: number;
+    }): Promise<RecoveryCompactionResult>;
+    /** Restores the configured primary after fallback cooldown expiry. */
+    maybeRestoreRetryFallbackPrimary(): Promise<void>;
+    /** Applies automatic retry, credential rotation, and model fallback policy. */
+    handleRetryableError(message: AssistantMessage, options?: {
+        allowModelFallback?: boolean;
+        fireworksFastFallback?: boolean;
+        hardErrorFallback?: boolean;
+        preserveFailedTurn?: boolean;
+    }): Promise<boolean>;
+    /** Prompts after transient overlap with a prior agent run. */
+    promptAgentWithIdleRetry(messages: AgentMessage[], options?: {
+        toolChoice?: ToolChoice;
+    }): Promise<void>;
+    /** Parses provider retry and rate-limit reset hints into a delay. */
+    parseRetryAfterMsFromError(errorMessage: string): number | undefined;
+    /** Resolve the pending retry promise */
+    resolveRetry(): void;
+    removeAssistantMessageFromActiveContext(assistantMessage: AssistantMessage, reason?: string): void;
+    /**
+     * Drop an assistant turn from BOTH the live agent context and the persisted
+     * session branch (reparenting the leaf to the turn's parent), so a discarded
+     * turn does not resurface on reload. Used for empty/reasoning-only stops and
+     * the Gemini header-runaway interrupt, which must not replay a partial,
+     * loop-fueling thinking block.
+     */
+    discardAssistantTurn(assistantMessage: AssistantMessage): void;
+    /**
+     * Retry an empty, reason-less provider abort: a turn with no content that
+     * carries the generic sentinel (bare `abort()`), whether the provider
+     * finalized it as `stopReason: "aborted"` or leaked it as `stopReason:
+     * "error"` (a stalled/dropped stream reported as an error rather than an
+     * abort — issue #5375). Only fires while the session is neither aborting nor
+     * tearing down. A user/lifecycle abort (`#abortInProgress`), a dispose-driven
+     * abort (`#isDisposed`), or a session-induced streaming-edit guard abort
+     * (`StreamingEditGuard.abortTriggered` — auto-generated-file guard or failed-patch
+     * preview) is deliberate and MUST settle the turn instead: routing it through
+     * retry would orphan `#retryPromise` on a continuation the guard skips
+     * (hanging the in-flight `prompt()`) or silently undo the guard's intended
+     * abort. Deliberate user interrupts (`UserInterrupt`) and silent aborts carry
+     * their own marker, not the generic sentinel, so they never match here.
+     */
+    isRetryableReasonlessAbort(message: AssistantMessage): boolean;
+    /**
+     * Check if an error is retryable (transient errors or usage limits).
+     * Context overflow is NOT retryable (handled by compaction instead).
+     * Usage-limit errors are retryable because the retry handler performs credential switching.
+     */
+    isRetryableError(message: AssistantMessage): boolean;
+    /**
+     * Resume a stalled turn after every emitted tool call has produced a result.
+     * Cursor calls must also carry the server-execution marker. The failed
+     * assistant/tool-result pair stays in context so completed side effects are
+     * continued from rather than replayed.
+     */
+    canResumeResolvedStreamStall(message: AssistantMessage): boolean;
+    /** Checks whether a provider error represents a classifier refusal. */
+    isClassifierRefusal(message: AssistantMessage): boolean;
+    /** Clears fallback ownership after an explicit model change. */
+    clearActiveRetryFallback(): void;
+    /** Checks whether a fallback selector remains in cooldown. */
+    isRetryFallbackSelectorSuppressed(selector: RetryFallbackSelector): boolean;
+    /** Records the cooldown that should suppress a failing selector. */
+    noteRetryFallbackCooldown(currentSelector: string, retryAfterMs: number | undefined, errorMessage: string): void;
+    /**
+     * Map the failing model selector to the chain key that owns it, by
+     * specificity: an exact model-selector key, then a `provider/*` wildcard,
+     * then a model role whose current assignment matches, then `default`.
+     * Model-oriented keys win over roles so a chain follows the model across
+     * role reassignments.
+     */
+    resolveRetryFallbackRole(currentSelector: string, currentModel?: Model | null | undefined): string | undefined;
+    /** Finds fallback candidates that follow the active selector. */
+    findRetryFallbackCandidates(role: string, currentSelector: string, currentModel?: Model | null | undefined): RetryFallbackSelector[];
+    applyRetryFallbackCandidate(role: string, selector: RetryFallbackSelector, currentSelector: string, options?: {
+        pinFallback?: boolean;
+        apiKey?: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * True when the current turn failed on a Fireworks Fast (`-fast`) model in a
+     * way that should degrade to the reliable base (Standard) model. Fast is a
+     * speed-optimized router with no SLA, so any *pre-content* failure — a
+     * transient overload/5xx or a hard "router/model not found / unsupported" —
+     * is worth retrying on the base id. Skips failures the base model shares:
+     * context overflow (compaction's job), usage limits and auth errors (same
+     * account/key), and turns that already emitted a tool call (replaying would
+     * duplicate work). Requires the base model to exist in the registry.
+     */
+    isFireworksFastFallbackEligible(message: AssistantMessage): boolean;
+    /**
+     * True when a turn failed with a hard (non-retryable) provider error but a
+     * configured `retry.fallbackChains` entry covers the active model: the same
+     * model is not worth retrying, yet a DIFFERENT model is a fresh chance, so
+     * the chain is consulted before the error becomes final. Skips failures a
+     * model switch cannot fix or must not replay: cancellations (abort-flavored
+     * errors are not model faults), context overflow (compaction's job),
+     * classifier refusals (chain consult is handled on the retryable path with
+     * `pinFallback`), and turns that already emitted a tool call (replaying
+     * could duplicate work).
+     */
+    isHardErrorFallbackEligible(message: AssistantMessage): boolean;
+    /**
+     * Cancel in-progress retry.
+     */
+    abortRetry(): void;
+    /** Whether auto-retry is currently in progress */
+    get isRetrying(): boolean;
+    /** Whether auto-retry is enabled */
+    get autoRetryEnabled(): boolean;
+    /**
+     * Toggle auto-retry setting.
+     */
+    setAutoRetryEnabled(enabled: boolean): void;
+    /**
+     * Manually retry the last failed assistant turn.
+     * Removes the error message from active agent state when present and
+     * re-attempts with a fresh retry budget.
+     *
+     * A stream that stalls or aborts mid-tool-call ends the turn with
+     * `stopReason: "error" | "aborted"` and then appends one synthetic
+     * {@link isSyntheticToolResultMessage tool_result} per emitted tool call to
+     * preserve the provider's tool_use/tool_result pairing (see
+     * `createAbortedToolResult` in `agent-loop.ts`). Those placeholders trail the
+     * failed assistant turn, so the retry lookback walks back over them before
+     * checking the assistant message; it strips both the placeholders and the
+     * failed turn before re-attempting.
+     *
+     * A restored session deliberately omits failed assistant turns from provider
+     * context. In that case, the persisted display transcript remains the source
+     * of truth for whether the current branch has a retryable failed tail.
+     *
+     * @returns true if retry was initiated, false if no failed turn to retry or agent is busy
+     */
+    retry(): Promise<boolean>;
+}

package/dist/types/slash-commands/helpers/session-pin.d.ts

@@ -0,0 +1,9 @@
+import type { OAuthAccountSummary } from "../../session/auth-storage.js";
+/** Stored OAuth account rendered and matched by `/session pin`. */
+export interface SessionPinAccount extends OAuthAccountSummary {
+    label: string;
+}
+/** Add stable user-facing labels to provider account summaries. */
+export declare function toSessionPinAccounts(accounts: readonly OAuthAccountSummary[]): SessionPinAccount[];
+/** Match a `/session pin` selector by 1-based position or exact account identity. */
+export declare function matchSessionPinAccounts(accounts: readonly SessionPinAccount[], selector: string): SessionPinAccount[];

package/dist/types/stt/index.d.ts

@@ -4,5 +4,3 @@ export * from "./downloader.js";
 export * from "./models.js";
 export * from "./stt-controller.js";
 export * from "./submit-trigger.js";
-export * from "./transcriber.js";
-export * from "./wav.js";

package/dist/types/stt/stt-controller.d.ts

@@ -15,8 +15,15 @@ interface Editor {
     submit(): void;
     deleteBeforeCursor(count: number): void;
 }
+interface CaptureHandle {
+    stop(): void;
+}
+type CaptureFactory = (onAudio: (error: Error | null, samples: Float32Array) => void) => CaptureHandle;
+/** Coordinates native microphone capture with incremental local transcription. */
 export declare class STTController {
     #private;
+    /** Creates a controller; tests may replace the hardware capture boundary. */
+    constructor(createCapture?: CaptureFactory);
     get state(): SttState;
     toggle(editor: Editor, options: ToggleOptions): Promise<void>;
     dispose(): void;

package/dist/types/system-prompt.d.ts

@@ -72,6 +72,8 @@ export interface BuildSystemPromptOptions {
     skillsSettings?: SkillsSettings;
     /** Working directory. Default: getProjectDir() */
     cwd?: string;
+    /** Additional workspace directories beyond cwd (multi-root), absolute. Injected into the project prompt. */
+    additionalWorkspaceRoots?: string[];
     /** Pre-loaded context files (skips discovery if provided). */
     contextFiles?: Array<{
         path: string;

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

@@ -17,6 +17,7 @@ import type { HindsightSessionState } from "../hindsight/state.js";
 import type { LocalProtocolOptions } from "../internal-urls/index.js";
 import type { MCPManager } from "../mcp/manager.js";
 import type { MnemopiSessionState } from "../mnemopi/state.js";
+import { type AgentReviver } from "../registry/agent-lifecycle.js";
 import type { AgentSession } from "../session/agent-session.js";
 import type { ArtifactManager } from "../session/artifacts.js";
 import type { AuthStorage } from "../session/auth-storage.js";
@@ -44,6 +45,8 @@ export declare function buildBudgetNotice(requests: number, budget: number): str
 /** Options for subagent execution */
 export interface ExecutorOptions {
     cwd: string;
+    /** Additional workspace directories to seed on the subagent session (multi-root). */
+    additionalDirectories?: string[];
     worktree?: string;
     agent: AgentDefinition;
     task: string;
@@ -249,7 +252,7 @@ export declare function finalizeSubagentLifecycle(args: {
     keepAlive: boolean;
     isolated: boolean;
     agentIdleTtlMs: number;
-    reviveSession: (() => Promise<AgentSession>) | null;
+    reviveSession: AgentReviver | null;
 }): Promise<void>;
 /** Options for {@link runSubagentFollowUpTurn}. */
 export interface FollowUpTurnOptions {

package/dist/types/task/output-manager.d.ts

@@ -3,13 +3,15 @@
  *
  * The first allocation of a given name keeps the name as-is; subsequent
  * allocations of the same name get a `-2`, `-3`, … suffix. On resume, scans
- * existing output files so previously written outputs are never overwritten.
+ * existing output and child-session files so prior state is never overwritten.
  */
 export declare class AgentOutputManager {
     #private;
     constructor(getArtifactsDir: () => string | null, options?: {
         parentPrefix?: string;
     });
+    /** Reserve final IDs discovered outside the output directory scan. */
+    reserve(ids: Iterable<string>): Promise<void>;
     /**
      * Allocate a unique ID.
      *

package/dist/types/tiny/title-client.d.ts

@@ -50,6 +50,16 @@ export declare class TinyTitleClient {
     #private;
     constructor(spawnWorker?: () => RefCountedWorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>);
     onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void;
+    /**
+     * Spawn the tiny-model worker ahead of first use without loading any model.
+     * Called from idle TUI startup so the first {@link generate} reuses a live,
+     * unref'd subprocess instead of paying subprocess-spawn latency on the submit
+     * hot path (issue #6462). No-ops for online / non-local keys and for models
+     * already marked failed. A no-op `ping` round-trips the transport to fault in
+     * the worker's module graph; no pending request is registered, so
+     * {@link #syncWorkerRef} leaves the worker unref'd and idle sessions still exit.
+     */
+    prewarm(modelKey: string): void;
     generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
     generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;
     complete(modelKey: string, prompt: string, options?: {

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

@@ -16,6 +16,7 @@ export interface ResolvedApproval {
     tier: ToolTier;
     reason?: string;
     override: boolean;
+    source?: "tool" | "user" | "mode";
 }
 /**
  * Evaluate a tool's own approval declaration against `args` and return the

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

@@ -14,6 +14,7 @@ export declare const BROWSER_PROTOCOL_TIMEOUT_MS = 60000;
 export declare function loadPuppeteer(): Promise<typeof Puppeteer>;
 export declare function loadPuppeteerInWorker(safeDir: string): Promise<typeof Puppeteer>;
 export declare function ensureChromiumExecutable(): Promise<string | undefined>;
+/** Options shared by headless Chromium consumers. */
 export interface LaunchHeadlessOptions {
     headless: boolean;
     viewport?: {
@@ -21,6 +22,10 @@ export interface LaunchHeadlessOptions {
         height: number;
         deviceScaleFactor?: number;
     };
+    /** Additional Chromium arguments merged with the centralized launch defaults. */
+    args?: readonly string[];
+    /** Additional exact Puppeteer default arguments to suppress. */
+    ignoreDefaultArgs?: readonly string[];
 }
 export declare function launchHeadlessBrowser(opts: LaunchHeadlessOptions): Promise<Browser>;
 export declare function applyViewport(page: Page, viewport?: {

package/dist/types/tools/builtin-names.d.ts

@@ -1,4 +1,4 @@
-export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "github", "glob", "grep", "lsp", "inspect_image", "browser", "checkpoint", "rewind", "task", "hub", "todo", "web_search", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
+export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_grep", "ast_edit", "ask", "debug", "eval", "github", "glob", "grep", "lsp", "inspect_image", "browser", "computer", "checkpoint", "rewind", "task", "hub", "todo", "web_search", "write", "memory_edit", "retain", "recall", "reflect", "learn", "manage_skill"];
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 /** Hidden built-ins: constructible and `--tools`-addressable, but never part of the default active set. */
 export declare const HIDDEN_TOOL_NAMES: readonly ["yield", "goal"];

package/dist/types/tools/computer/protocol.d.ts

@@ -0,0 +1,43 @@
+import type { DesktopAction, DesktopCapabilities, DesktopCapture, DesktopSessionOptions } from "@oh-my-pi/pi-natives";
+export declare const COMPUTER_WORKER_ARG = "__omp_worker_computer";
+export type ComputerWorkerInbound = {
+    type: "ping";
+    id: string;
+} | {
+    type: "init";
+    options: DesktopSessionOptions;
+} | {
+    type: "execute";
+    id: string;
+    actions: DesktopAction[];
+} | {
+    type: "close";
+};
+export type ComputerWorkerOutbound = {
+    type: "pong";
+    id: string;
+} | {
+    type: "ready";
+    capabilities: DesktopCapabilities;
+} | {
+    type: "result";
+    id: string;
+    capture: DesktopCapture;
+    capabilities: DesktopCapabilities;
+} | {
+    type: "error";
+    id?: string;
+    error: ComputerWorkerError;
+} | {
+    type: "closed";
+};
+export interface ComputerWorkerError {
+    name: string;
+    message: string;
+    stack?: string;
+}
+export interface ComputerWorkerTransport {
+    send(message: ComputerWorkerOutbound, transfer?: Bun.Transferable[]): void;
+    onMessage(handler: (message: ComputerWorkerInbound) => void): () => void;
+    close(): void;
+}

package/dist/types/tools/computer/supervisor.d.ts

@@ -0,0 +1,32 @@
+import type { DesktopAction, DesktopCapabilities, DesktopCapture, DesktopSessionOptions } from "@oh-my-pi/pi-natives";
+import { type ComputerWorkerInbound, type ComputerWorkerOutbound } from "./protocol.js";
+export interface ComputerController {
+    readonly capabilities: DesktopCapabilities | undefined;
+    execute(actions: DesktopAction[], signal?: AbortSignal): Promise<DesktopCapture>;
+    close(): Promise<void>;
+}
+export interface ComputerWorkerHandle {
+    send(message: ComputerWorkerInbound): void;
+    onMessage(handler: (message: ComputerWorkerOutbound) => void): () => void;
+    onError(handler: (error: Error) => void): () => void;
+    terminate(): Promise<void>;
+}
+export interface ComputerSupervisorTimeouts {
+    startMs: number;
+    closeMs: number;
+}
+export type ComputerWorkerFactory = () => ComputerWorkerHandle;
+export declare function spawnComputerWorker(): ComputerWorkerHandle;
+export declare class ComputerSupervisor implements ComputerController {
+    #private;
+    private readonly options;
+    private readonly createWorker;
+    private readonly timeouts;
+    constructor(options: DesktopSessionOptions, createWorker?: ComputerWorkerFactory, timeouts?: ComputerSupervisorTimeouts);
+    get capabilities(): DesktopCapabilities | undefined;
+    execute(actions: DesktopAction[], signal?: AbortSignal): Promise<DesktopCapture>;
+    close(): Promise<void>;
+}
+export declare function registerComputerController(ownerId: string | undefined, controller: ComputerController): () => void;
+export declare function releaseComputerSessionsForOwner(ownerId: string | undefined): Promise<void>;
+export declare function smokeTestComputerWorker(timeoutMs?: number): Promise<void>;

package/dist/types/tools/computer/worker-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tools/computer/worker.d.ts

@@ -0,0 +1,15 @@
+import { type DesktopAction, type DesktopCapture, DesktopSession, type DesktopSessionOptions } from "@oh-my-pi/pi-natives";
+import type { ComputerWorkerTransport } from "./protocol.js";
+export interface NativeDesktopSession {
+    readonly capabilities: DesktopSession["capabilities"];
+    capture(): Promise<DesktopCapture>;
+    execute(actions: DesktopAction[]): Promise<DesktopCapture>;
+    close(): Promise<void>;
+}
+export type NativeDesktopSessionFactory = (options: DesktopSessionOptions) => NativeDesktopSession;
+export declare class ComputerWorkerCore {
+    #private;
+    private readonly transport;
+    private readonly createSession;
+    constructor(transport: ComputerWorkerTransport, createSession?: NativeDesktopSessionFactory);
+}

package/dist/types/tools/computer-renderer.d.ts

@@ -0,0 +1,22 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
+import type { Theme } from "../modes/theme/theme.js";
+interface ComputerRenderArgs {
+    actions?: Array<{
+        type?: unknown;
+    }>;
+}
+interface ComputerRenderResult {
+    content: Array<{
+        type: string;
+        text?: string;
+    }>;
+    details?: unknown;
+    isError?: boolean;
+}
+export declare const computerToolRenderer: {
+    mergeCallAndResult: boolean;
+    renderCall(args: ComputerRenderArgs, _options: RenderResultOptions, theme: Theme): Component;
+    renderResult(result: ComputerRenderResult, options: RenderResultOptions, theme: Theme, args?: ComputerRenderArgs): Component;
+};
+export {};

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

@@ -0,0 +1,71 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
+import type { ComputerAction } from "@oh-my-pi/pi-ai";
+import type { DesktopCapabilities, DesktopCapture, DesktopDisplay, DesktopSessionOptions } from "@oh-my-pi/pi-natives";
+import { type ComputerController } from "./computer/supervisor.js";
+import type { ToolSession } from "./index.js";
+declare const computerSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    actions?: {
+        type: "click" | "double_click" | "drag" | "keypress" | "move" | "screenshot" | "scroll" | "type" | "wait";
+        x?: number | undefined;
+        y?: number | undefined;
+        button?: "back" | "forward" | "left" | "right" | "wheel" | undefined;
+        path?: {
+            x: number;
+            y: number;
+        }[] | undefined;
+        keys?: string[] | null | undefined;
+        scroll_x?: number | undefined;
+        scroll_y?: number | undefined;
+        text?: string | undefined;
+    }[] | undefined;
+}, {}>;
+export type ComputerParams = typeof computerSchema.infer;
+export interface ComputerToolDetails {
+    width: number;
+    height: number;
+    backend: DesktopCapture["backend"];
+    displayServer?: string;
+    capturePermission: string;
+    inputPermission: string;
+    displays: DesktopDisplay[];
+    capabilities?: DesktopCapabilities;
+    actions: ComputerAction["type"][];
+}
+export type ComputerControllerFactory = (options: DesktopSessionOptions) => ComputerController;
+export declare function computerApproval(args: unknown): ToolApprovalDecision;
+export declare class ComputerTool implements AgentTool<typeof computerSchema, ComputerToolDetails> {
+    #private;
+    readonly session: ToolSession;
+    readonly name = "computer";
+    readonly native: {
+        readonly type: "computer";
+    };
+    readonly label = "Computer";
+    readonly loadMode: "essential";
+    readonly concurrency: "exclusive";
+    readonly summary = "Capture and control the host desktop through native OS APIs";
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        actions?: {
+            type: "click" | "double_click" | "drag" | "keypress" | "move" | "screenshot" | "scroll" | "type" | "wait";
+            x?: number | undefined;
+            y?: number | undefined;
+            button?: "back" | "forward" | "left" | "right" | "wheel" | undefined;
+            path?: {
+                x: number;
+                y: number;
+            }[] | undefined;
+            keys?: string[] | null | undefined;
+            scroll_x?: number | undefined;
+            scroll_y?: number | undefined;
+            text?: string | undefined;
+        }[] | undefined;
+    }, {}>;
+    readonly strict = false;
+    readonly approval: typeof computerApproval;
+    readonly formatApprovalDetails: (args: unknown) => string[];
+    constructor(session: ToolSession, createController?: ComputerControllerFactory);
+    get description(): string;
+    execute(_toolCallId: string, params: ComputerParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<ComputerToolDetails>, context?: AgentToolContext): Promise<AgentToolResult<ComputerToolDetails>>;
+    close(): Promise<void>;
+}
+export {};

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

@@ -12,6 +12,8 @@ declare module "@oh-my-pi/pi-agent-core" {
          *  wrapper must not re-prompt for the same action (explicit per-tool
          *  policies and overrides still apply). */
         xdevApproved?: boolean;
+        /** Set only after an interactive prompt approves provider computer safety checks. */
+        providerSafetyApproved?: boolean;
     }
 }
 export declare class ToolContextStore {

package/dist/types/tools/default-renderer.d.ts

@@ -0,0 +1,21 @@
+import type { Component } from "@oh-my-pi/pi-tui";
+import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
+import type { Theme } from "../modes/theme/theme.js";
+/** Inputs rendered by the fallback card used when a tool has no bespoke renderer. */
+export interface DefaultToolRenderInput {
+    /** Human-readable tool label. */
+    label: string;
+    /** Tool arguments, shown inline when collapsed and as a tree when expanded. */
+    args: unknown;
+    /** Settled or streaming result; omitted while only the call is available. */
+    result?: {
+        output: string;
+        isError?: boolean;
+    };
+    /** Current expansion and lifecycle state. */
+    options: RenderResultOptions;
+}
+/** Format one generic tool call/result card at the available content width. */
+export declare function formatDefaultToolExecution(input: DefaultToolRenderInput, contentWidth: number, uiTheme: Theme): string;
+/** Render the generic fallback as the state-tinted card used by direct custom tools. */
+export declare function renderDefaultToolExecution(input: DefaultToolRenderInput, uiTheme: Theme): Component;

package/dist/types/tools/image-gen.d.ts

@@ -1,7 +1,8 @@
 import { type Model } from "@oh-my-pi/pi-ai";
 import { type ModelRegistry } from "../config/model-registry.js";
 import type { CustomTool } from "../extensibility/custom-tools/types.js";
-export type ImageProvider = "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter" | "xai";
+import { type ImageProvider } from "./image-providers.js";
+export type { ImageProvider } from "./image-providers.js";
 export type ImageProviderPreference = ImageProvider | "auto";
 declare const responseModalitySchema: import("arktype/internal/variants/string.ts").StringType<"IMAGE" | "TEXT", {}>;
 export declare const imageGenSchema: import("arktype/internal/variants/object.ts").ObjectType<{
@@ -59,9 +60,8 @@ interface InlineImageData {
     mimeType: string;
 }
 export declare function isImageProviderPreference(value: unknown): value is ImageProviderPreference;
-/** Set the preferred image provider from settings */
-export declare function setPreferredImageProvider(provider: ImageProviderPreference): void;
+/** Set the configured image-provider priority from settings; invalid IDs are dropped. */
+export declare function setImageProviderOrder(providers: readonly string[]): void;
 export declare const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails>;
 export declare function getImageGenTools(_modelRegistry?: ModelRegistry, _activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
 export declare function getImageGenToolsWithRegistry(_modelRegistry: ModelRegistry, _activeModel?: Model): Promise<Array<CustomTool<typeof imageGenSchema, ImageGenToolDetails>>>;
-export {};