@oh-my-pi/pi-coding-agent 16.0.5 → 16.0.6

package/dist/types/modes/components/btw-panel.d.ts

@@ -11,6 +11,7 @@ export declare class BtwPanelComponent extends Container {
     markComplete(): void;
     markAborted(): void;
     markError(message: string): void;
+    isBranchable(): boolean;
     close(): void;
 }
 export {};

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,6 +1,6 @@
 import { Editor, type KeyId } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings";
-type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
+type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.retry" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
 /** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
  *  deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
 export declare const SPACE_REPEAT_MAX_GAP_MS = 120;
@@ -79,6 +79,8 @@ export declare class CustomEditor extends Editor {
     onPasteTextRaw?: () => void;
     /** Called when the configured dequeue shortcut is pressed. */
     onDequeue?: () => void;
+    /** Called when the configured retry shortcut is pressed. */
+    onRetry?: () => void;
     /** Called when Caps Lock is pressed. */
     onCapsLock?: () => void;
     /** Called when left-arrow is pressed while the editor is empty (cursor necessarily at start). */

package/dist/types/modes/controllers/btw-controller.d.ts

@@ -4,6 +4,8 @@ export declare class BtwController {
     private readonly ctx;
     constructor(ctx: InteractiveModeContext);
     hasActiveRequest(): boolean;
+    canBranch(): boolean;
+    handleBranch(): Promise<boolean>;
     handleEscape(): boolean;
     dispose(): void;
     start(question: string): Promise<void>;

package/dist/types/modes/controllers/input-controller.d.ts

@@ -18,6 +18,7 @@ export declare class InputController {
     handleCtrlD(): void;
     handleCtrlZ(): void;
     handleDequeue(): void;
+    handleRetry(): Promise<void>;
     /** Send editor text as a follow-up message (queued behind current stream). */
     handleFollowUp(): Promise<void>;
     restoreQueuedMessagesToEditor(options?: {

package/dist/types/modes/interactive-mode.d.ts

@@ -330,6 +330,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleTanCommand(work: string): Promise<void>;
     hasActiveBtw(): boolean;
     handleBtwEscape(): boolean;
+    canBranchBtw(): boolean;
+    handleBtwBranchKey(): Promise<boolean>;
+    handleBtwBranch(question: string, assistantMessage: AssistantMessage): Promise<void>;
     handleOmfgCommand(complaint: string): Promise<void>;
     hasActiveOmfg(): boolean;
     handleOmfgEscape(): boolean;

package/dist/types/modes/setup-wizard/index.d.ts

@@ -3,6 +3,7 @@ import { CURRENT_SETUP_VERSION } from "../setup-version";
 import type { InteractiveModeContext } from "../types";
 import type { SetupScene } from "./scenes/types";
 export type { SetupScene, SetupSceneController, SetupSceneHost, SetupSceneResult } from "./scenes/types";
+export { runStartupSplash } from "./startup-splash";
 export { CURRENT_SETUP_VERSION };
 export declare const ALL_SCENES: readonly [SetupScene, SetupScene, SetupScene];
 export interface SetupSceneSelectionOptions {

package/dist/types/modes/setup-wizard/startup-splash.d.ts

@@ -0,0 +1,7 @@
+import type { InteractiveModeContext } from "../types";
+export interface RunStartupSplashOptions {
+    readonly durationMs?: number;
+    readonly tickMs?: number;
+    readonly now?: () => number;
+}
+export declare function runStartupSplash(ctx: InteractiveModeContext, options?: RunStartupSplashOptions): Promise<void>;

package/dist/types/modes/theme/theme.d.ts

@@ -290,7 +290,7 @@ export declare function setColorBlindMode(enabled: boolean): Promise<void>;
  * Get the current color blind mode setting.
  */
 export declare function getColorBlindMode(): boolean;
-export declare function onThemeChange(callback: () => void): void;
+export declare function onThemeChange(callback: () => void): () => void;
 /**
  * Monotonic counter bumped on any theme-affecting change that should invalidate
  * cached renders: theme swaps and reloads (including the invalid-theme dark

package/dist/types/modes/types.d.ts

@@ -316,6 +316,9 @@ export interface InteractiveModeContext {
     handleTanCommand(work: string): Promise<void>;
     hasActiveBtw(): boolean;
     handleBtwEscape(): boolean;
+    handleBtwBranchKey(): Promise<boolean>;
+    canBranchBtw(): boolean;
+    handleBtwBranch(question: string, assistantMessage: AssistantMessage): Promise<void>;
     handleOmfgCommand(complaint: string): Promise<void>;
     hasActiveOmfg(): boolean;
     handleOmfgEscape(): boolean;

package/dist/types/sdk.d.ts

@@ -162,6 +162,11 @@ export interface CreateAgentSessionOptions {
     localProtocolOptions?: LocalProtocolOptions;
     /** Settings instance. Default: Settings.init({ cwd, agentDir }) */
     settings?: Settings;
+    /**
+     * Legacy alias for `settings`. Older Pi extensions pass SettingsManager.create(...)
+     * through this field; accept it so their SDK calls keep the configured settings.
+     */
+    settingsManager?: Settings | Promise<Settings>;
     /** Whether UI is available (enables interactive tools like ask). Default: false */
     hasUI?: boolean;
     /**

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

@@ -1076,6 +1076,10 @@ export declare class AgentSession {
         selectedText: string;
         cancelled: boolean;
     }>;
+    branchFromBtw(question: string, assistantMessage: AssistantMessage): Promise<{
+        cancelled: boolean;
+        sessionFile: string | undefined;
+    }>;
     /**
      * Navigate to a different node in the session tree.
      * Unlike branch() which creates a new session file, this stays in the same file.

package/dist/types/startup-splash.d.ts

@@ -0,0 +1,12 @@
+/** Inputs used to decide whether the optional startup splash may run for this process. */
+export interface StartupSplashDecisionOptions {
+    readonly configured: boolean;
+    readonly isInteractive: boolean;
+    readonly resuming: boolean;
+    readonly quiet: boolean;
+    readonly timing: boolean;
+    readonly stdinIsTTY: boolean | undefined;
+    readonly stdoutIsTTY: boolean | undefined;
+}
+/** Returns true only for explicitly enabled, normal interactive TTY startup. */
+export declare function shouldShowStartupSplash(options: StartupSplashDecisionOptions): boolean;

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

@@ -1,6 +1,5 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
-import { z } from "zod/v4";
 import type { AgentSessionEvent } from "../session/agent-session";
 import type { NestedRepoPatch } from "./worktree";
 /** Source of an agent definition */
@@ -55,12 +54,12 @@ export interface SubagentLifecyclePayload {
 export declare const ROLE_LABEL_MAX = 80;
 /** Schema bound on the raw `role` input, before it is label-normalized at every use site. */
 export declare const ROLE_INPUT_MAX = 256;
-export declare const taskItemSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodString>;
-    assignment: z.ZodString;
-}, z.core.$strip>;
+export declare const taskItemSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    id?: string | undefined;
+    description?: string | undefined;
+    role?: string | undefined;
+    assignment: string;
+}, {}>;
 /** Single task item. Fields are optional defensively: args stream in token by token. */
 export interface TaskItem {
     /** Stable agent id; default = generated AdjectiveNoun. */
@@ -74,47 +73,47 @@ export interface TaskItem {
     /** Run this spawn in an isolated worktree (batch form; flat form carries it top-level). */
     isolated?: boolean;
 }
-export declare const taskSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodString>;
-    assignment: z.ZodString;
-    isolated: z.ZodOptional<z.ZodBoolean>;
-    agent: z.ZodString;
-}, z.core.$strip>;
-declare const ALL_TASK_SCHEMAS: readonly [z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodString>;
-    assignment: z.ZodString;
-    isolated: z.ZodOptional<z.ZodBoolean>;
-    agent: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodString>;
-    assignment: z.ZodString;
-    agent: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    context: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        role: z.ZodOptional<z.ZodString>;
-        assignment: z.ZodString;
-        isolated: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    agent: z.ZodString;
-    context: z.ZodString;
-    tasks: z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        role: z.ZodOptional<z.ZodString>;
-        assignment: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>];
+export declare const taskSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    id?: string | undefined;
+    description?: string | undefined;
+    role?: string | undefined;
+    assignment: string;
+    isolated?: boolean | undefined;
+}, {}>;
+declare const ALL_TASK_SCHEMAS: readonly [import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    id?: string | undefined;
+    description?: string | undefined;
+    role?: string | undefined;
+    assignment: string;
+    isolated?: boolean | undefined;
+}, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    id?: string | undefined;
+    description?: string | undefined;
+    role?: string | undefined;
+    assignment: string;
+}, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    context: string;
+    tasks: {
+        id?: string | undefined;
+        description?: string | undefined;
+        role?: string | undefined;
+        assignment: string;
+        isolated?: boolean | undefined;
+    }[];
+}, {}>, import("arktype/internal/variants/object.ts").ObjectType<{
+    agent: string;
+    context: string;
+    tasks: {
+        id?: string | undefined;
+        description?: string | undefined;
+        role?: string | undefined;
+        assignment: string;
+    }[];
+}, {}>];
 type DynamicTaskSchema = (typeof ALL_TASK_SCHEMAS)[number];
 export type TaskSchema = typeof taskSchema;
 /** Active task tool parameter schema for the current isolation / batch flags */

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

