@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.19

package/dist/worker/console/chat/browser-routes.js

@@ -1,10 +1,7 @@
 /**
- * HTTP routes for the Operator Chat browser panel: one read-only probe
- * endpoint the panel uses to explain an iframe refusal (X-Frame-Options /
- * CSP frame-ancestors are exactly the signals the browser enforces when it
- * refuses to embed a site). The probe is display-only (headers back to the
- * caller), restricted to http(s) URLs, with a hard timeout. Local addresses
- * are allowed — the panel routinely browses local dev servers.
+ * HTTP API for the Console Browser panel. The panel renders screenshots from
+ * the controlled browser and sends pointer/keyboard input back to the same
+ * Playwright page used by Operator Chat tools.
  */
 import { embeddabilityOf, extractFrameAncestors, normalizeBrowserUrl, } from "./browser-policy.js";
 function workspaceIdOf(req) {
@@ -22,7 +19,38 @@ function sendJson(res, status, body) {
     });
     res.end(JSON.stringify(body));
 }
-/** Route dispatcher; returns true when the request was handled. */
+function errorPayload(error) {
+    return {
+        code: error instanceof Error && "code" in error
+            ? String(error.code)
+            : "BROWSER_OPERATION_FAILED",
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+function requireScope(req, deps) {
+    const ws = workspaceIdOf(req);
+    if (!ws) {
+        return { ok: false, status: 400, code: "WORKSPACE_REQUIRED", message: "workspaceId is required" };
+    }
+    if (deps.requireWorkspace && !deps.requireWorkspace(req).ok) {
+        return { ok: false, status: 403, code: "WORKSPACE_DENIED", message: "workspace scope mismatch" };
+    }
+    return { ok: true };
+}
+async function readJson(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.byteLength;
+        if (size > 1024 * 1024)
+            throw new Error("request body exceeds 1MB");
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0)
+        return {};
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
 export async function handleBrowserRequest(req, res, deps, pathname) {
     if (!pathname.startsWith("/api/operator/v1/chat/browser"))
         return false;
@@ -31,27 +59,33 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
     const parts = rest.split("/").filter(Boolean);
     const sub = parts[0] ?? "";
     try {
-        if (method === "GET" && sub === "probe" && parts.length === 1) {
-            // Fail-closed: the probe needs a workspaceId like every chat API.
-            if (deps.requireWorkspace) {
-                const ws = deps.requireWorkspace(req);
-                if (!ws.ok) {
-                    sendJson(res, 400, {
-                        ok: false,
-                        error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
-                    });
-                    return true;
-                }
+        if (method === "GET" && sub === "state" && parts.length === 1) {
+            const scope = requireScope(req, deps);
+            if (!scope.ok) {
+                sendJson(res, scope.status, {
+                    ok: false,
+                    error: { code: scope.code, message: scope.message },
+                });
+                return true;
             }
-            else if (!workspaceIdOf(req)) {
-                sendJson(res, 400, {
+            if (!deps.automation) {
+                sendJson(res, 200, { ok: true, data: { page: null } });
+                return true;
+            }
+            const page = await deps.automation.state();
+            sendJson(res, 200, { ok: true, data: { page } });
+            return true;
+        }
+        if (method === "GET" && sub === "probe" && parts.length === 1) {
+            const scope = requireScope(req, deps);
+            if (!scope.ok) {
+                sendJson(res, scope.status, {
                     ok: false,
-                    error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
+                    error: { code: scope.code, message: scope.message },
                 });
                 return true;
             }
-            const url = new URL(req.url ?? "/", "http://localhost");
-            const raw = url.searchParams.get("url") ?? "";
+            const raw = new URL(req.url ?? "/", "http://localhost").searchParams.get("url") ?? "";
             const normalized = normalizeBrowserUrl(raw);
             if (normalized.kind !== "ok") {
                 sendJson(res, 400, {
@@ -65,26 +99,22 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
                 });
                 return true;
             }
-            const parsed = new URL(normalized.url);
             const controller = new AbortController();
             const timer = setTimeout(() => controller.abort(), 8000);
             try {
-                let response = await fetch(parsed, {
+                let response = await fetch(normalized.url, {
                     method: "HEAD",
                     redirect: "follow",
                     signal: controller.signal,
                 });
-                // Some servers answer HEAD with 405/501; retry once as GET
-                // (the body is discarded — only the headers matter).
                 if (response.status === 405 || response.status === 501) {
-                    response = await fetch(parsed, {
+                    response = await fetch(normalized.url, {
                         method: "GET",
                         redirect: "follow",
                         signal: controller.signal,
                     });
                 }
-                const csp = response.headers.get("content-security-policy");
-                const frameAncestors = extractFrameAncestors(csp);
+                const frameAncestors = extractFrameAncestors(response.headers.get("content-security-policy"));
                 const xFrameOptions = response.headers.get("x-frame-options");
                 const probe = {
                     reachable: true,
@@ -100,11 +130,12 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
                 return true;
             }
             catch {
-                // DNS / TLS / connection / timeout: nothing to judge — the
-                // client keeps the plain iframe.
                 sendJson(res, 200, {
                     ok: true,
-                    data: { probe: { reachable: false }, verdict: "unknown" },
+                    data: {
+                        probe: { reachable: false },
+                        verdict: "unknown",
+                    },
                 });
                 return true;
             }
@@ -112,30 +143,25 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
                 clearTimeout(timer);
             }
         }
-        if (method === "GET" && sub === "commands" && parts.length === 1) {
-            const ws = workspaceIdOf(req);
-            if (!ws) {
-                sendJson(res, 400, {
+        if (method === "POST" && parts.length >= 1) {
+            const scope = requireScope(req, deps);
+            if (!scope.ok) {
+                sendJson(res, scope.status, {
                     ok: false,
-                    error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
+                    error: { code: scope.code, message: scope.message },
                 });
                 return true;
             }
-            if (deps.requireWorkspace) {
-                const scope = deps.requireWorkspace(req);
-                if (!scope.ok) {
-                    sendJson(res, 403, {
-                        ok: false,
-                        error: { code: "WORKSPACE_DENIED", message: "workspace scope mismatch" },
-                    });
-                    return true;
-                }
-            }
             if (!deps.automation) {
-                sendJson(res, 200, { ok: true, data: { commands: [] } });
+                sendJson(res, 503, {
+                    ok: false,
+                    error: { code: "BROWSER_UNAVAILABLE", message: "browser service unavailable" },
+                });
                 return true;
             }
-            sendJson(res, 200, { ok: true, data: { commands: deps.automation.take() } });
+            const body = await readJson(req);
+            const result = await dispatchBrowserPost(deps.automation, sub, body);
+            sendJson(res, 200, { ok: true, data: result });
             return true;
         }
         sendJson(res, 404, {
@@ -146,13 +172,7 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
     }
     catch (error) {
         if (!res.headersSent) {
-            sendJson(res, 500, {
-                ok: false,
-                error: {
-                    code: "BROWSER_INTERNAL",
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            });
+            sendJson(res, 500, { ok: false, error: errorPayload(error) });
         }
         else {
             res.end();
@@ -160,3 +180,101 @@ export async function handleBrowserRequest(req, res, deps, pathname) {
         return true;
     }
 }
+async function dispatchBrowserPost(automation, action, body) {
+    switch (action) {
+        case "navigate": {
+            const result = await automation.navigate(string(body.url));
+            if (!result.ok)
+                throw new BrowserRouteError(result.code, result.error);
+            return result.page;
+        }
+        case "focus":
+            return automation.focus();
+        case "reload":
+            return automation.reload();
+        case "back":
+            return automation.goBack();
+        case "forward":
+            return automation.goForward();
+        case "scroll":
+            return automation.scroll({
+                direction: body.direction === "up" ? "up" : "down",
+                amount: numberOrUndefined(body.amount),
+            });
+        case "tab":
+            if (body.mode === "new")
+                return automation.newTab(optionalString(body.url));
+            if (body.mode === "close")
+                return automation.closeTab(numberOrUndefined(body.tabId));
+            return automation.selectTab(number(body.tabId));
+        case "dialog":
+            return automation.handleDialog(body.action === "dismiss" ? "dismiss" : "accept", optionalString(body.promptText));
+        case "pointer": {
+            const type = string(body.type);
+            if (!["mousemove", "mousedown", "mouseup", "wheel"].includes(type)) {
+                throw new Error("invalid pointer event type");
+            }
+            const event = type === "wheel"
+                ? {
+                    type,
+                    x: number(body.x),
+                    y: number(body.y),
+                    deltaX: number(body.deltaX ?? 0),
+                    deltaY: number(body.deltaY ?? 0),
+                }
+                : {
+                    type,
+                    x: number(body.x),
+                    y: number(body.y),
+                    ...(body.button === "middle" || body.button === "right"
+                        ? { button: body.button }
+                        : {}),
+                };
+            return automation.dispatchPointer(event);
+        }
+        case "keyboard": {
+            const type = string(body.type);
+            if (type !== "keydown" && type !== "keyup")
+                throw new Error("invalid keyboard event type");
+            const key = string(body.key);
+            if (!isPanelKeyboardKey(key)) {
+                throw new Error("invalid keyboard key; use the text action for printable characters");
+            }
+            return automation.dispatchKeyboard({ type, key });
+        }
+        case "text":
+            return automation.inputText(string(body.text));
+        case "wait":
+            return automation.waitFor(number(body.ms ?? 500));
+        default:
+            throw new Error(`unknown browser action: ${action}`);
+    }
+}
+class BrowserRouteError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "BrowserRouteError";
+    }
+}
+function string(value) {
+    if (typeof value !== "string")
+        throw new Error("expected string");
+    return value;
+}
+function optionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function number(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new Error("expected finite number");
+    return value;
+}
+function numberOrUndefined(value) {
+    return value === undefined || value === null ? undefined : number(value);
+}
+function isPanelKeyboardKey(key) {
+    return /^(Control|Meta|Alt|Shift)(\+[A-Za-z0-9][A-Za-z0-9]*)?$/.test(key)
+        || (key.length > 1 && /^[A-Za-z][A-Za-z0-9]*$/.test(key));
+}

package/dist/worker/console/chat/explore-tools.js

@@ -279,8 +279,11 @@ export async function safeGrep(repoRoot, pattern, options) {
             for (let i = 0; i < lines.length; i++) {
                 if (matches.length >= GREP_MATCH_LIMIT)
                     break;
-                if (re.test(lines[i])) {
-                    const { scrubbed, redactions } = scrubSecrets(lines[i]);
+                const line = lines[i];
+                if (line === undefined)
+                    continue;
+                if (re.test(line)) {
+                    const { scrubbed, redactions } = scrubSecrets(line);
                     if (redactions.length > 0) {
                         for (const r of redactions) {
                             const found = totalRedactions.find((t) => t.name === r.name);

package/dist/worker/console/chat/pi-mode-loop-isolation.js

@@ -0,0 +1,155 @@
+/**
+ * Pi-mode loop isolation for loop-agent init projections.
+ *
+ * Pi mode ("自由对话") should not auto-load the governance AGENTS.md managed
+ * block that `loop-agent init` writes into a target project, nor the loop-agent
+ * built-in skills it mirrors into `<cwd>/.agents/skills/`. Manual `/skills:name`
+ * invocation and third-party/custom project skills must stay available; the
+ * Workflow mode is untouched (isolation applied only for `sessionMode ===
+ * "pi"`).
+ *
+ * Everything here is a pure function over discovered resources + persisted
+ * auto-invocation prefs, so it is trivially unit-testable.
+ */
+import path from "node:path";
+import { skillResourceId, } from "./resource-preferences-store.js";
+/** init.ts `MANAGED_BLOCK_START` / `MANAGED_BLOCK_END` (docs/templates/init-managed-agents.md). */
+export const LOOP_AGENTS_MANAGED_BLOCK_START = "<!-- LOOP_AGENT_INIT_START -->";
+export const LOOP_AGENTS_MANAGED_BLOCK_END = "<!-- LOOP_AGENT_INIT_END -->";
+/**
+ * Built-in skill directory names that `loop-agent init` mirrors from the
+ * package's `skills/` into a target project's `.agents/skills/`.
+ *
+ * MUST be kept in sync with the repo-root `skills/` directory; a CI check
+ * asserts they match (see `scripts/check-loop-builtin-skills.sh`).
+ */
+export const LOOP_BUILTIN_SKILL_DIR_NAMES = [
+    "agent-worker",
+    "ai-engineering-context",
+    "analyze-product-dependencies",
+    "analyze-product-requirements",
+    "browser-tools",
+    "code-review-core",
+    "codebase-scout",
+    "fe-test-ui-scout",
+    "frontend-bounded-implement",
+    "frontend-contract",
+    "frontend-design-review",
+    "frontend-plan",
+    "frontend-review",
+    "frontend-scout",
+    "frontend-verification",
+    "grill-me",
+    "grill-with-docs",
+    "improve-codebase-architecture",
+    "init-capability-evolution",
+    "local-jacoco-coverage",
+    "loop-agent",
+    "playwright-cli",
+    "playwright-cli-case-generator",
+    "requesting-code-review",
+    "systematic-debugging",
+    "test-driven-development",
+    "using-git-worktrees",
+    "verification-before-completion",
+    "webapp-testing",
+];
+/* Case-insensitive set for fast membership (paths are compared lower-cased). */
+const LOOP_BUILTIN_SKILL_NAMES_LOWER = new Set(LOOP_BUILTIN_SKILL_DIR_NAMES.map((name) => name.toLowerCase()));
+/** Normalize to forward slashes + lower case for Windows/macOS path compares. */
+function normalizeForCompare(value) {
+    return value.replace(/\\/g, "/").toLowerCase();
+}
+/**
+ * Strip the loop-agent init managed block (inclusive of both markers) from an
+ * AGENTS.md content string.
+ *
+ * Returns the content unchanged when no valid marker pair is present (missing
+ * either marker, or END before START), so user-authored AGENTS.md and non-loop
+ * roots are never touched.
+ */
+export function stripLoopManagedBlock(content) {
+    const start = content.indexOf(LOOP_AGENTS_MANAGED_BLOCK_START);
+    if (start < 0)
+        return content;
+    const end = content.indexOf(LOOP_AGENTS_MANAGED_BLOCK_END, start + LOOP_AGENTS_MANAGED_BLOCK_START.length);
+    if (end < 0)
+        return content;
+    const endPos = end + LOOP_AGENTS_MANAGED_BLOCK_END.length;
+    const before = content.slice(0, start).trimEnd();
+    const after = content.slice(endPos).trimStart();
+    return `${before}${before && after ? "\n\n" : ""}${after}`;
+}
+/**
+ * True when a discovered skill is a loop-agent init projection: its file path
+ * is under `<cwd>/.agents/skills/<builtin-name>/` for a name in the builtin
+ * whitelist. Global user skills (`~/.agents/skills`, `~/.pi/agent/skills`) and
+ * third-party project skills outside the whitelist return false.
+ */
+export function isLoopInitProjectedSkill(skill, cwd) {
+    if (!skill?.filePath)
+        return false;
+    const cwdNorm = normalizeForCompare(path.resolve(cwd));
+    const fileNorm = normalizeForCompare(path.resolve(skill.filePath));
+    const prefix = `${cwdNorm}/.agents/skills/`;
+    if (!fileNorm.startsWith(prefix))
+        return false;
+    const rest = fileNorm.slice(prefix.length);
+    const topSeg = rest.split("/")[0];
+    if (!topSeg)
+        return false;
+    return LOOP_BUILTIN_SKILL_NAMES_LOWER.has(topSeg);
+}
+/**
+ * Pi-mode default isolation over skills: for skills that are loop init
+ * projections, default `disableModelInvocation` to true UNLESS the user has
+ * EXPLICITLY tuned auto-invocation ON for that resource id in the persisted
+ * prefs. Explicitly ON wins over the Pi default; explicit OFF is treated as the
+ * Pi default. Non-loop skills pass through untouched.
+ */
+export function applyPiModeSkillIsolation(skills, prefs, cwd) {
+    return skills.map((skill) => {
+        if (!isLoopInitProjectedSkill(skill, cwd))
+            return skill;
+        const id = skillResourceId(skill);
+        const pref = prefs.skills[id];
+        if (pref?.autoInvocationEnabled === true)
+            return skill;
+        if (skill.disableModelInvocation === true)
+            return skill;
+        return { ...skill, disableModelInvocation: true };
+    });
+}
+/**
+ * Build the pi-mode loop isolation resource-loader option fragments.
+ *
+ * - When `enabled` (session mode pi): returns an `agentsFilesOverride` that
+ *   strips the loop-agent managed AGENTS.md block, and wraps the given
+ *   `skillsOverride` so it ALSO applies Pi-mode default isolation after the
+ *   persisted auto-invocation prefs.
+ * - When disabled (workflow): returns ONLY the provided `skillsOverride`
+ *   unchanged, so workflow session behavior is byte-for-byte identical to today.
+ */
+export function buildPiModeLoopIsolationOptions(options) {
+    if (!options.enabled) {
+        return { skillsOverride: options.skillsOverride };
+    }
+    const { cwd, readPreferences } = options;
+    const agentsFilesOverride = (current) => ({
+        agentsFiles: current.agentsFiles.map((file) => ({
+            ...file,
+            content: stripLoopManagedBlock(file.content),
+        })),
+    });
+    return {
+        agentsFilesOverride,
+        skillsOverride: (current) => {
+            const prefs = readPreferences() ?? { schemaVersion: 1, skills: {} };
+            const withPrefs = options.skillsOverride(current);
+            return {
+                skills: applyPiModeSkillIsolation(withPrefs.skills, prefs, cwd),
+                diagnostics: current.diagnostics,
+            };
+        },
+    };
+}

package/dist/worker/console/chat/pi-runtime/custom-tools/browser-tools.js

@@ -1,9 +1,9 @@
 /**
- * Session-independent browser tools shared by workflow and Pi chat modes.
- * Navigation is visible in the Console sidebar; inspection is server-side and
- * bounded to avoid exposing raw credentials or arbitrary page scripts.
+ * Session-independent Playwright browser tools shared by workflow and Pi chat
+ * modes. Actions use refs from the AI-mode aria snapshot and return a fresh
+ * snapshot. Screenshots are captured only by the explicit screenshot tool.
  */
-const BROWSER_TOOLS_DESCRIPTION = "Operate the Console sidebar browser. `browser_navigate` shows a URL in the panel; `browser_search` opens a search URL and returns elements; `browser_inspect` returns title/links/form controls; `browser_act` fills/submits a static GET form or clicks a static link. For natural-language search requests, prefer `browser_search` over navigating to a homepage and simulating its form. It never edits the workspace and cannot execute browser scripts. Dynamic-page and POST-form operations are out of scope.";
+const BROWSER_TOOLS_DESCRIPTION = "Operate the workspace-controlled visible external browser. The Console sidebar stays an iframe and does not proxy page input. `browser_navigate` opens a URL in the external window; `browser_snapshot` returns the current aria snapshot with element refs; `browser_act` clicks/fills/presses/hovers a ref; `browser_search` fills and submits the real search form; `browser_tabs`, `browser_scroll`, `browser_press`, `browser_dialog`, `browser_wait`, and `browser_screenshot` manage state. Use refs only from the immediately preceding snapshot. It never edits workspace files and does not execute page JavaScript.";
 export async function buildBrowserTools(options) {
     const [{ Type }, { defineTool }] = await Promise.all([
         import("typebox"),
@@ -11,7 +11,10 @@ export async function buildBrowserTools(options) {
     ]);
     const automation = options.automation;
     const urlParameter = Type.String({
-        description: "Absolute http(s) URL. Prefer URLs/element selectors returned by prior browser tools.",
+        description: "Absolute http(s) URL.",
+    });
+    const refParameter = Type.String({
+        description: "Element ref from the most recent browser_snapshot (for example e12).",
     });
     async function execute(operation) {
         try {
@@ -37,17 +40,17 @@ export async function buildBrowserTools(options) {
     return [
         defineTool({
             name: "browser_navigate",
-            label: "Sidebar browser navigate",
+            label: "Browser navigate",
             description: BROWSER_TOOLS_DESCRIPTION,
             promptSnippet: BROWSER_TOOLS_DESCRIPTION,
             parameters: Type.Object({ url: urlParameter }, { additionalProperties: false }),
             async execute(_toolCallId, params) {
-                return execute(() => automation.navigate(params.url, { includeSnapshot: true }));
+                return execute(() => automation.navigate(params.url));
             },
         }),
         defineTool({
             name: "browser_search",
-            label: "Sidebar browser search",
+            label: "Browser search",
             description: BROWSER_TOOLS_DESCRIPTION,
             promptSnippet: BROWSER_TOOLS_DESCRIPTION,
             parameters: Type.Object({
@@ -59,30 +62,122 @@ export async function buildBrowserTools(options) {
             },
         }),
         defineTool({
-            name: "browser_inspect",
-            label: "Sidebar browser inspect",
+            name: "browser_snapshot",
+            label: "Browser snapshot",
             description: BROWSER_TOOLS_DESCRIPTION,
             promptSnippet: BROWSER_TOOLS_DESCRIPTION,
-            parameters: Type.Object({ url: urlParameter }, { additionalProperties: false }),
-            async execute(_toolCallId, params) {
-                return execute(() => automation.inspect(params.url));
+            parameters: Type.Object({}, { additionalProperties: false }),
+            async execute() {
+                return execute(() => automation.snapshot({ screenshot: false }));
             },
         }),
         defineTool({
             name: "browser_act",
-            label: "Sidebar browser act",
+            label: "Browser act",
             description: BROWSER_TOOLS_DESCRIPTION,
             promptSnippet: BROWSER_TOOLS_DESCRIPTION,
             parameters: Type.Object({
-                url: urlParameter,
-                type: Type.Union([Type.Literal("click"), Type.Literal("fill")]),
-                selector: Type.String({ description: "Selector returned by browser_inspect." }),
+                type: Type.Union([
+                    Type.Literal("click"),
+                    Type.Literal("fill"),
+                    Type.Literal("press"),
+                    Type.Literal("hover"),
+                ]),
+                ref: refParameter,
                 value: Type.Optional(Type.String()),
+                key: Type.Optional(Type.String()),
+            }, { additionalProperties: false }),
+            async execute(_toolCallId, params) {
+                return execute(() => automation.act(params.type === "fill"
+                    ? { type: "fill", ref: params.ref, value: params.value ?? "" }
+                    : params.type === "press"
+                        ? { type: "press", ref: params.ref, key: params.key ?? "Enter" }
+                        : { type: params.type, ref: params.ref }));
+            },
+        }),
+        defineTool({
+            name: "browser_tabs",
+            label: "Browser tabs",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({
+                action: Type.Union([
+                    Type.Literal("list"),
+                    Type.Literal("new"),
+                    Type.Literal("select"),
+                    Type.Literal("close"),
+                ]),
+                tabId: Type.Optional(Type.Integer()),
+                url: Type.Optional(urlParameter),
+            }, { additionalProperties: false }),
+            async execute(_toolCallId, params) {
+                return execute(() => {
+                    if (params.action === "list")
+                        return automation.snapshot({ screenshot: false });
+                    if (params.action === "new")
+                        return automation.newTab(params.url);
+                    if (params.tabId === undefined)
+                        throw new Error("tabId is required");
+                    return params.action === "select"
+                        ? automation.selectTab(params.tabId)
+                        : automation.closeTab(params.tabId);
+                });
+            },
+        }),
+        defineTool({
+            name: "browser_scroll",
+            label: "Browser scroll",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({
+                direction: Type.Union([Type.Literal("up"), Type.Literal("down")]),
+                amount: Type.Optional(Type.Integer({ minimum: 50, maximum: 3000 })),
+            }, { additionalProperties: false }),
+            async execute(_toolCallId, params) {
+                return execute(() => automation.scroll(params));
+            },
+        }),
+        defineTool({
+            name: "browser_press",
+            label: "Browser press key",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({ key: Type.String() }, { additionalProperties: false }),
+            async execute(_toolCallId, params) {
+                return execute(() => automation.pressKey(params.key));
+            },
+        }),
+        defineTool({
+            name: "browser_dialog",
+            label: "Browser dialog",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({
+                action: Type.Union([Type.Literal("accept"), Type.Literal("dismiss")]),
+                promptText: Type.Optional(Type.String()),
             }, { additionalProperties: false }),
             async execute(_toolCallId, params) {
-                return execute(() => automation.act(params.url, params.type === "click"
-                    ? { type: "click", selector: params.selector }
-                    : { type: "fill", selector: params.selector, value: params.value ?? "" }));
+                return execute(() => automation.handleDialog(params.action, params.promptText));
+            },
+        }),
+        defineTool({
+            name: "browser_wait",
+            label: "Browser wait",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({ ms: Type.Integer({ minimum: 0, maximum: 10_000 }) }, { additionalProperties: false }),
+            async execute(_toolCallId, params) {
+                return execute(() => automation.waitFor(params.ms));
+            },
+        }),
+        defineTool({
+            name: "browser_screenshot",
+            label: "Browser screenshot",
+            description: BROWSER_TOOLS_DESCRIPTION,
+            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
+            parameters: Type.Object({}, { additionalProperties: false }),
+            async execute() {
+                return execute(() => automation.screenshot());
             },
         }),
     ];