agents 0.24.0 → 0.26.0

package/dist/browser-tool-CQ10e6Kj.js

@@ -0,0 +1,480 @@
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-DZBYAB34.js";
+import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-qMjJ6sHQ.js";
+import { E as CdpProtocolError, k as validateConnectorArgs } from "./connector-58XDGvc3.js";
+import { o as resolveCtx, s as transformBrowserResult } from "./ai-fm7xx1BK.js";
+import { CodemodeConnector, DynamicWorkerExecutor, createCodemodeRuntime } from "@cloudflare/codemode";
+/**
+* `cdp.attachToTarget` returns `{ sessionId: "target:<targetId>" }` — a
+* stable handle rather than a connection-scoped CDP session id, so replayed
+* code computes identical arguments. `send` resolves it on the live socket.
+*/
+const ATTACH_HANDLE_PREFIX = "target:";
+/** Chrome's JSON-RPC code for a CDP session id it doesn't know. */
+const CDP_SESSION_NOT_FOUND = -32001;
+/** {@link BrowserSessionConnector} `#liveParams`: nothing to detach. */
+const DETACHED = Symbol("detached");
+/** Reports awaiting their tool call; bounded in case a caller never reads. */
+const MAX_PENDING_REPORTS = 100;
+/**
+* Commands that would end the browser. The host owns its lifetime, so the
+* model can't close it out from under the agent (and lose its logins).
+*/
+const BROWSER_LIFETIME_COMMANDS = /* @__PURE__ */ new Set([
+	"Browser.close",
+	"Browser.crash",
+	"Browser.crashGpuProcess"
+]);
+const INSTRUCTIONS = [
+	"This browser persists between executions: tabs, cookies, and logins you leave behind are still there next time. It is managed for you — there is nothing to start, close, or reset.",
+	"The browser can still be replaced between runs (idle timeout, crash) — even between the passes of a run that paused for approval. The tool result then says restarted: true, and earlier tabs, cookies, and logins are gone. Don't assume a page from an earlier run is still there: check where you are before an action that matters (submitting a form, making a purchase).",
+	"Page-scoped commands (Page.*, Runtime.*, DOM.*, Input.*, Network.*, Emulation.*) need sessionId: \"active\" — the tab you are working in, which stays the same across executions. Example: await cdp.send({ method: \"Page.navigate\", params: { url }, sessionId: \"active\" }).",
+	"Browser- and Target-scoped commands (Target.getTargets, Target.createTarget, Browser.getVersion) take no sessionId.",
+	"Opening a tab with Target.createTarget makes it the active tab. To switch to another open tab, call cdp.attachToTarget({ targetId }): it becomes active, and the returned sessionId works like \"active\" for that tab, in this run and later ones. A raw Target.attachToTarget sent through cdp.send returns Chrome's own sessionId, which only lasts for the current run.",
+	"Tabs a page opens on its own (popups, target=_blank links) do not become active; the tool result lists them as newTabs.",
+	"cdp.send returns the CDP method result directly, not the JSON-RPC envelope: Target.createTarget returns { targetId }, Runtime.evaluate returns { result: { value } }, Page.captureScreenshot returns { data }.",
+	"Issue CDP calls sequentially — never in parallel (no Promise.all): call order is recorded for durable replay.",
+	"Page.navigate resolves before the page finishes loading. Poll Runtime.evaluate of document.readyState until it is 'complete' before reading the page.",
+	"Use cdp.spec() to discover commands, events, and types when unsure. If a command fails or times out, check cdp.getDebugLog() for recent protocol traffic.",
+	"Return small results. Write large page dumps to a file or workspace and pass references around."
+].join("\n");
+var _browser = /* @__PURE__ */ new WeakMap();
+var _states = /* @__PURE__ */ new WeakMap();
+var _connecting = /* @__PURE__ */ new WeakMap();
+var _reports = /* @__PURE__ */ new WeakMap();
+var _BrowserSessionConnector_brand = /* @__PURE__ */ new WeakSet();
+/**
+* Codemode connector exposing one host-named, persistent browser over the
+* Chrome DevTools Protocol as the `cdp` global.
+*
+* The model never manages sessions: every execution reattaches to the
+* browser (or gets a replacement, reported as `restarted`), and
+* `sessionId: "active"` addresses the tab it last worked in. The active tab
+* is stored on the browser's record, so it survives between executions for as
+* long as the tab does.
+*
+* The CDP socket is per pass: opened on the first call, closed when the pass
+* ends. The browser itself outlives the execution.
+*/
+var BrowserSessionConnector = class extends CodemodeConnector {
+	constructor(ctx, options) {
+		super(ctx, {});
+		_classPrivateMethodInitSpec(this, _BrowserSessionConnector_brand);
+		_classPrivateFieldInitSpec(this, _browser, void 0);
+		_classPrivateFieldInitSpec(this, _states, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _connecting, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _reports, /* @__PURE__ */ new Map());
+		_classPrivateFieldSet2(_browser, this, options.browser);
+	}
+	name() {
+		return "cdp";
+	}
+	instructions() {
+		return INSTRUCTIONS;
+	}
+	tool(name, tool) {
+		return validateConnectorArgs(this.name(), name, tool);
+	}
+	tools() {
+		return {
+			send: {
+				description: "Send a CDP command and return its method result directly. Pass sessionId: \"active\" for page-scoped commands; omit it for Browser/Target commands.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						method: {
+							type: "string",
+							description: "CDP method, e.g. \"Page.navigate\""
+						},
+						params: {
+							type: "object",
+							description: "CDP command parameters"
+						},
+						sessionId: {
+							type: "string",
+							description: "\"active\" for the current tab, or a handle from attachToTarget. Omit for Browser/Target commands."
+						},
+						timeoutMs: {
+							type: "number",
+							description: "Per-command timeout override in milliseconds"
+						}
+					},
+					required: ["method"]
+				},
+				execute: async (args, ctx) => {
+					const { method, params, sessionId, timeoutMs } = args;
+					if (BROWSER_LIFETIME_COMMANDS.has(method)) throw new Error(`${method} is not available: this browser is managed for you and persists between runs. To close a tab, send Target.closeTarget with its targetId.`);
+					const state = await _assertClassBrand(_BrowserSessionConnector_brand, this, _state).call(this, _assertClassBrand(_BrowserSessionConnector_brand, this, _executionId).call(this, ctx));
+					const live = await _assertClassBrand(_BrowserSessionConnector_brand, this, _resolveSessionId).call(this, state, sessionId);
+					const liveParams = _assertClassBrand(_BrowserSessionConnector_brand, this, _liveParams).call(this, state, method, params);
+					if (liveParams === DETACHED) return {};
+					let result;
+					try {
+						result = await state.connected.cdp.send(method, liveParams, {
+							sessionId: live,
+							timeoutMs
+						});
+					} catch (error) {
+						throw await _assertClassBrand(_BrowserSessionConnector_brand, this, _teach).call(this, state, error, method, sessionId);
+					}
+					_assertClassBrand(_BrowserSessionConnector_brand, this, _observe).call(this, state, method, liveParams, result);
+					return result;
+				}
+			},
+			attachToTarget: {
+				description: "Switch to an open tab: make it the active tab and return { sessionId } — a handle you can pass to page-scoped send calls for that tab.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						targetId: {
+							type: "string",
+							description: "Target id from Target.getTargets/createTarget"
+						},
+						timeoutMs: { type: "number" }
+					},
+					required: ["targetId"]
+				},
+				outputSchema: {
+					type: "object",
+					properties: { sessionId: {
+						type: "string",
+						description: "Session handle for page-scoped send calls"
+					} },
+					required: ["sessionId"]
+				},
+				execute: async (args, ctx) => {
+					const { targetId, timeoutMs } = args;
+					const state = await _assertClassBrand(_BrowserSessionConnector_brand, this, _state).call(this, _assertClassBrand(_BrowserSessionConnector_brand, this, _executionId).call(this, ctx));
+					await _assertClassBrand(_BrowserSessionConnector_brand, this, _attach).call(this, state, targetId, timeoutMs);
+					_assertClassBrand(_BrowserSessionConnector_brand, this, _setActive).call(this, state, targetId);
+					return { sessionId: attachHandle(targetId) };
+				}
+			},
+			spec: {
+				description: "Return the searchable Chrome DevTools Protocol spec: domains with their commands, events, and types.",
+				replay: "reexecute",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				},
+				execute: async (_args, ctx) => {
+					return (await _assertClassBrand(_BrowserSessionConnector_brand, this, _state).call(this, _assertClassBrand(_BrowserSessionConnector_brand, this, _executionId).call(this, ctx))).connected.spec();
+				}
+			},
+			getDebugLog: {
+				description: "Return recent CDP protocol traffic (sends, receives, warnings) for this execution — useful to diagnose failures and timeouts.",
+				replay: "reexecute",
+				inputSchema: {
+					type: "object",
+					properties: { limit: {
+						type: "number",
+						minimum: 1,
+						description: "Max entries to return, newest last (default 50; only the last 400 are kept)"
+					} }
+				},
+				execute: async (args, ctx) => {
+					const { limit } = args ?? {};
+					return (await _assertClassBrand(_BrowserSessionConnector_brand, this, _state).call(this, _assertClassBrand(_BrowserSessionConnector_brand, this, _executionId).call(this, ctx))).connected.cdp.getDebugLog(limit);
+				}
+			},
+			clearDebugLog: {
+				description: "Clear the CDP debug log for this execution.",
+				inputSchema: {
+					type: "object",
+					properties: {}
+				},
+				execute: async (_args, ctx) => {
+					(await _assertClassBrand(_BrowserSessionConnector_brand, this, _state).call(this, _assertClassBrand(_BrowserSessionConnector_brand, this, _executionId).call(this, ctx))).connected.cdp.clearDebugLog();
+					return null;
+				}
+			}
+		};
+	}
+	/**
+	* The pass is over: note tabs the page opened, save the active tab on the
+	* browser's record, and drop the socket. The browser stays alive.
+	*/
+	async onPassEnd(executionId) {
+		const state = _classPrivateFieldGet2(_states, this).get(executionId);
+		if (!state) return;
+		_classPrivateFieldGet2(_states, this).delete(executionId);
+		try {
+			const open = await _assertClassBrand(_BrowserSessionConnector_brand, this, _recordNewTabs).call(this, executionId, state);
+			await _assertClassBrand(_BrowserSessionConnector_brand, this, _saveActiveTarget).call(this, state, open);
+		} finally {
+			state.connected.cdp.disconnect();
+		}
+	}
+	/** Nothing per execution outlives the pass; the named browser persists. */
+	async disposeExecution(executionId) {
+		const state = _classPrivateFieldGet2(_states, this).get(executionId);
+		if (!state) return;
+		_classPrivateFieldGet2(_states, this).delete(executionId);
+		state.connected.cdp.disconnect();
+	}
+	/**
+	* Take (and forget) what happened to the browser during an execution.
+	* `undefined` when the execution never touched the browser. Covers the
+	* passes this instance ran; see the note on `#reports`.
+	*/
+	takeReport(executionId) {
+		const report = _classPrivateFieldGet2(_reports, this).get(executionId);
+		_classPrivateFieldGet2(_reports, this).delete(executionId);
+		return report;
+	}
+};
+function _executionId(ctx) {
+	if (!ctx?.executionId) throw new Error("Browser tools must run inside a codemode execution");
+	return ctx.executionId;
+}
+/**
+* Connect once per pass. Concurrent first calls (model code that uses
+* Promise.all despite the instructions) share one connect.
+*/
+function _state(executionId) {
+	const existing = _classPrivateFieldGet2(_states, this).get(executionId);
+	if (existing) return Promise.resolve(existing);
+	const inFlight = _classPrivateFieldGet2(_connecting, this).get(executionId);
+	if (inFlight) return inFlight;
+	const promise = _assertClassBrand(_BrowserSessionConnector_brand, this, _connect).call(this, executionId).finally(() => {
+		_classPrivateFieldGet2(_connecting, this).delete(executionId);
+	});
+	_classPrivateFieldGet2(_connecting, this).set(executionId, promise);
+	return promise;
+}
+async function _connect(executionId) {
+	const connected = await _classPrivateFieldGet2(_browser, this).connect();
+	let initialPages;
+	try {
+		initialPages = await _assertClassBrand(_BrowserSessionConnector_brand, this, _pages).call(this, connected.cdp);
+	} catch (error) {
+		connected.cdp.disconnect();
+		throw error;
+	}
+	const state = {
+		connected,
+		attached: /* @__PURE__ */ new Map(),
+		initialPages: new Set(initialPages.map((page) => page.targetId)),
+		activeResolved: false
+	};
+	_classPrivateFieldGet2(_states, this).set(executionId, state);
+	_assertClassBrand(_BrowserSessionConnector_brand, this, _report).call(this, executionId, connected.restarted);
+	return state;
+}
+function _report(executionId, restarted) {
+	let report = _classPrivateFieldGet2(_reports, this).get(executionId);
+	if (!report) {
+		report = {
+			restarted,
+			newTabs: []
+		};
+		_classPrivateFieldGet2(_reports, this).set(executionId, report);
+		if (_classPrivateFieldGet2(_reports, this).size > MAX_PENDING_REPORTS) {
+			const oldest = _classPrivateFieldGet2(_reports, this).keys().next().value;
+			if (oldest !== void 0) _classPrivateFieldGet2(_reports, this).delete(oldest);
+		}
+	}
+	report.restarted ||= restarted;
+	return report;
+}
+/**
+* Add tabs the page opened this pass to the execution's report, and drop
+* earlier ones that have since closed: `newTabs` lists page-opened tabs
+* still open when the execution ends, across every pass. Returns the open
+* tabs, or `undefined` when the browser couldn't be asked.
+*/
+async function _recordNewTabs(executionId, state) {
+	let pages;
+	try {
+		pages = await _assertClassBrand(_BrowserSessionConnector_brand, this, _pages).call(this, state.connected.cdp);
+	} catch (error) {
+		_assertClassBrand(_BrowserSessionConnector_brand, this, _warn).call(this, "list the open tabs", error);
+		return;
+	}
+	const report = _assertClassBrand(_BrowserSessionConnector_brand, this, _report).call(this, executionId, state.connected.restarted);
+	const opened = new Set(report.newTabs.map((tab) => tab.targetId));
+	for (const page of pages) if (!state.initialPages.has(page.targetId) && page.openerId) opened.add(page.targetId);
+	report.newTabs = pages.filter((page) => opened.has(page.targetId)).map(({ targetId, url, title }) => ({
+		targetId,
+		url,
+		title
+	}));
+	return new Set(pages.map((page) => page.targetId));
+}
+/**
+* Save the tab this pass settled on, forgetting one that has since closed.
+* Without the list of open tabs, save the choice unchecked: the next
+* execution checks the stored tab is still open before using it.
+*/
+async function _saveActiveTarget(state, open) {
+	const stored = state.connected.activeTargetId;
+	const candidate = state.activeResolved ? state.activeTargetId : stored;
+	const active = candidate && (!open || open.has(candidate)) ? candidate : void 0;
+	if (active === stored) return;
+	try {
+		await state.connected.setActiveTarget(active);
+	} catch (error) {
+		_assertClassBrand(_BrowserSessionConnector_brand, this, _warn).call(this, "save the active tab", error);
+	}
+}
+function _warn(action, error) {
+	console.warn(`[agents/browser] Failed to ${action} for browser "${_classPrivateFieldGet2(_browser, this).name}"`, error);
+}
+async function _pages(cdp) {
+	return ((await cdp.send("Target.getTargets"))?.targetInfos ?? []).filter((info) => info.type === "page");
+}
+async function _resolveSessionId(state, sessionId) {
+	if (sessionId === "active") return _assertClassBrand(_BrowserSessionConnector_brand, this, _attach).call(this, state, await _assertClassBrand(_BrowserSessionConnector_brand, this, _activeTarget).call(this, state));
+	if (isAttachHandle(sessionId)) return _assertClassBrand(_BrowserSessionConnector_brand, this, _attach).call(this, state, targetOfHandle(sessionId));
+	return sessionId;
+}
+/**
+* Decide which tab `"active"` means, once per pass: the stored tab if it
+* is still open, else the only open tab, else a new blank tab when none
+* are open, else the first listed tab.
+*/
+async function _activeTarget(state) {
+	if (state.activeTargetId) return state.activeTargetId;
+	const pages = await _assertClassBrand(_BrowserSessionConnector_brand, this, _pages).call(this, state.connected.cdp);
+	const stored = state.connected.activeTargetId;
+	let targetId = pages.find((page) => page.targetId === stored)?.targetId;
+	if (!targetId && pages.length === 0) targetId = (await state.connected.cdp.send("Target.createTarget", { url: "about:blank" })).targetId;
+	targetId ??= pages[0].targetId;
+	_assertClassBrand(_BrowserSessionConnector_brand, this, _setActive).call(this, state, targetId);
+	return targetId;
+}
+function _setActive(state, targetId) {
+	state.activeTargetId = targetId;
+	state.activeResolved = true;
+}
+async function _attach(state, targetId, timeoutMs) {
+	const existing = state.attached.get(targetId);
+	if (existing) return existing;
+	const live = await state.connected.cdp.attachToTarget(targetId, { timeoutMs });
+	state.attached.set(targetId, live);
+	return live;
+}
+/** Track tab changes the model makes through raw Target commands. */
+function _observe(state, method, params, result) {
+	const targetId = typeof params?.targetId === "string" ? params.targetId : void 0;
+	if (method === "Target.createTarget") {
+		const created = result?.targetId;
+		if (typeof created === "string") _assertClassBrand(_BrowserSessionConnector_brand, this, _setActive).call(this, state, created);
+	} else if (method === "Target.attachToTarget" && targetId) _assertClassBrand(_BrowserSessionConnector_brand, this, _setActive).call(this, state, targetId);
+	else if (method === "Target.closeTarget" && targetId) {
+		state.attached.delete(targetId);
+		if (state.activeTargetId === targetId) state.activeTargetId = void 0;
+	} else if (method === "Target.detachFromTarget") {
+		for (const [target, live] of state.attached) if (target === targetId || live === params?.sessionId) state.attached.delete(target);
+	}
+}
+/**
+* Swap a handle in `Target.detachFromTarget`'s `sessionId` param for the
+* live CDP session id. Returns {@link DETACHED} when the handle's tab isn't
+* attached on this socket, so there is nothing to detach.
+*/
+function _liveParams(state, method, params) {
+	const handle = params?.sessionId;
+	if (method !== "Target.detachFromTarget" || typeof handle !== "string") return params;
+	if (!isAttachHandle(handle)) return params;
+	const live = state.attached.get(targetOfHandle(handle));
+	return live ? {
+		...params,
+		sessionId: live
+	} : DETACHED;
+}
+/**
+* Turn the common protocol mistakes into instructions: sending an
+* event as a command, and a page-scoped command without a session.
+*/
+async function _teach(state, error, method, sessionId) {
+	if (!(error instanceof CdpProtocolError)) return error;
+	if (error.code === CDP_SESSION_NOT_FOUND && sessionId && sessionId !== "active" && !isAttachHandle(sessionId)) return /* @__PURE__ */ new Error(`${error.message}. CDP session ids don't carry over between runs. Use sessionId: "active" for the current tab, or the handle from cdp.attachToTarget({ targetId }) for another tab.`);
+	if (error.code !== -32601) return error;
+	if (await _assertClassBrand(_BrowserSessionConnector_brand, this, _isEvent).call(this, state, method)) return /* @__PURE__ */ new Error(`${error.message}. '${method}' is a CDP *event*, not a command — it cannot be sent. To wait for page state, poll instead (e.g. Runtime.evaluate of document.readyState until "complete").`);
+	if (!sessionId) return /* @__PURE__ */ new Error(`${error.message}. '${method}' is page-scoped: pass sessionId: "active" to run it in the current tab — cdp.send({ method: "${method}", params, sessionId: "active" }).`);
+	return error;
+}
+async function _isEvent(state, method) {
+	try {
+		const spec = await state.connected.spec();
+		const domain = method.split(".")[0];
+		return spec.domains.some((d) => d.name === domain && d.events.some((e) => e.event === method));
+	} catch {
+		return false;
+	}
+}
+function attachHandle(targetId) {
+	return `${ATTACH_HANDLE_PREFIX}${targetId}`;
+}
+function isAttachHandle(sessionId) {
+	return sessionId?.startsWith(ATTACH_HANDLE_PREFIX) ?? false;
+}
+function targetOfHandle(handle) {
+	return handle.slice(7);
+}
+//#endregion
+//#region src/browser/browser-tool.ts
+/**
+* The harness-neutral core of `browserTool`, shared by the AI SDK
+* (`agents/browser/ai-sdk`) and TanStack AI (`agents/browser/tanstack-ai`)
+* adapters. Internal — not an entry point.
+*/
+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.";
+/**
+* A codemode runtime name per browser. Browser names are host-chosen and
+* unrestricted; runtime names allow only `[a-zA-Z0-9_.-]`, so anything else
+* (including `.`, the escape) is hex-escaped.
+*/
+function browserRuntimeName(name) {
+	return `browser-tool_${name.replace(/[^a-zA-Z0-9_-]/g, (char) => `.${char.codePointAt(0)?.toString(16)}.`)}`;
+}
+/** Add what happened to the browser to the codemode result. */
+function withBrowserReport(output, report) {
+	if (!report) return output;
+	return {
+		...output,
+		...report.restarted ? {
+			restarted: true,
+			notice: RESTARTED_NOTICE
+		} : {},
+		...report.newTabs.length > 0 ? { newTabs: report.newTabs } : {}
+	};
+}
+/** Report sentences that must survive a screenshot's text summary. */
+function browserReportNotes(output) {
+	const notes = [];
+	if (output.notice) notes.push(output.notice);
+	if (output.newTabs?.length) notes.push(`New tabs opened by the page: ${JSON.stringify(output.newTabs)}`);
+	return notes;
+}
+/**
+* Build the codemode runtime and connector for one `browserTool`, and wrap
+* `execute` so each result carries the browser report.
+*/
+function createBrowserToolCore(options, adapter) {
+	const ctx = resolveCtx(options);
+	if (!ctx) throw new Error("browserTool requires a Durable Object 'ctx' — pass it explicitly, or call from within an Agent so it can be resolved via getCurrentAgent()");
+	const connector = new BrowserSessionConnector(ctx, { browser: options.browser });
+	const codemodeTool = createCodemodeRuntime({
+		ctx,
+		executor: new DynamicWorkerExecutor({
+			loader: options.loader,
+			timeout: options.timeoutMs
+		}),
+		connectors: [connector],
+		name: browserRuntimeName(options.browser.name),
+		transformResult: transformBrowserResult
+	}).tool({ connectorHints: { cdp: `A persistent browser over CDP — tabs and logins carry over between runs. Use sessionId: "active" for page commands. ${adapter.screenshotHint}` } });
+	return {
+		description: codemodeTool.description,
+		inputSchema: codemodeTool.inputSchema,
+		execute: async (input, executeOptions) => {
+			const output = await codemodeTool.execute(input, executeOptions);
+			return withBrowserReport(output, connector.takeReport(output.executionId));
+		}
+	};
+}
+//#endregion
+export { createBrowserToolCore as n, browserReportNotes as t };
+
+//# sourceMappingURL=browser-tool-CQ10e6Kj.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser-tool-CQ10e6Kj.js","names":[],"sources":["../src/browser/session-connector.ts","../src/browser/browser-tool.ts"],"sourcesContent":["import {\n  CodemodeConnector,\n  type ConnectorTool,\n  type ConnectorTools,\n  type ToolExecuteContext\n} from \"@cloudflare/codemode\";\nimport { validateConnectorArgs } from \"./connector-validation\";\nimport {\n  CDP_METHOD_NOT_FOUND,\n  CdpProtocolError,\n  type CdpConnection\n} from \"./cdp-connection\";\nimport type { BrowserConnection } from \"./browser\";\nimport type { SearchableCdpSpec } from \"./spec\";\n\n/**\n * Where a {@link BrowserSessionConnector} gets its browser. Usually a\n * `Browser` installed on the host's Lifecycle.\n */\nexport interface BrowserSource {\n  /** The browser's name, for log messages. */\n  readonly name: string;\n  /** Reattach to the browser (or replace it) and open a CDP connection. */\n  connect(): Promise<BrowserConnection>;\n}\n\nexport interface BrowserSessionConnectorOptions {\n  /** The persistent browser this connector drives. */\n  browser: BrowserSource;\n}\n\n/** A tab a page opened on its own during an execution. */\nexport interface BrowserNewTab {\n  targetId: string;\n  url?: string;\n  title?: string;\n}\n\n/**\n * What happened to the browser during one execution, beyond the code's own\n * result — read by the tool after the run via\n * {@link BrowserSessionConnector.takeReport}.\n */\nexport interface BrowserExecutionReport {\n  /** The browser was replaced before this run; earlier page state is gone. */\n  restarted: boolean;\n  /** Tabs the page opened itself (popups, `target=_blank`). */\n  newTabs: BrowserNewTab[];\n}\n\n/** `sessionId` value that addresses the tab the agent is working in. */\nexport const ACTIVE_PAGE_SESSION = \"active\";\n\n/**\n * `cdp.attachToTarget` returns `{ sessionId: \"target:<targetId>\" }` — a\n * stable handle rather than a connection-scoped CDP session id, so replayed\n * code computes identical arguments. `send` resolves it on the live socket.\n */\nconst ATTACH_HANDLE_PREFIX = \"target:\";\n\n/** Chrome's JSON-RPC code for a CDP session id it doesn't know. */\nconst CDP_SESSION_NOT_FOUND = -32001;\n\n/** {@link BrowserSessionConnector} `#liveParams`: nothing to detach. */\nconst DETACHED = Symbol(\"detached\");\n\n/** Reports awaiting their tool call; bounded in case a caller never reads. */\nconst MAX_PENDING_REPORTS = 100;\n\n/**\n * Commands that would end the browser. The host owns its lifetime, so the\n * model can't close it out from under the agent (and lose its logins).\n */\nconst BROWSER_LIFETIME_COMMANDS = new Set([\n  \"Browser.close\",\n  \"Browser.crash\",\n  \"Browser.crashGpuProcess\"\n]);\n\n/** A CDP target id — for this connector, a tab. */\ntype TargetId = string & { readonly __brand: \"TargetId\" };\n\n/** A CDP session id from `Target.attachToTarget`, valid on one socket only. */\ntype LiveSessionId = string & { readonly __brand: \"LiveSessionId\" };\n\n/** The stable `sessionId` handle `cdp.attachToTarget` gives the model. */\ntype AttachHandle = `${typeof ATTACH_HANDLE_PREFIX}${string}`;\n\ninterface TargetInfo {\n  targetId: TargetId;\n  type: string;\n  url?: string;\n  title?: string;\n  /** The tab that opened this one (popups, `target=_blank` links). */\n  openerId?: TargetId;\n}\n\n/** Per-execution state for one pass. Dropped when the pass ends. */\ninterface ExecutionState {\n  connected: BrowserConnection;\n  /** Live CDP session per target, valid on this socket only. */\n  attached: Map<TargetId, LiveSessionId>;\n  /** Page targets open when the pass connected. */\n  initialPages: Set<TargetId>;\n  /** The tab `\"active\"` resolves to — decided lazily on first use. */\n  activeTargetId?: TargetId;\n  /** Whether {@link activeTargetId} was decided (vs. never needed). */\n  activeResolved: boolean;\n}\n\nconst INSTRUCTIONS = [\n  \"This browser persists between executions: tabs, cookies, and logins you leave behind are still there next time. It is managed for you — there is nothing to start, close, or reset.\",\n  \"The browser can still be replaced between runs (idle timeout, crash) — even between the passes of a run that paused for approval. The tool result then says restarted: true, and earlier tabs, cookies, and logins are gone. Don't assume a page from an earlier run is still there: check where you are before an action that matters (submitting a form, making a purchase).\",\n  'Page-scoped commands (Page.*, Runtime.*, DOM.*, Input.*, Network.*, Emulation.*) need sessionId: \"active\" — the tab you are working in, which stays the same across executions. Example: await cdp.send({ method: \"Page.navigate\", params: { url }, sessionId: \"active\" }).',\n  \"Browser- and Target-scoped commands (Target.getTargets, Target.createTarget, Browser.getVersion) take no sessionId.\",\n  'Opening a tab with Target.createTarget makes it the active tab. To switch to another open tab, call cdp.attachToTarget({ targetId }): it becomes active, and the returned sessionId works like \"active\" for that tab, in this run and later ones. A raw Target.attachToTarget sent through cdp.send returns Chrome\\'s own sessionId, which only lasts for the current run.',\n  \"Tabs a page opens on its own (popups, target=_blank links) do not become active; the tool result lists them as newTabs.\",\n  \"cdp.send returns the CDP method result directly, not the JSON-RPC envelope: Target.createTarget returns { targetId }, Runtime.evaluate returns { result: { value } }, Page.captureScreenshot returns { data }.\",\n  \"Issue CDP calls sequentially — never in parallel (no Promise.all): call order is recorded for durable replay.\",\n  \"Page.navigate resolves before the page finishes loading. Poll Runtime.evaluate of document.readyState until it is 'complete' before reading the page.\",\n  \"Use cdp.spec() to discover commands, events, and types when unsure. If a command fails or times out, check cdp.getDebugLog() for recent protocol traffic.\",\n  \"Return small results. Write large page dumps to a file or workspace and pass references around.\"\n].join(\"\\n\");\n\n/**\n * Codemode connector exposing one host-named, persistent browser over the\n * Chrome DevTools Protocol as the `cdp` global.\n *\n * The model never manages sessions: every execution reattaches to the\n * browser (or gets a replacement, reported as `restarted`), and\n * `sessionId: \"active\"` addresses the tab it last worked in. The active tab\n * is stored on the browser's record, so it survives between executions for as\n * long as the tab does.\n *\n * The CDP socket is per pass: opened on the first call, closed when the pass\n * ends. The browser itself outlives the execution.\n */\nexport class BrowserSessionConnector extends CodemodeConnector {\n  readonly #browser: BrowserSource;\n  #states = new Map<string, ExecutionState>();\n  #connecting = new Map<string, Promise<ExecutionState>>();\n  /**\n   * In memory, on this instance. An execution resumed after an approval\n   * pause may run on a fresh connector, whose report starts over. Nothing\n   * pauses today — the browser tool wires no approval tools — so reporting\n   * across a resume is left for when approvals are added.\n   *\n   * The same goes for raw CDP session ids from `Target.attachToTarget` sent\n   * through `send`: they belong to one pass's socket, so a replay after a\n   * pause would reuse a dead id. The stable handles from `attachToTarget`\n   * are the replay-safe path.\n   */\n  #reports = new Map<string, BrowserExecutionReport>();\n\n  constructor(\n    ctx: DurableObjectState | ExecutionContext,\n    options: BrowserSessionConnectorOptions\n  ) {\n    super(ctx, {});\n    this.#browser = options.browser;\n  }\n\n  name(): string {\n    return \"cdp\";\n  }\n\n  protected instructions(): string {\n    return INSTRUCTIONS;\n  }\n\n  protected override tool(name: string, tool: ConnectorTool): ConnectorTool {\n    return validateConnectorArgs(this.name(), name, tool);\n  }\n\n  protected tools(): ConnectorTools {\n    return {\n      send: {\n        description:\n          'Send a CDP command and return its method result directly. Pass sessionId: \"active\" for page-scoped commands; omit it for Browser/Target commands.',\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            method: {\n              type: \"string\",\n              description: 'CDP method, e.g. \"Page.navigate\"'\n            },\n            params: {\n              type: \"object\",\n              description: \"CDP command parameters\"\n            },\n            sessionId: {\n              type: \"string\",\n              description:\n                '\"active\" for the current tab, or a handle from attachToTarget. Omit for Browser/Target commands.'\n            },\n            timeoutMs: {\n              type: \"number\",\n              description: \"Per-command timeout override in milliseconds\"\n            }\n          },\n          required: [\"method\"]\n        },\n        execute: async (args, ctx) => {\n          const { method, params, sessionId, timeoutMs } = args as {\n            method: string;\n            params?: Record<string, unknown>;\n            sessionId?: string;\n            timeoutMs?: number;\n          };\n          if (BROWSER_LIFETIME_COMMANDS.has(method)) {\n            throw new Error(\n              `${method} is not available: this browser is managed for you ` +\n                `and persists between runs. To close a tab, send ` +\n                `Target.closeTarget with its targetId.`\n            );\n          }\n          const state = await this.#state(this.#executionId(ctx));\n          const live = await this.#resolveSessionId(state, sessionId);\n          const liveParams = this.#liveParams(state, method, params);\n          if (liveParams === DETACHED) return {};\n          let result: unknown;\n          try {\n            result = await state.connected.cdp.send(method, liveParams, {\n              sessionId: live,\n              timeoutMs\n            });\n          } catch (error) {\n            throw await this.#teach(state, error, method, sessionId);\n          }\n          this.#observe(state, method, liveParams, result);\n          return result;\n        }\n      },\n\n      attachToTarget: {\n        description:\n          \"Switch to an open tab: make it the active tab and return { sessionId } — a handle you can pass to page-scoped send calls for that tab.\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            targetId: {\n              type: \"string\",\n              description: \"Target id from Target.getTargets/createTarget\"\n            },\n            timeoutMs: { type: \"number\" }\n          },\n          required: [\"targetId\"]\n        },\n        outputSchema: {\n          type: \"object\",\n          properties: {\n            sessionId: {\n              type: \"string\",\n              description: \"Session handle for page-scoped send calls\"\n            }\n          },\n          required: [\"sessionId\"]\n        },\n        execute: async (args, ctx) => {\n          const { targetId, timeoutMs } = args as {\n            targetId: TargetId;\n            timeoutMs?: number;\n          };\n          const state = await this.#state(this.#executionId(ctx));\n          await this.#attach(state, targetId, timeoutMs);\n          this.#setActive(state, targetId);\n          return { sessionId: attachHandle(targetId) };\n        }\n      },\n\n      spec: {\n        description:\n          \"Return the searchable Chrome DevTools Protocol spec: domains with their commands, events, and types.\",\n        replay: \"reexecute\",\n        inputSchema: { type: \"object\", properties: {} },\n        execute: async (_args, ctx): Promise<SearchableCdpSpec> => {\n          const state = await this.#state(this.#executionId(ctx));\n          return state.connected.spec();\n        }\n      },\n\n      getDebugLog: {\n        description:\n          \"Return recent CDP protocol traffic (sends, receives, warnings) for this execution — useful to diagnose failures and timeouts.\",\n        replay: \"reexecute\",\n        inputSchema: {\n          type: \"object\",\n          properties: {\n            limit: {\n              type: \"number\",\n              minimum: 1,\n              description:\n                \"Max entries to return, newest last (default 50; only the last 400 are kept)\"\n            }\n          }\n        },\n        execute: async (args, ctx) => {\n          const { limit } = (args ?? {}) as { limit?: number };\n          const state = await this.#state(this.#executionId(ctx));\n          return state.connected.cdp.getDebugLog(limit);\n        }\n      },\n\n      clearDebugLog: {\n        description: \"Clear the CDP debug log for this execution.\",\n        inputSchema: { type: \"object\", properties: {} },\n        execute: async (_args, ctx) => {\n          const state = await this.#state(this.#executionId(ctx));\n          state.connected.cdp.clearDebugLog();\n          return null;\n        }\n      }\n    };\n  }\n\n  // ── Codemode execution hooks ─────────────────────────────────────────────\n\n  /**\n   * The pass is over: note tabs the page opened, save the active tab on the\n   * browser's record, and drop the socket. The browser stays alive.\n   */\n  override async onPassEnd(executionId: string): Promise<void> {\n    const state = this.#states.get(executionId);\n    if (!state) return;\n    this.#states.delete(executionId);\n    try {\n      const open = await this.#recordNewTabs(executionId, state);\n      await this.#saveActiveTarget(state, open);\n    } finally {\n      state.connected.cdp.disconnect();\n    }\n  }\n\n  /** Nothing per execution outlives the pass; the named browser persists. */\n  override async disposeExecution(executionId: string): Promise<void> {\n    const state = this.#states.get(executionId);\n    if (!state) return;\n    this.#states.delete(executionId);\n    state.connected.cdp.disconnect();\n  }\n\n  /**\n   * Take (and forget) what happened to the browser during an execution.\n   * `undefined` when the execution never touched the browser. Covers the\n   * passes this instance ran; see the note on `#reports`.\n   */\n  takeReport(executionId: string): BrowserExecutionReport | undefined {\n    const report = this.#reports.get(executionId);\n    this.#reports.delete(executionId);\n    return report;\n  }\n\n  // ── Internals ────────────────────────────────────────────────────────────\n\n  #executionId(ctx: ToolExecuteContext | undefined): string {\n    if (!ctx?.executionId) {\n      throw new Error(\"Browser tools must run inside a codemode execution\");\n    }\n    return ctx.executionId;\n  }\n\n  /**\n   * Connect once per pass. Concurrent first calls (model code that uses\n   * Promise.all despite the instructions) share one connect.\n   */\n  #state(executionId: string): Promise<ExecutionState> {\n    const existing = this.#states.get(executionId);\n    if (existing) return Promise.resolve(existing);\n    const inFlight = this.#connecting.get(executionId);\n    if (inFlight) return inFlight;\n    const promise = this.#connect(executionId).finally(() => {\n      this.#connecting.delete(executionId);\n    });\n    this.#connecting.set(executionId, promise);\n    return promise;\n  }\n\n  async #connect(executionId: string): Promise<ExecutionState> {\n    const connected = await this.#browser.connect();\n    let initialPages: TargetInfo[];\n    try {\n      initialPages = await this.#pages(connected.cdp);\n    } catch (error) {\n      connected.cdp.disconnect();\n      throw error;\n    }\n    const state: ExecutionState = {\n      connected,\n      attached: new Map(),\n      initialPages: new Set(initialPages.map((page) => page.targetId)),\n      activeResolved: false\n    };\n    this.#states.set(executionId, state);\n    this.#report(executionId, connected.restarted);\n    return state;\n  }\n\n  #report(executionId: string, restarted: boolean): BrowserExecutionReport {\n    let report = this.#reports.get(executionId);\n    if (!report) {\n      report = { restarted, newTabs: [] };\n      this.#reports.set(executionId, report);\n      if (this.#reports.size > MAX_PENDING_REPORTS) {\n        const oldest = this.#reports.keys().next().value;\n        if (oldest !== undefined) this.#reports.delete(oldest);\n      }\n    }\n    // A replacement on any pass means earlier page state is gone.\n    report.restarted ||= restarted;\n    return report;\n  }\n\n  /**\n   * Add tabs the page opened this pass to the execution's report, and drop\n   * earlier ones that have since closed: `newTabs` lists page-opened tabs\n   * still open when the execution ends, across every pass. Returns the open\n   * tabs, or `undefined` when the browser couldn't be asked.\n   */\n  async #recordNewTabs(\n    executionId: string,\n    state: ExecutionState\n  ): Promise<Set<TargetId> | undefined> {\n    let pages: TargetInfo[];\n    try {\n      pages = await this.#pages(state.connected.cdp);\n    } catch (error) {\n      this.#warn(\"list the open tabs\", error);\n      return undefined;\n    }\n    const report = this.#report(executionId, state.connected.restarted);\n    const opened = new Set<string>(report.newTabs.map((tab) => tab.targetId));\n    for (const page of pages) {\n      // Chrome sets openerId only on tabs a page opened, never on\n      // Target.createTarget tabs — including ones another execution sharing\n      // this browser created meanwhile.\n      if (!state.initialPages.has(page.targetId) && page.openerId) {\n        opened.add(page.targetId);\n      }\n    }\n    report.newTabs = pages\n      .filter((page) => opened.has(page.targetId))\n      .map(({ targetId, url, title }) => ({ targetId, url, title }));\n    return new Set(pages.map((page) => page.targetId));\n  }\n\n  /**\n   * Save the tab this pass settled on, forgetting one that has since closed.\n   * Without the list of open tabs, save the choice unchecked: the next\n   * execution checks the stored tab is still open before using it.\n   */\n  async #saveActiveTarget(\n    state: ExecutionState,\n    open: Set<TargetId> | undefined\n  ): Promise<void> {\n    const stored = state.connected.activeTargetId as TargetId | undefined;\n    const candidate = state.activeResolved ? state.activeTargetId : stored;\n    const active =\n      candidate && (!open || open.has(candidate)) ? candidate : undefined;\n    if (active === stored) return;\n    try {\n      await state.connected.setActiveTarget(active);\n    } catch (error) {\n      this.#warn(\"save the active tab\", error);\n    }\n  }\n\n  #warn(action: string, error: unknown): void {\n    console.warn(\n      `[agents/browser] Failed to ${action} for browser \"${this.#browser.name}\"`,\n      error\n    );\n  }\n\n  async #pages(cdp: CdpConnection): Promise<TargetInfo[]> {\n    const result = (await cdp.send(\"Target.getTargets\")) as {\n      targetInfos?: TargetInfo[];\n    };\n    return (result?.targetInfos ?? []).filter((info) => info.type === \"page\");\n  }\n\n  async #resolveSessionId(\n    state: ExecutionState,\n    sessionId: string | undefined\n  ): Promise<LiveSessionId | undefined> {\n    if (sessionId === ACTIVE_PAGE_SESSION) {\n      return this.#attach(state, await this.#activeTarget(state));\n    }\n    if (isAttachHandle(sessionId)) {\n      return this.#attach(state, targetOfHandle(sessionId));\n    }\n    // Omitted, or a raw CDP session id the model got from send().\n    return sessionId as LiveSessionId | undefined;\n  }\n\n  /**\n   * Decide which tab `\"active\"` means, once per pass: the stored tab if it\n   * is still open, else the only open tab, else a new blank tab when none\n   * are open, else the first listed tab.\n   */\n  async #activeTarget(state: ExecutionState): Promise<TargetId> {\n    if (state.activeTargetId) return state.activeTargetId;\n    const pages = await this.#pages(state.connected.cdp);\n    const stored = state.connected.activeTargetId;\n    let targetId = pages.find((page) => page.targetId === stored)?.targetId;\n    if (!targetId && pages.length === 0) {\n      const created = (await state.connected.cdp.send(\"Target.createTarget\", {\n        url: \"about:blank\"\n      })) as { targetId: TargetId };\n      targetId = created.targetId;\n    }\n    targetId ??= pages[0].targetId;\n    this.#setActive(state, targetId);\n    return targetId;\n  }\n\n  #setActive(state: ExecutionState, targetId: TargetId | undefined): void {\n    state.activeTargetId = targetId;\n    state.activeResolved = true;\n  }\n\n  async #attach(\n    state: ExecutionState,\n    targetId: TargetId,\n    timeoutMs?: number\n  ): Promise<LiveSessionId> {\n    const existing = state.attached.get(targetId);\n    if (existing) return existing;\n    const live = (await state.connected.cdp.attachToTarget(targetId, {\n      timeoutMs\n    })) as LiveSessionId;\n    state.attached.set(targetId, live);\n    return live;\n  }\n\n  /** Track tab changes the model makes through raw Target commands. */\n  #observe(\n    state: ExecutionState,\n    method: string,\n    params: Record<string, unknown> | undefined,\n    result: unknown\n  ): void {\n    const targetId =\n      typeof params?.targetId === \"string\"\n        ? (params.targetId as TargetId)\n        : undefined;\n    if (method === \"Target.createTarget\") {\n      const created = (result as { targetId?: unknown } | undefined)?.targetId;\n      if (typeof created === \"string\") {\n        this.#setActive(state, created as TargetId);\n      }\n    } else if (method === \"Target.attachToTarget\" && targetId) {\n      this.#setActive(state, targetId);\n    } else if (method === \"Target.closeTarget\" && targetId) {\n      state.attached.delete(targetId);\n      // The next \"active\" use picks a tab afresh.\n      if (state.activeTargetId === targetId) state.activeTargetId = undefined;\n    } else if (method === \"Target.detachFromTarget\") {\n      // Forget a session the model detached, so the next use reattaches.\n      for (const [target, live] of state.attached) {\n        if (target === targetId || live === params?.sessionId) {\n          state.attached.delete(target);\n        }\n      }\n    }\n  }\n\n  /**\n   * Swap a handle in `Target.detachFromTarget`'s `sessionId` param for the\n   * live CDP session id. Returns {@link DETACHED} when the handle's tab isn't\n   * attached on this socket, so there is nothing to detach.\n   */\n  #liveParams(\n    state: ExecutionState,\n    method: string,\n    params: Record<string, unknown> | undefined\n  ): Record<string, unknown> | undefined | typeof DETACHED {\n    const handle = params?.sessionId;\n    if (method !== \"Target.detachFromTarget\" || typeof handle !== \"string\") {\n      return params;\n    }\n    if (!isAttachHandle(handle)) return params;\n    const live = state.attached.get(targetOfHandle(handle));\n    return live ? { ...params, sessionId: live } : DETACHED;\n  }\n\n  /**\n   * Turn the common protocol mistakes into instructions: sending an\n   * event as a command, and a page-scoped command without a session.\n   */\n  async #teach(\n    state: ExecutionState,\n    error: unknown,\n    method: string,\n    sessionId: string | undefined\n  ): Promise<unknown> {\n    if (!(error instanceof CdpProtocolError)) return error;\n    if (\n      error.code === CDP_SESSION_NOT_FOUND &&\n      sessionId &&\n      sessionId !== ACTIVE_PAGE_SESSION &&\n      !isAttachHandle(sessionId)\n    ) {\n      return new Error(\n        `${error.message}. CDP session ids don't carry over between runs. ` +\n          `Use sessionId: \"active\" for the current tab, or the handle from ` +\n          `cdp.attachToTarget({ targetId }) for another tab.`\n      );\n    }\n    if (error.code !== CDP_METHOD_NOT_FOUND) return error;\n    if (await this.#isEvent(state, method)) {\n      return new Error(\n        `${error.message}. '${method}' is a CDP *event*, not a command — it ` +\n          `cannot be sent. To wait for page state, poll instead (e.g. ` +\n          `Runtime.evaluate of document.readyState until \"complete\").`\n      );\n    }\n    if (!sessionId) {\n      return new Error(\n        `${error.message}. '${method}' is page-scoped: pass sessionId: ` +\n          `\"active\" to run it in the current tab — ` +\n          `cdp.send({ method: \"${method}\", params, sessionId: \"active\" }).`\n      );\n    }\n    return error;\n  }\n\n  async #isEvent(state: ExecutionState, method: string): Promise<boolean> {\n    try {\n      const spec = await state.connected.spec();\n      const domain = method.split(\".\")[0];\n      return spec.domains.some(\n        (d) => d.name === domain && d.events.some((e) => e.event === method)\n      );\n    } catch {\n      return false;\n    }\n  }\n}\n\nfunction attachHandle(targetId: TargetId): AttachHandle {\n  return `${ATTACH_HANDLE_PREFIX}${targetId}`;\n}\n\nfunction isAttachHandle(\n  sessionId: string | undefined\n): sessionId is AttachHandle {\n  return sessionId?.startsWith(ATTACH_HANDLE_PREFIX) ?? false;\n}\n\nfunction targetOfHandle(handle: AttachHandle): TargetId {\n  return handle.slice(ATTACH_HANDLE_PREFIX.length) as TargetId;\n}\n","/**\n * The harness-neutral core of `browserTool`, shared by the AI SDK\n * (`agents/browser/ai-sdk`) and TanStack AI (`agents/browser/tanstack-ai`)\n * adapters. Internal — not an entry point.\n */\nimport {\n  createCodemodeRuntime,\n  DynamicWorkerExecutor,\n  type ProxyToolOutput\n} from \"@cloudflare/codemode\";\nimport {\n  BrowserSessionConnector,\n  type BrowserExecutionReport,\n  type BrowserNewTab,\n  type BrowserSource\n} from \"./session-connector\";\nimport { resolveCtx, transformBrowserResult } from \"./tool-helpers\";\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   * WorkerLoader binding for sandboxed code execution.\n   *\n   * Requires `\"worker_loaders\": [{ \"binding\": \"LOADER\" }]` in wrangler.jsonc.\n   */\n  loader: WorkerLoader;\n\n  /** Sandbox execution timeout in milliseconds. Defaults to 30000 (30s). */\n  timeoutMs?: number;\n\n  /**\n   * Durable Object state for the codemode runtime facet. Optional inside an\n   * Agent (resolved via `getCurrentAgent()`); pass it explicitly elsewhere.\n   *\n   * The worker must export the `CodemodeRuntime` class (the\n   * `@cloudflare/codemode/vite` plugin does this automatically, or add\n   * `export { CodemodeRuntime } from \"@cloudflare/codemode\"` to your entry).\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/**\n * The result of one `browserTool` run: the codemode execution result,\n * plus what happened to the browser.\n */\nexport type BrowserToolOutput = ProxyToolOutput & {\n  /** The browser was replaced before this run; earlier tabs are gone. */\n  restarted?: true;\n  /** A sentence telling the model what `restarted` means for it. */\n  notice?: string;\n  /** Tabs the page opened itself (popups, `target=_blank` links). */\n  newTabs?: BrowserNewTab[];\n};\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\n/**\n * A codemode runtime name per browser. Browser names are host-chosen and\n * unrestricted; runtime names allow only `[a-zA-Z0-9_.-]`, so anything else\n * (including `.`, the escape) is hex-escaped.\n */\nfunction browserRuntimeName(name: string): string {\n  const escaped = name.replace(\n    /[^a-zA-Z0-9_-]/g,\n    (char) => `.${char.codePointAt(0)?.toString(16)}.`\n  );\n  return `browser-tool_${escaped}`;\n}\n\n/** Add what happened to the browser to the codemode result. */\nfunction withBrowserReport(\n  output: ProxyToolOutput,\n  report: BrowserExecutionReport | undefined\n): BrowserToolOutput {\n  if (!report) return output;\n  return {\n    ...output,\n    ...(report.restarted\n      ? { restarted: true as const, notice: RESTARTED_NOTICE }\n      : {}),\n    ...(report.newTabs.length > 0 ? { newTabs: report.newTabs } : {})\n  };\n}\n\n/** Report sentences that must survive a screenshot's text summary. */\nexport function browserReportNotes(output: BrowserToolOutput): string[] {\n  const notes: string[] = [];\n  if (output.notice) notes.push(output.notice);\n  if (output.newTabs?.length) {\n    notes.push(\n      `New tabs opened by the page: ${JSON.stringify(output.newTabs)}`\n    );\n  }\n  return notes;\n}\n\n/**\n * Build the codemode runtime and connector for one `browserTool`, and wrap\n * `execute` so each result carries the browser report.\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 ctx = resolveCtx(options);\n  if (!ctx) {\n    throw new Error(\n      \"browserTool requires a Durable Object 'ctx' — pass it explicitly, or call from within an Agent so it can be resolved via getCurrentAgent()\"\n    );\n  }\n\n  const connector = new BrowserSessionConnector(ctx, {\n    browser: options.browser\n  });\n  const runtime = createCodemodeRuntime({\n    ctx,\n    executor: new DynamicWorkerExecutor({\n      loader: options.loader,\n      timeout: options.timeoutMs\n    }),\n    connectors: [connector],\n    name: browserRuntimeName(options.browser.name),\n    transformResult: transformBrowserResult\n  });\n\n  const codemodeTool = runtime.tool({\n    connectorHints: {\n      cdp: `A persistent browser over CDP — tabs and logins carry over between runs. Use sessionId: \"active\" for page commands. ${adapter.screenshotHint}`\n    }\n  });\n\n  return {\n    description: codemodeTool.description,\n    inputSchema: codemodeTool.inputSchema,\n    execute: async (\n      input: BrowserToolInput,\n      executeOptions?: unknown\n    ): Promise<BrowserToolOutput> => {\n      const output = await codemodeTool.execute(input, executeOptions);\n      return withBrowserReport(\n        output,\n        connector.takeReport(output.executionId)\n      );\n    }\n  };\n}\n"],"mappings":"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"}

