agents 0.30.0 → 0.31.0

package/dist/browser-tool-lGnvEBLJ.js

@@ -0,0 +1,497 @@
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
+import { i as validate, n as BrowserSession } from "./session-7CDgVE0z.js";
+import { a as truncateResult, i as transformBrowserResult } from "./tool-helpers-BodWi4gd.js";
+import "./browser-1eUbPvC2.js";
+import { RpcTarget } from "cloudflare:workers";
+//#region src/browser/browser-functions.ts
+const SPEC_SCHEMA = {
+	type: "object",
+	properties: { domain: {
+		type: "string",
+		minLength: 1
+	} }
+};
+const BROWSER_FUNCTIONS = {
+	cdp: {
+		doc: "`browser.cdp({ method, params?, sessionId?, timeoutMs? })` sends a CDP command and returns its result without the JSON-RPC envelope. Page-scoped commands take `sessionId: \"active\"`: `await browser.cdp({ method: \"Page.navigate\", params: { url }, sessionId: \"active\" })` returns `{ frameId, errorText? }`. `timeoutMs` limits this one command. A failed command throws, and the error often says how to fix the call.",
+		call: (session, input) => session.send(input)
+	},
+	attachToTarget: {
+		doc: "`browser.attachToTarget({ targetId })` switches to an open tab, with `targetId` from `Target.getTargets`, and makes it active: `sessionId: \"active\"` points at it from then on. Returns `{ sessionId }` for that tab.",
+		call: (session, input) => session.attachToTarget(input)
+	},
+	spec: {
+		doc: "`browser.spec()` lists the protocol's domains as `{ domains: [{ name, description }] }`; `browser.spec({ domain: \"Page\" })` returns one domain's `{ commands, events, types }`, each command a `{ name, method, description, parameters, returns }` (`name` is `\"navigate\"`, `method` is `\"Page.navigate\"`). Big domains get cut short in your result, so filter in code: `(await browser.spec({ domain: \"Network\" })).commands.find((c) => c.name === \"enable\")`.",
+		call: async (session, input) => {
+			const { domain } = validate("browser.spec", SPEC_SCHEMA, input);
+			return specResult(await session.spec(), domain);
+		}
+	},
+	getDebugLog: {
+		doc: "`browser.getDebugLog({ limit? })` returns recent protocol traffic, newest last (50 entries unless `limit` says otherwise), each `{ at, type, ... }`. Use it when a command fails or times out.",
+		call: (session, input) => session.getDebugLog(input)
+	},
+	clearDebugLog: {
+		doc: "`browser.clearDebugLog()` forgets the traffic recorded so far, so the next `getDebugLog` shows only what follows.",
+		call: (session) => session.clearDebugLog()
+	}
+};
+/**
+* Without a domain, every domain's name and first sentence, which is small;
+* with one, that domain's commands, events and types. The whole protocol is
+* about 650 KB, too much for one result.
+*/
+function specResult(spec, domain) {
+	const { domains } = spec;
+	if (domain === void 0) return {
+		domains: domains.map(({ name, description }) => ({
+			name,
+			...description ? { description: firstSentence(description) } : {}
+		})),
+		hint: "browser.spec({ domain: \"Page\" }) returns one domain's commands, events and types."
+	};
+	const found = domains.find((d) => d.name === domain);
+	if (found) return found;
+	const near = domains.find((d) => d.name.toLowerCase() === domain.toLowerCase());
+	throw new Error(`No CDP domain named '${domain}'.` + (near ? ` Did you mean '${near.name}'?` : " browser.spec() lists the domains."));
+}
+/** A CDP description's first sentence, for the list of domains. */
+function firstSentence(text) {
+	return text.match(/^[\s\S]*?\.(?=\s|$)/)?.[0] ?? text;
+}
+/** The `host` field of a hosts function's input, or a fix-it error. */
+function hostOf(name, input) {
+	const host = typeof input === "object" && input !== null ? input.host : void 0;
+	if (typeof host !== "string") throw new Error(`browser.${name} needs { host }: the bare hostname, like "preview.internal".`);
+	return host;
+}
+const HOSTS_FUNCTIONS = {
+	listHosts: {
+		doc: "`browser.listHosts()` returns each internal site and the target it points at.",
+		call: (hosts) => hosts.list()
+	},
+	assignHost: {
+		doc: "`browser.assignHost({ host, target })` points an assignable site at a target matching its schema and returns `{ url }`; `host` is the bare hostname, like \"preview.internal\". Navigate to the url next. It stays assigned across runs.",
+		assignable: true,
+		call: (hosts, input) => hosts.assign(hostOf("assignHost", input), input.target)
+	},
+	clearHost: {
+		doc: "`browser.clearHost({ host })` unassigns a site and returns `{ cleared }`. An unassigned site answers 502.",
+		assignable: true,
+		call: async (hosts, input) => ({ cleared: await hosts.clear(hostOf("clearHost", input)) })
+	}
+};
+/** The hosts functions to offer: assign and clear only if any host can be. */
+function hostsFunctions(infos) {
+	const assignable = infos.some((info) => info.assignable);
+	return Object.entries(HOSTS_FUNCTIONS).filter(([, definition]) => assignable || !definition.assignable);
+}
+/**
+* The `browser` object's functions, bound to one run's session, plus the
+* hosts functions when the browser has internal hostnames.
+*/
+function browserFunctions(session, hosts) {
+	const functions = Object.fromEntries(Object.entries(BROWSER_FUNCTIONS).map(([name, definition]) => [name, (input) => definition.call(session, input)]));
+	if (hosts) for (const [name, definition] of hostsFunctions(hosts.describe())) functions[name] = (input) => definition.call(hosts, input);
+	return functions;
+}
+/** How one internal site reads in the docs. */
+function describeHost(info) {
+	const description = info.description ? ` — ${info.description}` : "";
+	const target = info.assignable ? `. Assignable; target schema: ${JSON.stringify(info.targetSchema ?? {})}` : "";
+	return `- ${info.url}${description}${target}`;
+}
+/**
+* The `browser` object's docs for the model, in Markdown: one line per
+* function, then the internal sites when the browser has any.
+*/
+function browserFunctionDocs(hosts) {
+	const infos = hosts?.describe() ?? [];
+	const lines = [...Object.values(BROWSER_FUNCTIONS), ...hosts ? hostsFunctions(infos).map(([, definition]) => definition) : []].map((definition) => `- ${definition.doc}`);
+	if (!hosts) return lines.join("\n");
+	return [
+		...lines,
+		"",
+		"## Internal sites",
+		"",
+		"The browser can open these sites, which aren't on the public internet. Plain http only: no https:// and no WebSockets, so a dev server's hot reload won't connect; reload the page instead.",
+		"",
+		...infos.map(describeHost)
+	].join("\n");
+}
+/**
+* How to use the browser, one rule per line. Each rule fixes a mistake
+* models make with CDP, or states something about this browser they can't
+* know; leave out what a model knows already. Rules about how the code runs
+* (timeouts, screenshots) belong to whatever runs it.
+*/
+const BROWSER_RULES = [
+	"The browser persists between runs: tabs, cookies, and logins are still there next time. You never start or close it.",
+	"If the browser was replaced (idle timeout, crash), a notice says so and earlier tabs and logins are gone. Before an action that matters (submitting a form, a purchase), check you're on the page you expect.",
+	"Page-scoped commands (Page.*, Runtime.*, DOM.*, Input.*, Network.*, Emulation.*) need sessionId: \"active\", your tab, which is remembered between runs. Browser.* and Target.* commands take no sessionId.",
+	"Other open tabs (Target.getTargets) may belong to other conversations using this browser: don't close, navigate, or attach to a tab you didn't open unless the user asks.",
+	"Target.createTarget opens a tab and makes it active. To switch to another open tab, call browser.attachToTarget({ targetId }); the sessionId it returns keeps working in later runs, while one from a raw Target.attachToTarget only works in the current run.",
+	"Tabs a page opens itself (popups, target=_blank links) don't become active; a notice lists them.",
+	"Runtime.evaluate: pass returnByValue: true, or objects come back as a remote reference with no value, and awaitPromise: true for async expressions. The value is at result.value. A thrown error doesn't reject: check exceptionDetails.",
+	"Page.navigate returns before the page loads and doesn't throw when it fails: check errorText, then poll document.readyState with Runtime.evaluate until it is 'complete'.",
+	"Pick out what you need inside Runtime.evaluate and return only that. A screenshot over 1 MB fails the run."
+];
+//#endregion
+//#region src/browser/sandbox.ts
+/**
+* Runs model-written JavaScript in a Dynamic Worker, with a `browser`
+* object whose functions run on the host. Used by `browserTool`.
+* Internal — not an entry point.
+*
+* The Worker has no network access (`globalOutbound: null`) and no bindings:
+* the only way out is `browser`, whose calls go back to the host over RPC.
+*/
+/**
+* Code run as a function body returns nothing unless it says `return`. Tell
+* the model, rather than parse the code to return its last expression. A text
+* search for `return` can't tell a real one from one inside a string, so any
+* body run that comes back empty gets the notice.
+*/
+const STATEMENTS_NOTICE = "Your code ran as statements and returned nothing. If you wanted a value, `return` it, or write an async arrow function.";
+var _functions = /* @__PURE__ */ new WeakMap();
+/**
+* The host side of `browser`. A failed call resolves with `{ error }`
+* instead of rejecting across RPC; the sandbox rethrows it as a local error
+* the code can catch.
+*/
+var HostFunctions = class extends RpcTarget {
+	constructor(functions) {
+		super();
+		_classPrivateFieldInitSpec(this, _functions, void 0);
+		_classPrivateFieldSet2(_functions, this, functions);
+	}
+	async call(name, input) {
+		const fn = Object.hasOwn(_classPrivateFieldGet2(_functions, this), name) ? _classPrivateFieldGet2(_functions, this)[name] : void 0;
+		if (!fn) return { error: `browser.${name} is not a function.` };
+		try {
+			return { value: await fn(input) };
+		} catch (error) {
+			return { error: error instanceof Error ? error.message : String(error) };
+		}
+	}
+};
+/** Console lines a run keeps, and the characters kept of each. */
+const MAX_LOG_LINES = 100;
+const MAX_LOG_LINE_CHARS = 2e3;
+/**
+* The entry module. `code.js` holds the model's code; keeping it in its own
+* module keeps the harness's names out of its scope.
+*/
+function mainModule(timeoutMs, names) {
+	return `import { WorkerEntrypoint } from "cloudflare:workers";
+import run from "./code.js";
+
+export default class BrowserCode extends WorkerEntrypoint {
+  async evaluate(binding) {
+    // Logs are kept in the tool's stored output, so bound them here.
+    const lines = [];
+    let dropped = 0;
+    const record = (prefix) => (...args) => {
+      if (lines.length >= ${MAX_LOG_LINES}) {
+        dropped++;
+        return;
+      }
+      const line = prefix + args.map(String).join(" ");
+      lines.push(
+        line.length > ${MAX_LOG_LINE_CHARS}
+          ? line.slice(0, ${MAX_LOG_LINE_CHARS}) + "…"
+          : line
+      );
+    };
+    const logs = () =>
+      dropped > 0 ? [...lines, "[" + dropped + " more lines dropped]"] : lines;
+    console.log = record("");
+    console.info = record("");
+    console.warn = record("[warn] ");
+    console.error = record("[error] ");
+    const call = async (method, input) => {
+      const reply = await binding.call(method, input);
+      if ("error" in reply) throw new Error(reply.error);
+      return reply.value;
+    };
+    const browser = Object.freeze({
+${names.map((name) => `      ${JSON.stringify(name)}: (input) => call(${JSON.stringify(name)}, input),`).join("\n")}
+    });
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error("Execution timed out after ${timeoutMs}ms")),
+        ${timeoutMs}
+      );
+    });
+    try {
+      return {
+        result: await Promise.race([run(browser), timeout]),
+        logs: logs()
+      };
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : String(error),
+        logs: logs()
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+`;
+}
+/** Strip the markdown fences models often wrap code in. */
+function stripFences(code) {
+	return code.trim().match(/^```(?:js|javascript|typescript|ts|tsx|jsx)?\s*\n([\s\S]*?)```\s*$/)?.[1] ?? code.trim();
+}
+/**
+* The model's code as an expression: an async arrow function (what the tool
+* asks for) is called, and any other expression is awaited.
+*/
+function expressionModule(code) {
+	return `export default async function (browser) {
+  const value = (
+${code.replace(/^export\s+default\s+/, "").replace(/;\s*(\/\/[^\n"'`]*)?\s*$/, "")}
+  );
+  return typeof value === "function" ? await value() : await value;
+}
+`;
+}
+/** The model's code as a function body, for statements with a `return`. */
+function bodyModule(code) {
+	return `export default async function (browser) {
+${code}
+}
+`;
+}
+/** The Worker failed to start because a module didn't parse. */
+function isSyntaxError(error) {
+	return error instanceof Error && /SyntaxError/.test(error.message);
+}
+/**
+* Run the model's code in a fresh Dynamic Worker, with `browser` bound to
+* `functions`.
+*
+* The code is first loaded as an expression (an async arrow function, as
+* the tool asks for). If that doesn't parse, it's loaded once more as a
+* function body, so statements ending in `return` work too; statements
+* with no `return` at all get a `notice`. Errors thrown
+* by the code, including timeouts, come back as `{ error }`; this only
+* rejects when the Worker can't run at all.
+*/
+async function runBrowserCode(options) {
+	const code = stripFences(options.code);
+	if (code === "") return {
+		result: void 0,
+		logs: []
+	};
+	const binding = new HostFunctions(options.functions);
+	try {
+		return await evaluate(options, expressionModule(code), binding);
+	} catch (error) {
+		if (!isSyntaxError(error)) throw error;
+	}
+	let ran;
+	try {
+		ran = await evaluate(options, bodyModule(code), binding);
+	} catch (error) {
+		if (!isSyntaxError(error)) throw error;
+		return {
+			error: `Your code didn't parse: ${error.message}. Write an async arrow function, async () => { ... }.`,
+			logs: []
+		};
+	}
+	return "result" in ran && ran.result === void 0 ? {
+		...ran,
+		notice: STATEMENTS_NOTICE
+	} : ran;
+}
+/**
+* How long past `timeoutMs` the host waits before giving up on a run whose
+* sandbox didn't time itself out. Capped at `timeoutMs` for short runs.
+*/
+const HOST_TIMEOUT_GRACE_MS = 5e3;
+async function evaluate(options, codeModule, binding) {
+	const worker = options.loader.load({
+		compatibilityDate: "2025-06-01",
+		mainModule: "main.js",
+		modules: {
+			"main.js": mainModule(options.timeoutMs, Object.keys(options.functions)),
+			"code.js": codeModule
+		},
+		globalOutbound: null
+	});
+	try {
+		const entrypoint = worker.getEntrypoint();
+		const running = entrypoint.evaluate(binding);
+		running.catch(() => {});
+		let timer;
+		const deadline = new Promise((resolve) => {
+			timer = setTimeout(() => resolve({
+				error: `Execution timed out after ${options.timeoutMs}ms`,
+				logs: []
+			}), options.timeoutMs + Math.min(HOST_TIMEOUT_GRACE_MS, options.timeoutMs));
+		});
+		try {
+			return await Promise.race([running, deadline]);
+		} finally {
+			clearTimeout(timer);
+			disposeQuietly(entrypoint);
+		}
+	} finally {
+		disposeQuietly(worker);
+	}
+}
+function disposeQuietly(resource) {
+	if (typeof resource !== "object" || resource === null || !(Symbol.dispose in resource)) return;
+	const dispose = resource[Symbol.dispose];
+	if (typeof dispose !== "function") return;
+	try {
+		dispose.call(resource);
+	} catch {}
+}
+//#endregion
+//#region src/browser/browser-tool.ts
+/**
+* The harness-neutral core of `browserTool`, shared by the adapters
+* in `tools/` (`agents/browser/ai-sdk`, `agents/browser/tanstack-ai`,
+* `agents/browser/pi`). Internal — not an entry point.
+*/
+const DEFAULT_TIMEOUT_MS = 6e4;
+const RESTARTED_NOTICE = "The browser was restarted before this run (it expired or was closed): earlier tabs, logins, and page state are gone. Your code ran in a fresh browser — navigate again before relying on page state.";
+const TAB_CLOSED_NOTICE = "The tab you were working in was closed (by another conversation using this browser, or a person). `sessionId: \"active\"` now opens a blank tab — navigate again before relying on page state.";
+const TAB_SHARED_NOTICE = "Another conversation using this browser is also working in your tab, so its page may change between your runs. Open a tab of your own with Target.createTarget if you need one.";
+/**
+* The model's input schema, as a Standard Schema with a JSON Schema view,
+* so the AI SDK and TanStack AI both accept it without zod.
+*/
+const inputJsonSchema = {
+	type: "object",
+	properties: { code: {
+		type: "string",
+		description: "An async arrow function that drives the browser with `browser`"
+	} },
+	required: ["code"],
+	additionalProperties: false
+};
+const browserToolInputSchema = { "~standard": {
+	version: 1,
+	vendor: "agents",
+	types: void 0,
+	validate: (value) => typeof value === "object" && value !== null && "code" in value && typeof value.code === "string" ? { value: { code: value.code } } : { issues: [{ message: "Expected an object with a string code property" }] },
+	jsonSchema: {
+		input: (_options) => inputJsonSchema,
+		output: (_options) => inputJsonSchema
+	}
+} };
+/**
+* The latest run queued per browser and scope, so runs in one scope go one
+* at a time, even from tools built separately (one per turn, say). Per
+* isolate, which is per Durable Object.
+*/
+const runQueues = /* @__PURE__ */ new WeakMap();
+function queued(browser, scope, run) {
+	let queues = runQueues.get(browser);
+	if (!queues) runQueues.set(browser, queues = /* @__PURE__ */ new Map());
+	const next = (queues.get(scope) ?? Promise.resolve()).then(run, run);
+	const settled = next.catch(() => void 0);
+	queues.set(scope, settled);
+	settled.then(() => {
+		if (queues.get(scope) === settled) queues.delete(scope);
+	});
+	return next;
+}
+/** The report as a notice on the result, in sentences the model reads. */
+function reportFields(report) {
+	if (!report) return {};
+	const notices = [
+		report.restarted && RESTARTED_NOTICE,
+		report.tabClosed && !report.restarted && TAB_CLOSED_NOTICE,
+		report.tabShared && TAB_SHARED_NOTICE,
+		report.newTabs.length > 0 && `New tabs opened by the page: ${JSON.stringify(report.newTabs)}`
+	].filter((notice) => typeof notice === "string");
+	return notices.length > 0 ? { notice: notices.join(" ") } : {};
+}
+/**
+* Build the description and `execute` for one `browserTool`.
+*
+* Each run opens a session on the browser in its scope, runs the model's
+* code in a fresh Dynamic Worker with `browser` bound to that session, closes
+* the session, and adds its report to the result. Runs in one scope wait
+* for each other, since they drive one tab; runs in different scopes go in
+* parallel.
+*/
+function createBrowserToolCore(options, adapter) {
+	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const rules = [
+		...BROWSER_RULES,
+		"Results over about 24,000 characters are cut short.",
+		`Each run times out after ${Math.round(timeoutMs / 1e3)}s, so split long jobs (crawling a site, say) across runs.`,
+		adapter.screenshotHint,
+		"If your code doesn't parse, the line number in the error counts from wrapper code, not yours. Check regex literals and escapes."
+	].map((rule) => `- ${rule}`).join("\n");
+	const description = [
+		"Run JavaScript that drives a persistent Chrome browser over the Chrome DevTools Protocol (CDP).",
+		"",
+		"Write an async arrow function, `async () => { ... }`, and return a small JSON value. Use the `browser` global to reach the browser. `fetch` is blocked and there is no file system or Node.js API.",
+		"",
+		"## browser",
+		"",
+		browserFunctionDocs(options.browser.internalHosts),
+		"",
+		"## Rules",
+		"",
+		rules
+	].join("\n");
+	const defaultScope = options.scope ?? "shared";
+	async function run(input, scope) {
+		const executionId = crypto.randomUUID();
+		const session = new BrowserSession(options.browser, { scope });
+		let output;
+		try {
+			const ran = await runBrowserCode({
+				loader: options.loader,
+				code: input.code,
+				functions: browserFunctions(session, options.browser.internalHosts),
+				timeoutMs
+			});
+			const logs = ran.logs.length > 0 ? { logs: ran.logs } : {};
+			output = "error" in ran ? {
+				status: "error",
+				executionId,
+				error: truncateResult(ran.error),
+				...logs
+			} : {
+				status: "completed",
+				executionId,
+				result: transformBrowserResult(ran.result),
+				...logs,
+				...ran.notice ? { notice: ran.notice } : {}
+			};
+		} catch (error) {
+			output = {
+				status: "error",
+				executionId,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+		const report = reportFields(await session.close());
+		const notice = [output.notice, report.notice].filter(Boolean).join(" ");
+		return {
+			...output,
+			...report,
+			...notice ? { notice } : {}
+		};
+	}
+	return {
+		description,
+		inputSchema: browserToolInputSchema,
+		/** Run `input` in `scope`, which defaults to the tool's `scope`. */
+		execute: (input, scope = defaultScope) => queued(options.browser, scope, () => run(input, scope))
+	};
+}
+//#endregion
+export { createBrowserToolCore as t };
+
+//# sourceMappingURL=browser-tool-lGnvEBLJ.js.map

package/dist/browser-tool-lGnvEBLJ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-tool-lGnvEBLJ.js","names":[],"sources":["../src/browser/browser-functions.ts","../src/browser/sandbox.ts","../src/browser/browser-tool.ts"],"sourcesContent":["/**\n * The `browser` object model-written code drives a browser with, defined\n * once. `browserTool`'s sandbox exposes it as the `browser` global, and the same functions, docs and rules are what a\n * Workspace module would expose later. Internal — not an entry point.\n *\n * Every function takes one options object. The CDP functions are backed by\n * a `BrowserSession`, which validates the input; `spec` shapes the session's\n * full protocol into pieces small enough for a result. The hosts functions,\n * there only when the browser has internal hostnames, are backed by its\n * `internalHosts`.\n */\nimport type { BrowserInternalHosts } from \"./browser\";\nimport type { InternalHostInfo } from \"./internal-hosts\";\nimport {\n  validate,\n  type BrowserAttachInput,\n  type BrowserDebugLogInput,\n  type BrowserSendInput,\n  type BrowserSession\n} from \"./session\";\nimport type { SearchableCdpSpec } from \"./spec\";\n\n/** One function on the `browser` object, as the host runs it. */\nexport type BrowserFunction = (input: unknown) => Promise<unknown>;\n\ninterface BrowserFunctionDefinition {\n  /** One line for the model: how to call it and what it returns. */\n  doc: string;\n  call(session: BrowserSession, input: unknown): Promise<unknown>;\n}\n\n/** `browser.spec`'s input. */\ninterface BrowserSpecInput {\n  /** A CDP domain, e.g. `\"Page\"`. Omit for the list of domains. */\n  domain?: string;\n}\n\nconst SPEC_SCHEMA = {\n  type: \"object\",\n  properties: { domain: { type: \"string\", minLength: 1 } }\n} as const;\n\n// SAFETY: Each session method validates its input before using it, so the\n// casts below only tell TypeScript what the session checks at runtime.\nconst BROWSER_FUNCTIONS = {\n  cdp: {\n    doc: '`browser.cdp({ method, params?, sessionId?, timeoutMs? })` sends a CDP command and returns its result without the JSON-RPC envelope. Page-scoped commands take `sessionId: \"active\"`: `await browser.cdp({ method: \"Page.navigate\", params: { url }, sessionId: \"active\" })` returns `{ frameId, errorText? }`. `timeoutMs` limits this one command. A failed command throws, and the error often says how to fix the call.',\n    call: (session, input) => session.send(input as BrowserSendInput)\n  },\n  attachToTarget: {\n    doc: '`browser.attachToTarget({ targetId })` switches to an open tab, with `targetId` from `Target.getTargets`, and makes it active: `sessionId: \"active\"` points at it from then on. Returns `{ sessionId }` for that tab.',\n    call: (session, input) =>\n      session.attachToTarget(input as BrowserAttachInput)\n  },\n  spec: {\n    doc: '`browser.spec()` lists the protocol\\'s domains as `{ domains: [{ name, description }] }`; `browser.spec({ domain: \"Page\" })` returns one domain\\'s `{ commands, events, types }`, each command a `{ name, method, description, parameters, returns }` (`name` is `\"navigate\"`, `method` is `\"Page.navigate\"`). Big domains get cut short in your result, so filter in code: `(await browser.spec({ domain: \"Network\" })).commands.find((c) => c.name === \"enable\")`.',\n    call: async (session, input) => {\n      // Check the input before connecting, like the session's own methods.\n      const { domain } = validate(\n        \"browser.spec\",\n        SPEC_SCHEMA,\n        input\n      ) as BrowserSpecInput;\n      return specResult(await session.spec(), domain);\n    }\n  },\n  getDebugLog: {\n    doc: \"`browser.getDebugLog({ limit? })` returns recent protocol traffic, newest last (50 entries unless `limit` says otherwise), each `{ at, type, ... }`. Use it when a command fails or times out.\",\n    call: (session, input) => session.getDebugLog(input as BrowserDebugLogInput)\n  },\n  clearDebugLog: {\n    doc: \"`browser.clearDebugLog()` forgets the traffic recorded so far, so the next `getDebugLog` shows only what follows.\",\n    call: (session) => session.clearDebugLog()\n  }\n} satisfies Record<string, BrowserFunctionDefinition>;\n\n/**\n * Without a domain, every domain's name and first sentence, which is small;\n * with one, that domain's commands, events and types. The whole protocol is\n * about 650 KB, too much for one result.\n */\nfunction specResult(spec: SearchableCdpSpec, domain: string | undefined) {\n  const { domains } = spec;\n  if (domain === undefined) {\n    return {\n      domains: domains.map(({ name, description }) => ({\n        name,\n        ...(description ? { description: firstSentence(description) } : {})\n      })),\n      hint: 'browser.spec({ domain: \"Page\" }) returns one domain\\'s commands, events and types.'\n    };\n  }\n  const found = domains.find((d) => d.name === domain);\n  if (found) return found;\n  const near = domains.find(\n    (d) => d.name.toLowerCase() === domain.toLowerCase()\n  );\n  throw new Error(\n    `No CDP domain named '${domain}'.` +\n      (near\n        ? ` Did you mean '${near.name}'?`\n        : \" browser.spec() lists the domains.\")\n  );\n}\n\n/** A CDP description's first sentence, for the list of domains. */\nfunction firstSentence(text: string): string {\n  return text.match(/^[\\s\\S]*?\\.(?=\\s|$)/)?.[0] ?? text;\n}\n\ninterface HostsFunctionDefinition {\n  doc: string;\n  /** Only offered when at least one host is assignable. */\n  assignable?: true;\n  call(hosts: BrowserInternalHosts, input: unknown): Promise<unknown>;\n}\n\n/** The `host` field of a hosts function's input, or a fix-it error. */\nfunction hostOf(name: string, input: unknown): string {\n  const host =\n    typeof input === \"object\" && input !== null\n      ? (input as { host?: unknown }).host\n      : undefined;\n  if (typeof host !== \"string\") {\n    throw new Error(\n      `browser.${name} needs { host }: the bare hostname, like \"preview.internal\".`\n    );\n  }\n  return host;\n}\n\nconst HOSTS_FUNCTIONS = {\n  listHosts: {\n    doc: \"`browser.listHosts()` returns each internal site and the target it points at.\",\n    call: (hosts) => hosts.list()\n  },\n  assignHost: {\n    doc: '`browser.assignHost({ host, target })` points an assignable site at a target matching its schema and returns `{ url }`; `host` is the bare hostname, like \"preview.internal\". Navigate to the url next. It stays assigned across runs.',\n    assignable: true,\n    call: (hosts, input) =>\n      hosts.assign(\n        hostOf(\"assignHost\", input),\n        (input as { target?: unknown }).target\n      )\n  },\n  clearHost: {\n    doc: \"`browser.clearHost({ host })` unassigns a site and returns `{ cleared }`. An unassigned site answers 502.\",\n    assignable: true,\n    call: async (hosts, input) => ({\n      cleared: await hosts.clear(hostOf(\"clearHost\", input))\n    })\n  }\n} satisfies Record<string, HostsFunctionDefinition>;\n\n/** The hosts functions to offer: assign and clear only if any host can be. */\nfunction hostsFunctions(\n  infos: InternalHostInfo[]\n): [string, HostsFunctionDefinition][] {\n  const assignable = infos.some((info) => info.assignable);\n  return Object.entries(HOSTS_FUNCTIONS).filter(\n    ([, definition]: [string, HostsFunctionDefinition]) =>\n      assignable || !definition.assignable\n  );\n}\n\n/**\n * The `browser` object's functions, bound to one run's session, plus the\n * hosts functions when the browser has internal hostnames.\n */\nexport function browserFunctions(\n  session: BrowserSession,\n  hosts?: BrowserInternalHosts\n): Record<string, BrowserFunction> {\n  const functions: Record<string, BrowserFunction> = Object.fromEntries(\n    Object.entries(BROWSER_FUNCTIONS).map(([name, definition]) => [\n      name,\n      (input: unknown) => definition.call(session, input)\n    ])\n  );\n  if (hosts) {\n    for (const [name, definition] of hostsFunctions(hosts.describe())) {\n      functions[name] = (input: unknown) => definition.call(hosts, input);\n    }\n  }\n  return functions;\n}\n\n/** How one internal site reads in the docs. */\nfunction describeHost(info: InternalHostInfo): string {\n  const description = info.description ? ` — ${info.description}` : \"\";\n  const target = info.assignable\n    ? `. Assignable; target schema: ${JSON.stringify(info.targetSchema ?? {})}`\n    : \"\";\n  return `- ${info.url}${description}${target}`;\n}\n\n/**\n * The `browser` object's docs for the model, in Markdown: one line per\n * function, then the internal sites when the browser has any.\n */\nexport function browserFunctionDocs(hosts?: BrowserInternalHosts): string {\n  const infos = hosts?.describe() ?? [];\n  const functions = [\n    ...Object.values(BROWSER_FUNCTIONS),\n    ...(hosts ? hostsFunctions(infos).map(([, definition]) => definition) : [])\n  ];\n  const lines = functions.map((definition) => `- ${definition.doc}`);\n  if (!hosts) return lines.join(\"\\n\");\n  return [\n    ...lines,\n    \"\",\n    \"## Internal sites\",\n    \"\",\n    \"The browser can open these sites, which aren't on the public internet. Plain http only: no https:// and no WebSockets, so a dev server's hot reload won't connect; reload the page instead.\",\n    \"\",\n    ...infos.map(describeHost)\n  ].join(\"\\n\");\n}\n\n/**\n * How to use the browser, one rule per line. Each rule fixes a mistake\n * models make with CDP, or states something about this browser they can't\n * know; leave out what a model knows already. Rules about how the code runs\n * (timeouts, screenshots) belong to whatever runs it.\n */\nexport const BROWSER_RULES: readonly string[] = [\n  \"The browser persists between runs: tabs, cookies, and logins are still there next time. You never start or close it.\",\n  \"If the browser was replaced (idle timeout, crash), a notice says so and earlier tabs and logins are gone. Before an action that matters (submitting a form, a purchase), check you're on the page you expect.\",\n  'Page-scoped commands (Page.*, Runtime.*, DOM.*, Input.*, Network.*, Emulation.*) need sessionId: \"active\", your tab, which is remembered between runs. Browser.* and Target.* commands take no sessionId.',\n  \"Other open tabs (Target.getTargets) may belong to other conversations using this browser: don't close, navigate, or attach to a tab you didn't open unless the user asks.\",\n  \"Target.createTarget opens a tab and makes it active. To switch to another open tab, call browser.attachToTarget({ targetId }); the sessionId it returns keeps working in later runs, while one from a raw Target.attachToTarget only works in the current run.\",\n  \"Tabs a page opens itself (popups, target=_blank links) don't become active; a notice lists them.\",\n  \"Runtime.evaluate: pass returnByValue: true, or objects come back as a remote reference with no value, and awaitPromise: true for async expressions. The value is at result.value. A thrown error doesn't reject: check exceptionDetails.\",\n  \"Page.navigate returns before the page loads and doesn't throw when it fails: check errorText, then poll document.readyState with Runtime.evaluate until it is 'complete'.\",\n  \"Pick out what you need inside Runtime.evaluate and return only that. A screenshot over 1 MB fails the run.\"\n];\n","/**\n * Runs model-written JavaScript in a Dynamic Worker, with a `browser`\n * object whose functions run on the host. Used by `browserTool`.\n * Internal — not an entry point.\n *\n * The Worker has no network access (`globalOutbound: null`) and no bindings:\n * the only way out is `browser`, whose calls go back to the host over RPC.\n */\nimport { RpcTarget } from \"cloudflare:workers\";\nimport type { BrowserFunction } from \"./browser-functions\";\n\n/**\n * What a run returns: the code's result or error, its console output, and a\n * `notice` for the model when the code likely didn't do what it meant.\n */\nexport type BrowserCodeRun =\n  | { result: unknown; logs: string[]; notice?: string }\n  | { error: string; logs: string[] };\n\n/**\n * Code run as a function body returns nothing unless it says `return`. Tell\n * the model, rather than parse the code to return its last expression. A text\n * search for `return` can't tell a real one from one inside a string, so any\n * body run that comes back empty gets the notice.\n */\nconst STATEMENTS_NOTICE =\n  \"Your code ran as statements and returned nothing. If you wanted a value, `return` it, or write an async arrow function.\";\n\nexport interface RunBrowserCodeOptions {\n  loader: WorkerLoader;\n  /** The model's code: an async arrow function, or a function body. */\n  code: string;\n  /** The functions on the `browser` global, run on the host. */\n  functions: Record<string, BrowserFunction>;\n  /** How long the code may run before it fails. */\n  timeoutMs: number;\n}\n\n/**\n * The host side of `browser`. A failed call resolves with `{ error }`\n * instead of rejecting across RPC; the sandbox rethrows it as a local error\n * the code can catch.\n */\nclass HostFunctions extends RpcTarget {\n  readonly #functions: Record<string, BrowserFunction>;\n\n  constructor(functions: Record<string, BrowserFunction>) {\n    super();\n    this.#functions = functions;\n  }\n\n  async call(\n    name: string,\n    input: unknown\n  ): Promise<{ value: unknown } | { error: string }> {\n    const fn = Object.hasOwn(this.#functions, name)\n      ? this.#functions[name]\n      : undefined;\n    if (!fn) return { error: `browser.${name} is not a function.` };\n    try {\n      return { value: await fn(input) };\n    } catch (error) {\n      return { error: error instanceof Error ? error.message : String(error) };\n    }\n  }\n}\n\n/** Console lines a run keeps, and the characters kept of each. */\nconst MAX_LOG_LINES = 100;\nconst MAX_LOG_LINE_CHARS = 2_000;\n\n/**\n * The entry module. `code.js` holds the model's code; keeping it in its own\n * module keeps the harness's names out of its scope.\n */\nfunction mainModule(timeoutMs: number, names: string[]): string {\n  return `import { WorkerEntrypoint } from \"cloudflare:workers\";\nimport run from \"./code.js\";\n\nexport default class BrowserCode extends WorkerEntrypoint {\n  async evaluate(binding) {\n    // Logs are kept in the tool's stored output, so bound them here.\n    const lines = [];\n    let dropped = 0;\n    const record = (prefix) => (...args) => {\n      if (lines.length >= ${MAX_LOG_LINES}) {\n        dropped++;\n        return;\n      }\n      const line = prefix + args.map(String).join(\" \");\n      lines.push(\n        line.length > ${MAX_LOG_LINE_CHARS}\n          ? line.slice(0, ${MAX_LOG_LINE_CHARS}) + \"…\"\n          : line\n      );\n    };\n    const logs = () =>\n      dropped > 0 ? [...lines, \"[\" + dropped + \" more lines dropped]\"] : lines;\n    console.log = record(\"\");\n    console.info = record(\"\");\n    console.warn = record(\"[warn] \");\n    console.error = record(\"[error] \");\n    const call = async (method, input) => {\n      const reply = await binding.call(method, input);\n      if (\"error\" in reply) throw new Error(reply.error);\n      return reply.value;\n    };\n    const browser = Object.freeze({\n${names.map((name) => `      ${JSON.stringify(name)}: (input) => call(${JSON.stringify(name)}, input),`).join(\"\\n\")}\n    });\n    let timer;\n    const timeout = new Promise((_, reject) => {\n      timer = setTimeout(\n        () => reject(new Error(\"Execution timed out after ${timeoutMs}ms\")),\n        ${timeoutMs}\n      );\n    });\n    try {\n      return {\n        result: await Promise.race([run(browser), timeout]),\n        logs: logs()\n      };\n    } catch (error) {\n      return {\n        error: error instanceof Error ? error.message : String(error),\n        logs: logs()\n      };\n    } finally {\n      clearTimeout(timer);\n    }\n  }\n}\n`;\n}\n\n/** Strip the markdown fences models often wrap code in. */\nfunction stripFences(code: string): string {\n  const fenced =\n    /^```(?:js|javascript|typescript|ts|tsx|jsx)?\\s*\\n([\\s\\S]*?)```\\s*$/;\n  return code.trim().match(fenced)?.[1] ?? code.trim();\n}\n\n/**\n * The model's code as an expression: an async arrow function (what the tool\n * asks for) is called, and any other expression is awaited.\n */\nfunction expressionModule(code: string): string {\n  const expression = code\n    .replace(/^export\\s+default\\s+/, \"\")\n    // A last `;`, even with a comment after it, would end the expression.\n    .replace(/;\\s*(\\/\\/[^\\n\"'`]*)?\\s*$/, \"\");\n  return `export default async function (browser) {\n  const value = (\n${expression}\n  );\n  return typeof value === \"function\" ? await value() : await value;\n}\n`;\n}\n\n/** The model's code as a function body, for statements with a `return`. */\nfunction bodyModule(code: string): string {\n  return `export default async function (browser) {\n${code}\n}\n`;\n}\n\n/** The Worker failed to start because a module didn't parse. */\nfunction isSyntaxError(error: unknown): boolean {\n  return error instanceof Error && /SyntaxError/.test(error.message);\n}\n\n/**\n * Run the model's code in a fresh Dynamic Worker, with `browser` bound to\n * `functions`.\n *\n * The code is first loaded as an expression (an async arrow function, as\n * the tool asks for). If that doesn't parse, it's loaded once more as a\n * function body, so statements ending in `return` work too; statements\n * with no `return` at all get a `notice`. Errors thrown\n * by the code, including timeouts, come back as `{ error }`; this only\n * rejects when the Worker can't run at all.\n */\nexport async function runBrowserCode(\n  options: RunBrowserCodeOptions\n): Promise<BrowserCodeRun> {\n  const code = stripFences(options.code);\n  if (code === \"\") return { result: undefined, logs: [] };\n  const binding = new HostFunctions(options.functions);\n  try {\n    return await evaluate(options, expressionModule(code), binding);\n  } catch (error) {\n    if (!isSyntaxError(error)) throw error;\n  }\n  let ran: BrowserCodeRun;\n  try {\n    ran = await evaluate(options, bodyModule(code), binding);\n  } catch (error) {\n    if (!isSyntaxError(error)) throw error;\n    return {\n      error: `Your code didn't parse: ${(error as Error).message}. Write an async arrow function, async () => { ... }.`,\n      logs: []\n    };\n  }\n  return \"result\" in ran && ran.result === undefined\n    ? { ...ran, notice: STATEMENTS_NOTICE }\n    : ran;\n}\n\n/**\n * How long past `timeoutMs` the host waits before giving up on a run whose\n * sandbox didn't time itself out. Capped at `timeoutMs` for short runs.\n */\nconst HOST_TIMEOUT_GRACE_MS = 5_000;\n\nasync function evaluate(\n  options: RunBrowserCodeOptions,\n  codeModule: string,\n  binding: HostFunctions\n): Promise<BrowserCodeRun> {\n  // `load()`, not `get(id, ...)`: every run's code is different, so there\n  // is nothing to cache by id.\n  const worker = options.loader.load({\n    compatibilityDate: \"2025-06-01\",\n    mainModule: \"main.js\",\n    modules: {\n      \"main.js\": mainModule(options.timeoutMs, Object.keys(options.functions)),\n      \"code.js\": codeModule\n    },\n    globalOutbound: null\n  });\n  // The loaded Worker and its entrypoint stub own native handles. Dispose\n  // both once the run settles rather than leaving them to GC, which can\n  // finalize them during isolate shutdown and crash workerd.\n  try {\n    const entrypoint = worker.getEntrypoint() as unknown as {\n      evaluate(binding: HostFunctions): Promise<BrowserCodeRun>;\n    };\n    const running = entrypoint.evaluate(binding);\n    // If the deadline wins, the run's own settling is ignored.\n    running.catch(() => {});\n    // The sandbox times itself out, but its code can cancel that timer, so\n    // the host keeps a deadline too. Missing it frees the scope's queue;\n    // the run's later browser calls fail once its session closes.\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    const deadline = new Promise<BrowserCodeRun>((resolve) => {\n      timer = setTimeout(\n        () =>\n          resolve({\n            error: `Execution timed out after ${options.timeoutMs}ms`,\n            logs: []\n          }),\n        options.timeoutMs + Math.min(HOST_TIMEOUT_GRACE_MS, options.timeoutMs)\n      );\n    });\n    try {\n      return await Promise.race([running, deadline]);\n    } finally {\n      clearTimeout(timer);\n      disposeQuietly(entrypoint);\n    }\n  } finally {\n    disposeQuietly(worker);\n  }\n}\n\nfunction disposeQuietly(resource: unknown): void {\n  if (\n    typeof resource !== \"object\" ||\n    resource === null ||\n    !(Symbol.dispose in resource)\n  ) {\n    return;\n  }\n  const dispose = (resource as { [Symbol.dispose]?: unknown })[Symbol.dispose];\n  if (typeof dispose !== \"function\") return;\n  try {\n    (dispose as () => void).call(resource);\n  } catch {\n    // Disposal must never mask the run's result.\n  }\n}\n","/**\n * The harness-neutral core of `browserTool`, shared by the adapters\n * in `tools/` (`agents/browser/ai-sdk`, `agents/browser/tanstack-ai`,\n * `agents/browser/pi`). Internal — not an entry point.\n */\nimport { DEFAULT_BROWSER_SCOPE } from \"./browser\";\nimport {\n  BROWSER_RULES,\n  browserFunctionDocs,\n  browserFunctions\n} from \"./browser-functions\";\nimport { runBrowserCode } from \"./sandbox\";\nimport {\n  BrowserSession,\n  type BrowserSessionReport,\n  type BrowserSource\n} from \"./session\";\nimport { transformBrowserResult } from \"./tool-helpers\";\nimport { truncateResult } from \"./truncate\";\n\nexport interface BrowserToolOptions {\n  /**\n   * The browser the tool drives — usually a `Browser` installed on the\n   * host's Lifecycle. Tools built from the same `Browser` share it.\n   */\n  browser: BrowserSource;\n\n  /**\n   * Worker Loader binding the model's code runs in. Each run gets a fresh\n   * Dynamic Worker with no network access.\n   *\n   * Requires `\"worker_loaders\": [{ \"binding\": \"LOADER\" }]` in wrangler.jsonc.\n   */\n  loader: WorkerLoader;\n\n  /** How long one run may take, in milliseconds. Defaults to 60000 (60s). */\n  timeoutMs?: number;\n\n  /**\n   * Who is driving, when several chats or users share one `Browser`: runs\n   * with the same scope share an active tab, and each scope keeps its own.\n   * Cookies and logins are shared by every scope. Defaults to `\"shared\"`,\n   * one active tab for every tool that leaves it out.\n   */\n  scope?: string;\n\n  /**\n   * @deprecated Not needed any more: the tool no longer runs on a codemode\n   * facet. Ignored.\n   */\n  ctx?: DurableObjectState;\n}\n\n/** The model's input to `browserTool`: JavaScript to run. */\nexport interface BrowserToolInput {\n  code: string;\n}\n\n/** What happened to the browser during a run, added to its result. */\ninterface BrowserReportFields {\n  /**\n   * Sentences telling the model what happened to its browser: it was\n   * restarted, its tab was closed by someone else, another scope is working\n   * in its tab too, or the page opened new tabs.\n   */\n  notice?: string;\n}\n\n/**\n * The result of one `browserTool` run: the code's result, or the\n * error it threw, plus what happened to the browser. Errors are returned,\n * not thrown, so the model can read them and try again.\n */\nexport type BrowserToolOutput = (\n  | {\n      status: \"completed\";\n      /** Identifies the run, for logs and UIs. */\n      executionId: string;\n      result: unknown;\n      /** What the code wrote to the console. */\n      logs?: string[];\n    }\n  | {\n      status: \"error\";\n      executionId: string;\n      error: string;\n      logs?: string[];\n    }\n) &\n  BrowserReportFields;\n\nconst DEFAULT_TIMEOUT_MS = 60_000;\n\nconst RESTARTED_NOTICE =\n  \"The browser was restarted before this run (it expired or was closed): earlier tabs, logins, and page state are gone. Your code ran in a fresh browser — navigate again before relying on page state.\";\n\nconst TAB_CLOSED_NOTICE =\n  'The tab you were working in was closed (by another conversation using this browser, or a person). `sessionId: \"active\"` now opens a blank tab — navigate again before relying on page state.';\n\nconst TAB_SHARED_NOTICE =\n  \"Another conversation using this browser is also working in your tab, so its page may change between your runs. Open a tab of your own with Target.createTarget if you need one.\";\n\n/**\n * The model's input schema, as a Standard Schema with a JSON Schema view,\n * so the AI SDK and TanStack AI both accept it without zod.\n */\nconst inputJsonSchema = {\n  type: \"object\",\n  properties: {\n    code: {\n      type: \"string\",\n      description:\n        \"An async arrow function that drives the browser with `browser`\"\n    }\n  },\n  required: [\"code\"],\n  additionalProperties: false\n};\n\nconst browserToolInputSchema = {\n  \"~standard\": {\n    version: 1 as const,\n    vendor: \"agents\",\n    types: undefined as\n      | { readonly input: BrowserToolInput; readonly output: BrowserToolInput }\n      | undefined,\n    validate: (\n      value: unknown\n    ):\n      | { readonly value: BrowserToolInput }\n      | { readonly issues: ReadonlyArray<{ readonly message: string }> } =>\n      typeof value === \"object\" &&\n      value !== null &&\n      \"code\" in value &&\n      typeof value.code === \"string\"\n        ? { value: { code: value.code } }\n        : {\n            issues: [\n              { message: \"Expected an object with a string code property\" }\n            ]\n          },\n    jsonSchema: {\n      input: (_options: { readonly target: string }) => inputJsonSchema,\n      output: (_options: { readonly target: string }) => inputJsonSchema\n    }\n  }\n};\n\n/**\n * The latest run queued per browser and scope, so runs in one scope go one\n * at a time, even from tools built separately (one per turn, say). Per\n * isolate, which is per Durable Object.\n */\nconst runQueues = new WeakMap<BrowserSource, Map<string, Promise<unknown>>>();\n\nfunction queued<T>(\n  browser: BrowserSource,\n  scope: string,\n  run: () => Promise<T>\n): Promise<T> {\n  let queues = runQueues.get(browser);\n  if (!queues) runQueues.set(browser, (queues = new Map()));\n  const previous = queues.get(scope) ?? Promise.resolve();\n  const next = previous.then(run, run);\n  const settled = next.catch(() => undefined);\n  queues.set(scope, settled);\n  void settled.then(() => {\n    if (queues.get(scope) === settled) queues.delete(scope);\n  });\n  return next;\n}\n\n/** The report as a notice on the result, in sentences the model reads. */\nfunction reportFields(\n  report: BrowserSessionReport | undefined\n): BrowserReportFields {\n  if (!report) return {};\n  const notices = [\n    report.restarted && RESTARTED_NOTICE,\n    report.tabClosed && !report.restarted && TAB_CLOSED_NOTICE,\n    report.tabShared && TAB_SHARED_NOTICE,\n    report.newTabs.length > 0 &&\n      `New tabs opened by the page: ${JSON.stringify(report.newTabs)}`\n  ].filter((notice) => typeof notice === \"string\");\n  return notices.length > 0 ? { notice: notices.join(\" \") } : {};\n}\n\n/**\n * Build the description and `execute` for one `browserTool`.\n *\n * Each run opens a session on the browser in its scope, runs the model's\n * code in a fresh Dynamic Worker with `browser` bound to that session, closes\n * the session, and adds its report to the result. Runs in one scope wait\n * for each other, since they drive one tab; runs in different scopes go in\n * parallel.\n */\nexport function createBrowserToolCore(\n  options: BrowserToolOptions,\n  adapter: {\n    /** What the adapter does with screenshots, told to the model. */\n    screenshotHint: string;\n  }\n) {\n  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n  const rules = [\n    ...BROWSER_RULES,\n    \"Results over about 24,000 characters are cut short.\",\n    `Each run times out after ${Math.round(timeoutMs / 1000)}s, so split long jobs (crawling a site, say) across runs.`,\n    adapter.screenshotHint,\n    \"If your code doesn't parse, the line number in the error counts from wrapper code, not yours. Check regex literals and escapes.\"\n  ]\n    .map((rule) => `- ${rule}`)\n    .join(\"\\n\");\n  const description = [\n    \"Run JavaScript that drives a persistent Chrome browser over the Chrome DevTools Protocol (CDP).\",\n    \"\",\n    \"Write an async arrow function, `async () => { ... }`, and return a small JSON value. Use the `browser` global to reach the browser. `fetch` is blocked and there is no file system or Node.js API.\",\n    \"\",\n    \"## browser\",\n    \"\",\n    browserFunctionDocs(options.browser.internalHosts),\n    \"\",\n    \"## Rules\",\n    \"\",\n    rules\n  ].join(\"\\n\");\n\n  const defaultScope = options.scope ?? DEFAULT_BROWSER_SCOPE;\n\n  async function run(input: BrowserToolInput, scope: string) {\n    const executionId = crypto.randomUUID();\n    const session = new BrowserSession(options.browser, { scope });\n    let output: BrowserToolOutput;\n    try {\n      const ran = await runBrowserCode({\n        loader: options.loader,\n        code: input.code,\n        functions: browserFunctions(session, options.browser.internalHosts),\n        timeoutMs\n      });\n      const logs = ran.logs.length > 0 ? { logs: ran.logs } : {};\n      output =\n        \"error\" in ran\n          ? {\n              status: \"error\",\n              executionId,\n              // The code can throw anything, so bound it like a result.\n              error: truncateResult(ran.error) as string,\n              ...logs\n            }\n          : {\n              status: \"completed\",\n              executionId,\n              result: transformBrowserResult(ran.result),\n              ...logs,\n              ...(ran.notice ? { notice: ran.notice } : {})\n            };\n    } catch (error) {\n      output = {\n        status: \"error\",\n        executionId,\n        error: error instanceof Error ? error.message : String(error)\n      };\n    }\n    const report = reportFields(await session.close());\n    const notice = [output.notice, report.notice].filter(Boolean).join(\" \");\n    return { ...output, ...report, ...(notice ? { notice } : {}) };\n  }\n\n  return {\n    description,\n    inputSchema: browserToolInputSchema,\n    /** Run `input` in `scope`, which defaults to the tool's `scope`. */\n    execute: (\n      input: BrowserToolInput,\n      scope: string = defaultScope\n    ): Promise<BrowserToolOutput> =>\n      queued(options.browser, scope, () => run(input, scope))\n  };\n}\n"],"mappings":"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"}

