agents 0.30.1 → 0.32.0

package/dist/browser-tool-B1mhifin.js

@@ -1,616 +0,0 @@
-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 { b as CdpProtocolError, s as validateConnectorArgs } from "./session-store-yvwq1f9x.js";
-import { i as transformBrowserResult, r as resolveCtx } from "./tool-helpers-O5BDVEAY.js";
-import "./browser-DccPw_wW.js";
-import { CodemodeConnector, DynamicWorkerExecutor, MAX_DURABLE_VALUE_BYTES, 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;
-/**
-* Codemode records every `send` result for replay and fails the run when one
-* is over {@link MAX_DURABLE_VALUE_BYTES}, telling the model to write to a
-* file, which this sandbox can't. A full-page screenshot is the usual
-* culprit, so say how to take a smaller one instead.
-*/
-function assertScreenshotFits(result) {
-	const size = JSON.stringify(result ?? null).length;
-	if (size <= MAX_DURABLE_VALUE_BYTES) return;
-	const megabytes = (size / 1e6).toFixed(1);
-	throw new Error(`The screenshot result is ${megabytes} MB, over the 1 MB limit on a cdp.send result. Capture just the viewport (no captureBeyondViewport or clip larger than the window), or pass format: "jpeg" with quality: 60.`);
-}
-/** {@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"
-]);
-/**
-* How to use the `cdp` connector, one rule per line. `codemode.describe("cdp")`
-* returns these, and `browserTool` puts them in its description. 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.
-*/
-const BROWSER_INSTRUCTIONS = [
-	"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), the result says restarted: true 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 cdp.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; the result lists them as newTabs.",
-	"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. Results over about 24,000 characters are cut short, and a single cdp.send result over 1 MB (a full-page screenshot, say) fails the run."
-].join("\n");
-var _browser = /* @__PURE__ */ new WeakMap();
-var _scope = /* @__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 per scope (see {@link BrowserSessionConnectorOptions.scope}), so
-* it survives between executions for as long as the tab does, and one
-* scope's executions never land in another scope's tab unless the model
-* attaches to it.
-*
-* 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, _scope, 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);
-		_classPrivateFieldSet2(_scope, this, options.scope);
-	}
-	name() {
-		return "cdp";
-	}
-	instructions() {
-		return BROWSER_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);
-					if (method === "Page.captureScreenshot") assertScreenshotFits(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 scope's active
-	* tab, note whether another scope shares it, 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);
-			const active = await _assertClassBrand(_BrowserSessionConnector_brand, this, _saveActiveTarget).call(this, state, open);
-			if (active && state.activeResolved) await _assertClassBrand(_BrowserSessionConnector_brand, this, _recordSharedTab).call(this, state, active);
-		} 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(_classPrivateFieldGet2(_scope, this) === void 0 ? void 0 : { scope: _classPrivateFieldGet2(_scope, this) });
-	let initialPages;
-	try {
-		initialPages = await _assertClassBrand(_BrowserSessionConnector_brand, this, _pages).call(this, connected.cdp);
-	} catch (error) {
-		connected.cdp.disconnect();
-		throw error;
-	}
-	const state = {
-		executionId,
-		connected,
-		attached: /* @__PURE__ */ new Map(),
-		workedIn: /* @__PURE__ */ new Set(),
-		initialPages: new Set(initialPages.map((page) => page.targetId)),
-		activeResolved: false,
-		closed: /* @__PURE__ */ new Set()
-	};
-	_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: [],
-			tabClosed: false,
-			tabShared: false
-		};
-		_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));
-	let grew = true;
-	while (grew) {
-		grew = false;
-		for (const page of pages) {
-			const opener = page.openerId;
-			if (!opener || opened.has(page.targetId) || state.initialPages.has(page.targetId)) continue;
-			if (state.workedIn.has(opener) || opened.has(opener)) {
-				opened.add(page.targetId);
-				grew = true;
-			}
-		}
-	}
-	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,
-* and return it. 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;
-	if (!state.activeResolved && stored && open && !open.has(stored) && !state.closed.has(stored)) _assertClassBrand(_BrowserSessionConnector_brand, this, _report).call(this, state.executionId, state.connected.restarted).tabClosed = true;
-	const candidate = state.activeResolved ? state.activeTargetId : stored;
-	const active = candidate && (!open || open.has(candidate)) ? candidate : void 0;
-	if (active === stored) return active;
-	try {
-		await state.connected.setActiveTarget(active);
-	} catch (error) {
-		_assertClassBrand(_BrowserSessionConnector_brand, this, _warn).call(this, "save the active tab", error);
-	}
-	return active;
-}
-/** Report when another scope is working in this pass's tab too. */
-async function _recordSharedTab(state, active) {
-	try {
-		if ((await state.connected.targetsInOtherScopes()).has(active)) _assertClassBrand(_BrowserSessionConnector_brand, this, _report).call(this, state.executionId, state.connected.restarted).tabShared = true;
-	} catch (error) {
-		_assertClassBrand(_BrowserSessionConnector_brand, this, _warn).call(this, "check whether the active tab is shared", 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 scope's stored tab
-* if it is still open, else a new blank tab. Never a tab the scope didn't
-* open, even a blank one: it may be another scope's, or a popup.
-*/
-async function _activeTarget(state) {
-	if (state.activeTargetId) return state.activeTargetId;
-	const { connected } = state;
-	const pages = await _assertClassBrand(_BrowserSessionConnector_brand, this, _pages).call(this, connected.cdp);
-	const stored = connected.activeTargetId;
-	let targetId = pages.find((page) => page.targetId === stored)?.targetId;
-	if (!targetId && stored && !state.closed.has(stored)) _assertClassBrand(_BrowserSessionConnector_brand, this, _report).call(this, state.executionId, connected.restarted).tabClosed = true;
-	if (!targetId) targetId = (await connected.cdp.send("Target.createTarget", { url: "about:blank" })).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);
-	state.workedIn.add(targetId);
-	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);
-		state.workedIn.add(targetId);
-	} else if (method === "Target.closeTarget" && targetId) {
-		state.attached.delete(targetId);
-		state.closed.add(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 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.";
-/** Scopes whose runtime and connector stay built; older ones are rebuilt. */
-const MAX_CACHED_SCOPES = 32;
-/**
-* 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)}.`)}`;
-}
-/**
-* 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;
-}
-/** Add what happened to the browser to the codemode result. */
-function withBrowserReport(output, report) {
-	if (!report) return output;
-	const notices = [
-		report.restarted && RESTARTED_NOTICE,
-		report.tabClosed && !report.restarted && TAB_CLOSED_NOTICE,
-		report.tabShared && TAB_SHARED_NOTICE
-	].filter((notice) => typeof notice === "string");
-	return {
-		...output,
-		...report.restarted ? { restarted: true } : {},
-		...notices.length > 0 ? { notice: notices.join(" ") } : {},
-		...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.
-*
-* Each scope gets its own connector (which knows its scope) on the same
-* codemode runtime, built on first use. 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 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 timeout = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const executor = new DynamicWorkerExecutor({
-		loader: options.loader,
-		timeout
-	});
-	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 `cdp` global to reach the browser. `fetch` is blocked and there is no file system or Node.js API.",
-		"",
-		"## cdp",
-		"",
-		"- `cdp.send({ method, params?, sessionId?, timeoutMs? })` sends a CDP command and returns its result without the JSON-RPC envelope: `Page.navigate` returns `{ frameId, errorText? }`, `Runtime.evaluate` returns `{ result: { value }, exceptionDetails? }`.",
-		"- `cdp.attachToTarget({ targetId })` makes an open tab active and returns `{ sessionId }`.",
-		"- `cdp.spec()` returns the whole protocol (about 650 KB) as `{ domains: [{ name, commands, events, types }] }`. Filter it in code, for example `spec.domains.find((d) => d.name === \"Page\").commands.find((c) => c.name === \"navigate\")`.",
-		"- `cdp.getDebugLog()` returns recent protocol traffic, for when a command fails or times out.",
-		"",
-		"## Rules",
-		"",
-		[
-			BROWSER_INSTRUCTIONS,
-			`Each run times out after ${Math.round(timeout / 1e3)}s, so split long jobs (crawling a site, say) across runs.`,
-			adapter.screenshotHint
-		].join("\n").split("\n").map((rule) => `- ${rule}`).join("\n"),
-		"- A `SyntaxError` from \"Failed to start Worker\" means your code didn't parse; its line number points into wrapper code, not yours. Check regex literals and escapes."
-	].join("\n");
-	const durableCtx = ctx;
-	const scopes = /* @__PURE__ */ new Map();
-	function scoped(scope) {
-		const cached = scopes.get(scope);
-		if (cached) {
-			scopes.delete(scope);
-			scopes.set(scope, cached);
-			return cached;
-		}
-		const connector = new BrowserSessionConnector(durableCtx, {
-			browser: options.browser,
-			scope
-		});
-		const built = {
-			connector,
-			tool: createCodemodeRuntime({
-				ctx: durableCtx,
-				executor,
-				connectors: [connector],
-				name: browserRuntimeName(options.browser.name),
-				transformResult: transformBrowserResult
-			}).tool({ description })
-		};
-		scopes.set(scope, built);
-		if (scopes.size > MAX_CACHED_SCOPES) {
-			const oldest = scopes.keys().next().value;
-			if (oldest !== void 0) scopes.delete(oldest);
-		}
-		return built;
-	}
-	const defaultScope = options.scope ?? "shared";
-	const { inputSchema } = scoped(defaultScope).tool;
-	return {
-		description,
-		inputSchema,
-		/** Run `input` in `scope`, which defaults to the tool's `scope`. */
-		execute: (input, scope = defaultScope) => queued(options.browser, scope, async () => {
-			const { connector, tool } = scoped(scope);
-			const output = await tool.execute(input, void 0);
-			return withBrowserReport(output, connector.takeReport(output.executionId));
-		})
-	};
-}
-//#endregion
-export { createBrowserToolCore as n, browserReportNotes as t };
-
-//# sourceMappingURL=browser-tool-B1mhifin.js.map