package/dist/browser-tool-DuNdlwZ9.d.ts

@@ -0,0 +1,73 @@
+import { n as BrowserConnection } from "./browser-DE3d-RLk.js";
+import {
+  CodemodeConnector,
+  ConnectorTool,
+  ConnectorTools,
+  ProxyToolOutput
+} from "@cloudflare/codemode";
+
+//#region src/browser/session-connector.d.ts
+/**
+ * Where a {@link BrowserSessionConnector} gets its browser. Usually a
+ * `Browser` installed on the host's Lifecycle.
+ */
+interface BrowserSource {
+  /** The browser's name, for log messages. */
+  readonly name: string;
+  /** Reattach to the browser (or replace it) and open a CDP connection. */
+  connect(): Promise<BrowserConnection>;
+}
+/** A tab a page opened on its own during an execution. */
+interface BrowserNewTab {
+  targetId: string;
+  url?: string;
+  title?: string;
+}
+//#endregion
+//#region src/browser/browser-tool.d.ts
+interface BrowserToolOptions {
+  /**
+   * The browser the tool drives — usually a `Browser` installed on the
+   * host's Lifecycle. Tools built from the same `Browser` share it.
+   */
+  browser: BrowserSource;
+  /**
+   * WorkerLoader binding for sandboxed code execution.
+   *
+   * Requires `"worker_loaders": [{ "binding": "LOADER" }]` in wrangler.jsonc.
+   */
+  loader: WorkerLoader;
+  /** Sandbox execution timeout in milliseconds. Defaults to 30000 (30s). */
+  timeoutMs?: number;
+  /**
+   * Durable Object state for the codemode runtime facet. Optional inside an
+   * Agent (resolved via `getCurrentAgent()`); pass it explicitly elsewhere.
+   *
+   * The worker must export the `CodemodeRuntime` class (the
+   * `@cloudflare/codemode/vite` plugin does this automatically, or add
+   * `export { CodemodeRuntime } from "@cloudflare/codemode"` to your entry).
+   */
+  ctx?: DurableObjectState;
+}
+/** The model's input to `browserTool`: JavaScript to run. */
+interface BrowserToolInput {
+  code: string;
+}
+/**
+ * The result of one `browserTool` run: the codemode execution result,
+ * plus what happened to the browser.
+ */
+type BrowserToolOutput = ProxyToolOutput & {
+  /** The browser was replaced before this run; earlier tabs are gone. */ restarted?: true /** A sentence telling the model what `restarted` means for it. */;
+  notice?: string /** Tabs the page opened itself (popups, `target=_blank` links). */;
+  newTabs?: BrowserNewTab[];
+};
+//#endregion
+export {
+  BrowserSource as a,
+  BrowserNewTab as i,
+  BrowserToolOptions as n,
+  BrowserToolOutput as r,
+  BrowserToolInput as t
+};
+//# sourceMappingURL=browser-tool-DuNdlwZ9.d.ts.map