@swmansion/argent 0.27.1-next.0 → 0.27.1-next.2

package/dist/cli-cmds.mjs

@@ -21916,7 +21916,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID2 = randomUUID5();
 function readCliVersion() {
   if (true) {
-    return "0.27.1-next.0";
+    return "0.27.1-next.2";
   }
   return "0.0.0";
 }

package/dist/client.d.ts

@@ -1,3 +1,6 @@
+import type { ArgentToolArgs } from "./tool-args.generated.js";
+export type { ArgentToolArgs };
+export type ArgentToolName = keyof ArgentToolArgs;
 export interface ArgentTool {
     name: string;
     description: string;
@@ -38,11 +41,13 @@ export interface ArgentFlag {
 }
 /** Feature flags and their effective state: project overrides global, then the default. */
 export declare function listFlags(): ArgentFlag[];
+/** `args` may be omitted only when the tool has no required argument. */
+type CallToolParams<N extends ArgentToolName> = Record<never, never> extends ArgentToolArgs[N] ? [args?: ArgentToolArgs[N], options?: CallToolOptions] : [args: ArgentToolArgs[N], options?: CallToolOptions];
 export interface ArgentClient {
     listTools(options?: {
         signal?: AbortSignal;
     }): Promise<ArgentTool[]>;
-    callTool<T = unknown>(name: string, args?: Record<string, unknown>, options?: CallToolOptions): Promise<ArgentToolResult<T>>;
+    callTool<N extends ArgentToolName, T = unknown>(name: N, ...params: CallToolParams<N>): Promise<ArgentToolResult<T>>;
     /**
      * Stop this install's local tool-server, like `argent server stop`. The next
      * call starts a fresh one. Resolves false when none was running.

package/dist/installer.mjs

@@ -16730,7 +16730,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = randomUUID4();
 function readCliVersion() {
   if (true) {
-    return "0.27.1-next.0";
+    return "0.27.1-next.2";
   }
   return "0.0.0";
 }

package/dist/mcp-server.mjs

@@ -18768,6 +18768,9 @@ function toMcpTool(t) {
     ...Object.keys(meta2).length > 0 ? { _meta: meta2 } : {}
   };
 }
+function toMcpToolList(tools) {
+  return tools.filter((t) => !t.hideFromMcp).map(toMcpTool);
+}
 
 // ../argent-mcp/src/installed-version.ts
 import * as fs9 from "node:fs";
@@ -18912,13 +18915,13 @@ async function startMcpServer(options) {
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     try {
-      const tools = await fetchTools();
+      const tools = toMcpToolList(await fetchTools());
       await spyLog({
         ts: (/* @__PURE__ */ new Date()).toISOString(),
         event: "list_tools",
         count: tools.length
       });
