pi-browser-harness 0.3.2 → 0.5.0

package/src/client.ts

@@ -6,11 +6,20 @@ import { type CdpError, cdpError } from "./cdp/errors";
 import type { CdpTransport } from "./cdp/transport";
 import { createCdpTransport } from "./cdp/transport";
 import { type CdpSession, createCdpSession } from "./cdp/session";
+import { type OwnershipRegistry, createOwnershipRegistry } from "./cdp/ownership";
 import type { DaemonStatus, DialogInfo, PageInfo, TabInfo } from "./cdp/types";
 
 export type BrowserClientOptions = {
   readonly namespace: string;
   readonly remote?: { readonly cdpUrl: string; readonly browserId: string };
+  readonly initialOwnership?: {
+    readonly ownedTargetIds?: ReadonlyArray<string>;
+    readonly harnessWindowTargetId?: string;
+  };
+  readonly onOwnershipChange?: (snapshot: {
+    readonly ownedTargetIds: ReadonlyArray<string>;
+    readonly harnessWindowTargetId: string | undefined;
+  }) => void;
 };
 
 export type BrowserClient = {
@@ -25,6 +34,9 @@ export type BrowserClient = {
   listTabs(includeInternal?: boolean): Promise<Result<ReadonlyArray<TabInfo>, CdpError>>;
   switchTab(targetId: string): Promise<Result<void, CdpError>>;
   newTab(url?: string): Promise<Result<string, CdpError>>;
+  closeTab(targetId: string): Promise<Result<void, CdpError>>;
+  owns(targetId: string): boolean;
+  ownership(): OwnershipRegistry;
   current(): { readonly sessionId: string; readonly targetId: string } | null;
   session(): CdpSession;
   transport(): CdpTransport;
@@ -66,10 +78,27 @@ const parsePageInfoPayload = (v: unknown): Result<PageInfo, CdpError> => {
 
 export const createBrowserClient = (opts: BrowserClientOptions): BrowserClient => {
   const transport = createCdpTransport();
-  const session = createCdpSession(transport);
+  const ownershipInit: { ownedTargetIds?: ReadonlyArray<string>; harnessWindowTargetId?: string } = {};
+  if (opts.initialOwnership?.ownedTargetIds !== undefined) {
+    ownershipInit.ownedTargetIds = opts.initialOwnership.ownedTargetIds;
+  }
+  if (opts.initialOwnership?.harnessWindowTargetId !== undefined) {
+    ownershipInit.harnessWindowTargetId = opts.initialOwnership.harnessWindowTargetId;
+  }
+  const ownership = createOwnershipRegistry(ownershipInit);
+  if (opts.onOwnershipChange) {
+    const cb = opts.onOwnershipChange;
+    ownership.onChange(() => {
+      cb({
+        ownedTargetIds: ownership.list(),
+        harnessWindowTargetId: ownership.harnessWindow(),
+      });
+    });
+  }
+  const session = createCdpSession(transport, ownership);
   const mutationMutex = createMutex();
   let lastHealth = 0;
-  let pageCache: { readonly info: PageInfo; readonly at: number } | null = null;
+  let pageCaches = new Map<string, { readonly info: PageInfo; readonly at: number }>();
   let remote: BrowserClientOptions["remote"] | null = opts.remote ?? null;
 
   const start = async (): Promise<Result<void, CdpError>> => {
@@ -96,13 +125,13 @@ export const createBrowserClient = (opts: BrowserClientOptions): BrowserClient =
       return attached;
     }
     lastHealth = Date.now();
-    pageCache = null;
+    pageCaches.clear();
     return ok(undefined);
   };
 
   const stop = async (): Promise<void> => {
     await transport.close();
-    pageCache = null;
+    pageCaches.clear();
     lastHealth = 0;
   };
 
@@ -126,7 +155,7 @@ export const createBrowserClient = (opts: BrowserClientOptions): BrowserClient =
     if (!jsProbe.success && jsProbe.error.kind === "session_not_found") {
       const reattached = await session.attachFirstPage();
       if (reattached.success) {
-        pageCache = null;
+        pageCaches.clear();
         return ok(undefined);
       }
       await stop();
@@ -156,7 +185,9 @@ export const createBrowserClient = (opts: BrowserClientOptions): BrowserClient =
 
   const readPageInfo = async (): Promise<Result<PageInfo, CdpError>> => {
     const dirty = session.drainPageInfoInvalidations();
-    if (pageCache && !dirty && Date.now() - pageCache.at < PAGE_INFO_TTL_MS) return ok(pageCache.info);
+    const currentTid = session.current()?.targetId;
+    const cached = currentTid ? pageCaches.get(currentTid) : undefined;
+    if (cached && !dirty && Date.now() - cached.at < PAGE_INFO_TTL_MS) return ok(cached.info);
     const expr = safeJs`JSON.stringify({url:location.href,title:document.title,w:innerWidth,h:innerHeight,sx:scrollX,sy:scrollY,pw:document.documentElement.scrollWidth,ph:document.documentElement.scrollHeight})`;
     const raw = await evaluateJs(expr);
     if (!raw.success) return raw;
@@ -169,7 +200,7 @@ export const createBrowserClient = (opts: BrowserClientOptions): BrowserClient =
     }
     const info = parsePageInfoPayload(parsedRaw);
     if (!info.success) return info;
-    pageCache = { info: info.data, at: Date.now() };
+    if (currentTid) pageCaches.set(currentTid, { info: info.data, at: Date.now() });
     return ok(info.data);
   };
 
@@ -186,14 +217,30 @@ export const createBrowserClient = (opts: BrowserClientOptions): BrowserClient =
     const tabs = data.targetInfos
       .filter((t) => t.type === "page")
       .filter((t) => includeInternal || !t.url.startsWith("chrome://"))
-      .map((t): TabInfo => ({ targetId: t.targetId, title: t.title, url: t.url }));
+      .map((t): TabInfo => ({
+        targetId: t.targetId,
+        title: t.title,
+        url: t.url,
+        owned: ownership.has(t.targetId),
+      }));
+    // Reconcile any persisted owned ids that no longer exist as live page targets.
+    const live = new Set(tabs.map((t) => t.targetId));
+    const owned = ownership.list();
+    const survivors = owned.filter((id) => live.has(id));
+    if (survivors.length !== owned.length) ownership.replaceAll(survivors);
+    const hw = ownership.harnessWindow();
+    if (hw && !live.has(hw)) ownership.setHarnessWindow(undefined);
+    // Prune per-tab page caches for tabs that no longer exist
+    for (const tid of pageCaches.keys()) {
+      if (!live.has(tid)) pageCaches.delete(tid);
+    }
     return ok(tabs);
   };
 
   const switchTab = async (targetId: string): Promise<Result<void, CdpError>> => {
     const r = await session.switchTo(targetId);
     if (!r.success) return r;
-    pageCache = null;
+    // pageCache per-tab: no longer cleared — each tab retains its cache
     // Best-effort: mark the tab title with a green circle so the user can
     // see which tab the agent attached to. CSP or detached frames may
     // block the eval; we don't surface that as a switchTab failure.
@@ -204,19 +251,46 @@ export const createBrowserClient = (opts: BrowserClientOptions): BrowserClient =
   };
 
   const newTab = async (url?: string): Promise<Result<string, CdpError>> => {
-    const created = await session.callBrowser("Target.createTarget", { url: "about:blank" });
+    // Verify the recorded harness window still exists. Querying the live
+    // target list also gives listTabs's reconciliation a chance to run.
+    const tabsResult = await listTabs(true);
+    if (!tabsResult.success) return tabsResult;
+    const live = new Set(tabsResult.data.map((t) => t.targetId));
+    const hw = ownership.harnessWindow();
+
+    const params: Record<string, unknown> = { url: "about:blank" };
+    if (hw && live.has(hw)) {
+      // Open as a child of the harness window's seed tab — Chrome places
+      // it in the same window, giving us visual grouping for free.
+      params["openerId"] = hw;
+    } else {
+      // Either fresh session or the harness window was closed by the user.
+      // Spawn a new dedicated window.
+      params["newWindow"] = true;
+    }
+    const created = await session.callBrowser("Target.createTarget", params);
     if (!created.success) return created;
     const c = created.data as { targetId: string };
+
+    if (params["newWindow"]) ownership.setHarnessWindow(c.targetId);
+    ownership.add(c.targetId);
+
     const switched = await switchTab(c.targetId);
     if (!switched.success) return switched;
     if (url && url !== "about:blank") {
       const nav = await session.call("Page.navigate", { url });
       if (!nav.success) return nav;
-      pageCache = null;
     }
     return ok(c.targetId);
   };
 
+  const closeTab = async (targetId: string): Promise<Result<void, CdpError>> => {
+    const r = await session.callBrowser("Target.closeTarget", { targetId });
+    if (!r.success) return r;
+    ownership.remove(targetId);
+    return ok(undefined);
+  };
+
   const status = (): DaemonStatus => ({
     alive: transport.state() === "open" && session.current() !== null,
     sessionId: session.current()?.sessionId ?? null,
@@ -229,7 +303,9 @@ export const createBrowserClient = (opts: BrowserClientOptions): BrowserClient =
     ensureAlive, status, start, stop,
     evaluateJs, pageInfo,
     takeDialog: () => session.takeDialog(),
-    listTabs, switchTab, newTab,
+    listTabs, switchTab, newTab, closeTab,
+    owns: (id: string) => ownership.has(id),
+    ownership: () => ownership,
     current: () => session.current(),
     session: () => session,
     transport: () => transport,

package/src/domains/click.ts

@@ -41,14 +41,15 @@ export const clickTool = defineBrowserTool({
   name: "browser_click",
   label: "Browser Click",
   description:
-    "Click at viewport CSS-pixel coordinates. Compositor-level click works through iframes, shadow DOM, and cross-origin content. Use browser_screenshot first to find coordinates.",
+    "Click at viewport CSS-pixel coordinates. Compositor-level click works through iframes, shadow DOM, and cross-origin content. Get coordinates from browser_snapshot's @(x,y) hints — do not screenshot to find click targets.",
   promptSnippet: "Click at pixel coordinates (x, y) on the page",
   promptGuidelines: [
-    "Use browser_click for all clicks. Coordinates are viewport CSS pixels (not device pixels).",
-    "Capture a browser_screenshot BEFORE clicking to find the right coordinates.",
-    "Capture another browser_screenshot AFTER clicking to verify the action worked.",
+    "Get (x, y) from browser_snapshot — the outline shows '@(x,y)' for every interactive element. NO screenshot needed.",
+    "If the target isn't an interactive role in the snapshot, fall back to browser_execute_js with `el.getBoundingClientRect()` — still NO screenshot.",
+    "Coordinates are viewport CSS pixels (not device pixels).",
+    "After clicking, verify with browser_snapshot (or browser_execute_js for a specific value). Only screenshot if you need to confirm visual rendering.",
     "Compositor-level clicks pass through iframes, shadow DOM, and cross-origin content — no selector needed.",
-    "If a click doesn't register, try setting BH_DEBUG_CLICKS=1 to get annotated screenshots showing exact click positions.",
+    "If a click doesn't register, set BH_DEBUG_CLICKS=1 to get annotated screenshots showing exact click positions (debug only).",
     "For React/Vue components that don't respond to clicks, try browser_dispatch_key to send DOM-level events.",
   ],
   parameters: ClickArgs,

package/src/domains/console.ts

@@ -0,0 +1,173 @@
+import { Type } from "typebox";
+import { Markdown, Text } from "@mariozechner/pi-tui";
+import { getMarkdownTheme, keyHint } from "@mariozechner/pi-coding-agent";
+import { type Result, ok } from "../util/result";
+import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
+import { applyTruncation } from "../util/truncate";
+import type { ConsoleRecord, ConsoleLevel } from "../cdp/console-buffer";
+
+const ConsoleArgs = Type.Object({
+  levels: Type.Optional(
+    Type.Array(
+      Type.Union(
+        [
+          Type.Literal("log"),
+          Type.Literal("info"),
+          Type.Literal("warn"),
+          Type.Literal("error"),
+          Type.Literal("debug"),
+        ],
+      ),
+      { description: 'Filter to these levels only, e.g. ["error","warn"]. Default: all levels.' },
+    ),
+  ),
+  textPattern: Type.Optional(
+    Type.String({ description: "Substring match by default. Wrap in slashes (e.g. /TypeError/) for regex." }),
+  ),
+  sinceSeq: Type.Optional(
+    Type.Integer({ minimum: 0, description: "Only records with seq strictly greater than this. Use the previous call's nextCursor to see only what's new." }),
+  ),
+  sinceMs: Type.Optional(
+    Type.Integer({ minimum: 0, description: "Only records from the last N ms." }),
+  ),
+  limit: Type.Optional(
+    Type.Integer({ default: 50, minimum: 1, maximum: 500, description: "Max records to return." }),
+  ),
+});
+
+const levelTag = (lvl: ConsoleLevel): string => {
+  switch (lvl) {
+    case "error": return "[error]";
+    case "warn":  return "[warn] ";
+    case "info":  return "[info] ";
+    case "debug": return "[debug]";
+    default:      return "[log]  ";
+  }
+};
+
+const formatLocation = (r: ConsoleRecord): string => {
+  if (r.url === undefined || r.url === "") return "";
+  const short = r.url.length > 60 ? "…" + r.url.slice(-59) : r.url;
+  return r.lineNumber !== undefined ? `${short}:${r.lineNumber}` : short;
+};
+
+const renderConsoleMarkdown = (
+  records: ReadonlyArray<ConsoleRecord>,
+  opts: { total: number; bufferOverflowed: boolean; expanded: boolean; nextCursor: number | undefined },
+): string => {
+  if (records.length === 0) {
+    if (opts.bufferOverflowed) return "_No matching console records. (Buffer overflowed since last drain — some events were dropped.)_";
+    return "_No matching console records captured yet._";
+  }
+
+  const counts = records.reduce<Record<ConsoleLevel, number>>(
+    (acc, r) => { acc[r.level]++; return acc; },
+    { log: 0, info: 0, warn: 0, error: 0, debug: 0 },
+  );
+
+  const summaryParts: string[] = [];
+  if (counts.error > 0) summaryParts.push(`${counts.error} error${counts.error === 1 ? "" : "s"}`);
+  if (counts.warn  > 0) summaryParts.push(`${counts.warn} warning${counts.warn === 1 ? "" : "s"}`);
+  if (counts.info  > 0) summaryParts.push(`${counts.info} info`);
+  if (counts.log   > 0) summaryParts.push(`${counts.log} log${counts.log === 1 ? "" : "s"}`);
+  if (counts.debug > 0) summaryParts.push(`${counts.debug} debug`);
+
+  const headerLines: string[] = [`**${summaryParts.join(" · ")}**`];
+  if (opts.bufferOverflowed) headerLines.push("⚠ buffer overflowed since last drain — older entries dropped");
+  if (opts.total > records.length) headerLines.push(`(${records.length} of ${opts.total} matches shown — increase \`limit\` for more)`);
+
+  const renderRow = (r: ConsoleRecord, compact: boolean): string => {
+    const tag = levelTag(r.level);
+    const loc = formatLocation(r);
+    const maxText = compact ? 80 : 200;
+    const text = r.text.length > maxText ? r.text.slice(0, maxText - 1) + "…" : r.text;
+    const locSuffix = loc !== "" ? `  _at ${loc}_` : "";
+    const main = `\`${tag}\` ${text}${locSuffix}`;
+    if (!compact && r.stackTrace !== undefined) return `${main}\n\`\`\`\n${r.stackTrace}\n\`\`\``;
+    return main;
+  };
+
+  const visible = !opts.expanded && records.length > 5 ? records.slice(-5) : records;
+  const rows = visible.map((r) => renderRow(r, !opts.expanded)).join(opts.expanded ? "\n\n" : "\n");
+
+  const more = !opts.expanded && records.length > 5 ? `\n  … ${records.length - 5} earlier (expand to see all)` : "";
+  const cursor = opts.nextCursor !== undefined ? `\n\n_nextCursor=${opts.nextCursor}_` : "";
+
+  return `${headerLines.join("\n")}\n\n${rows}${more}${cursor}`;
+};
+
+type ConsoleDetails = {
+  total: number;
+  returned: number;
+  bufferOverflowed: boolean;
+  truncated: boolean;
+  fullOutputPath?: string;
+  records: ReadonlyArray<ConsoleRecord>;
+  nextCursor?: number;
+};
+
+export const consoleTool = defineBrowserTool({
+  name: "browser_console",
+  label: "Browser Console",
+  description:
+    "Read JS errors and console messages from the active tab. Diagnostic — use when an action looks broken or silent.",
+  promptSnippet: "Read JS errors / console output on the current tab",
+  promptGuidelines: [
+    "Use after a click, submit, or navigate produced no visible change — errors often explain it.",
+    "Pass `sinceSeq` from the previous call's `nextCursor` to see only new messages after an action.",
+    "Buffer is reset on tab switch (capacity 500 records). bufferOverflowed:true means older entries were dropped.",
+    "Don't use as a default observation tool — prefer browser_snapshot for page structure.",
+  ],
+  parameters: ConsoleArgs,
+
+  async handler(args, { client }): Promise<Result<ToolOk, ToolErr>> {
+    const session = client.session();
+    const drained = session.drainConsoleBuffer({
+      ...(args.levels !== undefined ? { levels: args.levels } : {}),
+      ...(args.textPattern !== undefined ? { textPattern: args.textPattern } : {}),
+      ...(args.sinceSeq !== undefined ? { sinceSeq: args.sinceSeq } : {}),
+      ...(args.sinceMs !== undefined ? { sinceMs: args.sinceMs } : {}),
+      limit: args.limit ?? 50,
+    });
+
+    const last = drained.records.at(-1);
+    const nextCursor = last?.seq;
+
+    const text = renderConsoleMarkdown(drained.records, {
+      total: drained.total,
+      bufferOverflowed: drained.bufferOverflowed,
+      expanded: true, // full text always returned to the LLM; renderResult handles compact view for humans
+      nextCursor,
+    });
+    const trunc = await applyTruncation(text, "console");
+
+    const details: ConsoleDetails = {
+      total: drained.total,
+      returned: drained.records.length,
+      bufferOverflowed: drained.bufferOverflowed,
+      truncated: trunc.wasTruncated,
+      records: drained.records,
+      ...(nextCursor !== undefined ? { nextCursor } : {}),
+    };
+    if (trunc.fullOutputPath !== undefined) details.fullOutputPath = trunc.fullOutputPath;
+
+    return ok({ text: trunc.text, details });
+  },
+
+  renderResult(result, expanded, theme) {
+    const details = result.details as ConsoleDetails | undefined;
+    if (!details) return new Text(theme.fg("error", "console: no details"), 0, 0);
+
+    const md = renderConsoleMarkdown(details.records, {
+      total: details.total,
+      bufferOverflowed: details.bufferOverflowed,
+      expanded,
+      nextCursor: details.nextCursor,
+    });
+    const tail = expanded
+      ? `\n\n${keyHint("app.tools.expand", "to collapse")}${details.fullOutputPath ? ` · full payload at \`${details.fullOutputPath}\`` : ""}`
+      : `\n\n${keyHint("app.tools.expand", "to expand")}`;
+
+    return new Markdown(md + tail, 0, 0, getMarkdownTheme());
+  },
+});

package/src/domains/js.ts

@@ -3,10 +3,20 @@ import { resolve, isAbsolute } from "node:path";
 import { tmpdir } from "node:os";
 import { createRequire } from "node:module";
 import { Type } from "typebox";
+import { Markdown, Text } from "@mariozechner/pi-tui";
+import { getMarkdownTheme, keyHint } from "@mariozechner/pi-coding-agent";
 import { type Result, err, ok } from "../util/result";
 import { defineBrowserTool, type ToolErr, type ToolOk } from "../util/tool";
 import { applyTruncation } from "../util/truncate";
 
+const COMPACT_PREVIEW_BYTES = 120;
+
+const formatBytes = (n: number): string => {
+  if (n >= 1_048_576) return `${(n / 1_048_576).toFixed(1)} MB`;
+  if (n >= 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${n} B`;
+};
+
 // AsyncFunction constructor — the documented Node.js mechanism for compiling
 // arbitrary user-supplied source. Equivalent to `new Function` but produces an
 // async function we can `await`. The full RCE risk is contained at the source
@@ -29,11 +39,15 @@ export const executeJsTool = defineBrowserTool({
   name: "browser_execute_js",
   label: "Browser Execute JS",
   description:
-    "Run JavaScript in the page (or a specific iframe target). `return X` gets auto-wrapped in an IIFE for convenience. Always use safeJs / JSON.stringify when interpolating untrusted strings into source.",
-  promptSnippet: "Execute JS in the page (or iframe)",
+    "Surgical reads from the DOM. The cheapest, most precise way to extract a specific element's text, attribute, value, or geometry. Prefer over browser_screenshot for ANY data extraction or coordinate lookup. `return X` is auto-wrapped in an IIFE. Always use safeJs / JSON.stringify when interpolating untrusted strings.",
+  promptSnippet: "Execute JS in the page — surgical DOM reads (preferred over screenshot)",
   promptGuidelines: [
+    "DEFAULT for extracting a specific value: `document.querySelector('.price').innerText`, `input.value`, `el.getAttribute('aria-label')`, etc.",
+    "For click coordinates not already in browser_snapshot: `JSON.stringify(document.querySelector('SELECTOR').getBoundingClientRect())` — beats a screenshot every time.",
+    "For 'is this element visible / enabled / checked / focused', a one-liner here beats a screenshot every time.",
+    "DO NOT call browser_screenshot to read a value or check element state. Use this tool.",
     "`return foo` is auto-wrapped in an IIFE — both `foo` and `(() => foo)()` work.",
-    "For iframes, get a targetId via browser_execute_js with `Object.values(document.querySelectorAll('iframe'))` then call browser_execute_js with targetId.",
+    "For iframes, first run `Object.values(document.querySelectorAll('iframe'))` to find the iframe, then pass its targetId.",
     "Result must be JSON-serializable (Runtime.evaluate returnByValue=true).",
   ],
   parameters: ExecuteJsArgs,
@@ -42,13 +56,58 @@ export const executeJsTool = defineBrowserTool({
     if (!r.success) return err({ kind: "cdp_error", message: r.error.message });
     const valueStr = r.data === undefined ? "undefined" : JSON.stringify(r.data);
     const truncated = await applyTruncation(valueStr, "js");
+    // If the value is JSON, pretty-print for the expanded TUI view. Falls back
+    // to the raw string if parse fails (e.g. value is "undefined" sentinel).
+    let pretty: string | undefined;
+    try {
+      const parsed = JSON.parse(valueStr);
+      pretty = JSON.stringify(parsed, null, 2);
+    } catch {
+      pretty = undefined;
+    }
     return ok({
       text: truncated.text,
-      details: truncated.fullOutputPath !== undefined
-        ? { valueLength: valueStr.length, fullOutputPath: truncated.fullOutputPath }
-        : { valueLength: valueStr.length },
+      details: {
+        valueLength: valueStr.length,
+        // Full value for the expanded renderer. Capped at 200 KB so a giant
+        // dump doesn't bloat the conversation transcript on disk.
+        full: valueStr.length > 200_000 ? valueStr.slice(0, 200_000) : valueStr,
+        ...(pretty !== undefined ? { pretty: pretty.length > 200_000 ? pretty.slice(0, 200_000) : pretty } : {}),
+        ...(truncated.fullOutputPath !== undefined ? { fullOutputPath: truncated.fullOutputPath } : {}),
+      },
     });
   },
+
+  renderResult(result, expanded, theme) {
+    const details = result.details as
+      | { valueLength?: number; full?: string; pretty?: string; fullOutputPath?: string }
+      | undefined;
+    if (!details) return new Text(theme.fg("error", "execute_js: no details"), 0, 0);
+
+    const len = details.valueLength ?? 0;
+    const full = details.full ?? "";
+    const isJson = details.pretty !== undefined;
+
+    if (!expanded) {
+      const preview = full.length > COMPACT_PREVIEW_BYTES ? full.slice(0, COMPACT_PREVIEW_BYTES) + "…" : full;
+      const md = [
+        `**${formatBytes(len)}** ${isJson ? "JSON" : "value"}`,
+        "```",
+        preview,
+        "```",
+        keyHint("app.tools.expand", "to expand"),
+      ].join("\n");
+      return new Markdown(md, 0, 0, getMarkdownTheme());
+    }
+
+    const body = details.pretty ?? full;
+    const fence = isJson ? "```json" : "```";
+    const tail = details.fullOutputPath
+      ? `\n\nFull value at \`${details.fullOutputPath}\` · ${keyHint("app.tools.expand", "to collapse")}`
+      : `\n\n${keyHint("app.tools.expand", "to collapse")}`;
+    const md = [`**${formatBytes(len)}** ${isJson ? "JSON" : "value"}`, fence, body, "```", tail].join("\n");
+    return new Markdown(md, 0, 0, getMarkdownTheme());
+  },
 });
 
 const RunScriptArgs = Type.Object({

package/src/domains/navigate.ts

@@ -75,7 +75,7 @@ export const openUrlsTool = defineBrowserTool({
   promptSnippet: "Open multiple URLs in new tabs (parallel)",
   promptGuidelines: [
     "Use after web_search to open citations in parallel.",
-    "After opening, use browser_list_tabs / browser_switch_tab / browser_screenshot to interact.",
+    "After opening, use browser_list_tabs / browser_switch_tab to navigate, then browser_snapshot to inspect each tab.",
     "Use browser_wait_for_load on a tab before extracting data from SPAs.",
   ],
   parameters: OpenUrlsArgs,