package/dist/capability-id-B3J8Nok_.js

@@ -0,0 +1,13 @@
+//#region src/browser/capability-id.ts
+/**
+* The Lifecycle capability id of the `Browser` named `name`. Its own module
+* so `Agent.fetchInternalHost()` can route to a browser without importing
+* the browser code.
+*/
+function browserCapabilityId(name) {
+	return `browser:${name}`;
+}
+//#endregion
+export { browserCapabilityId as t };
+
+//# sourceMappingURL=capability-id-B3J8Nok_.js.map

package/dist/capability-id-B3J8Nok_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capability-id-B3J8Nok_.js","names":[],"sources":["../src/browser/capability-id.ts"],"sourcesContent":["/**\n * The Lifecycle capability id of the `Browser` named `name`. Its own module\n * so `Agent.fetchInternalHost()` can route to a browser without importing\n * the browser code.\n */\nexport function browserCapabilityId(name: string): string {\n  return `browser:${name}`;\n}\n"],"mappings":";;;;;;AAKA,SAAgB,oBAAoB,MAAsB;CACxD,OAAO,WAAW;AACpB"}

package/dist/chat/index.d.ts

@@ -9,7 +9,7 @@ import {
   _ as FiberRecoveryContext$1,
   at as isPositionlessAgentToolChunk,
   z as AgentToolEventState
-} from "../agent-routing-CDbpVjYq.js";
+} from "../agent-routing-wS1TimZ_.js";
 import { _ as TaskStep, m as TaskRunOptions } from "../tasks-E89KdwkS.js";
 import {
   n as ClientToolSchema,
@@ -34,7 +34,7 @@ import {
   r as AgentToolProgressEmitResult,
   s as interceptAgentToolBroadcast,
   t as AgentToolBroadcastHooks
-} from "../agent-tools-C8DH8Yii.js";
+} from "../agent-tools-Bamxxb6Y.js";
 import { l as SessionMessage } from "../types-B7LojTe4.js";
 import { ModelMessage, UIMessage } from "ai";
 import { Connection, FiberRecoveryContext } from "agents";

package/dist/chat-sdk/index.d.ts

@@ -1,8 +1,8 @@
 import {
-  bn as DynamicAgentClass,
   c as Agent,
-  xn as DynamicAgentStub
-} from "../agent-routing-CDbpVjYq.js";
+  nn as DynamicAgentStub,
+  tn as DynamicAgentClass
+} from "../agent-routing-wS1TimZ_.js";
 import { Lock, QueueEntry, StateAdapter } from "chat";
 
 //#region src/chat-sdk/agent.d.ts

package/dist/chat-sdk/index.js

@@ -1,4 +1,4 @@
-import { i as getCurrentAgent, t as Agent } from "../src-DfLzdwlK.js";
+import { i as getCurrentAgent, t as Agent } from "../src-BGolXG_H.js";
 //#region src/chat-sdk/agent.ts
 const NEXT_CLEANUP_AT_KEY = "next_cleanup_at";
 const CLEANUP_SCHEDULE_ID_KEY = "cleanup_schedule_id";