-      return { tools: tools.map(toMcpTool) };
+      return { tools };
     } catch (err) {
       process.stderr.write(
         `[argent] Failed to list tools: ${err instanceof Error ? err.message : err}

package/dist/tool-args.generated.d.ts

@@ -0,0 +1,872 @@
+export interface ArgentToolArgs {
+    "await-screen-idle": {
+        /** Target device id from `list-devices` (iOS UDID, Android serial, or Chromium id). */
+        udid: string;
+        /** Max time to wait for the screen to settle before giving up (default 3000). */
+        timeoutMs?: number;
+        /** How often to re-read the tree (default 200). */
+        pollIntervalMs?: number;
+        /** The screen must hold the same content for at least this long to count as settled (default 250). */
+        minStableMs?: number;
+    };
+    "await-ui-element": {
+        /** Target device id from `list-devices` (iOS UDID, Android serial, or Chromium id). */
+        udid: string;
+        /** What to wait for. `exists`: selector is anywhere in the tree. `visible`: selector is present with a non-zero on-screen frame. `hidden`: selector is absent or zero-area. `text`: the first visible match in reading order (topmost), falling back to the first match overall if none is visible, contains (or, with textMatch `equals`, exactly matches) expectedText — if a loose selector hits several elements, only that one is checked, so narrow it to target the intended element. */
+        condition: "exists" | "visible" | "hidden" | "text";
+        /** Element to match (text / identifier / role). */
+        selector: {
+            /** Case-insensitive substring of the element's visible label or value. */
+            text?: string;
+            /** The element's identifier (accessibilityIdentifier / resource-id / testid), matched case-insensitively as the exact identifier or the unqualified resource-id name ('submit' matches 'com.example.app:id/submit'). */
+            identifier?: string;
+            /** Case-insensitive substring of the element's role (e.g. AXButton, button, TextView). */
+            role?: string;
+        };
+        /** For condition `text`: the string the first visible matched element (topmost in reading order; the first match overall if none is visible) must contain (default) or equal — see `textMatch`. Case-insensitive. */
+        expectedText?: string;
+        /** For condition `text`: how expectedText is compared. `contains` (default) is a case-insensitive substring; `equals` is a case-insensitive full-string match. */
+        textMatch?: "contains" | "equals";
+        /** Optional iOS app bundle id, passed to the describe fallback (see `describe`). Ignored on Android / Chromium, and on physical iOS. */
+        bundleId?: string;
+        /** Max time to wait for the condition before giving up (default 5000). */
+        timeoutMs?: number;
+        /** How often to re-check the tree (default 400). */
+        pollIntervalMs?: number;
+    };
+    await_user_selection: {
+        /** Max seconds to block this call before returning a re-awaitable { status: 'pending' } result (default 1800). The user's proposals stay live across timeouts — on 'pending' just call await_user_selection again. Lower this if your MCP client enforces a short request timeout. */
+        timeoutSeconds?: number;
+    };
+    "boot-device": {
+        /** iOS: simulator UDID to boot (from `list-devices`). Provide exactly one of `udid`, `avdName`, `vvdImage`, or `electronAppPath`. */
+        udid?: string;
+        /** Android: AVD name to launch a new emulator from (from `list-devices` → `avds[].name`). Provide exactly one of `udid`, `avdName`, `vvdImage`, or `electronAppPath`. */
+        avdName?: string;
+        /** Vega (Fire TV): VVD image to boot — the `vvdImage` of a Vega device from `list-devices` (e.g. `tv`). Starts the single SDK-managed Vega Virtual Device. Provide exactly one of `udid`, `avdName`, `vvdImage`, or `electronAppPath`. */
+        vvdImage?: string;
+        /** Android/Vega: overall budget for the boot sequence. Default 480000 (8 min) on Android, 120000 (2 min) on Vega. Clamped to [30s, 15min]. Ignored on iOS. */
+        bootTimeoutMs?: number;
+        /** Shut down and re-boot the device even if already running. */
+        force?: boolean;
+        /** Android only: boot the emulator with audio output enabled. Defaults to false — argent boots emulators MUTED so several agent-driven devices don't all play sound on the host machine; pass `true` when the task involves playing, hearing, or testing audio. Takes effect at boot: if the emulator is already running muted, add `force: true` to reboot it with sound. A boot snapshot saved in the other audio mode can't be reused, so the first boot after toggling is a slower cold boot. The `boot-sound` argent flag flips this default to true. Ignored on iOS/Vega/Electron, which argent never mutes. */
+        sound?: boolean;
+        /** iOS only: boot the simulator core WITHOUT opening its GUI window (Simulator.app, or Device Hub on Xcode 27+). The device still streams via simulator-server; used by Argent Lens. Set the `ARGENT_SIMULATOR_NO_WINDOW` env var (1/true/yes) to force this host-wide without passing the flag per call (the iOS analog of `ARGENT_EMULATOR_NO_WINDOW`). Ignored on Android/Vega/Electron, which have no equivalent GUI step. */
+        headless?: boolean;
+        /** Electron: path to the Electron app to launch. Either a packaged .app bundle / executable, or a project directory whose package.json points the Electron binary at the entry script. Mutually exclusive with udid/avdName. */
+        electronAppPath?: string;
+        /** Electron-only: CDP remote-debugging port to expose. Defaults to a free port; the resulting device id is `chromium-cdp-<port>`. */
+        electronPort?: number;
+        /** Electron-only: extra CLI arguments forwarded to the Electron binary after the app path. */
+        electronArgs?: Array<string>;
+    };
+    button: {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        udid: string;
+        /** Hardware button to press */
+        button: "home" | "back" | "power" | "volumeUp" | "volumeDown" | "appSwitch" | "actionButton";
+    };
+    "chromium-cookies": {
+        /** Chromium device id from `list-devices` (e.g. `chromium-cdp-9222`). */
+        udid: string;
+        /** get: read cookies. set: create/update a cookie. delete: remove a named cookie. clear: remove all browser cookies. */
+        action: "get" | "set" | "delete" | "clear";
+        /** set/delete: cookie name. */
+        name?: string;
+        /** set: cookie value. */
+        value?: string;
+        /** get: restrict to these URLs (defaults to the active page). set/delete: scope the cookie by URL. */
+        url?: string;
+        /** set/delete: scope the cookie by domain (alt to url). */
+        domain?: string;
+        /** set/delete: cookie path (default /). */
+        path?: string;
+        /** set: mark Secure. */
+        secure?: boolean;
+        /** set: mark HttpOnly. */
+        httpOnly?: boolean;
+        /** set: SameSite policy. */
+        sameSite?: "Strict" | "Lax" | "None";
+        /** set: expiry as a Unix timestamp (seconds). Omit for a session cookie. */
+        expires?: number;
+    };
+    "chromium-storage": {
+        /** Chromium device id from `list-devices` (e.g. `chromium-cdp-9222`). */
+        udid: string;
+        /** Which Web Storage area: `local` (localStorage) or `session` (sessionStorage). */
+        store: "local" | "session";
+        /** get: read one key (with `key`) or all entries. set: write `key`=`value`. remove: delete `key`. clear: empty the store. */
+        action: "get" | "set" | "remove" | "clear";
+        /** get (optional) / set / remove: the storage key. */
+        key?: string;
+        /** set: the value to store. */
+        value?: string;
+    };
+    "chromium-tabs": {
+        /** Chromium device id from `list-devices` (e.g. `chromium-cdp-9222`). */
+        udid: string;
+        /** list: enumerate tabs/windows. select: make a tab active (every other tool then acts on it). new: open a tab. close: close a tab. */
+        action: "list" | "select" | "new" | "close";
+        /** Target tab for `select` / `close`: a tabId like `t2` or a label. `close` defaults to the active tab. */
+        tab?: string;
+        /** `new` only: URL to open (defaults to about:blank). */
+        url?: string;
+        /** `new` only: a memorable label usable interchangeably with the tabId. */
+        label?: string;
+    };
+    "debugger-component-tree": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices — the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial). */
+        device_id: string;
+        /** iOS simulator UDID from list-devices. Pass it when device_id is a logicalDeviceId (two or more devices share one Metro), so that the tap coordinates of a landscape UI are on the screen's axes. Give the UDID of the simulator that shows the app. */
+        udid?: string;
+        /** When true (default), only components visible on screen are returned. Set to false to include all mounted components including those scrolled off-screen. Useful when you need to understand the full page structure. */
+        onScreenOnly?: boolean;
+        /** Maximum total nodes to include. When exceeded, intermediate single-child wrapper chains are collapsed to preserve both root structure and leaf elements. Default: no limit. */
+        maxNodes?: number;
+        /** When true, appends a summary of all filtered components: total fiber count, JS-side skip counts by name, and TS-side filter pass removals. Useful for understanding what was pruned from the tree. */
+        includeSkipped?: boolean;
+    };
+    "debugger-connect": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices: iOS simulator UDID, Android serial, Vega serial (amazon-...), or Chromium device id (chromium-cdp-<port>). Pass this SAME id as device_id to every subsequent debugger-* call to pin them to this device. The returned logicalDeviceId is informational (Metro's own per-connection handle, absent on Vega); you do not switch to it — forwarding it still resolves here, but the list-devices id is the stable one. */
+        device_id: string;
+    };
+    "debugger-evaluate": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices — the SAME id you passed to debugger-connect (iOS simulator UDID, Android serial, Vega serial, or Chromium device id). The logicalDeviceId debugger-connect returns also resolves here, but prefer the stable list-devices id. */
+        device_id: string;
+        /** JavaScript expression to evaluate in the app runtime */
+        expression: string;
+    };
+    "debugger-inspect-element": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices — the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial). */
+        device_id: string;
+        /** Logical X coordinate on device screen */
+        x: number;
+        /** Logical Y coordinate on device screen */
+        y: number;
+        /** Lines of source context to include around the component definition */
+        contextLines?: number;
+        /** When true, resolves bundled frame locations to original source files via Metro symbolication and includes a code fragment. When false, returns the raw bundled frame info (file, line, column) without symbolication or source reading. */
+        resolveSourceMaps?: boolean;
+        /** Maximum number of hierarchy items to return, counted from the bottom (most specific component first). The hierarchy walks from the tapped element up to the root — the first items are the most relevant for editing. Increase to 70+ if you need to understand the broader navigation/screen structure. */
+        maxItems?: number;
+        /** When true, items that would normally be filtered are kept in the response with skipped=true and a skipReason. Useful for understanding what was pruned. */
+        includeSkipped?: boolean;
+    };
+    "debugger-log-registry": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices — the SAME id you passed to debugger-connect (iOS simulator UDID, Android serial, Vega serial, or Chromium device id). The logicalDeviceId debugger-connect returns also resolves here, but prefer the stable list-devices id. */
+        device_id: string;
+    };
+    "debugger-reload-metro": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices — the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial). */
+        device_id: string;
+    };
+    "debugger-status": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices — the SAME id you passed to debugger-connect (iOS simulator UDID, Android serial, Vega serial, or Chromium device id). The logicalDeviceId debugger-connect returns also resolves here, but prefer the stable list-devices id. */
+        device_id: string;
+    };
+    describe: {
+        /** Target device id from `list-devices` (iOS UDID, Android serial, Vega serial, or Chromium id). */
+        udid: string;
+        /** Optional app bundle ID. Used as a target hint on iOS when the AX-service returns no elements and the describe tool falls back to native-devtools inspection. If omitted, the fallback auto-detects the frontmost connected app. Ignored on Android / Chromium, and on a physical iOS device. */
+        bundleId?: string;
+    };
+    "dismiss-update": {
+        /** Number of hours to suppress the update notification */
+        hours: number;
+    };
+    "flow-add-echo": {
+        /** Name of the flow being recorded — the one passed to flow-start-recording. */
+        name: string;
+        /** Absolute path to the project root of the flow being recorded — the same value passed to flow-start-recording. Together with `name` it identifies which recording this echo belongs to. */
+        project_root: string;
+        /** Message to echo when the flow is replayed */
+        message: string;
+    };
+    "flow-add-script": {
+        /** Flow name passed to flow-start-recording. */
+        name: string;
+        /** Absolute project root passed to flow-start-recording. */
+        project_root: string;
+        /** Path to the .mjs file, relative to the flow YAML. For example: "../../scripts/seed-order.mjs". */
+        path: string;
+        /** Optional time limit in milliseconds. The default is 30000 and the minimum is 100. */
+        timeout?: number;
+    };
+    "flow-add-step": {
+        /** Name of the flow being recorded — the one passed to flow-start-recording. */
+        name: string;
+        /** Absolute path to the project root of the flow being recorded — the same value passed to flow-start-recording. Together with `name` it identifies which recording this step belongs to. */
+        project_root: string;
+        /** MCP tool to execute and record, for example "gesture-tap". Do not pass a flow directive or a recording tool. Call flow-add-script directly for a requested script step. */
+        command: string;
+        /** Tool arguments as a JSON string, e.g. '{"udid": "ABC", "x": 0.5, "y": 0.3}'. Omit for tools with no arguments. */
+        args?: string;
+        /** Milliseconds to sleep before executing this step during replay. */
+        delayMs?: number;
+    };
+    "flow-execute": {
+        /** Name of a saved flow to run from `.argent/flows` (e.g. "settings-explore"). Omit when flow_path is set. */
+        name?: string;
+        /** Absolute path to the calling agent's project root — the cwd it is working in. With name, the saved flow is read from `.argent/flows/<name>.yaml` under this root; with flow_path, the flow, its run: siblings, its script: paths and baselines all resolve beside the YAML instead, so pass the agent's cwd. A script still RUNS in this root whichever source was used. */
+        project_root: string;
+        /** Path to the flow .yaml as readable by the tool-server. Internal — the argent client derives it from project_root and name automatically; leave unset. */
+        flow_file?: string;
+        /** Omit when name is set. Absolute path to a co-located flow .yaml on the client and tool server's shared filesystem. This must be supplied through the file-input boundary. For remote execution, pass name + project_root instead. */
+        flow_path?: string;
+        /** Device id to run against (iOS UDID, Android/Vega serial, Chromium id) — the id list-devices reports. Auto-detected when omitted, but only when exactly one booted device matches (optionally narrowed by `platform`); with several booted the run fails and lists them, so pass this explicitly whenever more than one device is up. */
+        device?: string;
+        /** Restrict auto-detection to this platform when several devices are booted. `ios` selects local simulators only — pass `ios-remote` to select a remote one. `chromium` does more than filter: with no `device` it SELECTS the self-boot branch for an e2e flow - the runner boots an Electron instance from the `launch` step's chromium value and tears it down after the run (a single-key `launch: { chromium: … }` map selects it on its own, without this parameter). When it selects that branch it never falls back to device auto-detection (a fragment, or an e2e launch map with no `chromium` key, still does), and the launch value must be a real Electron app path on the tool-server host: a bare-string `launch:` - what the recorder writes - holds an installed-app bundle id, so passing `chromium` for one fails the whole run with `Electron boot: path does not exist`. Edit the launch to `{ chromium: <app path> }` first. */
+        platform?: "ios" | "android" | "chromium" | "vega" | "ios-remote";
+        /** Write/refresh screenshot baselines for `snapshot` steps instead of diffing against them. */
+        updateBaselines?: boolean;
+        /** Set to true to confirm the execution prerequisite has been met. Required (LLM path) when a fragment defines an executionPrerequisite. */
+        prerequisiteAcknowledged?: boolean;
+    };
+    "flow-finish-recording": {
+        /** Name of the flow being recorded — the one passed to flow-start-recording. */
+        name: string;
+        /** Absolute path to the project root of the flow being recorded — the same value passed to flow-start-recording. Together with `name` it identifies which recording to finish. */
+        project_root: string;
+    };
+    "flow-read-prerequisite": {
+        /** Name of a saved flow to inspect from `.argent/flows` (e.g. "settings-explore"). Omit when flow_path is set. */
+        name?: string;
+        /** Absolute path to the calling agent's project root — the cwd it is working in. With name, the saved flow is read from `.argent/flows/<name>.yaml` under this root; with flow_path, the prerequisite is read from that YAML instead, so pass the agent's cwd. */
+        project_root: string;
+        /** Path to the flow .yaml as readable by the tool-server. Internal — the argent client derives it from project_root and name automatically; leave unset. */
+        flow_file?: string;
+        /** Omit when name is set. Absolute path to a co-located flow .yaml on the client and tool server's shared filesystem. This must be supplied through the file-input boundary. Pass the same flow source here as to flow-execute, so the prerequisite you read belongs to the flow that will run; for remote reads, pass name + project_root instead. */
+        flow_path?: string;
+    };
+    "flow-start-recording": {
+        /** Name for this flow (e.g. "settings-explore") — letters, digits, underscore and hyphen only. */
+        name: string;
+        /** Absolute path to the project root directory (the directory that contains or should contain `.argent/flows/`). The flow file is created at `<project_root>/.argent/flows/<name>.yaml`. */
+        project_root: string;
+        /** Fragments only: the app/device state assumed on entry (e.g. "Settings app open on General page"). For a self-contained e2e flow, omit this and record a `restart-app` as the first step instead — it is captured as the flow's `launch` step. restart-app has no chromium support, so a chromium flow records as a fragment; add the `launch: { chromium: <app path> }` line to the YAML afterward, deleting the executionPrerequisite line if you passed one — a flow that starts with a launch must not declare it. */
+        executionPrerequisite?: string;
+    };
+    fold: {
+        /** Target device id from `list-devices` (a foldable iOS simulator UDID). */
+        udid: string;
+        /** Where to move the hinge: `closed` (0°, the cover panel), `half-open` (120°) or `open` (180°, the inner panel). Exactly one of `posture` and `angle`. */
+        posture?: "closed" | "half-open" | "open";
+        /** The hinge angle in degrees, 0 (closed) to 180 (open). Exactly one of `posture` and `angle`. */
+        angle?: number;
+    };
+    "gather-workspace-data": {
+        /** Absolute path to the project root directory to inspect (e.g. /Users/dev/MyApp) */
+        workspacePath: string;
+    };
+    "gesture-custom": {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        udid: string;
+        /** Sequence of touch events; x/y (and optional second touch) are normalized 0.0–1.0, not pixels */
+        events: Array<{
+            /** Touch event type */
+            type: "Down" | "Move" | "Up";
+            /** Normalized x 0.0–1.0 (not pixels; same as tap/swipe) */
+            x: number;
+            /** Normalized y 0.0–1.0 (not pixels; same as tap/swipe) */
+            y: number;
+            /** Second touch x for two-finger gestures: normalized 0.0–1.0 (not pixels) */
+            x2?: number;
+            /** Second touch y for two-finger gestures: normalized 0.0–1.0 (not pixels) */
+            y2?: number;
+            /** Delay before this event in milliseconds (default 16ms ≈ 60fps) */
+            delayMs?: number;
+        }>;
+        /** Number of intermediate Move events to auto-insert between each pair of consecutive events. Smooths out gestures by linearly interpolating both primary (x,y) and secondary (x2,y2) coordinates. The delay is split evenly across interpolated frames. Default: no interpolation. */
+        interpolate?: number;
+    };
+    "gesture-drag": {
+        /** Target Chromium device id from `list-devices` (chromium-cdp-<port>). */
+        udid: string;
+        /** Press x: normalized 0.0–1.0 (fraction of window width, not pixels). */
+        fromX: number;
+        /** Press y: normalized 0.0–1.0 (fraction of window height, not pixels). */
+        fromY: number;
+        /** Release x: normalized 0.0–1.0 (not pixels; same space as tap). */
+        toX: number;
+        /** Release y: normalized 0.0–1.0 (not pixels; same space as tap). */
+        toY: number;
+        /** Total drag duration in milliseconds (default 300, at most 10000 - the button stays down for exactly this long), interpolated at ~60fps. */
+        durationMs?: number;
+        /** Whether the drag releases with momentum; default true (a constant-speed drag). Pass false to decelerate into the release point (ease-out) so an app deriving fling from pointer release velocity (carousels, drag libraries) reads ~0 and applies little to no momentum — use it when the drag must stop where it was aimed rather than fling past. Deceleration needs wall clock: under ~100ms the whole drag fits inside the velocity window a page averages over (tens of ms), so some fling survives, and under ~70ms its extra frames cannot dispatch fast enough to fit durationMs. Keep durationMs at its default when the fling must be fully suppressed. */
+        momentum?: boolean;
+    };
+    "gesture-pinch": {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        udid: string;
+        /** Center of pinch, horizontal: normalized 0.0–1.0 (fraction of screen width, not pixels) */
+        centerX: number;
+        /** Center of pinch, vertical: normalized 0.0–1.0 (fraction of screen height, not pixels) */
+        centerY: number;
+        /** Initial distance between the two fingers: normalized 0.0–1.0 (fraction of screen, not pixels). E.g. 0.2 = fingers 20% of screen apart. Use a larger startDistance than endDistance to pinch in (zoom out). */
+        startDistance: number;
+        /** Final distance between the two fingers: normalized 0.0–1.0 (fraction of screen, not pixels). E.g. 0.6 = fingers 60% of screen apart. Use a larger endDistance than startDistance to pinch out (zoom in). */
+        endDistance: number;
+        /** Final horizontal center of the pinch: normalized 0.0–1.0. When set, the centroid drifts linearly from centerX to endCenterX over the gesture (e.g. to keep expanding fingers on-screen near an edge). Omit for a fixed center. */
+        endCenterX?: number;
+        /** Final vertical center of the pinch: normalized 0.0–1.0. When set, the centroid drifts linearly from centerY to endCenterY over the gesture. Omit for a fixed center. */
+        endCenterY?: number;
+        /** Axis angle in degrees along which the fingers are placed (default 0 = horizontal). */
+        angle?: number;
+        /** Total gesture duration in milliseconds (default 300) */
+        durationMs?: number;
+    };
+    "gesture-rotate": {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        udid: string;
+        /** Center of rotation, horizontal: normalized 0.0–1.0 (fraction of screen width, not pixels) */
+        centerX: number;
+        /** Center of rotation, vertical: normalized 0.0–1.0 (fraction of screen height, not pixels) */
+        centerY: number;
+        /** Distance from center to each finger: normalized 0.0–1.0 (fraction of screen, not pixels). E.g. 0.15 = fingers placed 15% of screen away from center. One value for both axes, so on a non-square screen the orbit is a physical ellipse — pass radiusX+radiusY instead for a true circle. Required unless radiusX and radiusY are given. */
+        radius?: number;
+        /** Per-axis finger distance, horizontal: normalized 0.0–1.0 fraction of screen WIDTH. Give both radiusX and radiusY (they override radius) with radiusX·screenWidth = radiusY·screenHeight for a physically circular orbit — constant finger separation, no pinch coupled into the turn. */
+        radiusX?: number;
+        /** Per-axis finger distance, vertical: normalized 0.0–1.0 fraction of screen HEIGHT. Always paired with radiusX — see radiusX. */
+        radiusY?: number;
+        /** Starting angle in degrees (0 = right, 90 = down) */
+        startAngle: number;
+        /** Ending angle in degrees. endAngle > startAngle = clockwise. */
+        endAngle: number;
+        /** Total gesture duration in milliseconds (default 300) */
+        durationMs?: number;
+    };
+    "gesture-scroll": {
+        /** Target Chromium device id from `list-devices` (chromium-cdp-<port>). */
+        udid: string;
+        /** Anchor x: normalized 0.0–1.0 (fraction of window width, not pixels). The wheel events land here — put it over the element you want to scroll. */
+        x: number;
+        /** Anchor y: normalized 0.0–1.0 (fraction of window height, not pixels). */
+        y: number;
+        /** Horizontal scroll distance as a fraction of the window width (e.g. 0.5 = half a window). Positive scrolls content right (reveals content to the right). */
+        deltaX?: number;
+        /** Vertical scroll distance as a fraction of the window height (e.g. 0.5 = half a window). Positive scrolls content down (reveals content below), like rolling a mouse wheel toward you. */
+        deltaY?: number;
+        /** Spread the scroll over this many milliseconds in wheel-event steps (default 300) so scroll handlers fire progressively. */
+        durationMs?: number;
+    };
+    "gesture-swipe": {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        udid: string;
+        /** Start x: normalized 0.0–1.0 (not pixels; same as tap) */
+        fromX: number;
+        /** Start y: normalized 0.0–1.0 (not pixels; same as tap) */
+        fromY: number;
+        /** End x: normalized 0.0–1.0 (not pixels; same as tap) */
+        toX: number;
+        /** End y: normalized 0.0–1.0 (not pixels; same as tap) */
+        toY: number;
+        /** Total gesture duration in milliseconds (default 300, at most 10000 - the gesture holds a finger down for exactly this long) */
+        durationMs?: number;
+        /** Whether the swipe releases with momentum; default true (a natural flinging swipe). Pass false for a momentum-free swipe at the default durationMs: the finger decelerates into the end point (ease-out) so the OS reads ~0 release velocity and applies little to no fling. Use false for scroll-to-element loops. momentum: false needs durationMs >= 150 and is rejected below it: a shorter ease-out gives the OS velocity fit too little wall clock to read the deceleration as a stop, and it flings harder than a plain swipe instead (on Android, backwards). At 150 itself the swipe lands short of where the finger stopped, and 2 of 47 runs still flung backwards. */
+        momentum?: boolean;
+    };
+    "gesture-tap": {
+        /** Target device id from `list-devices` (iOS UDID, Android serial, or Chromium id). */
+        udid: string;
+        /** Normalized horizontal position 0.0–1.0 (left=0, right=1), not pixels */
+        x: number;
+        /** Normalized vertical position 0.0–1.0 (top=0, bottom=1), not pixels */
+        y: number;
+        /** Number of taps/clicks dispatched as ONE multi-tap gesture (2 = double-tap / double-click). The taps land inside the OS double-tap window; on Chromium each click carries an escalating CDP clickCount so dblclick actually fires; on physical iOS 2 is the native double-tap and higher counts land as separate taps. Default 1. */
+        clickCount?: number;
+    };
+    keyboard: {
+        /** Target device id from `list-devices` (iOS UDID, Android serial, Vega serial, or Chromium id). */
+        udid: string;
+        /** Text to type character by character. Cannot be combined with `key` in one call — one call per action; to type and then press a key, put two `keyboard` steps in one `run-sequence`. Handles uppercase and common punctuation. To type a credential without its plaintext ever entering your context, use a secret placeholder: `{{secret:<NAME>}}` — e.g. text: "{{secret:APP_PASSWORD}}". The value is resolved on the machine running the tool-server, from the first source that defines the name: the `ARGENT_SECRET_<NAME>` environment variable, `.argent/secrets.env` in the project, the project's `.env.local` / `.env` (only their `ARGENT_SECRET_`-prefixed keys), then `~/.argent/secrets.env`. Nothing else on the host is reachable. Placeholders can be embedded in longer text and are never echoed back resolved. If the secret you need is not set, the failure lists the available names and every source it looked in — ask the user to add it to one of them (a secrets file applies immediately; an env var needs a restart), NEVER ask the user to paste the secret value into the conversation. */
+        text?: string;
+        /** Named key to press: enter, escape, backspace, tab, space, arrow-up, arrow-down, arrow-left, arrow-right, f1-f12. Cannot be combined with `text` in one call: one call per action; to type and then press a key, put two `keyboard` steps in one `run-sequence`. Not supported on TV targets; move focus with `tv-remote` (up/down/left/right) instead. Physical iOS: only `enter` and `backspace`. */
+        key?: string;
+        /** Delay in ms between key presses (default 50). Ignored on Android phones/tablets (typed via `adb input text`, which has no per-key cadence), on Vega (text/keys injected in a single shot), on TV targets (Apple TV / Android TV type the whole string at the daemon's own cadence), and on physical iOS. */
+        delayMs?: number;
+    };
+    "launch-app": {
+        /** Target device id from `list-devices` (iOS UDID, Android serial, or Chromium id). */
+        udid: string;
+        /** App identifier. iOS: bundle id (e.g. com.apple.MobileSMS). Android: package name from build.gradle `applicationId` (e.g. com.android.settings). Chromium: any tag matching the same alphabet (letters, digits, '.', '_' and '-'); the call is a no-op since the renderer is already running. */
+        bundleId: string;
+        /** Android-only: fully-qualified Activity name (e.g. `.MainActivity` or `com.example/com.example.MainActivity`). If omitted on Android, the app's default launcher activity is used. Ignored on iOS / Chromium. */
+        activity?: string;
+    };
+    "list-devices": Record<string, never>;
+    "native-describe-screen": {
+        /** Simulator UDID */
+        udid: string;
+        /** Bundle ID of the app */
+        bundleId: string;
+        /** Exact UIView class names whose entire subtree should be pruned (e.g. ["UIImageView"] to drop image-heavy branches) */
+        skipClasses?: Array<string>;
+        /** Class name prefixes to prune entire subtrees. For SwiftUI apps use ["_TtGC7SwiftUI"] to drop mangled SwiftUI generic type subtrees while keeping UIKit bridges. */
+        skipClassPrefixes?: Array<string>;
+    };
+    "native-devtools-status": {
+        /** Simulator UDID */
+        udid: string;
+        /** Bundle ID of the app to check (e.g. com.example.MyApp) */
+        bundleId: string;
+    };
+    "native-find-views": {
+        /** Simulator UDID */
+        udid: string;
+        /** Bundle ID of the app */
+        bundleId: string;
+        /** UIView class name to match (exact, e.g. UIButton) */
+        className?: string;
+        /** Accessibility identifier to match (exact) */
+        identifier?: string;
+        /** Accessibility label to match (exact) */
+        label?: string;
+        /** UIView tag integer to match */
+        tag?: number;
+        /** React Native nativeID prop to match (exact) */
+        nativeID?: string;
+        /** Include ancestor chain for each matched view (default true) */
+        includeAncestors?: boolean;
+        /** Include child views for each matched view (default true) */
+        includeChildren?: boolean;
+        /** View fields to include. Defaults: className, frame, hidden, alpha, identifier, label, nativeID, userInteractionEnabled, depth. Additional: pointer, tag, windowFrame, screenFrame, bounds, center, opaque, clipsToBounds, transform, contentMode, backgroundColor, tintColor, layerName */
+        fields?: Array<string>;
+    };
+    "native-full-hierarchy": {
+        /** Simulator UDID */
+        udid: string;
+        /** Bundle ID of the app */
+        bundleId: string;
+        /** View fields to include. Use EXACT names: className, frame, hidden, alpha, identifier, label, nativeID, userInteractionEnabled, depth, pointer, tag, windowFrame, screenFrame, bounds, center, opaque, clipsToBounds, transform, contentMode, backgroundColor, tintColor, layerName. Defaults to all of the first group when omitted. */
+        fields?: Array<string>;
+        /** Exact UIView class names whose entire subtree should be pruned (e.g. ["UIImageView"] to drop image leaf nodes) */
+        skipClasses?: Array<string>;
+        /** Class name prefixes to prune entire subtrees. For SwiftUI apps use ["_TtGC7SwiftUI"] to drop mangled SwiftUI generic type subtrees while keeping _UIHostingView and UIKit bridges. Avoid broad prefixes like "_UI" — they prune useful system views. */
+        skipClassPrefixes?: Array<string>;
+        /** Maximum recursion depth (default 8). Increase for deeper inspection, decrease to reduce output size. */
+        maxDepth?: number;
+    };
+    "native-network-logs": {
+        /** Simulator UDID */
+        udid: string;
+        /** Bundle ID of the app */
+        bundleId: string;
+        /** Maximum number of events to return (most recent first) */
+        limit?: number;
+        /** Clear the log after reading */
+        clear?: boolean;
+    };
+    "native-profiler-analyze": {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        device_id: string;
+    };
+    "native-profiler-start": {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        device_id: string;
+        /** iOS: the CFBundleExecutable or display name of the app to profile. Android: the app's package name. If omitted, auto-detects the currently running foreground app. Only provide this if auto-detection picks the wrong app. */
+        app_process?: string;
+        /** iOS-only: path to an Instruments .tracetemplate file (defaults to bundled Argent template). Ignored on Android. */
+        template_path?: string;
+        /** iOS-only. When true, cold-launches the app under the profiler with Malloc Stack Logging enabled so memory leaks carry an allocation backtrace (responsible frame + library). Without it, leaks are still detected but unattributable — Instruments reports '<Call stack limit reached>'. Trade-offs: this RESTARTS the app (current state is lost), adds memory/CPU overhead, and makes the app noticeably slow to launch (every startup allocation records a backtrace), so leave it off for pure CPU/hang profiling. Requires a non-degraded Xcode: on Xcode 26.4 and later the cold-launch path is broken, so the call is rejected up front (re-run without the flag, or set ARGENT_IOS_CAPTURE=device to override if the device path works on your host). ARGENT_IOS_CAPTURE=all-processes — e.g. exported globally for the normal capture path — also rejects this flag up front, since that fallback cannot cold-launch; unset it (or set it to device) first. Ignored on Android. */
+        malloc_stack_logging?: boolean;
+    };
+    "native-profiler-stop": {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        device_id: string;
+    };
+    "native-user-interactable-view-at-point": {
+        /** Simulator UDID */
+        udid: string;
+        /** Bundle ID of the app */
+        bundleId: string;
+        /** Raw X coordinate in points, on the portrait axes of the screen (the axes of native-describe-screen frames). NOT normalized [0,1] tap space. */
+        x: number;
+        /** Raw Y coordinate in points, on the portrait axes of the screen (the axes of native-describe-screen frames). NOT normalized [0,1] tap space. */
+        y: number;
+        /** Include ancestor chain for the matched view (default true) */
+        includeAncestors?: boolean;
+        /** Include child views for the matched view (default false) */
+        includeChildren?: boolean;
+        /** View fields to include. Defaults: pointer, className, tag, frame, windowFrame, screenFrame, bounds, hidden, alpha, opaque, clipsToBounds, userInteractionEnabled, depth, identifier, label, layerName, nativeID. Additional: center, transform, contentMode, backgroundColor, tintColor */
+        fields?: Array<string>;
+        /** Exact UIView class names whose entire subtree should be pruned */
+        skipClasses?: Array<string>;
+        /** Class name prefixes to prune entire subtrees */
+        skipClassPrefixes?: Array<string>;
+        /** Maximum depth for returned child/ancestor serialization (default 150) */
+        maxDepth?: number;
+    };
+    "native-view-at-point": {
+        /** Simulator UDID */
+        udid: string;
+        /** Bundle ID of the app */
+        bundleId: string;
+        /** Raw X coordinate in points, on the portrait axes of the screen (the axes of native-describe-screen frames). NOT normalized [0,1] tap space. */
+        x: number;
+        /** Raw Y coordinate in points, on the portrait axes of the screen (the axes of native-describe-screen frames). NOT normalized [0,1] tap space. */
+        y: number;
+        /** Include ancestor chain for the matched view (default true) */
+        includeAncestors?: boolean;
+        /** Include child views for the matched view (default false) */
+        includeChildren?: boolean;
+        /** View fields to include. Defaults: pointer, className, tag, frame, windowFrame, screenFrame, bounds, hidden, alpha, opaque, clipsToBounds, userInteractionEnabled, depth, identifier, label, layerName, nativeID. Additional: center, transform, contentMode, backgroundColor, tintColor */
+        fields?: Array<string>;
+        /** Exact UIView class names whose entire subtree should be pruned */
+        skipClasses?: Array<string>;
+        /** Class name prefixes to prune entire subtrees */
+        skipClassPrefixes?: Array<string>;
+        /** Maximum depth for returned child/ancestor serialization (default 150) */
+        maxDepth?: number;
+    };
+    "open-url": {
+        /** Target device id from `list-devices` (iOS UDID, Android serial, or Chromium id). */
+        udid: string;
+        /** URL or scheme to open (e.g. https://example.com, messages://, tel:555, geo:37.0,-122.0). For Chromium this navigates the renderer. */
+        url: string;
+        /** Physical iOS only: the app that receives the URL. Defaults to Safari for http(s); required for any other scheme. Ignored elsewhere. */
+        bundleId?: string;
+    };
+    paste: {
+        /** Target device id from `list-devices` (iOS simulator UDID or Android emulator serial). */
+        udid: string;
+        /** Text to put on the device clipboard and paste into the focused field. Supports `{{secret:<NAME>}}` placeholders, resolved on the tool-server from the `ARGENT_SECRET_<NAME>` environment variable or an argent secrets file — the same sources as `keyboard` — so a credential never enters your context. If the secret is not set, the failure lists the available names and every source it looked in; ask the user to add it there, NEVER ask for the value in the conversation. */
+        text: string;
+    };
+    "profiler-combined-report": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** iOS Simulator/device UDID or Android serial */
+        device_id: string;
+    };
+    "profiler-commit-query": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId). */
+        device_id: string;
+        /** Query mode: by_component (commits for a component), by_time_range (commits in a window), by_index (full detail for one commit), cascade_tree (parent-child cascade for a commit) */
+        mode: "by_component" | "by_time_range" | "by_index" | "cascade_tree";
+        /** Component name for by_component mode */
+        component_name?: string;
+        /** Time range filter for by_time_range mode */
+        time_range_ms?: {
+            /** Start of range in ms since profiling started — the same clock profiler-commit-query prints */
+            start: number;
+            /** End of range in ms since profiling started — the same clock profiler-commit-query prints */
+            end: number;
+        };
+        /** Commit index for by_index and cascade_tree modes */
+        commit_index?: number;
+        /** Max results to return. Defaults to 20 for by_component / by_time_range, which count commits. by_index counts individual fibers and returns all of them unless this is set, because one commit's fibers collapse to far fewer distinct components — a small cap there can show less than the analyze report it is meant to expand on. */
+        top_n?: number;
+    };
+    "profiler-cpu-query": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId). */
+        device_id: string;
+        /** Query mode: top_functions (global hotspots), time_window (CPU in a time range), call_tree (callers/callees of a function), component_cpu (CPU during a component's commits) */
+        mode: "top_functions" | "time_window" | "call_tree" | "component_cpu";
+        /** Time window filter for time_window mode (ms since profiling started — the same clock profiler-commit-query prints) */
+        time_window_ms?: {
+            /** Start of window in ms since profiling started — the same clock profiler-commit-query prints */
+            start: number;
+            /** End of window in ms since profiling started — the same clock profiler-commit-query prints */
+            end: number;
+        };
+        /** Component name for component_cpu mode */
+        component_name?: string;
+        /** Function name for call_tree mode */
+        function_name?: string;
+        /** Number of results to return (default 15) */
+        top_n?: number;
+        /** For call_tree mode: also show callers of the function */
+        include_callers?: boolean;
+    };
+    "profiler-load": {
+        /** list: show available sessions on disk. load_react: load a React profiler session into memory for query tools. load_native: re-parse native profiler XML files (xctrace on iOS) into memory for query tools. */
+        mode: "list" | "load_react" | "load_native";
+        /** Timestamp-based session identifier (e.g. '20250313-143022') from the list output. Required for load_react and load_native modes. */
+        session_id?: string;
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Target device id from `list-devices`. Used to cache the loaded React session under the correct port+device key, and required to resolve the native profiler session for load_native. */
+        device_id: string;
+        /** Android package name to use when restoring older load_native .pftrace sessions that do not have a metadata sidecar. */
+        app_process?: string;
+    };
+    "profiler-stack-query": {
+        /** iOS Simulator UDID or Android serial. */
+        device_id: string;
+        /** Query mode: hang_stacks (full CPU context during a hang), function_callers (who calls a native function), thread_breakdown (CPU split by thread), leak_stacks (leak details by object type) */
+        mode: "hang_stacks" | "function_callers" | "thread_breakdown" | "leak_stacks";
+        /** 0-based index into the hang list for hang_stacks mode */
+        hang_index?: number;
+        /** Function name for function_callers mode */
+        function_name?: string;
+        /** Thread filter. thread_breakdown: case-insensitive substring match. function_callers: exact raw thread name (e.g. ".blueskyweb.app"), or "main" for the UI thread; omit to search ALL threads (each result is tagged with its thread). Run thread_breakdown first to see the exact raw names. */
+        thread?: string;
+        /** Object type filter for leak_stacks mode */
+        object_type?: string;
+        /** Max results to return (default 15) */
+        top_n?: number;
+    };
+    propose_variant: {
+        /** Human name of the on-screen element this variant targets, e.g. "Foo button" or "profile header". Repeated calls with the same element accumulate multiple variants on it. Used as the default screen matcher when `match` is omitted. */
+        element: string;
+        /** Device id (iOS udid / Android serial) the variants were captured on. The preview window streams THIS device directly — pass the same udid you screenshotted/described with, so the human never has to pick a simulator. Set it on the first propose_variant of a round; later calls may omit it (the last non-empty value wins). */
+        udid?: string;
+        /** Optional precise matcher so the floating variant bubble anchors to the right element on the streamed screen. Defaults to { by: 'text', value: element }. Get exact labels/identifiers from the `describe` tool first for reliable anchoring. */
+        match?: {
+            /** How the preview window locates the live element in the running app's accessibility tree: `text` (fuzzy contains on label/value/identifier), `label` (exact a11y label), `identifier` (exact testID / accessibilityIdentifier / resource-id), `role` (e.g. Button). */
+            by: "text" | "label" | "identifier" | "role";
+            /** Value to match against, per `by`. */
+            value: string;
+        };
+        /** The variant being proposed for `element`. */
+        variant: {
+            /** Short variant name shown on the chip, e.g. "Bold CTA". */
+            name: string;
+            /** One- or two-sentence description of what this variant changes and why. */
+            summary: string;
+            /** Optional inline code/JSX for the variant, shown when the chip is expanded. */
+            code?: string;
+            /** Optional path to a file containing the variant implementation. */
+            filePath?: string;
+            /** Required preview of how the variant looks, shown on the floating card. An http(s) URL, a data: URI, or a local image file path (e.g. a screenshot path returned by the screenshot tool after you rendered the variant). */
+            previewImage: string;
+            /** Normalized [0..1] bounds (fractions of screen width/height) of the target element AS IT APPEARS IN THIS VARIANT — read the matched node's `frame` from `describe` AFTER applying this variant. The preview window crops the screenshot to these bounds, so each variant shows its own re-laid-out element instead of every variant sharing one stale frame. The element moves/resizes between variants, so capture it per variant. Omit if unknown. */
+            frame?: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+            };
+        };
+    };
+    "react-profiler-analyze": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId). */
+        device_id: string;
+        /** Absolute path to the RN project root for session context detection */
+        project_root: string;
+        /** Target platform */
+        platform?: "ios" | "android";
+        /** React Native version (e.g. "0.73.4") */
+        rn_version?: string;
+        /** Optional list of user actions with their time offset from profiling start. Compute offsetMs = tapTimestampMs - startedAtEpochMs, where tapTimestampMs comes from the tap/swipe tool return value and startedAtEpochMs comes from react-profiler-start return value. */
+        annotations?: Array<{
+            /** Milliseconds since profiling started. Compute as: tapTimestampMs - startedAtEpochMs, using the timestampMs returned by tap/swipe and the startedAtEpochMs returned by react-profiler-start. */
+            offsetMs: number;
+            /** Description of the action performed */
+            label: string;
+        }>;
+    };
+    "react-profiler-component-source": {
+        /** Name of the React component to look up */
+        component_name: string;
+        /** Absolute path to the RN project root */
+        project_root: string;
+    };
+    "react-profiler-cpu-summary": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId). */
+        device_id: string;
+        /** Number of top hotspot functions to return (default 20) */
+        top_n?: number;
+        /** If true, only show React component functions (PascalCase names) */
+        react_only?: boolean;
+    };
+    "react-profiler-fiber-tree": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId). */
+        device_id: string;
+        /** Maximum tree depth to traverse (default 10) */
+        max_depth?: number;
+        /** Regex string to filter component names */
+        filter?: string;
+    };
+    "react-profiler-renders": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId). */
+        device_id: string;
+        /** Number of top re-rendering components to return (default 20) */
+        top_n?: number;
+    };
+    "react-profiler-start": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices — the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial). */
+        device_id: string;
+        /** CPU sampling interval in microseconds (default 100) */
+        sample_interval_us?: number;
+        /** Take over an active profiling session even when it is owned by another tool-server and still fresh. Set to true only when you know the prior owner is gone. */
+        force?: boolean;
+    };
+    "react-profiler-status": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device logicalDeviceId from debugger-connect (iOS simulator UDID or Android logicalDeviceId). */
+        device_id: string;
+    };
+    "react-profiler-stop": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices — the SAME id you passed to debugger-connect (iOS simulator UDID or Android serial). */
+        device_id: string;
+    };
+    "reinstall-app": {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        udid: string;
+        /** App identifier that matches the bundle at `appPath`. iOS: bundle id (used to uninstall first). Android: package name (used to uninstall first; the install itself identifies the app from the APK). Vega: interactive component app id (e.g. com.example.app.main), used to uninstall first. */
+        bundleId: string;
+        /** Path to the app bundle. iOS: `.app` directory (e.g. ./build/.../MyApp.app). Android: `.apk` file (e.g. android/app/build/outputs/apk/debug/app-debug.apk). Vega: `.vpkg` file. Relative paths are resolved from the current working directory. */
+        appPath: string;
+    };
+    "restart-app": {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        udid: string;
+        /** App identifier. iOS: bundle id. Android: package name. */
+        bundleId: string;
+        /** Android-only: relaunch a non-launcher Activity (e.g. `.SettingsActivity` or `com.example/com.example.SettingsActivity`). If omitted, the app's default launcher activity is used. Ignored on iOS. */
+        activity?: string;
+    };
+    rotate: {
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        udid: string;
+        /** Target orientation */
+        orientation: "Portrait" | "LandscapeLeft" | "LandscapeRight" | "PortraitUpsideDown";
+    };
+    "run-sequence": {
+        /** Target device id from `list-devices` (iOS UDID, Android serial, Vega serial, or Chromium id) — shared across all steps. */
+        udid: string;
+        /** Ordered list of interaction steps to execute sequentially */
+        steps: Array<{
+            /** Tool name — one of: gesture-tap, gesture-swipe, gesture-scroll, gesture-drag, gesture-custom, gesture-pinch, gesture-rotate, button, keyboard, paste, rotate, shake, fold, tv-remote, await-ui-element. On a TV target (Apple TV / Android TV / Vega) use tv-remote (remote presses) and keyboard (text). */
+            tool: string;
+            /** Tool arguments (excluding udid, which is injected automatically) */
+            args: {
+                [key: string]: unknown;
+            };
+            /** Wait time in ms after this step before the next (default 100) */
+            delayMs?: number;
+        }>;
+    };
+    "screen-recording-start": {
+        /** Target device id from `list-devices` (iOS Simulator UDID or Android serial). */
+        udid: string;
+        /** Auto-stop cap in seconds (default 180, max 600). Set it to slightly more than the interaction you plan to capture. */
+        timeLimitSeconds?: number;
+        /** Default true. Collapse stretches where the screen does not change: the first second of each still stretch is kept, then unchanged frames are dropped until something moves again, so a long recording with brief activity comes back short instead of full of dead air. The returned durationMs is the trimmed length; wallClockMs/trimmedMs report what was removed. Set false to keep a faithful real-time recording. */
+        trimStatic?: boolean;
+        /** Default true. Draw simulator-server's touch visualizer into the recording: a pulse marks each tap, a comet trail follows swipes and drags, and paired markers show two-finger pinch/rotate, so the video makes clear where every interaction landed. Set false to record the raw screen with no overlay. */
+        showTouches?: boolean;
+    };
+    "screen-recording-stop": {
+        /** Target device id from `list-devices` (iOS Simulator UDID or Android serial). */
+        udid: string;
+    };
+    screenshot: {
+        /** Target device id from `list-devices` (iOS UDID, Android serial, Apple TV UDID, Vega serial, or Chromium id). */
+        udid: string;
+        /** Orientation override for the screenshot (rotates the captured image after Page.captureScreenshot on Chromium). On Android the capture already follows the device's rotation. Ignored on physical iPhones. */
+        rotation?: "Portrait" | "LandscapeLeft" | "LandscapeRight" | "PortraitUpsideDown";
+        /** Scale factor (0.01-1.0). Defaults to ARGENT_SCREENSHOT_SCALE env var, or 0.25 if unset for iOS/Android. On Chromium the default is 1.0 (no downscale); pass <1 to opt in. Downscaling on Chromium requires the optional `sharp` dependency. */
+        scale?: number;
+        /** Default true. Set false only when capturing a full-resolution PNG (scale: 1.0) to save as a baseline/current for screenshot-diff — the file is still written, but the image bytes are not attached to the agent context. */
+        includeImageInContext?: boolean;
+        /** Downscaling algorithm when scale<1 on Chromium. Defaults to lanczos3 (highest quality). Mirrors sim-server's wire enum. Ignored on physical iPhones. */
+        downscaler?: "lanczos3" | "box" | "bilinear" | "nearest";
+    };
+    "screenshot-diff": {
+        /** Path to the baseline PNG file. Required unless captureBaseline is true. */
+        baselinePath?: string;
+        /** Path to the current PNG file. Required unless captureCurrent is true. */
+        currentPath?: string;
+        /** Target device id from `list-devices` (iOS UDID or Android serial). */
+        udid: string;
+        /** Capture the baseline screenshot live at full resolution before diffing. Cannot be combined with captureCurrent. */
+        captureBaseline?: boolean;
+        /** Capture the current screenshot live at full resolution before diffing. Cannot be combined with captureBaseline. */
+        captureCurrent?: boolean;
+        /** Orientation override for live baseline/current captures. Ignored on physical iPhones. */
+        rotation?: "Portrait" | "LandscapeLeft" | "LandscapeRight" | "PortraitUpsideDown";
+        /** Directory where diff artifacts should be written. Optional — defaults to a temp directory; the diff images are returned in the result either way. */
+        outputDir?: string;
+    };
+    "settings-permissions": {
+        /** Target device id from `list-devices` (iOS simulator UDID or Android serial). */
+        udid: string;
+        /** `grant` pre-authorizes the permission, `deny` refuses it, `reset` returns it to the not-yet-asked state so the app prompts on next use. */
+        action: "grant" | "deny" | "reset";
+        /** The permission to change. `notifications` is Android-only (iOS has no simctl service for it); `reminders` is iOS-only; `camera` works on Android and on iOS only when the target simulator's runtime models the service (varies by simruntime, not by the installed Xcode). */
+        permission: "camera" | "microphone" | "photos" | "contacts" | "notifications" | "calendar" | "location" | "location-always" | "media-library" | "motion" | "reminders";
+        /** App to change the permission for — required for every action. iOS: bundle id (e.g. com.example.app). Android: package name. `reset` is per-app too: simctl's device-wide reset (no bundleId) silently leaves existing per-app grants untouched on recent iOS, so the permission is always reset for this one app. */
+        bundleId: string;
+    };
+    shake: {
+        /** Target device id from `list-devices` (iOS simulator UDID or Android emulator serial). */
+        udid: string;
+        /** How many shake gestures to deliver back-to-back (default 1, max 10). Raise it for apps whose shake detector needs sustained motion before it fires. */
+        count?: number;
+    };
+    "stop-all-simulator-servers": {
+        /** Device ids (iOS UDID / Android serial / Chromium id) to scope the teardown to — pass the devices THIS session actually used. Omit only for a deliberate machine-wide cleanup: one tool-server serves every agent using this argent install, so an unscoped stop also kills devices another agent is mid-session on. */
+        devices?: Array<string>;
+    };
+    "stop-metro": {
+        /** TCP port Metro is listening on (default 8081) */
+        port?: number;
+    };
+    "stop-simulator-server": {
+        /** Target device id (iOS UDID, Android serial, or Chromium id) whose transport session to stop */
+        udid: string;
+    };
+    "tv-remote": {
+        /** Target TV device id from `list-devices` (Apple TV, Android TV, or Vega). */
+        udid: string;
+        /** A single TV-remote button, or a path of them run in one call. Buttons: up/down/left/right (D-pad), select (OK), back, home, menu, playPause, rewind, fastForward, next, previous, volumeUp, volumeDown, mute. The media-transport and volume keys work on Android TV and Vega; on the Apple TV simulator they are rejected (its HID stack ignores them) — the D-pad/select/back/menu/home/playPause core works on all three. For multi-step navigation pass an array, e.g. ["up","right","right","select"] — strongly prefer this over multiple `tv-remote` calls: the whole path runs in a single call. */
+        button?: "up" | "down" | "left" | "right" | "select" | "back" | "home" | "menu" | "playPause" | "rewind" | "fastForward" | "next" | "previous" | "volumeUp" | "volumeDown" | "mute" | Array<"up" | "down" | "left" | "right" | "select" | "back" | "home" | "menu" | "playPause" | "rewind" | "fastForward" | "next" | "previous" | "volumeUp" | "volumeDown" | "mute">;
+        /** Repeat the whole `button` value this many times (default 1). Compact for long same-button runs, e.g. { button: "down", repeat: 12 }. */
+        repeat?: number;
+    };
+    "update-argent": {
+        /** Which install to update. 'auto' (default) updates the install serving this session — the global PATH install or this project's local devDependency, whichever this server runs from. Pass 'global' / 'local' to force one, or 'both' when the user has both and wants each updated. */
+        target?: "auto" | "global" | "local" | "both";
+    };
+    "view-network-logs": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices (iOS simulator UDID or Android serial) — the same id used with debugger-connect. */
+        device_id: string;
+        /** Page index (0-based) or "latest" for the most recent page. Each page contains up to 50 entries. */
+        pageIndex?: number | "latest";
+    };
+    "view-network-request-details": {
+        /** Metro server port. Optional — omit it to use this device's port, 8081 by default. Ignored for Chromium, whose CDP port is encoded in device_id. */
+        port?: number;
+        /** Device id from list-devices (iOS simulator UDID or Android serial) — the same id used with debugger-connect. */
+        device_id: string;
+        /** The requestId from view-network-logs to get full details for */
+        requestId: string;
+        /** Whether to include the response body (if captured). Defaults to true. */
+        includeBody?: boolean;
+    };
+}

package/dist/tool-server.cjs

@@ -94814,7 +94814,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID = (0, import_node_crypto3.randomUUID)();
 function readCliVersion() {
   if (true) {
-    return "0.27.1-next.0";
+    return "0.27.1-next.2";
   }
   return "0.0.0";
 }
@@ -115596,6 +115596,7 @@ function createHttpApp(registry2, options) {
       if (def.alwaysLoad) entry.alwaysLoad = true;
       if (def.searchHint) entry.searchHint = def.searchHint;
       if (def.longRunning) entry.longRunning = true;
+      if (def.hideFromMcp) entry.hideFromMcp = true;
       return entry;
     });
     res.json({ tools });
@@ -158522,11 +158523,13 @@ function createRegistry() {
   registry2.registerTool(updateArgentTool);
   registry2.registerTool(dismissUpdateTool);
   if (process.platform === "darwin") {
-    registry2.registerTool(createProposeVariantTool(registry2));
-    registry2.registerTool(awaitUserSelectionTool);
+    for (const tool of createLensTools(registry2)) registry2.registerTool(tool);
   }
   return registry2;
 }
+function createLensTools(registry2) {
+  return [createProposeVariantTool(registry2), awaitUserSelectionTool];
+}
 
 // ../tool-server/src/utils/probe-argent-tool-server.ts
 var http5 = __toESM(require("node:http"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swmansion/argent",
-  "version": "0.27.1-next.0",
+  "version": "0.27.1-next.2",
   "mcpName": "io.github.software-mansion/argent",
   "description": "MCP server for iOS Simulator and Android Emulator control",
   "license": "Apache-2.0",
@@ -40,7 +40,8 @@
   },
   "scripts": {
     "build": "npm run build:dispatcher && npm run build:bundles && npm run sync-readme",
-    "build:dispatcher": "rm -rf dist tsconfig.tsbuildinfo && tsc",
+    "build:dispatcher": "npm run build:tool-args && rm -rf dist tsconfig.tsbuildinfo && tsc",
+    "build:tool-args": "tsc --build ../tool-server && node ../tool-server/dist/sdk-tool-args.js src/tool-args.generated.ts",
     "build:bundles": "node scripts/bundle-tools.cjs",
     "sync-readme": "node scripts/sync-readme.cjs",
     "prepack": "node scripts/sync-readme.cjs",