Skip to content

Computer use for the Pi coding agent — Windows apps, browsers and desktops through native UI trees, screenshots and real input.

feat: typed computer_wait and computer_browser (LPT-934 step 2)

alexshpunt-clanker[bot]93e47cc53aa4
diff --git a/docs/computer-resources.md b/docs/computer-resources.md
index 043febe..76465d4 100644
--- a/docs/computer-resources.md
+++ b/docs/computer-resources.md
@@ -18,6 +18,8 @@ Some operations have their own tool with typed fields, in both modes. They are d
| `computer_open` | Starts an app by name or path, a Playwright browser, a Windows Sandbox or an isolated session at a machine address; opens an app address; attaches Playwright to a browser window address | Insert `open`, `open_browser`, `open_sandbox`, `open_session`, `attach_browser` |
| `computer_window` | Moves, resizes, maximizes, minimizes, focuses or restores a window by its address | Read `state`, then Insert into the window-state address |
| `computer_display` | Changes a display's resolution | Insert `resize` into a display |
+| `computer_wait` | Waits until a window's UI or a browser page meets [conditions](#verify-and-wait), or checks them once (`mode: "check"`) | Insert `wait_for` and `verify` into a window |
+| `computer_browser` | Navigates, manages tabs, answers dialogs, uploads, waits for or cancels downloads, and runs page JavaScript in a browser window by its address | Insert of those [page actions](#browser-pages) into a DOM observation |
| Delete (`computer_delete` without IDE) | Closes a window like its close button, or releases a sandbox, isolated session, machine or `computer:session` | Insert `close` and `kill` |
Delete of a window asks it to close: a browser the session opened closes with its disposable profile, an attached browser is detached first, and any other window gets the standard close request. The receipt says whether the window closed; an app that asks about unsaved work keeps it open, so Read it next. Add `?force=true` to the window address to kill the hung app of a window this session opened. Safe mode closes only windows the session opened.
@@ -149,6 +151,8 @@ Insert one JSON action into the latest DOM observation:
| `cancel_download` | optional `download` id; defaults to the latest |
| `evaluate` | `expression` (JavaScript); optional `target` passed to a function expression |
+`computer_browser` runs `navigate`, `back`, `forward`, `reload`, `wait_load`, the tab actions, `dialog`, `upload`, the download actions and `evaluate` on the browser's window address, with the same fields; it needs no DOM observation first, and a `ref` target resolves against the page's latest snapshot.
+
Every action accepts `timeout_ms` (1..60000; default 5000, 30000 for navigation, `wait_load`, `new_tab`, `upload`, `wait_download` and `evaluate`). Playwright waits for the element to be visible, stable, enabled and to receive events, then sends normal browser input. For example:
```json
@@ -377,7 +381,7 @@ Files and other resources keep returning text.
## Verify and wait
-Insert `{"action":"wait_for","conditions":[...],"timeout_ms":3000}` into a **window** address to wait until every condition holds, or `{"action":"verify","conditions":[...]}` for one sample. Nothing is sent to the window. Optional `interval_ms` (50..5000, default 250) sets the sample spacing and `stable` (1..10) how many consecutive samples must agree; `timeout_ms` is 0..60000 (default 5000). Up to 16 conditions; each has one check:
+Call `computer_wait` with the window address and conditions, or Insert `{"action":"wait_for","conditions":[...],"timeout_ms":3000}` into a **window** address to wait until every condition holds, or `{"action":"verify","conditions":[...]}` for one sample. Nothing is sent to the window. Optional `interval_ms` (50..5000, default 250) sets the sample spacing and `stable` (1..10) how many consecutive samples must agree; `timeout_ms` is 0..60000 (default 5000). Up to 16 conditions; each has one check:
| Check | Native windows | Browser pages |
| --- | --- | --- |
diff --git a/src/computer-resources.ts b/src/computer-resources.ts
index dc6bc0c..a92b255 100644
--- a/src/computer-resources.ts
+++ b/src/computer-resources.ts
@@ -127,6 +127,8 @@ function openTarget(command: Record<string, unknown>, where: string): string | {
if (!Array.isArray(args) || args.length > 32 || args.some(arg => typeof arg !== "string" || arg.length > 8192)) throw new ComputerRequestError("args must be up to 32 strings.");
return { path: command.path, args: args as string[], ...(command.debugging ? { debugging: true } : {}) };
}
+/** Browser operations that need no element of a snapshot: computer_browser runs them on a browser window. */
+export const PAGE_ACTIONS = ["navigate", "back", "forward", "reload", "wait_load", "new_tab", "switch_tab", "close_tab", "dialog", "upload", "wait_download", "cancel_download", "evaluate"];
/** The Delete option that kills the process of a hung window the session opened instead of asking it to close. */
export const FORCE = "?force=true";
const FILE_ACTIONS = ["put", "get", "files", "clipboard_read", "clipboard_write", "record_start", "record_stop", "audio_record"];
@@ -851,6 +853,22 @@ export class ComputerResources {
details: { ...state.details, status: "refused" } });
return this.stamp(place, management ? await session.manageWindow(address.ref, id, management, signal) : await session.restoreWindow(address.ref, id, signal));
}
+ /**
+ * Run one page operation (navigation, tabs, dialogs, files, page code) in a browser window by its address. The
+ * window's earlier observations retire, and the page's next snapshot becomes its current observation.
+ */
+ async browserAction(address: ComputerAddress, cwd: string, command: Record<string, unknown>, signal?: AbortSignal): Promise<ComputerResult> {
+ if (address.kind !== "window") throw new ComputerRequestError("computer_browser needs the window address of a browser opened with computer_open or attached to it.");
+ if (!PAGE_ACTIONS.includes(String(command.action))) throw new ComputerRequestError(`computer_browser runs ${PAGE_ACTIONS.join(", ")}.`);
+ let action;
+ try { action = validateWebAction(command); }
+ catch (error) { throw new ComputerRequestError(error instanceof Error ? error.message : String(error)); }
+ const place = this.place(address);
+ const session = await this.sessionFor(cwd, { window_ref: address.ref }, signal);
+ this.retireWindow(address.ref);
+ const result = await session.actPage(address.ref, action, signal);
+ return this.stamp(place, result.details.dom ? this.remember({ window_ref: address.ref }, result) : result);
+ }
/** Dispatch exactly one literal Write or JSON Insert against its address-bound target; the receipt names its machine. */
async perform(address: ComputerAddress, cwd: string, value: string, tool: "write" | "insert", signal?: AbortSignal): Promise<ComputerResult> {
const place = this.place(address);
diff --git a/src/computer-tools.ts b/src/computer-tools.ts
index 837bb22..b197100 100644
--- a/src/computer-tools.ts
+++ b/src/computer-tools.ts
@@ -90,6 +90,62 @@ const displayParameters = Type.Object({
height: Type.Integer({ minimum: 480, maximum: 16384, description: "New height in physical pixels." }),
}, { additionalProperties: false });
+const literals = <T extends string>(values: readonly T[], description: string) => Type.Union(values.map(value => Type.Literal(value)), { description });
+/** An element of a window or page: a Playwright locator string, or locator fields that must all match. */
+const targetSchema = (description: string) => Type.Union([
+ Type.String({ description: "A Playwright locator such as getByRole('button', { name: 'Save' }) or getByLabel('Name').nth(1)." }),
+ Type.Object({
+ ref: Type.Optional(Type.String({ description: "Browser pages: an aria ref such as e12 from the page's latest snapshot, alone." })),
+ role: Type.Optional(Type.String()), name: Type.Optional(Type.String({ description: "Accessible name; needs role." })),
+ label: Type.Optional(Type.String()), text: Type.Optional(Type.String()), placeholder: Type.Optional(Type.String()), test_id: Type.Optional(Type.String()),
+ css: Type.Optional(Type.String({ description: "Browser pages only." })),
+ exact: Type.Optional(Type.Boolean({ description: "Match name and text exactly instead of as a case-insensitive substring." })),
+ frames: Type.Optional(Type.Array(Type.String(), { maxItems: 8, description: "Browser pages only: CSS selectors of the nested iframes, outermost first." })),
+ }, { additionalProperties: false }),
+], { description });
+
+const waitParameters = Type.Object({
+ window: Type.String({ description: "Window address from Search, Read or a name; a browser window checks its active tab." }),
+ conditions: Type.Array(Type.Object({
+ target: Type.Optional(targetSchema("The element the check applies to; omit for aria on the whole window or page, and for url_contains and title.")),
+ is: Type.Optional(literals(["exists", "absent", "visible", "hidden", "enabled", "disabled", "selected", "checked", "unchecked", "focused"] as const, "State the target is in.")),
+ value: Type.Optional(Type.String({ description: "The target's value (its name if it has none, or a page element's text) equals this." })),
+ contains: Type.Optional(Type.String({ description: "The target's value, name or text contains this." })),
+ count: Type.Optional(Type.Integer({ minimum: 0, maximum: 10000, description: "Exactly this many elements match the target." })),
+ aria: Type.Optional(Type.String({ description: "Playwright aria snapshot template the target's subtree, or the whole window or page, contains, such as - button /Count \\d+/." })),
+ url_contains: Type.Optional(Type.String({ description: "Browser windows: the active tab's URL contains this." })),
+ title: Type.Optional(Type.String({ description: "Browser windows: the active tab's title equals this." })),
+ }, { additionalProperties: false }), { minItems: 1, maxItems: 16, description: "Every condition must hold. Each takes one check: is, value, contains, count or aria with a target, aria alone, or url_contains or title alone." }),
+ mode: Type.Optional(literals(["wait", "check"] as const, "wait (default) samples until every condition holds or timeout_ms passes; check takes one sample.")),
+ timeout_ms: Type.Optional(Type.Integer({ minimum: 0, maximum: 60000, description: "wait: longest wait, default 5000." })),
+ interval_ms: Type.Optional(Type.Integer({ minimum: 50, maximum: 5000, description: "wait: time between samples, default 250." })),
+ stable: Type.Optional(Type.Integer({ minimum: 1, maximum: 10, description: "wait: consecutive satisfied samples required, default 1." })),
+}, { additionalProperties: false });
+
+/** The Insert wait_for or verify command of computer_wait. */
+export function waitCommand(params: Static<typeof waitParameters>): Record<string, unknown> {
+ const { window: _window, mode, conditions, ...timing } = params;
+ if (mode === "check" && Object.keys(timing).length) throw new ComputerRequestError(`check takes one sample, so ${Object.keys(timing).join(", ")} do not apply.`);
+ return { action: mode === "check" ? "verify" : "wait_for", conditions, ...timing };
+}
+
+const browserParameters = Type.Object({
+ window: Type.String({ description: "Window address of a browser opened with computer_open or attached to it." }),
+ action: literals(["navigate", "back", "forward", "reload", "wait_load", "new_tab", "switch_tab", "close_tab", "dialog", "upload", "wait_download", "cancel_download", "evaluate"] as const,
+ "What to do in the active tab: navigate to url; back, forward or reload; wait_load until the page reaches state; new_tab (optional url) becomes active; switch_tab or close_tab by tab; dialog answers the open JavaScript dialog; upload files into target; wait_download or cancel_download by download; evaluate runs expression."),
+ url: Type.Optional(Type.String({ description: "navigate and new_tab: an http(s) URL." })),
+ tab: Type.Optional(Type.String({ description: "switch_tab and close_tab: a tab id such as t2 from the snapshot's tab list; close_tab defaults to the active tab." })),
+ state: Type.Optional(literals(["load", "domcontentloaded", "networkidle"] as const, "wait_load: load state to reach, default load.")),
+ accept: Type.Optional(Type.Boolean({ description: "dialog: accept (true) or dismiss (false)." })),
+ text: Type.Optional(Type.String({ description: "dialog: the answer to an accepted prompt." })),
+ target: Type.Optional(targetSchema("upload: the file input, or with chooser the element that opens the file chooser; evaluate: the element passed to a function expression.")),
+ files: Type.Optional(Type.Array(Type.String(), { minItems: 1, maxItems: 32, description: "upload: absolute WSL or Windows paths of existing files." })),
+ chooser: Type.Optional(Type.Boolean({ description: "upload: click target and fill the file chooser it opens; no native dialog appears." })),
+ download: Type.Optional(Type.String({ description: "wait_download and cancel_download: a download id such as d1; defaults to the latest." })),
+ expression: Type.Optional(Type.String({ description: "evaluate: JavaScript; a function expression is called with the target element. Promises are awaited." })),
+ timeout_ms: Type.Optional(Type.Integer({ minimum: 1, maximum: 60000, description: "Time limit; default 5000 for switch_tab, close_tab, dialog and cancel_download, 30000 otherwise." })),
+}, { additionalProperties: false });
+
/**
* Register the typed computer_* tools that replace Insert commands one cluster at a time. They are deferred: a
* tool_search for computer loads them, so sessions that never use the computer pay nothing for them.
@@ -130,6 +186,34 @@ export function registerComputerTools(pi: ExtensionAPI, resources: ComputerResou
}, address => resources.manageWindow(address, ctx.cwd, command, signal)));
},
});
+ pi.registerTool({
+ ...common, name: "computer_wait", label: "Computer wait",
+ description: "Use computer_wait to wait until a window's UI or a browser page meets conditions, or to check them once, without sending input. The last sample becomes the window's current observation.",
+ parameters: waitParameters,
+ annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+ ...rendered("computer_wait", args => `${args.window} ${args.mode ?? "wait"} ${(args.conditions as unknown[] | undefined)?.length ?? 0} condition(s)`),
+ async execute(_id, params, signal, _update, ctx) {
+ let command: Record<string, unknown> = {};
+ return actionResult(await computerAction(resources, params.window, params.mode === "check" ? "verify" : "wait_for", () => {
+ command = waitCommand(params);
+ const address = resources.address(params.window);
+ if (address.kind !== "window") throw new ComputerRequestError("computer_wait needs a window address from Search, Read or a name.");
+ return address;
+ }, address => resources.perform(address, ctx.cwd, JSON.stringify(command), "insert", signal)));
+ },
+ });
+ pi.registerTool({
+ ...common, name: "computer_browser", label: "Computer browser",
+ description: "Use computer_browser to navigate, manage tabs, answer JavaScript dialogs, upload or download files, and run page JavaScript in a browser window. The result shows the page's fresh snapshot.",
+ parameters: browserParameters,
+ annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+ ...rendered("computer_browser", args => `${args.window} ${args.action}${args.url ? ` ${args.url}` : args.tab ? ` ${args.tab}` : ""}`),
+ async execute(_id, params, signal, _update, ctx) {
+ const { window, ...command } = params;
+ return actionResult(await computerAction(resources, window, params.action, () => resources.address(window),
+ address => resources.browserAction(address, ctx.cwd, command, signal)));
+ },
+ });
pi.registerTool({
...common, name: "computer_display", label: "Computer display",
description: "Use computer_display to change a display's resolution in YOLO mode, for example to test an app at another size; closing computer use restores it.",
diff --git a/src/session.ts b/src/session.ts
index 69603ba..107b715 100644
--- a/src/session.ts
+++ b/src/session.ts
@@ -1176,6 +1176,25 @@ export class ComputerSession {
});
}
+ /**
+ * Perform one page action in the active tab of a browser window without a DOM observation: navigation, tabs,
+ * dialogs, files and page code. Refs in a target resolve against the page's latest snapshot. The result carries
+ * the page's next snapshot as a new observation.
+ */
+ actPage(ref: string, action: WebAction, signal?: AbortSignal): Promise<ComputerResult> {
+ return this.queue(async () => {
+ const entry = await this.webEntry(ref, signal);
+ if (!("ref" in entry)) return entry;
+ if (!this.allowed(entry)) return this.denied(ref);
+ entry.dom = undefined; entry.windowState = undefined; entry.observation = undefined; entry.detail = undefined;
+ try {
+ const observed = this.webObservation(entry, await entry.web!.page("act", action, signal));
+ return this.result("delivered", `Playwright performed ${action.action}. Check the fresh snapshot below for the page's response.`,
+ undefined, { ...this.addressed(entry), observation_id: observed.id, dom: observed.page });
+ } catch (error) { return this.webFailure(entry, error, true); }
+ });
+ }
+
/** Whether this window is a browser this session opened or attached, whose pages Playwright drives. */
isBrowserWindow(ref: string): boolean {
return this.entries.get(ref)?.web !== undefined;
diff --git a/test/computer-tools.test.ts b/test/computer-tools.test.ts
index b862d5c..3244c53 100644
--- a/test/computer-tools.test.ts
+++ b/test/computer-tools.test.ts
@@ -1,6 +1,7 @@
import { expect, test, vi } from "vitest";
import { requireComputerAddress, ComputerResources } from "../src/computer-resources.ts";
-import { openCommand, windowCommand } from "../src/computer-tools.ts";
+import { openCommand, waitCommand, windowCommand } from "../src/computer-tools.ts";
+import type { WebBrowser, WebLauncher } from "../src/web-browser.ts";
import type { MachineHost } from "../src/machine-host.ts";
import { deleteComputer } from "../src/provider.ts";
import { ComputerSession, type ComputerMode, type Driver } from "../src/session.ts";
@@ -36,6 +37,52 @@ test("computer_window takes exactly the fields of its action", () => {
expect(() => windowCommand({ window: "w", action: "focus", width: 1 })).toThrow("focus takes no coordinates or size.");
});
+test("computer_wait maps to wait_for or a single verify sample", () => {
+ const conditions = [{ target: "getByRole('button', { name: 'Save' })", is: "enabled" as const }];
+ expect(waitCommand({ window: "w", conditions, timeout_ms: 2000, stable: 2 })).toEqual({ action: "wait_for", conditions, timeout_ms: 2000, stable: 2 });
+ expect(waitCommand({ window: "w", conditions, mode: "check" })).toEqual({ action: "verify", conditions });
+ expect(() => waitCommand({ window: "w", conditions, mode: "check", timeout_ms: 10 })).toThrow("check takes one sample, so timeout_ms do not apply.");
+});
+
+/** A Chrome window (pid 4100) attached to a fake Playwright worker that records page actions. */
+function browserFixture() {
+ const target = { pid: 4100, window_id: 77, title: "Page - Google Chrome", app_name: "chrome.exe" };
+ const driver: Driver = {
+ identity: vi.fn(async () => "life-77") as Driver["identity"], close: vi.fn(async () => {}),
+ call: vi.fn<Driver["call"]>(async name => {
+ if (name === "list_windows") return { content: [], structuredContent: { windows: [target] } };
+ throw new Error(`Unexpected native call ${name}`);
+ }),
+ };
+ const page = vi.fn(async (_kind: string, _action?: unknown) => ({ url: "https://example.com/next", title: "Next", snapshot: "- heading \"Next\" [ref=e1]", tabs: [], events: [] }));
+ const launch = vi.fn<WebLauncher>(async () => ({ browser: { close: vi.fn(async () => {}), page } as unknown as WebBrowser,
+ opened: { pid: target.pid, version: "155", url: "https://example.com", title: "Page", via: "cdp" } }));
+ const session = new ComputerSession(driver, () => "yolo", undefined, undefined, undefined, launch);
+ const resources = new ComputerResources(async () => session, async () => session.close());
+ const window = async () => {
+ const ref = ((await resources.search(at("computer:machine/local/windows"), cwd, "Chrome")).details.state!.windows as { window_ref: string }[])[0].window_ref;
+ expect((await session.attachBrowser(ref)).details.status).toBe("delivered");
+ return at(`computer:window/${ref}`);
+ };
+ return { resources, page, window };
+}
+
+test("computer_browser runs a page action on the window and returns the page's next snapshot", async () => {
+ const f = browserFixture();
+ const window = await f.window();
+ const result = await f.resources.browserAction(window, cwd, { action: "navigate", url: "https://example.com/next" });
+ expect(result.details).toMatchObject({ status: "delivered", machine: "local" });
+ expect(f.page).toHaveBeenLastCalledWith("act", { action: "navigate", url: "https://example.com/next" }, undefined);
+ // The snapshot is the window's current observation, so its refs ground the next action.
+ const id = result.details.observation_id!;
+ expect((await f.resources.read(at(`computer:observation/${id}`), cwd)).details.status).toBe("observed");
+ await expect(f.resources.browserAction(window, cwd, { action: "click", target: { ref: "e1" } })).rejects.toThrow("computer_browser runs navigate, back");
+ await expect(f.resources.browserAction(window, cwd, { action: "navigate", url: "file:///etc/passwd" })).rejects.toThrow("url must be HTTP(S)");
+ await expect(f.resources.browserAction(at("computer:machine/local"), cwd, { action: "reload" })).rejects.toThrow("computer_browser needs the window address");
+ // Refused requests never reach Playwright.
+ expect(f.page).toHaveBeenCalledTimes(1);
+});
+
/** One window (pid 10, id 7) a session can list and observe; the host decides how a close request ends. */
function fixture(outcome: "closed" | "open" | "refused") {
let open = true, mode: ComputerMode = "yolo";
diff --git a/test/extension-modes.integration.test.ts b/test/extension-modes.integration.test.ts
index ba6e69b..4461cf0 100644
--- a/test/extension-modes.integration.test.ts
+++ b/test/extension-modes.integration.test.ts
@@ -39,7 +39,7 @@ test("without Pi Agent IDE, tool_search finds the deferred computer tools and th
expect(getToolExecution(result, id).isError, getToolResultText(result, id)).toBe(false);
expect(getToolResultText(result, "find")).toContain("computer_read");
// One search for computer loads the whole namespace.
- for (const tool of ["computer_open", "computer_window", "computer_display", "computer_delete"]) expect(getToolResultText(result, "find")).toContain(tool);
+ for (const tool of ["computer_open", "computer_window", "computer_display", "computer_wait", "computer_browser", "computer_delete"]) expect(getToolResultText(result, "find")).toContain(tool);
// A typed tool refuses a bad address with a receipt before any native work.
expect(getToolExecution(result, "display").isError).toBe(true);
expect(getToolResultText(result, "display")).not.toContain("unknown");
@@ -73,7 +73,7 @@ test("with Pi Agent IDE, computer use extends Read, Search, Insert and Delete an
expect(getToolResultText(result, "force")).toContain("?force=true applies to window addresses only.");
expect(getToolResultText(result, "find")).not.toContain("computer_read");
expect(getToolResultText(result, "find")).not.toContain("computer_delete");
- for (const tool of ["computer_open", "computer_window", "computer_display"]) expect(getToolResultText(result, "find")).toContain(tool);
+ for (const tool of ["computer_open", "computer_window", "computer_display", "computer_wait", "computer_browser"]) expect(getToolResultText(result, "find")).toContain(tool);
for (const id of ["session", "close", "delete"])
expect(getToolExecution(result, id).isError, getToolResultText(result, id)).toBe(false);
expect(getToolResultText(result, "session")).toContain("computer:session");
diff --git a/test/fixtures/window-management-extension.ts b/test/fixtures/window-management-extension.ts
index f407c58..41740cf 100644
--- a/test/fixtures/window-management-extension.ts
+++ b/test/fixtures/window-management-extension.ts
@@ -188,6 +188,15 @@ export default async function fixture(pi: ExtensionAPI): Promise<void> {
const restored = await window({ action: "restore" });
assert(!restored.isError && find(restored, "restore_requested") === true, `computer_window restore failed: ${body(restored)}`);
await control("reset");
+ // computer_wait samples the window's UI and sends nothing: the synthetic walk is complete and empty.
+ const button = "getByRole('button', { name: 'Save' })";
+ const absent = await call("computer_wait", { window: first, mode: "check", conditions: [{ target: button, is: "absent" }] });
+ assert(!absent.isError && find(absent, "verdict") === "satisfied", `computer_wait check failed: ${body(absent)}`);
+ const waited = await call("computer_wait", { window: first, timeout_ms: 300, conditions: [{ target: button, is: "exists" }] });
+ assert(find(waited, "verdict") === "unsatisfied" && find(waited, "timed_out") === true, `computer_wait did not time out: ${body(waited)}`);
+ await denied("computer_wait", { window: "computer:machine/local", conditions: [{ target: button, is: "exists" }] });
+ await denied("computer_wait", { window: first, mode: "check", timeout_ms: 10, conditions: [{ target: button, is: "exists" }] });
+ await denied("computer_browser", { window: first, action: "reload" });
const external = reference(await ok("search", { path: "computer:machine/local/windows", query: "Unowned management fixture" }), "window");
mode = "safe";
const refused = await window({ action: "focus" }, external);
diff --git a/test/unified-tools.integration.test.ts b/test/unified-tools.integration.test.ts
index 0762d7d..d83aff3 100644
--- a/test/unified-tools.integration.test.ts
+++ b/test/unified-tools.integration.test.ts
@@ -30,7 +30,7 @@ test("production Pi exposes only computer tools, with no direct or Codemode brow
],
}).run("Check the production loadout. Only discover apps; never open a window or send input.");
// Without Pi Agent IDE, production computer use offers deferred tools that tool_search loads.
- const standalone = ["computer_delete", "computer_display", "computer_insert", "computer_open", "computer_read", "computer_search", "computer_window", "computer_write"];
+ const standalone = ["computer_browser", "computer_delete", "computer_display", "computer_insert", "computer_open", "computer_read", "computer_search", "computer_wait", "computer_window", "computer_write"];
expect(getToolExecutionDetails(getToolExecution(result, "registry"))).toEqual({
names: standalone,
exposure: Object.fromEntries(standalone.map(name => [name, "deferred"])),