@@ -17,23 +17,22 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample } from "@oh-my-pi/pi-ai";
 import { type Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
-declare const askSchema: z.ZodObject<{
-    questions: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        question: z.ZodString;
-        options: z.ZodArray<z.ZodObject<{
-            label: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        multi: z.ZodOptional<z.ZodBoolean>;
-        recommended: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type AskToolInput = z.infer<typeof askSchema>;
+declare const askSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    questions: {
+        id: string;
+        question: string;
+        options: {
+            label: string;
+            description?: string | undefined;
+        }[];
+        multi?: boolean | undefined;
+        recommended?: number | undefined;
+    }[];
+}, {}>;
+export type AskToolInput = typeof askSchema.infer;
 /** Result for a single question */
 export interface QuestionResult {
     id: string;
@@ -71,20 +70,20 @@ export declare class AskTool implements AgentTool<typeof askSchema, AskToolDetai
     readonly label = "Ask";
     readonly summary = "Ask the user a clarifying question";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        questions: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            question: z.ZodString;
-            options: z.ZodArray<z.ZodObject<{
-                label: z.ZodString;
-                description: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            multi: z.ZodOptional<z.ZodBoolean>;
-            recommended: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        questions: {
+            id: string;
+            question: string;
+            options: {
+                label: string;
+                description?: string | undefined;
+            }[];
+            multi?: boolean | undefined;
+            recommended?: number | undefined;
+        }[];
+    }, {}>;
     readonly strict = true;
-    readonly examples: readonly ToolExample<z.input<typeof askSchema>>[];
+    readonly examples: readonly ToolExample<typeof askSchema.infer>[];
     readonly concurrency = "exclusive";
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);

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

@@ -1,18 +1,17 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
-declare const astEditSchema: z.ZodObject<{
-    ops: z.ZodArray<z.ZodObject<{
-        pat: z.ZodString;
-        out: z.ZodString;
-    }, z.core.$strip>>;
-    paths: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
+declare const astEditSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    ops: {
+        pat: string;
+        out: string;
+    }[];
+    paths: string[];
+}, {}>;
 export interface AstEditToolDetails {
     totalReplacements: number;
     filesTouched: number;
@@ -39,6 +38,7 @@ export interface AstEditToolDetails {
      * renderer resolves them against this; `searchPath` is the scope target. */
     cwd?: string;
 }
+type AstEditSchemaInfer = typeof astEditSchema.infer;
 export declare class AstEditTool implements AgentTool<typeof astEditSchema, AstEditToolDetails> {
     private readonly session;
     readonly name = "ast_edit";
@@ -47,19 +47,19 @@ export declare class AstEditTool implements AgentTool<typeof astEditSchema, AstE
     readonly label = "AST Edit";
     readonly summary = "Perform AST-aware code edits (structural refactoring)";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        ops: z.ZodArray<z.ZodObject<{
-            pat: z.ZodString;
-            out: z.ZodString;
-        }, z.core.$strip>>;
-        paths: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        ops: {
+            pat: string;
+            out: string;
+        }[];
+        paths: string[];
+    }, {}>;
     readonly strict = true;
-    readonly examples: readonly ToolExample<z.input<typeof astEditSchema>>[];
+    readonly examples: readonly ToolExample<AstEditSchemaInfer>[];
     readonly deferrable = true;
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
-    execute(_toolCallId: string, params: z.infer<typeof astEditSchema>, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstEditToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstEditToolDetails>>;
+    execute(_toolCallId: string, params: AstEditSchemaInfer, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstEditToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstEditToolDetails>>;
 }
 interface AstEditRenderArgs {
     ops?: Array<{

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

@@ -1,16 +1,15 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
-declare const astGrepSchema: z.ZodObject<{
-    pat: z.ZodString;
-    paths: z.ZodArray<z.ZodString>;
-    skip: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-}, z.core.$strip>;
+declare const astGrepSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    pat: string;
+    paths: string[];
+    skip?: number | undefined;
+}, {}>;
 export interface AstGrepToolDetails {
     matchCount: number;
     fileCount: number;
@@ -43,16 +42,16 @@ export declare class AstGrepTool implements AgentTool<typeof astGrepSchema, AstG
     readonly label = "AST Grep";
     readonly summary = "Search code with AST patterns (structural grep)";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        pat: z.ZodString;
-        paths: z.ZodArray<z.ZodString>;
-        skip: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        pat: string;
+        paths: string[];
+        skip?: number | undefined;
+    }, {}>;
     readonly strict = true;
-    readonly examples: readonly ToolExample<z.input<typeof astGrepSchema>>[];
+    readonly examples: readonly ToolExample<typeof astGrepSchema.inferIn>[];
     readonly loadMode = "discoverable";
     constructor(session: ToolSession);
-    execute(_toolCallId: string, params: z.infer<typeof astGrepSchema>, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstGrepToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstGrepToolDetails>>;
+    execute(_toolCallId: string, params: typeof astGrepSchema.infer, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<AstGrepToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<AstGrepToolDetails>>;
 }
 interface AstGrepRenderArgs {
     pat?: string;

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

@@ -1,6 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { type Theme } from "../modes/theme/theme";
 import type { ToolSession } from ".";
@@ -14,21 +13,25 @@ export declare const BASH_DEFAULT_PREVIEW_LINES = 10;
  * New patterns should target shapes that are virtually never legitimate in automation.
  */
 export declare const CRITICAL_BASH_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
-declare const bashSchemaBase: z.ZodObject<{
-    command: z.ZodString;
-    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    cwd: z.ZodOptional<z.ZodString>;
-    pty: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-declare const bashSchemaWithAsync: z.ZodObject<{
-    command: z.ZodString;
-    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    cwd: z.ZodOptional<z.ZodString>;
-    pty: z.ZodOptional<z.ZodBoolean>;
-    async: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+declare const bashSchemaBase: import("arktype/internal/variants/object.ts").ObjectType<{
+    command: string;
+    env?: {
+        [x: string]: string;
+    } | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+    pty?: boolean | undefined;
+}, {}>;
+declare const bashSchemaWithAsync: import("arktype/internal/variants/object.ts").ObjectType<{
+    command: string;
+    env?: {
+        [x: string]: string;
+    } | undefined;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+    pty?: boolean | undefined;
+    async?: boolean | undefined;
+}, {}>;
 type BashToolSchema = typeof bashSchemaBase | typeof bashSchemaWithAsync;
 export interface BashToolInput {
     command: string;
@@ -59,7 +62,7 @@ export interface BashToolOptions {
  *
  * Executes bash commands with optional timeout and working directory.
  */
-export declare class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
+export declare class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSchemaWithAsync, BashToolDetails> {
     #private;
     private readonly session;
     readonly name = "bash";

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

@@ -1,6 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample } from "@oh-my-pi/pi-ai";
-import { z } from "zod/v4";
 import type { ToolSession } from "../sdk";
 import { type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
@@ -9,42 +8,30 @@ export { cmuxSnapshotToObservation, mapWaitUntil, resolveCmuxKind, serializeEval
 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<{
-    action: z.ZodEnum<{
-        close: "close";
-        open: "open";
-        run: "run";
-    }>;
-    name: z.ZodOptional<z.ZodString>;
-    url: z.ZodOptional<z.ZodString>;
-    app: z.ZodOptional<z.ZodObject<{
-        path: z.ZodOptional<z.ZodString>;
-        cdp_url: z.ZodOptional<z.ZodString>;
-        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        target: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    viewport: z.ZodOptional<z.ZodObject<{
-        width: z.ZodNumber;
-        height: z.ZodNumber;
-        scale: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    wait_until: z.ZodOptional<z.ZodEnum<{
-        domcontentloaded: "domcontentloaded";
-        load: "load";
-        networkidle0: "networkidle0";
-        networkidle2: "networkidle2";
-    }>>;
-    dialogs: z.ZodOptional<z.ZodEnum<{
-        accept: "accept";
-        dismiss: "dismiss";
-    }>>;
-    code: z.ZodOptional<z.ZodString>;
-    timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-    all: z.ZodOptional<z.ZodBoolean>;
-    kill: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
+declare const browserSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    action: "close" | "open" | "run";
+    name?: string | undefined;
+    url?: string | undefined;
+    app?: {
+        path?: string | undefined;
+        cdp_url?: string | undefined;
+        args?: string[] | undefined;
+        target?: string | undefined;
+    } | undefined;
+    viewport?: {
+        width: number;
+        height: number;
+        scale?: number | undefined;
+    } | undefined;
+    wait_until?: "domcontentloaded" | "load" | "networkidle0" | "networkidle2" | undefined;
+    dialogs?: "accept" | "dismiss" | undefined;
+    code?: string | undefined;
+    timeout?: number | undefined;
+    all?: boolean | undefined;
+    kill?: boolean | undefined;
+}, {}>;
 /** Input schema for the browser tool. */
-export type BrowserParams = z.infer<typeof browserSchema>;
+export type BrowserParams = typeof browserSchema.infer;
 /** Details describing a browser tool execution result (for renderers + transcript). */
 export interface BrowserToolDetails {
     action: BrowserParams["action"];
@@ -76,42 +63,30 @@ export declare class BrowserTool implements AgentTool<typeof browserSchema, Brow
     readonly label = "Browser";
     readonly loadMode = "discoverable";
     readonly summary = "Control a headless browser to navigate and interact with web pages";
-    readonly parameters: z.ZodObject<{
-        action: z.ZodEnum<{
-            close: "close";
-            open: "open";
-            run: "run";
-        }>;
-        name: z.ZodOptional<z.ZodString>;
-        url: z.ZodOptional<z.ZodString>;
-        app: z.ZodOptional<z.ZodObject<{
-            path: z.ZodOptional<z.ZodString>;
-            cdp_url: z.ZodOptional<z.ZodString>;
-            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            target: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        viewport: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            scale: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        wait_until: z.ZodOptional<z.ZodEnum<{
-            domcontentloaded: "domcontentloaded";
-            load: "load";
-            networkidle0: "networkidle0";
-            networkidle2: "networkidle2";
-        }>>;
-        dialogs: z.ZodOptional<z.ZodEnum<{
-            accept: "accept";
-            dismiss: "dismiss";
-        }>>;
-        code: z.ZodOptional<z.ZodString>;
-        timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-        all: z.ZodOptional<z.ZodBoolean>;
-        kill: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        action: "close" | "open" | "run";
+        name?: string | undefined;
+        url?: string | undefined;
+        app?: {
+            path?: string | undefined;
+            cdp_url?: string | undefined;
+            args?: string[] | undefined;
+            target?: string | undefined;
+        } | undefined;
+        viewport?: {
+            width: number;
+            height: number;
+            scale?: number | undefined;
+        } | undefined;
+        wait_until?: "domcontentloaded" | "load" | "networkidle0" | "networkidle2" | undefined;
+        dialogs?: "accept" | "dismiss" | undefined;
+        code?: string | undefined;
+        timeout?: number | undefined;
+        all?: boolean | undefined;
+        kill?: boolean | undefined;
+    }, {}>;
     readonly strict = true;
-    readonly examples: readonly ToolExample<z.input<typeof browserSchema>>[];
+    readonly examples: readonly ToolExample<typeof browserSchema.infer>[];
     constructor(session: ToolSession);
     get description(): string;
     /** Restart browser to apply mode changes (e.g. headless toggle). Drops only headless browsers. */