@allternit/computer-driver 0.1.0 → 0.2.0

package/dist/v2-generated.d.ts

@@ -0,0 +1,1445 @@
+export declare const COMPUTER_V2_MEMBER_NAMES: readonly ["screenshot", "zoom", "left_click", "right_click", "middle_click", "double_click", "triple_click", "mouse_move", "left_click_drag", "left_mouse_down", "left_mouse_up", "scroll", "type", "key", "hold_key", "wait", "cursor_position", "read_ui", "act", "run_batch", "verify", "request_human", "use_credential", "run_subtask", "run_parallel", "run_skill", "skills"];
+export type ComputerV2MemberName = (typeof COMPUTER_V2_MEMBER_NAMES)[number];
+/** The ten driver-backed structured members (read_ui … skills). */
+export declare const COMPUTER_V2_STRUCTURED_MEMBER_NAMES: readonly ["read_ui", "act", "run_batch", "verify", "request_human", "use_credential", "run_subtask", "run_parallel", "run_skill", "skills"];
+export type ComputerV2StructuredMemberName = (typeof COMPUTER_V2_STRUCTURED_MEMBER_NAMES)[number];
+/** Take a screenshot of the screen. */
+export type ComputerV2ScreenshotInput = Record<string, unknown>;
+/** Take a screenshot of a rectangular region. Region coordinates are in the full-screenshot space (not physical display pixels). The crop is scaled up to fill the image budget so fine details become legible. */
+export type ComputerV2ZoomInput = {
+    region: Array<number>;
+};
+/** Click the left mouse button at the specified (x, y) pixel coordinate, or the current cursor position if `coordinate` is omitted. */
+export type ComputerV2LeftClickInput = {
+    coordinate?: Array<number> | null;
+    text?: string | null;
+};
+/** Click the right mouse button at the specified (x, y) pixel coordinate, or the current cursor position if `coordinate` is omitted. */
+export type ComputerV2RightClickInput = {
+    coordinate?: Array<number> | null;
+    text?: string | null;
+};
+/** Click the middle mouse button at the specified (x, y) pixel coordinate, or the current cursor position if `coordinate` is omitted. */
+export type ComputerV2MiddleClickInput = {
+    coordinate?: Array<number> | null;
+    text?: string | null;
+};
+/** Double-click the left mouse button at the specified (x, y) pixel coordinate, or the current cursor position if `coordinate` is omitted. */
+export type ComputerV2DoubleClickInput = {
+    coordinate?: Array<number> | null;
+    text?: string | null;
+};
+/** Triple-click the left mouse button at the specified (x, y) pixel coordinate, or the current cursor position if `coordinate` is omitted. */
+export type ComputerV2TripleClickInput = {
+    coordinate?: Array<number> | null;
+    text?: string | null;
+};
+/** Move the cursor to a specified (x, y) pixel coordinate. Use this ONLY to hover without clicking; otherwise use a click action directly. */
+export type ComputerV2MouseMoveInput = {
+    coordinate: Array<number>;
+};
+/** Click and drag the cursor from `start_coordinate` to `coordinate`. */
+export type ComputerV2LeftClickDragInput = {
+    coordinate: Array<number>;
+    start_coordinate: Array<number>;
+    text?: string | null;
+};
+/** Press and hold the left mouse button at the current cursor position. */
+export type ComputerV2LeftMouseDownInput = Record<string, unknown>;
+/** Release the left mouse button. */
+export type ComputerV2LeftMouseUpInput = Record<string, unknown>;
+/** Scroll the screen at the specified (x, y) pixel coordinate, or the current cursor position if `coordinate` is omitted. Do NOT use PageUp/PageDown to scroll. */
+export type ComputerV2ScrollInput = {
+    scroll_amount: number;
+    scroll_direction: "up" | "down" | "left" | "right";
+    coordinate?: Array<number> | null;
+    text?: string | null;
+};
+/** Type a string of text on the keyboard. */
+export type ComputerV2TypeInput = {
+    text: string;
+};
+/** Press a key or key-combination on the keyboard. Use "+" to combine modifiers with a key (e.g. "ctrl+s", "alt+Tab", "ctrl+shift+Escape"). Key names are case-insensitive; common names like "Return", "Tab", "Escape", "Up", "Down", "Left", "Right", "Home", "End", "Page_Up", "Page_Down", "Delete", "BackSpace" are supported. */
+export type ComputerV2KeyInput = {
+    text: string;
+    repeat?: number | null;
+};
+/** Hold down a key or key-combination for a specified duration. Uses the same key syntax as `key`. */
+export type ComputerV2HoldKeyInput = {
+    duration: number;
+    text: string;
+};
+/** Wait for a specified duration. */
+export type ComputerV2WaitInput = {
+    duration: number;
+};
+/** Get the current (x, y) pixel coordinate of the cursor. */
+export type ComputerV2CursorPositionInput = Record<string, unknown>;
+/** Read the target window or app's UI as a structured element tree (roles, names, values, bounds) with NO screenshot. Returns stable element ids for act, run_batch and verify. Pass `since` (a version from an earlier read_ui) to get only the diff; `query` filters by text; `max_elements` caps the list (default 200). When the window has no usable accessibility tree (canvas apps, games, remote desktops, custom-drawn UIs) the read falls back to vision: numbered set-of-marks regions come back as elements with `source: "vision"` and a `mark` number, and act on their ids works the same way. `source` and `source_reason` say which was used. Pass `target` (a description such as 'the Export button') to ground it with the local grounder: `grounded.id` is the element to act on. */
+export type ComputerV2ReadUiInput = {
+    app?: string | null;
+    pid?: number | null;
+    window_id?: number | null;
+    query?: string | null;
+    max_elements?: number | null;
+    since?: number | null;
+    paths?: boolean | null;
+    crops?: boolean | null;
+    vision?: "auto" | "off" | "only" | null;
+    target?: string | null;
+    zoom?: "auto" | "always" | "never" | null;
+};
+/** Act on an element id from read_ui (tree ids and vision ids alike; a vision element is clicked or typed into at its centre after a pixel freshness check, and menu needs a window). op: click, set_value (clear and set the field's value), select (pick a child by name), press (a key), menu (choose a menu path such as 'File > Save'), focus. set_value/select/press on this Mac need the person's approval (the same rule as typing). */
+export type ComputerV2ActInput = {
+    id: string;
+    op: "click" | "set_value" | "select" | "press" | "menu" | "focus";
+    value?: string | null;
+    key?: string | null;
+    path?: string | Array<string> | null;
+    version?: number | null;
+    app?: string | null;
+    pid?: number | null;
+    window_id?: number | null;
+};
+/** Run ordered steps in one window in a single call: act steps ({id, op, value?, key?}), menu steps (path), pixel steps ({tool, args}) and waits (ms). Each step may carry wait_for (checked before the step) and expect (checked after); a failed check stops the batch and one observe read returns the fresh map. This is the fast path: batch several steps instead of screenshot-per-action loops. */
+export type ComputerV2RunBatchInput = {
+    app?: string | null;
+    pid?: number | null;
+    window_id?: number | null;
+    version?: number | null;
+    steps: Array<{
+        act?: {
+            id: string;
+            op: "click" | "set_value" | "select" | "press" | "menu" | "focus";
+            value?: string | null;
+            key?: string | null;
+        } | null;
+        menu?: string | Array<string> | null;
+        pixel?: {
+            tool: string;
+            args?: Record<string, unknown> | null;
+        } | null;
+        wait?: number | null;
+        wait_for?: {
+            id?: string | null;
+            role?: string | null;
+            name?: string | null;
+            text?: string | null;
+            gone?: boolean | null;
+            value?: string | null;
+            enabled?: boolean | null;
+        } | null;
+        expect?: {
+            id?: string | null;
+            role?: string | null;
+            name?: string | null;
+            text?: string | null;
+            gone?: boolean | null;
+            value?: string | null;
+            enabled?: boolean | null;
+        } | null;
+        timeout_ms?: number | null;
+    }>;
+};
+/** Check bounded conditions on the current UI without acting: role, name, text, gone, value, enabled. Each check is {id?, role?, name?, text?, gone?, value?, enabled?}; all given parts must hold. Returns one ok per check. Use after act/run_batch, or to poll with timeout_ms. */
+export type ComputerV2VerifyInput = {
+    app?: string | null;
+    pid?: number | null;
+    window_id?: number | null;
+    checks: Array<{
+        id?: string | null;
+        role?: string | null;
+        name?: string | null;
+        text?: string | null;
+        gone?: boolean | null;
+        value?: string | null;
+        enabled?: boolean | null;
+    }>;
+    timeout_ms?: number | null;
+};
+/** Pause and hand the computer to a person: the live view opens with input enabled and the agent's hold on control is released. The same session resumes when the person signals done, or when timeout_ms elapses. Use for CAPTCHAs, push/SMS 2FA and judgment calls. */
+export type ComputerV2RequestHumanInput = {
+    reason?: string | null;
+    timeout_ms?: number | null;
+};
+/** Type a vault credential into the FOCUSED field. The value never enters the model context, prompts or logs. kind: secret (the stored value) or totp (a fresh code from a stored TOTP seed). The credential is bound to an app or domain: pass `domain` (the app you are filling into); it must match the credential's binding. On this Mac a person approves each use, like typing. */
+export type ComputerV2UseCredentialInput = {
+    name: string;
+    kind?: "secret" | "totp" | null;
+    source?: "vault" | "keychain" | "bitwarden" | "onepassword" | null;
+    domain?: string | null;
+};
+/** Hand a bounded UI subtask (fill a form, search and pick a result, toggle settings) to the fast decision loop instead of driving each step yourself. Give the goal, the literal inputs it may type (it never invents text), success checks in verify syntax, and limits. Each step reads the element map, picks one action from the visible elements x allowed ops with a ~100 ms typed decision (POST /v1/decisions), runs it through the same lease/approval/audit path (predictable steps batched with expect checks), and checks success with verify. Returns a step trace and a status: done, escalated (with the reason and the current screen: continue from there yourself), or failed. One approval covers the whole subtask on this computer. Repeat subtasks replay from the cache with zero decisions (the result's cache block says hit, healed, recorded or miss); only subtasks with at least one exact (non-ask) success check are cached. Input values are never stored, only their names. With api_options, an MCP/API call you hold is offered ahead of GUI steps (status use_api hands it back to you). With best_of N and computers, N rollouts run on N sandbox computers and a judge picks one by step narratives. */
+export type ComputerV2RunSubtaskInput = {
+    goal: string;
+    inputs?: Array<{
+        name: string;
+        value: string;
+    }> | null;
+    success?: Array<{
+        id?: string | null;
+        role?: string | null;
+        name?: string | null;
+        text?: string | null;
+        gone?: boolean | null;
+        value?: string | null;
+        enabled?: boolean | null;
+        ask?: string | null;
+    }> | null;
+    constraints?: {
+        ops?: Array<"click" | "set_value" | "select" | "press" | "focus"> | null;
+        avoid?: Array<string> | null;
+        allow_irreversible?: boolean | null;
+    } | null;
+    max_steps?: number | null;
+    budget_ms?: number | null;
+    app?: string | null;
+    pid?: number | null;
+    window_id?: number | null;
+    query?: string | null;
+    max_elements?: number | null;
+    cache?: "auto" | "off" | "refresh" | null;
+    save_as?: string | null;
+    api_options?: Array<{
+        tool: string;
+        description?: string | null;
+    }> | null;
+    best_of?: number | null;
+    computers?: Array<string> | null;
+    max_cost_usd?: number | null;
+};
+/** Run independent bounded subtasks on separate computers at the same time (one run_subtask per computer, each under its own computer's control lease), and get every result back in order. Each subtask names its computer (default: this one) and takes run_subtask's fields. One computer never runs two subtasks at once: a repeated computer, or one another subtask is already driving, is refused. Limits: max_parallel subtasks at once, a total budget_ms, and max_cost_usd on decision spend; subtasks that can't start inside them come back skipped. One approval covers the whole call when any subtask targets a non-sandbox computer. */
+export type ComputerV2RunParallelInput = {
+    subtasks: Array<{
+        computer?: string | null;
+        goal: string;
+        inputs?: Array<{
+            name: string;
+            value: string;
+        }> | null;
+        success?: Array<{
+            id?: string | null;
+            role?: string | null;
+            name?: string | null;
+            text?: string | null;
+            gone?: boolean | null;
+            value?: string | null;
+            enabled?: boolean | null;
+            ask?: string | null;
+        }> | null;
+        constraints?: {
+            ops?: Array<"click" | "set_value" | "select" | "press" | "focus"> | null;
+            avoid?: Array<string> | null;
+            allow_irreversible?: boolean | null;
+        } | null;
+        max_steps?: number | null;
+        budget_ms?: number | null;
+        app?: string | null;
+        pid?: number | null;
+        window_id?: number | null;
+        query?: string | null;
+        max_elements?: number | null;
+        api_options?: Array<{
+            tool: string;
+            description?: string | null;
+        }> | null;
+    }>;
+    max_parallel?: number | null;
+    budget_ms?: number | null;
+    max_cost_usd?: number | null;
+};
+/** Run a saved skill (a recording taught with run_subtask save_as) by name, with new values for its inputs. It replays the recorded steps with no decisions, checks each step and the skill's success checks with verify, re-infers a step whose element moved and rewrites the recording. Returns the same result as run_subtask. List skills with the skills member. */
+export type ComputerV2RunSkillInput = {
+    name: string;
+    inputs?: Array<{
+        name: string;
+        value: string;
+    }> | null;
+    app?: string | null;
+    pid?: number | null;
+    window_id?: number | null;
+    max_steps?: number | null;
+    budget_ms?: number | null;
+};
+/** List the saved skills (taught recordings) this person can run with run_skill: name, goal, app, input names, step count, last use. Pass forget to delete one first. */
+export type ComputerV2SkillsInput = {
+    forget?: string | null;
+};
+export interface ComputerV2MemberInputs {
+    screenshot: ComputerV2ScreenshotInput;
+    zoom: ComputerV2ZoomInput;
+    left_click: ComputerV2LeftClickInput;
+    right_click: ComputerV2RightClickInput;
+    middle_click: ComputerV2MiddleClickInput;
+    double_click: ComputerV2DoubleClickInput;
+    triple_click: ComputerV2TripleClickInput;
+    mouse_move: ComputerV2MouseMoveInput;
+    left_click_drag: ComputerV2LeftClickDragInput;
+    left_mouse_down: ComputerV2LeftMouseDownInput;
+    left_mouse_up: ComputerV2LeftMouseUpInput;
+    scroll: ComputerV2ScrollInput;
+    type: ComputerV2TypeInput;
+    key: ComputerV2KeyInput;
+    hold_key: ComputerV2HoldKeyInput;
+    wait: ComputerV2WaitInput;
+    cursor_position: ComputerV2CursorPositionInput;
+    read_ui: ComputerV2ReadUiInput;
+    act: ComputerV2ActInput;
+    run_batch: ComputerV2RunBatchInput;
+    verify: ComputerV2VerifyInput;
+    request_human: ComputerV2RequestHumanInput;
+    use_credential: ComputerV2UseCredentialInput;
+    run_subtask: ComputerV2RunSubtaskInput;
+    run_parallel: ComputerV2RunParallelInput;
+    run_skill: ComputerV2RunSkillInput;
+    skills: ComputerV2SkillsInput;
+}
+/** The per-member JSON Schemas, for building provider function tools. */
+export declare const COMPUTER_V2_TOOL_SCHEMAS: {
+    readonly screenshot: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly zoom: {
+        readonly type: "object";
+        readonly properties: {
+            readonly region: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 4;
+                readonly maxItems: 4;
+                readonly description: "(x0, y0, x1, y1): The region to capture.";
+            };
+        };
+        readonly required: readonly ["region"];
+        readonly additionalProperties: false;
+    };
+    readonly left_click: {
+        readonly type: "object";
+        readonly properties: {
+            readonly coordinate: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 2;
+                readonly maxItems: 2;
+                readonly description: "(x, y): x pixels from the left edge, y pixels from the top edge.";
+            };
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Optional key combination to hold down during this action (e.g. \"ctrl\", \"shift\", \"ctrl+shift\").";
+            };
+        };
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly right_click: {
+        readonly type: "object";
+        readonly properties: {
+            readonly coordinate: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 2;
+                readonly maxItems: 2;
+                readonly description: "(x, y): x pixels from the left edge, y pixels from the top edge.";
+            };
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Optional key combination to hold down during this action (e.g. \"ctrl\", \"shift\", \"ctrl+shift\").";
+            };
+        };
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly middle_click: {
+        readonly type: "object";
+        readonly properties: {
+            readonly coordinate: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 2;
+                readonly maxItems: 2;
+                readonly description: "(x, y): x pixels from the left edge, y pixels from the top edge.";
+            };
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Optional key combination to hold down during this action (e.g. \"ctrl\", \"shift\", \"ctrl+shift\").";
+            };
+        };
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly double_click: {
+        readonly type: "object";
+        readonly properties: {
+            readonly coordinate: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 2;
+                readonly maxItems: 2;
+                readonly description: "(x, y): x pixels from the left edge, y pixels from the top edge.";
+            };
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Optional key combination to hold down during this action (e.g. \"ctrl\", \"shift\", \"ctrl+shift\").";
+            };
+        };
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly triple_click: {
+        readonly type: "object";
+        readonly properties: {
+            readonly coordinate: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 2;
+                readonly maxItems: 2;
+                readonly description: "(x, y): x pixels from the left edge, y pixels from the top edge.";
+            };
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Optional key combination to hold down during this action (e.g. \"ctrl\", \"shift\", \"ctrl+shift\").";
+            };
+        };
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly mouse_move: {
+        readonly type: "object";
+        readonly properties: {
+            readonly coordinate: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 2;
+                readonly maxItems: 2;
+                readonly description: "(x, y): x pixels from the left edge, y pixels from the top edge.";
+            };
+        };
+        readonly required: readonly ["coordinate"];
+        readonly additionalProperties: false;
+    };
+    readonly left_click_drag: {
+        readonly type: "object";
+        readonly properties: {
+            readonly coordinate: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 2;
+                readonly maxItems: 2;
+                readonly description: "(x, y): x pixels from the left edge, y pixels from the top edge.";
+            };
+            readonly start_coordinate: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 2;
+                readonly maxItems: 2;
+                readonly description: "(x, y): x pixels from the left edge, y pixels from the top edge.";
+            };
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Optional key combination to hold down during this action (e.g. \"ctrl\", \"shift\", \"ctrl+shift\").";
+            };
+        };
+        readonly required: readonly ["coordinate", "start_coordinate"];
+        readonly additionalProperties: false;
+    };
+    readonly left_mouse_down: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly left_mouse_up: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly scroll: {
+        readonly type: "object";
+        readonly properties: {
+            readonly scroll_amount: {
+                readonly type: "number";
+                readonly description: "Number of 'clicks' of the scroll wheel.";
+            };
+            readonly scroll_direction: {
+                readonly type: "string";
+                readonly enum: readonly ["up", "down", "left", "right"];
+            };
+            readonly coordinate: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                };
+                readonly minItems: 2;
+                readonly maxItems: 2;
+                readonly description: "(x, y): x pixels from the left edge, y pixels from the top edge.";
+            };
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Optional key combination to hold down during this action (e.g. \"ctrl\", \"shift\", \"ctrl+shift\").";
+            };
+        };
+        readonly required: readonly ["scroll_amount", "scroll_direction"];
+        readonly additionalProperties: false;
+    };
+    readonly type: {
+        readonly type: "object";
+        readonly properties: {
+            readonly text: {
+                readonly type: "string";
+                readonly description: "The text to type.";
+            };
+        };
+        readonly required: readonly ["text"];
+        readonly additionalProperties: false;
+    };
+    readonly key: {
+        readonly type: "object";
+        readonly properties: {
+            readonly text: {
+                readonly type: "string";
+                readonly description: "The key or key-combination to press.";
+            };
+            readonly repeat: {
+                readonly type: "number";
+                readonly description: "Number of times to repeat the key press. Default is 1.";
+            };
+        };
+        readonly required: readonly ["text"];
+        readonly additionalProperties: false;
+    };
+    readonly hold_key: {
+        readonly type: "object";
+        readonly properties: {
+            readonly duration: {
+                readonly type: "number";
+                readonly description: "Duration to hold the key, in seconds.";
+            };
+            readonly text: {
+                readonly type: "string";
+                readonly description: "The key or key-combination to hold.";
+            };
+        };
+        readonly required: readonly ["duration", "text"];
+        readonly additionalProperties: false;
+    };
+    readonly wait: {
+        readonly type: "object";
+        readonly properties: {
+            readonly duration: {
+                readonly type: "number";
+                readonly description: "Duration to wait, in seconds.";
+            };
+        };
+        readonly required: readonly ["duration"];
+        readonly additionalProperties: false;
+    };
+    readonly cursor_position: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly read_ui: {
+        readonly type: "object";
+        readonly properties: {
+            readonly app: {
+                readonly type: "string";
+                readonly description: "App name or bundle id (macOS); default: the frontmost app.";
+            };
+            readonly pid: {
+                readonly type: "integer";
+            };
+            readonly window_id: {
+                readonly type: "integer";
+            };
+            readonly query: {
+                readonly type: "string";
+                readonly description: "Only elements whose name or value contains this text.";
+            };
+            readonly max_elements: {
+                readonly type: "integer";
+                readonly description: "Cap the element list (default 200).";
+            };
+            readonly since: {
+                readonly type: "integer";
+                readonly description: "A map version from an earlier read_ui: answer only the changes since then.";
+            };
+            readonly paths: {
+                readonly type: "boolean";
+                readonly description: "Add each element's tree path (role:ordinal chain from the window). Replay locators use it; you rarely need it.";
+            };
+            readonly crops: {
+                readonly type: "boolean";
+                readonly description: "Add an 8x8 pixel hash per element (macOS). Slower: forces a fresh walk of the window. Replay's pixel fallback uses it.";
+            };
+            readonly vision: {
+                readonly type: "string";
+                readonly enum: readonly ["auto", "off", "only"];
+                readonly description: "The vision fallback: auto (default; used when the tree is empty or can't see into part of the window), off (tree only), only (vision only).";
+            };
+            readonly target: {
+                readonly type: "string";
+                readonly description: "Ground this description to one element with the local grounder; the answer's `grounded` has its id, point and confidence.";
+            };
+            readonly zoom: {
+                readonly type: "string";
+                readonly enum: readonly ["auto", "always", "never"];
+                readonly description: "target: zoom into a crop around a low-confidence answer and ground again (default auto).";
+            };
+        };
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly act: {
+        readonly type: "object";
+        readonly properties: {
+            readonly id: {
+                readonly type: "string";
+                readonly description: "The element id from read_ui.";
+            };
+            readonly op: {
+                readonly type: "string";
+                readonly enum: readonly ["click", "set_value", "select", "press", "menu", "focus"];
+                readonly description: "What to do to the element.";
+            };
+            readonly value: {
+                readonly type: "string";
+                readonly description: "set_value: the text to type into the element; select: the child's name to pick.";
+            };
+            readonly key: {
+                readonly type: "string";
+                readonly description: "press: the key name (Return, Tab, Escape, ...).";
+            };
+            readonly path: {
+                readonly anyOf: readonly [{
+                    readonly type: "string";
+                }, {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                }];
+                readonly description: "menu: the menu path, 'File > Save' or ['File', 'Save'].";
+            };
+            readonly version: {
+                readonly type: "integer";
+                readonly description: "The read_ui map version this action was planned on; a stale version is refused with the fresh map.";
+            };
+            readonly app: {
+                readonly type: "string";
+                readonly description: "App name or bundle id (macOS); default: the frontmost app.";
+            };
+            readonly pid: {
+                readonly type: "integer";
+            };
+            readonly window_id: {
+                readonly type: "integer";
+            };
+        };
+        readonly required: readonly ["id", "op"];
+        readonly additionalProperties: false;
+    };
+    readonly run_batch: {
+        readonly type: "object";
+        readonly properties: {
+            readonly app: {
+                readonly type: "string";
+                readonly description: "App name or bundle id (macOS); default: the frontmost app.";
+            };
+            readonly pid: {
+                readonly type: "integer";
+            };
+            readonly window_id: {
+                readonly type: "integer";
+            };
+            readonly version: {
+                readonly type: "integer";
+                readonly description: "Pin the read_ui map version the steps were planned on; stale is refused with the fresh map.";
+            };
+            readonly steps: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly maxItems: 50;
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly act: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly id: {
+                                    readonly type: "string";
+                                };
+                                readonly op: {
+                                    readonly type: "string";
+                                    readonly enum: readonly ["click", "set_value", "select", "press", "menu", "focus"];
+                                };
+                                readonly value: {
+                                    readonly type: "string";
+                                };
+                                readonly key: {
+                                    readonly type: "string";
+                                };
+                            };
+                            readonly required: readonly ["id", "op"];
+                            readonly additionalProperties: false;
+                        };
+                        readonly menu: {
+                            readonly anyOf: readonly [{
+                                readonly type: "string";
+                            }, {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                };
+                            }];
+                        };
+                        readonly pixel: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly tool: {
+                                    readonly type: "string";
+                                };
+                                readonly args: {
+                                    readonly type: "object";
+                                };
+                            };
+                            readonly required: readonly ["tool"];
+                            readonly additionalProperties: false;
+                        };
+                        readonly wait: {
+                            readonly type: "number";
+                            readonly description: "Wait this many milliseconds before the next step.";
+                        };
+                        readonly wait_for: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly id: {
+                                    readonly type: "string";
+                                    readonly description: "An element id from read_ui.";
+                                };
+                                readonly role: {
+                                    readonly type: "string";
+                                    readonly description: "An accessibility role, e.g. button, textfield, checkbox.";
+                                };
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly description: "Substring match against the element's name/label.";
+                                };
+                                readonly text: {
+                                    readonly type: "string";
+                                    readonly description: "Substring match against the element's displayed text or value.";
+                                };
+                                readonly gone: {
+                                    readonly type: "boolean";
+                                    readonly description: "True: no element may match; false: at least one must.";
+                                };
+                                readonly value: {
+                                    readonly type: "string";
+                                    readonly description: "The element's value must equal this exactly.";
+                                };
+                                readonly enabled: {
+                                    readonly type: "boolean";
+                                    readonly description: "The element's enabled state must equal this.";
+                                };
+                            };
+                            readonly required: readonly [];
+                            readonly additionalProperties: false;
+                            readonly description: "Precondition: checked before the step; failure stops the batch.";
+                        };
+                        readonly expect: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly id: {
+                                    readonly type: "string";
+                                    readonly description: "An element id from read_ui.";
+                                };
+                                readonly role: {
+                                    readonly type: "string";
+                                    readonly description: "An accessibility role, e.g. button, textfield, checkbox.";
+                                };
+                                readonly name: {
+                                    readonly type: "string";
+                                    readonly description: "Substring match against the element's name/label.";
+                                };
+                                readonly text: {
+                                    readonly type: "string";
+                                    readonly description: "Substring match against the element's displayed text or value.";
+                                };
+                                readonly gone: {
+                                    readonly type: "boolean";
+                                    readonly description: "True: no element may match; false: at least one must.";
+                                };
+                                readonly value: {
+                                    readonly type: "string";
+                                    readonly description: "The element's value must equal this exactly.";
+                                };
+                                readonly enabled: {
+                                    readonly type: "boolean";
+                                    readonly description: "The element's enabled state must equal this.";
+                                };
+                            };
+                            readonly required: readonly [];
+                            readonly additionalProperties: false;
+                            readonly description: "Postcondition: checked after the step; failure stops the batch.";
+                        };
+                        readonly timeout_ms: {
+                            readonly type: "integer";
+                            readonly description: "How long to wait for this step's checks (default 3000).";
+                        };
+                    };
+                    readonly required: readonly [];
+                    readonly additionalProperties: false;
+                };
+            };
+        };
+        readonly required: readonly ["steps"];
+        readonly additionalProperties: false;
+    };
+    readonly verify: {
+        readonly type: "object";
+        readonly properties: {
+            readonly app: {
+                readonly type: "string";
+                readonly description: "App name or bundle id (macOS); default: the frontmost app.";
+            };
+            readonly pid: {
+                readonly type: "integer";
+            };
+            readonly window_id: {
+                readonly type: "integer";
+            };
+            readonly checks: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                            readonly description: "An element id from read_ui.";
+                        };
+                        readonly role: {
+                            readonly type: "string";
+                            readonly description: "An accessibility role, e.g. button, textfield, checkbox.";
+                        };
+                        readonly name: {
+                            readonly type: "string";
+                            readonly description: "Substring match against the element's name/label.";
+                        };
+                        readonly text: {
+                            readonly type: "string";
+                            readonly description: "Substring match against the element's displayed text or value.";
+                        };
+                        readonly gone: {
+                            readonly type: "boolean";
+                            readonly description: "True: no element may match; false: at least one must.";
+                        };
+                        readonly value: {
+                            readonly type: "string";
+                            readonly description: "The element's value must equal this exactly.";
+                        };
+                        readonly enabled: {
+                            readonly type: "boolean";
+                            readonly description: "The element's enabled state must equal this.";
+                        };
+                    };
+                    readonly required: readonly [];
+                    readonly additionalProperties: false;
+                };
+            };
+            readonly timeout_ms: {
+                readonly type: "integer";
+                readonly description: "Wait up to this long for every check to hold (default 0: one fresh read).";
+            };
+        };
+        readonly required: readonly ["checks"];
+        readonly additionalProperties: false;
+    };
+    readonly request_human: {
+        readonly type: "object";
+        readonly properties: {
+            readonly reason: {
+                readonly type: "string";
+                readonly description: "What the person should do, shown in the live view (e.g. 'Complete the CAPTCHA').";
+            };
+            readonly timeout_ms: {
+                readonly type: "integer";
+                readonly description: "How long to wait for the person (default 300000, max 1800000).";
+            };
+        };
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+    readonly use_credential: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "The credential's name in the vault.";
+            };
+            readonly kind: {
+                readonly type: "string";
+                readonly enum: readonly ["secret", "totp"];
+                readonly description: "secret: type the stored value; totp: generate and type a fresh TOTP code.";
+            };
+            readonly source: {
+                readonly type: "string";
+                readonly enum: readonly ["vault", "keychain", "bitwarden", "onepassword"];
+                readonly description: "Where to resolve the credential from (default: the sealed vault, then this Mac's Keychain).";
+            };
+            readonly domain: {
+                readonly type: "string";
+                readonly description: "The app or domain the credential is being typed into; checked against the credential's binding.";
+            };
+        };
+        readonly required: readonly ["name"];
+        readonly additionalProperties: false;
+    };
+    readonly run_subtask: {
+        readonly type: "object";
+        readonly properties: {
+            readonly goal: {
+                readonly type: "string";
+                readonly description: "What the subtask must achieve, in one or two sentences (e.g. 'Fill the sign-up form and submit it').";
+            };
+            readonly inputs: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "string";
+                            readonly description: "What the value is (e.g. 'email', 'full name').";
+                        };
+                        readonly value: {
+                            readonly type: "string";
+                            readonly description: "The literal text to type.";
+                        };
+                    };
+                    readonly required: readonly ["name", "value"];
+                    readonly additionalProperties: false;
+                };
+                readonly description: "The only text the subtask may type. Not for secrets: use use_credential.";
+            };
+            readonly success: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly maxItems: 10;
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                            readonly description: "An element id from read_ui.";
+                        };
+                        readonly role: {
+                            readonly type: "string";
+                            readonly description: "An accessibility role, e.g. button, textfield, checkbox.";
+                        };
+                        readonly name: {
+                            readonly type: "string";
+                            readonly description: "Substring match against the element's name/label.";
+                        };
+                        readonly text: {
+                            readonly type: "string";
+                            readonly description: "Substring match against the element's displayed text or value.";
+                        };
+                        readonly gone: {
+                            readonly type: "boolean";
+                            readonly description: "True: no element may match; false: at least one must.";
+                        };
+                        readonly value: {
+                            readonly type: "string";
+                            readonly description: "The element's value must equal this exactly.";
+                        };
+                        readonly enabled: {
+                            readonly type: "boolean";
+                            readonly description: "The element's enabled state must equal this.";
+                        };
+                        readonly ask: {
+                            readonly type: "string";
+                            readonly description: "A fuzzy yes/no check in plain words (\"Is the confirmation message showing?\"), answered by a typed verify decision over the screen. Use only when role/name/text/value checks can't express it.";
+                        };
+                    };
+                    readonly required: readonly [];
+                    readonly additionalProperties: false;
+                };
+                readonly description: "Checks that all hold when the goal is met, in verify syntax ({role?, name?, text?, value?, gone?, enabled?}) or {ask: '...'} for a fuzzy yes/no. Without checks the loop stops when a decision picks done.";
+            };
+            readonly constraints: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly ops: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                            readonly enum: readonly ["click", "set_value", "select", "press", "focus"];
+                        };
+                        readonly description: "Ops the subtask may use (default click, set_value, select, press).";
+                    };
+                    readonly avoid: {
+                        readonly type: "array";
+                        readonly maxItems: 20;
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Never act on elements whose name contains any of these.";
+                    };
+                    readonly allow_irreversible: {
+                        readonly type: "boolean";
+                        readonly description: "Let the subtask click buttons named like send, pay, buy, delete, publish (default false: those hand back to you).";
+                    };
+                };
+                readonly required: readonly [];
+                readonly additionalProperties: false;
+            };
+            readonly max_steps: {
+                readonly type: "integer";
+                readonly description: "Most actions the subtask may take (default 12, at most 40).";
+            };
+            readonly budget_ms: {
+                readonly type: "integer";
+                readonly description: "Wall-clock budget in milliseconds (default 60000, at most 300000).";
+            };
+            readonly app: {
+                readonly type: "string";
+                readonly description: "App name or bundle id (macOS); default: the frontmost app.";
+            };
+            readonly pid: {
+                readonly type: "integer";
+            };
+            readonly window_id: {
+                readonly type: "integer";
+            };
+            readonly query: {
+                readonly type: "string";
+                readonly description: "Only consider elements whose name or value contains this text.";
+            };
+            readonly max_elements: {
+                readonly type: "integer";
+                readonly description: "Cap the elements read per step (default 120).";
+            };
+            readonly cache: {
+                readonly type: "string";
+                readonly enum: readonly ["auto", "off", "refresh"];
+                readonly description: "Replay cache (default auto). auto: a subtask seen before (same goal, app and window, same input names) replays its recorded steps with no decisions, checking each with verify, and re-infers only a step whose element moved; a new one runs the decision loop and is recorded once its success checks hold. refresh: ignore the cached steps and record anew. off: neither read nor write the cache.";
+            };
+            readonly save_as: {
+                readonly type: "string";
+                readonly description: "Save this subtask's recording as a named skill once it succeeds (overwrites a skill of that name). Run it later with run_skill and new input values.";
+            };
+            readonly api_options: {
+                readonly type: "array";
+                readonly maxItems: 10;
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly tool: {
+                            readonly type: "string";
+                            readonly description: "The MCP tool or API action you can call yourself (e.g. 'github.create_issue').";
+                        };
+                        readonly description: {
+                            readonly type: "string";
+                            readonly description: "What it does, in one line.";
+                        };
+                    };
+                    readonly required: readonly ["tool"];
+                    readonly additionalProperties: false;
+                };
+                readonly description: "MCP tools or API actions you hold that could do this goal without the GUI. They are offered ahead of every GUI option on the first step; if the decision picks one, the subtask stops with status use_api and names it, and you make that call yourself. An API call beats GUI clicks when both exist.";
+            };
+            readonly best_of: {
+                readonly type: "integer";
+                readonly description: "Behavior Best-of-N for high-value subtasks: run N rollouts (2-5) at once on N sandbox computers listed in computers, then a judge decision picks one by the rollouts' step narratives. Sandbox/cloud computers only, never the person's own machine. Returns the chosen rollout, why, and every rollout's narrative.";
+            };
+            readonly computers: {
+                readonly type: "array";
+                readonly maxItems: 5;
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "With best_of: the sandbox computer ids the rollouts run on, one rollout per computer (at least best_of distinct ids).";
+            };
+            readonly max_cost_usd: {
+                readonly type: "number";
+                readonly description: "With best_of: the cap on decision spend for the whole call in USD (default 0.25, at most 5). The judge may use the planner-class tier only while under it.";
+            };
+        };
+        readonly required: readonly ["goal"];
+        readonly additionalProperties: false;
+    };
+    readonly run_parallel: {
+        readonly type: "object";
+        readonly properties: {
+            readonly subtasks: {
+                readonly type: "array";
+                readonly minItems: 1;
+                readonly maxItems: 8;
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly computer: {
+                            readonly type: "string";
+                            readonly description: "The computer id this subtask runs on (default: the computer this call is made on).";
+                        };
+                        readonly goal: {
+                            readonly type: "string";
+                            readonly description: "What the subtask must achieve, in one or two sentences (e.g. 'Fill the sign-up form and submit it').";
+                        };
+                        readonly inputs: {
+                            readonly type: "array";
+                            readonly maxItems: 20;
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly name: {
+                                        readonly type: "string";
+                                        readonly description: "What the value is (e.g. 'email', 'full name').";
+                                    };
+                                    readonly value: {
+                                        readonly type: "string";
+                                        readonly description: "The literal text to type.";
+                                    };
+                                };
+                                readonly required: readonly ["name", "value"];
+                                readonly additionalProperties: false;
+                            };
+                            readonly description: "The only text the subtask may type. Not for secrets: use use_credential.";
+                        };
+                        readonly success: {
+                            readonly type: "array";
+                            readonly minItems: 1;
+                            readonly maxItems: 10;
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly id: {
+                                        readonly type: "string";
+                                        readonly description: "An element id from read_ui.";
+                                    };
+                                    readonly role: {
+                                        readonly type: "string";
+                                        readonly description: "An accessibility role, e.g. button, textfield, checkbox.";
+                                    };
+                                    readonly name: {
+                                        readonly type: "string";
+                                        readonly description: "Substring match against the element's name/label.";
+                                    };
+                                    readonly text: {
+                                        readonly type: "string";
+                                        readonly description: "Substring match against the element's displayed text or value.";
+                                    };
+                                    readonly gone: {
+                                        readonly type: "boolean";
+                                        readonly description: "True: no element may match; false: at least one must.";
+                                    };
+                                    readonly value: {
+                                        readonly type: "string";
+                                        readonly description: "The element's value must equal this exactly.";
+                                    };
+                                    readonly enabled: {
+                                        readonly type: "boolean";
+                                        readonly description: "The element's enabled state must equal this.";
+                                    };
+                                    readonly ask: {
+                                        readonly type: "string";
+                                        readonly description: "A fuzzy yes/no check in plain words (\"Is the confirmation message showing?\"), answered by a typed verify decision over the screen. Use only when role/name/text/value checks can't express it.";
+                                    };
+                                };
+                                readonly required: readonly [];
+                                readonly additionalProperties: false;
+                            };
+                            readonly description: "Checks that all hold when the goal is met, in verify syntax ({role?, name?, text?, value?, gone?, enabled?}) or {ask: '...'} for a fuzzy yes/no. Without checks the loop stops when a decision picks done.";
+                        };
+                        readonly constraints: {
+                            readonly type: "object";
+                            readonly properties: {
+                                readonly ops: {
+                                    readonly type: "array";
+                                    readonly items: {
+                                        readonly type: "string";
+                                        readonly enum: readonly ["click", "set_value", "select", "press", "focus"];
+                                    };
+                                    readonly description: "Ops the subtask may use (default click, set_value, select, press).";
+                                };
+                                readonly avoid: {
+                                    readonly type: "array";
+                                    readonly maxItems: 20;
+                                    readonly items: {
+                                        readonly type: "string";
+                                    };
+                                    readonly description: "Never act on elements whose name contains any of these.";
+                                };
+                                readonly allow_irreversible: {
+                                    readonly type: "boolean";
+                                    readonly description: "Let the subtask click buttons named like send, pay, buy, delete, publish (default false: those hand back to you).";
+                                };
+                            };
+                            readonly required: readonly [];
+                            readonly additionalProperties: false;
+                        };
+                        readonly max_steps: {
+                            readonly type: "integer";
+                            readonly description: "Most actions the subtask may take (default 12, at most 40).";
+                        };
+                        readonly budget_ms: {
+                            readonly type: "integer";
+                            readonly description: "Wall-clock budget in milliseconds (default 60000, at most 300000).";
+                        };
+                        readonly app: {
+                            readonly type: "string";
+                            readonly description: "App name or bundle id (macOS); default: the frontmost app.";
+                        };
+                        readonly pid: {
+                            readonly type: "integer";
+                        };
+                        readonly window_id: {
+                            readonly type: "integer";
+                        };
+                        readonly query: {
+                            readonly type: "string";
+                            readonly description: "Only consider elements whose name or value contains this text.";
+                        };
+                        readonly max_elements: {
+                            readonly type: "integer";
+                            readonly description: "Cap the elements read per step (default 120).";
+                        };
+                        readonly api_options: {
+                            readonly type: "array";
+                            readonly maxItems: 10;
+                            readonly items: {
+                                readonly type: "object";
+                                readonly properties: {
+                                    readonly tool: {
+                                        readonly type: "string";
+                                        readonly description: "The MCP tool or API action you can call yourself (e.g. 'github.create_issue').";
+                                    };
+                                    readonly description: {
+                                        readonly type: "string";
+                                        readonly description: "What it does, in one line.";
+                                    };
+                                };
+                                readonly required: readonly ["tool"];
+                                readonly additionalProperties: false;
+                            };
+                            readonly description: "MCP tools or API actions you hold that could do this goal without the GUI. They are offered ahead of every GUI option on the first step; if the decision picks one, the subtask stops with status use_api and names it, and you make that call yourself. An API call beats GUI clicks when both exist.";
+                        };
+                    };
+                    readonly required: readonly ["goal"];
+                    readonly additionalProperties: false;
+                };
+                readonly description: "Independent subtasks, one per computer. Same fields as run_subtask plus computer.";
+            };
+            readonly max_parallel: {
+                readonly type: "integer";
+                readonly description: "Most subtasks running at once (default 4, at most 8).";
+            };
+            readonly budget_ms: {
+                readonly type: "integer";
+                readonly description: "Wall-clock budget for the whole call in milliseconds (default 120000, at most 600000). Each subtask's own budget_ms is cut to what is left when it starts.";
+            };
+            readonly max_cost_usd: {
+                readonly type: "number";
+                readonly description: "Cap on decision spend for the whole call in USD (default 0.25, at most 5). Once reached, subtasks not yet started come back skipped.";
+            };
+        };
+        readonly required: readonly ["subtasks"];
+        readonly additionalProperties: false;
+    };
+    readonly run_skill: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "The skill's name (from skills).";
+            };
+            readonly inputs: {
+                readonly type: "array";
+                readonly maxItems: 20;
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly name: {
+                            readonly type: "string";
+                            readonly description: "What the value is (e.g. 'email', 'full name').";
+                        };
+                        readonly value: {
+                            readonly type: "string";
+                            readonly description: "The literal text to type.";
+                        };
+                    };
+                    readonly required: readonly ["name", "value"];
+                    readonly additionalProperties: false;
+                };
+                readonly description: "A value for each of the skill's inputs (skills lists their names). Not for secrets: use use_credential.";
+            };
+            readonly app: {
+                readonly type: "string";
+                readonly description: "App name or bundle id (macOS); default: the frontmost app.";
+            };
+            readonly pid: {
+                readonly type: "integer";
+            };
+            readonly window_id: {
+                readonly type: "integer";
+            };
+            readonly max_steps: {
+                readonly type: "integer";
+                readonly description: "Most actions the subtask may take (default 12, at most 40).";
+            };
+            readonly budget_ms: {
+                readonly type: "integer";
+                readonly description: "Wall-clock budget in milliseconds (default 60000, at most 300000).";
+            };
+        };
+        readonly required: readonly ["name"];
+        readonly additionalProperties: false;
+    };
+    readonly skills: {
+        readonly type: "object";
+        readonly properties: {
+            readonly forget: {
+                readonly type: "string";
+                readonly description: "Delete the saved skill with this name before listing.";
+            };
+        };
+        readonly required: readonly [];
+        readonly additionalProperties: false;
+    };
+};
+export interface ComputerV2StructuredMemberSpec {
+    name: string;
+    description: string;
+    risk: string;
+    default_enabled: boolean;
+    needs_confirm: boolean;
+    confirm: string;
+    result_kind: string;
+    ack_text?: string;
+    scale_fields: Record<string, string>;
+}
+export declare const COMPUTER_V2_STRUCTURED_MEMBERS: readonly [{
+    readonly name: "read_ui";
+    readonly description: "Read the target window or app's UI as a structured element tree (roles, names, values, bounds) with NO screenshot. Returns stable element ids for act, run_batch and verify. Pass `since` (a version from an earlier read_ui) to get only the diff; `query` filters by text; `max_elements` caps the list (default 200). When the window has no usable accessibility tree (canvas apps, games, remote desktops, custom-drawn UIs) the read falls back to vision: numbered set-of-marks regions come back as elements with `source: \"vision\"` and a `mark` number, and act on their ids works the same way. `source` and `source_reason` say which was used. Pass `target` (a description such as 'the Export button') to ground it with the local grounder: `grounded.id` is the element to act on.";
+    readonly risk: "reversible";
+    readonly default_enabled: true;
+    readonly needs_confirm: false;
+    readonly confirm: "never";
+    readonly result_kind: "none";
+    readonly ack_text: "Read the UI of {app}.";
+    readonly scale_fields: {};
+}, {
+    readonly name: "act";
+    readonly description: "Act on an element id from read_ui (tree ids and vision ids alike; a vision element is clicked or typed into at its centre after a pixel freshness check, and menu needs a window). op: click, set_value (clear and set the field's value), select (pick a child by name), press (a key), menu (choose a menu path such as 'File > Save'), focus. set_value/select/press on this Mac need the person's approval (the same rule as typing).";
+    readonly risk: "risky";
+    readonly default_enabled: true;
+    readonly needs_confirm: false;
+    readonly confirm: "never";
+    readonly result_kind: "none";
+    readonly ack_text: "{op} on {id}.";
+    readonly scale_fields: {};
+}, {
+    readonly name: "run_batch";
+    readonly description: "Run ordered steps in one window in a single call: act steps ({id, op, value?, key?}), menu steps (path), pixel steps ({tool, args}) and waits (ms). Each step may carry wait_for (checked before the step) and expect (checked after); a failed check stops the batch and one observe read returns the fresh map. This is the fast path: batch several steps instead of screenshot-per-action loops.";
+    readonly risk: "risky";
+    readonly default_enabled: true;
+    readonly needs_confirm: true;
+    readonly confirm: "non_sandbox";
+    readonly result_kind: "none";
+    readonly ack_text: "Ran {steps} batch steps.";
+    readonly scale_fields: {};
+}, {
+    readonly name: "verify";
+    readonly description: "Check bounded conditions on the current UI without acting: role, name, text, gone, value, enabled. Each check is {id?, role?, name?, text?, gone?, value?, enabled?}; all given parts must hold. Returns one ok per check. Use after act/run_batch, or to poll with timeout_ms.";
+    readonly risk: "reversible";
+    readonly default_enabled: true;
+    readonly needs_confirm: false;
+    readonly confirm: "never";
+    readonly result_kind: "none";
+    readonly ack_text: "Verified.";
+    readonly scale_fields: {};
+}, {
+    readonly name: "request_human";
+    readonly description: "Pause and hand the computer to a person: the live view opens with input enabled and the agent's hold on control is released. The same session resumes when the person signals done, or when timeout_ms elapses. Use for CAPTCHAs, push/SMS 2FA and judgment calls.";
+    readonly risk: "reversible";
+    readonly default_enabled: true;
+    readonly needs_confirm: false;
+    readonly confirm: "never";
+    readonly result_kind: "none";
+    readonly ack_text: "Human window closed ({reason}).";
+    readonly scale_fields: {};
+}, {
+    readonly name: "use_credential";
+    readonly description: "Type a vault credential into the FOCUSED field. The value never enters the model context, prompts or logs. kind: secret (the stored value) or totp (a fresh code from a stored TOTP seed). The credential is bound to an app or domain: pass `domain` (the app you are filling into); it must match the credential's binding. On this Mac a person approves each use, like typing.";
+    readonly risk: "risky";
+    readonly default_enabled: true;
+    readonly needs_confirm: true;
+    readonly confirm: "non_sandbox";
+    readonly result_kind: "none";
+    readonly ack_text: "Credential {name} typed.";
+    readonly scale_fields: {};
+}, {
+    readonly name: "run_subtask";
+    readonly description: "Hand a bounded UI subtask (fill a form, search and pick a result, toggle settings) to the fast decision loop instead of driving each step yourself. Give the goal, the literal inputs it may type (it never invents text), success checks in verify syntax, and limits. Each step reads the element map, picks one action from the visible elements x allowed ops with a ~100 ms typed decision (POST /v1/decisions), runs it through the same lease/approval/audit path (predictable steps batched with expect checks), and checks success with verify. Returns a step trace and a status: done, escalated (with the reason and the current screen: continue from there yourself), or failed. One approval covers the whole subtask on this computer. Repeat subtasks replay from the cache with zero decisions (the result's cache block says hit, healed, recorded or miss); only subtasks with at least one exact (non-ask) success check are cached. Input values are never stored, only their names. With api_options, an MCP/API call you hold is offered ahead of GUI steps (status use_api hands it back to you). With best_of N and computers, N rollouts run on N sandbox computers and a judge picks one by step narratives.";
+    readonly risk: "risky";
+    readonly default_enabled: true;
+    readonly needs_confirm: true;
+    readonly confirm: "non_sandbox";
+    readonly result_kind: "none";
+    readonly ack_text: "Ran the subtask.";
+    readonly scale_fields: {};
+}, {
+    readonly name: "run_parallel";
+    readonly description: "Run independent bounded subtasks on separate computers at the same time (one run_subtask per computer, each under its own computer's control lease), and get every result back in order. Each subtask names its computer (default: this one) and takes run_subtask's fields. One computer never runs two subtasks at once: a repeated computer, or one another subtask is already driving, is refused. Limits: max_parallel subtasks at once, a total budget_ms, and max_cost_usd on decision spend; subtasks that can't start inside them come back skipped. One approval covers the whole call when any subtask targets a non-sandbox computer.";
+    readonly risk: "risky";
+    readonly default_enabled: true;
+    readonly needs_confirm: true;
+    readonly confirm: "non_sandbox";
+    readonly result_kind: "none";
+    readonly ack_text: "Ran the subtasks.";
+    readonly scale_fields: {};
+}, {
+    readonly name: "run_skill";
+    readonly description: "Run a saved skill (a recording taught with run_subtask save_as) by name, with new values for its inputs. It replays the recorded steps with no decisions, checks each step and the skill's success checks with verify, re-infers a step whose element moved and rewrites the recording. Returns the same result as run_subtask. List skills with the skills member.";
+    readonly risk: "risky";
+    readonly default_enabled: true;
+    readonly needs_confirm: true;
+    readonly confirm: "non_sandbox";
+    readonly result_kind: "none";
+    readonly ack_text: "Ran the skill {name}.";
+    readonly scale_fields: {};
+}, {
+    readonly name: "skills";
+    readonly description: "List the saved skills (taught recordings) this person can run with run_skill: name, goal, app, input names, step count, last use. Pass forget to delete one first.";
+    readonly risk: "reversible";
+    readonly default_enabled: true;
+    readonly needs_confirm: false;
+    readonly confirm: "never";
+    readonly result_kind: "none";
+    readonly ack_text: "Listed the saved skills.";
+    readonly scale_fields: {};
+}];