agents 0.30.1 → 0.31.0

package/dist/protocol-BEgrJYC5.d.ts

@@ -109,35 +109,35 @@ type ContainerMessage = {
 };
 /** What an adapter reports while it runs. */
 type ContainerEvent =
-  /** Live text for an assistant message that is still being written. */ | {
-        readonly type: "text-delta";
-        readonly messageId: string;
-        readonly delta: string;
-      } /** Live reasoning for an assistant message that is still being written. */
-    | {
-        readonly type: "reasoning-delta";
-        readonly messageId: string;
-        readonly delta: string;
-      } /** A finished or updated transcript message. Stored. */
-    | {
-        readonly type: "message";
-        readonly message: ContainerMessage;
-      } /** Token and cost figures the adapter reports, as the adapter counts them. */
-    | {
-        readonly type: "usage";
-        readonly inputTokens?: number;
-        readonly outputTokens?: number;
-        readonly costUsd?: number;
-      } /** A diagnostic line. */
-    | {
-        readonly type: "log";
-        readonly level: "info" | "warn" | "error";
-        readonly message: string;
-      } /** Anything adapter-specific, passed through untouched. */
-    | {
-        readonly type: "raw";
-        readonly value: JsonValue;
-      };
+  | /** Live text for an assistant message that is still being written. */ {
+      readonly type: "text-delta";
+      readonly messageId: string;
+      readonly delta: string;
+    } /** Live reasoning for an assistant message that is still being written. */
+  | {
+      readonly type: "reasoning-delta";
+      readonly messageId: string;
+      readonly delta: string;
+    } /** A finished or updated transcript message. Stored. */
+  | {
+      readonly type: "message";
+      readonly message: ContainerMessage;
+    } /** Token and cost figures the adapter reports, as the adapter counts them. */
+  | {
+      readonly type: "usage";
+      readonly inputTokens?: number;
+      readonly outputTokens?: number;
+      readonly costUsd?: number;
+    } /** A diagnostic line. */
+  | {
+      readonly type: "log";
+      readonly level: "info" | "warn" | "error";
+      readonly message: string;
+    } /** Anything adapter-specific, passed through untouched. */
+  | {
+      readonly type: "raw";
+      readonly value: JsonValue;
+    };
 /** How an operation ended, as the daemon reports it. */
 type ContainerOutcome =
   | {

package/dist/react.d.ts

@@ -2,7 +2,7 @@ import {
   C as MCPServersState,
   J as AgentToolRunPart,
   Y as AgentToolRunState
-} from "./agent-routing-CDbpVjYq.js";
+} from "./agent-routing-wS1TimZ_.js";
 import { ClientParameters } from "./serializable.js";
 import { t as AgentTransport } from "./transport-protocol-ZTew5Wso.js";
 import {
@@ -15,7 +15,7 @@ import {
   p as RequiredAgentMethods,
   s as AgentStub,
   v as createStubProxy
-} from "./client-C27CtRZr.js";
+} from "./client-wn4-yqGz.js";
 import { PartySocket } from "partysocket";
 import { usePartySocket } from "partysocket/react";
 

package/dist/routing/index.d.ts

@@ -10,7 +10,7 @@ import {
   n as AgentOptions,
   r as RoutingRetryOptions,
   t as AgentGetOptions
-} from "../agent-routing-CDbpVjYq.js";
+} from "../agent-routing-wS1TimZ_.js";
 
 //#region src/routing/routed-agents.d.ts
 /** A public entry in an {@link RoutedAgents}. */

package/dist/serializable.d.ts

@@ -1,4 +1,4 @@
-import { k as StreamingResponse } from "./agent-routing-CDbpVjYq.js";
+import { k as StreamingResponse } from "./agent-routing-wS1TimZ_.js";
 
 //#region src/serializable.d.ts
 type SerializablePrimitive = undefined | null | string | number | boolean;

package/dist/{session-store-yvwq1f9x.js → session-7CDgVE0z.js}

@@ -303,19 +303,29 @@ function isUnimplementedBindingMethod(error, method) {
 * `acquire()`, as in fully local dev.
 */
 async function acquireBrowserSession(browser, options = {}) {
+	const { outboundByHost, ...httpOptions } = options;
 	if (browser.acquire) try {
 		const { sessionId } = await browser.acquire({
 			keepAlive: options.keepAliveMs,
 			recording: options.recording,
-			guardrails: options.guardrails
+			guardrails: options.guardrails,
+			...outboundByHost ? { outboundByHost } : {}
 		});
 		return { sessionId };
 	} catch (error) {
 		if (!isUnimplementedBindingMethod(error, "acquire")) throw error;
 	}
-	const { sessionId } = await createBrowserSession(browser, options);
+	if (outboundByHost) warnInternalHostsUnavailable(Object.keys(outboundByHost));
+	const { sessionId } = await createBrowserSession(browser, httpOptions);
 	return { sessionId };
 }
+let warnedInternalHostsUnavailable = false;
+/** Say once per isolate that internal hostnames need a deployed Worker. */
+function warnInternalHostsUnavailable(hosts) {
+	if (warnedInternalHostsUnavailable) return;
+	warnedInternalHostsUnavailable = true;
+	console.warn(`[agents/browser] Internal hostnames (${hosts.join(", ")}) only work once deployed: this Browser Run binding has no acquire(), as in local dev, so the browser starts without them.`);
+}
 /**
 * The HTTP status in a typed binding method's error. Browser Run's binding
 * errors carry it only in the message, e.g. `Not Found (status=404)`.
@@ -409,35 +419,6 @@ async function connectBrowserSession(browser, sessionId, options) {
 	});
 }
 //#endregion
-//#region src/browser/connector-validation.ts
-function formatToolValidationError(connector, tool, errors) {
-	const specific = errors.filter((error) => error.keyword !== "properties");
-	return `Invalid arguments for ${connector}.${tool}${(specific.length > 0 ? specific : errors).map((error) => {
-		const location = error.instanceLocation.replace(/^#\/?/, "").replaceAll("~1", "/").replaceAll("~0", "~").replaceAll("/", ".");
-		return `${location ? ` at ${location}` : ""}: ${error.error}`;
-	}).join(";")}`;
-}
-/**
-* Validate a connector tool's arguments against its input schema before it
-* runs, so the model gets a precise error instead of a failure deep inside
-* browser work. An omitted argument counts as `{}`: argumentless tools are
-* documented as `cdp.spec()`.
-*/
-function validateConnectorArgs(connector, name, tool) {
-	if (!tool.inputSchema) return tool;
-	const schema = tool.inputSchema;
-	const validator = new Validator(schema, "7", false);
-	return {
-		...tool,
-		execute: async (args, ctx) => {
-			const input = args === void 0 ? {} : args;
-			const result = validator.validate(input);
-			if (!result.valid) throw new Error(formatToolValidationError(connector, name, result.errors));
-			return await tool.execute(input, ctx);
-		}
-	};
-}
-//#endregion
 //#region src/browser/live-view.ts
 /**
 * Browser Run mints `devtoolsFrontendUrl`s (the Live View links) that are
@@ -654,6 +635,447 @@ var _queues = { _: /* @__PURE__ */ new WeakMap() };
 */
 const DEFAULT_SWEEP_IDLE_MS = 600 * 1e3;
 //#endregion
-export { connectUrl as S, listBrowserTargets as _, applyLiveViewMode as a, CdpProtocolError as b, BrowserRenderingError as c, connectBrowser as d, connectBrowserSession as f, isMissingBrowserSession as g, getBrowserRecording as h, LIVE_VIEW_URL_TTL_MS as i, acquireBrowserSession as l, deleteBrowserSession as m, DurableBrowserSessionStore as n, createLiveView as o, createBrowserSession as p, loadCdpSpec as r, validateConnectorArgs as s, DEFAULT_SWEEP_IDLE_MS as t, closeBrowserSession as u, CDP_METHOD_NOT_FOUND as v, CdpSession as x, CdpConnection as y };
+//#region src/browser/session.ts
+/**
+* `BrowserSession`: one run's connection to a persistent `Browser`, with the
+* rules that make CDP usable from model-written code.
+*
+* The model never manages CDP sessions. `sessionId: "active"` addresses the
+* tab the scope last worked in, `attachToTarget` returns a handle that keeps
+* working in later runs, and common protocol mistakes come back as
+* instructions. When the session closes it saves the scope's active tab and
+* reports what happened to the browser: a restart, a tab closed by someone
+* else, a tab shared with another scope, tabs the page opened.
+*
+* `browserTool` opens one per run.
+*/
+/** `sessionId` value that addresses the tab the agent is working in. */
+const ACTIVE_PAGE_SESSION = "active";
+/**
+* `attachToTarget` returns `{ sessionId: "target:<targetId>" }`, a stable
+* handle rather than a connection-scoped CDP session id, so it keeps working
+* in later runs. `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;
+/**
+* Screenshots are kept whole in the chat message for the UI, and a stored
+* message must fit SQLite's 2 MB row (see `ROW_MAX_BYTES` in chat/sanitize.ts),
+* or the image is compacted away. Failing early lets the model retake it
+* smaller. Other results are cut to a preview before they're stored.
+*
+* @internal The tools also refuse to keep a returned screenshot over it.
+*/
+const DEFAULT_MAX_RESULT_BYTES = 1e6;
+/** `#liveParams`: nothing to detach. */
+const DETACHED = Symbol("detached");
+const MANAGED_BROWSER = "this browser is managed for you and persists between runs. To close a tab, send Target.closeTarget with its targetId.";
+const HOST_ONLY = "it is for the host, not your code.";
+const NO_TUNNELING = "send each command with browser.cdp instead, passing sessionId to reach a tab.";
+/**
+* Commands model code can't send, and why.
+*
+* - Ending the browser: the host owns its lifetime, so the model can't close
+*   it out from under the agent (and lose its logins).
+* - Live View and handoff: a Live View link controls the whole browser, so it
+*   goes to a trusted person through `Browser.liveView()`, never to the model.
+* - Tunnels: these carry raw protocol messages past this check.
+*/
+const REFUSED_COMMANDS = /* @__PURE__ */ new Map([
+	["Browser.close", MANAGED_BROWSER],
+	["Browser.crash", MANAGED_BROWSER],
+	["Browser.crashGpuProcess", MANAGED_BROWSER],
+	["Cloudflare.getLiveView", HOST_ONLY],
+	["Cloudflare.handoff", HOST_ONLY],
+	["Target.sendMessageToTarget", NO_TUNNELING],
+	["Target.exposeDevToolsProtocol", NO_TUNNELING]
+]);
+const SEND_SCHEMA = {
+	type: "object",
+	properties: {
+		method: {
+			type: "string",
+			minLength: 1
+		},
+		params: { type: "object" },
+		sessionId: { type: "string" },
+		timeoutMs: {
+			type: "number",
+			exclusiveMinimum: 0
+		}
+	},
+	required: ["method"]
+};
+const ATTACH_SCHEMA = {
+	type: "object",
+	properties: {
+		targetId: {
+			type: "string",
+			minLength: 1
+		},
+		timeoutMs: {
+			type: "number",
+			exclusiveMinimum: 0
+		}
+	},
+	required: ["targetId"]
+};
+const DEBUG_LOG_SCHEMA = {
+	type: "object",
+	properties: { limit: {
+		type: "number",
+		minimum: 1
+	} }
+};
+var _browser = /* @__PURE__ */ new WeakMap();
+var _scope = /* @__PURE__ */ new WeakMap();
+var _maxResultBytes = /* @__PURE__ */ new WeakMap();
+var _state = /* @__PURE__ */ new WeakMap();
+var _connecting = /* @__PURE__ */ new WeakMap();
+var _closed = /* @__PURE__ */ new WeakMap();
+var _BrowserSession_brand = /* @__PURE__ */ new WeakSet();
+/**
+* One run's connection to a persistent browser, for one scope.
+*
+* It connects on its first call and stays connected until {@link close}.
+* Concurrent first calls share one connect. Every method takes one options
+* object, validated before anything touches the browser, because the input
+* usually comes from model-written code.
+*
+* Create one per run with `browser.session({ scope })`, and close it when
+* the run ends. The browser itself stays open.
+*
+* @experimental The API surface may change before stabilizing.
+*/
+var BrowserSession = class {
+	constructor(browser, options = {}) {
+		_classPrivateMethodInitSpec(this, _BrowserSession_brand);
+		_classPrivateFieldInitSpec(this, _browser, void 0);
+		_classPrivateFieldInitSpec(this, _scope, void 0);
+		_classPrivateFieldInitSpec(this, _maxResultBytes, void 0);
+		_classPrivateFieldInitSpec(this, _state, void 0);
+		_classPrivateFieldInitSpec(this, _connecting, void 0);
+		_classPrivateFieldInitSpec(this, _closed, false);
+		_classPrivateFieldSet2(_browser, this, browser);
+		_classPrivateFieldSet2(_scope, this, options.scope);
+		_classPrivateFieldSet2(_maxResultBytes, this, options.maxResultBytes ?? 1e6);
+	}
+	/**
+	* Send a CDP command and resolve with its result, without the JSON-RPC
+	* envelope. `sessionId: "active"` runs it in the scope's tab.
+	*/
+	async send(input) {
+		const { method, params, sessionId, timeoutMs } = validate("browser.cdp", SEND_SCHEMA, input);
+		const refused = REFUSED_COMMANDS.get(method);
+		if (refused) throw new Error(`${method} is not available: ${refused}`);
+		const state = await _assertClassBrand(_BrowserSession_brand, this, _connect).call(this);
+		const live = await _assertClassBrand(_BrowserSession_brand, this, _resolveSessionId).call(this, state, sessionId);
+		const liveParams = _assertClassBrand(_BrowserSession_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(_BrowserSession_brand, this, _teach).call(this, state, error, method, sessionId);
+		}
+		_assertClassBrand(_BrowserSession_brand, this, _observe).call(this, state, method, liveParams, result);
+		if (method === "Page.captureScreenshot") _assertClassBrand(_BrowserSession_brand, this, _assertFits).call(this, result);
+		return result;
+	}
+	/**
+	* Make an open tab the scope's active tab, and resolve with a `sessionId`
+	* handle for it that keeps working in later runs.
+	*/
+	async attachToTarget(input) {
+		const { targetId, timeoutMs } = validate("browser.attachToTarget", ATTACH_SCHEMA, input);
+		const state = await _assertClassBrand(_BrowserSession_brand, this, _connect).call(this);
+		const target = targetId;
+		await _assertClassBrand(_BrowserSession_brand, this, _attach).call(this, state, target, timeoutMs);
+		_assertClassBrand(_BrowserSession_brand, this, _setActive).call(this, state, target);
+		return { sessionId: attachHandle(target) };
+	}
+	/** The Chrome DevTools Protocol description the browser serves. */
+	async spec() {
+		return (await _assertClassBrand(_BrowserSession_brand, this, _connect).call(this)).connected.spec();
+	}
+	/** Recent CDP traffic on this session's connection, newest last. */
+	async getDebugLog(input) {
+		const { limit } = validate("browser.getDebugLog", DEBUG_LOG_SCHEMA, input);
+		return (await _assertClassBrand(_BrowserSession_brand, this, _connect).call(this)).connected.cdp.getDebugLog(limit);
+	}
+	/** Forget the CDP traffic recorded so far. */
+	async clearDebugLog() {
+		(await _assertClassBrand(_BrowserSession_brand, this, _connect).call(this)).connected.cdp.clearDebugLog();
+		return null;
+	}
+	/**
+	* End the session: save the scope's active tab, work out what happened to
+	* the browser, and close the connection. The browser stays open.
+	*
+	* Resolves with the report, or `undefined` when the session never
+	* connected. Never rejects: failures to read the browser's state are
+	* logged and leave the report incomplete. Later calls resolve with
+	* `undefined`, and other methods reject.
+	*/
+	async close() {
+		if (_classPrivateFieldGet2(_closed, this)) return void 0;
+		_classPrivateFieldSet2(_closed, this, true);
+		let state;
+		try {
+			state = _classPrivateFieldGet2(_state, this) ?? await _classPrivateFieldGet2(_connecting, this);
+		} catch {
+			return;
+		}
+		if (!state) return void 0;
+		_classPrivateFieldSet2(_state, this, void 0);
+		try {
+			const open = await _assertClassBrand(_BrowserSession_brand, this, _recordNewTabs).call(this, state);
+			const active = await _assertClassBrand(_BrowserSession_brand, this, _saveActiveTarget).call(this, state, open);
+			if (active && state.activeResolved) await _assertClassBrand(_BrowserSession_brand, this, _recordSharedTab).call(this, state, active);
+		} finally {
+			state.connected.cdp.disconnect();
+		}
+		return state.report;
+	}
+};
+/** Connect once. Concurrent first calls share one connect. */
+function _connect() {
+	if (_classPrivateFieldGet2(_closed, this)) return Promise.reject(/* @__PURE__ */ new Error("This browser session is closed."));
+	if (_classPrivateFieldGet2(_state, this)) return Promise.resolve(_classPrivateFieldGet2(_state, this));
+	_classPrivateFieldGet2(_connecting, this) ?? _classPrivateFieldSet2(_connecting, this, _assertClassBrand(_BrowserSession_brand, this, _open).call(this).finally(() => {
+		_classPrivateFieldSet2(_connecting, this, void 0);
+	}));
+	return _classPrivateFieldGet2(_connecting, this);
+}
+async function _open() {
+	const connected = await _classPrivateFieldGet2(_browser, this).connect(_classPrivateFieldGet2(_scope, this) === void 0 ? void 0 : { scope: _classPrivateFieldGet2(_scope, this) });
+	let initialPages;
+	try {
+		initialPages = await _assertClassBrand(_BrowserSession_brand, this, _pages).call(this, connected.cdp);
+	} catch (error) {
+		connected.cdp.disconnect();
+		throw error;
+	}
+	const state = {
+		connected,
+		attached: /* @__PURE__ */ new Map(),
+		workedIn: /* @__PURE__ */ new Set(),
+		initialPages: new Set(initialPages.map((page) => page.targetId)),
+		activeResolved: false,
+		closed: /* @__PURE__ */ new Set(),
+		report: {
+			restarted: connected.restarted,
+			newTabs: [],
+			tabClosed: false,
+			tabShared: false
+		}
+	};
+	if (_classPrivateFieldGet2(_closed, this)) return state;
+	_classPrivateFieldSet2(_state, this, state);
+	return state;
+}
+/**
+* A screenshot over the limit is too big to keep in the chat message
+* (see `DEFAULT_MAX_RESULT_BYTES`), so fail with how to take a smaller one.
+*/
+function _assertFits(result) {
+	const size = JSON.stringify(result ?? null).length;
+	if (size <= _classPrivateFieldGet2(_maxResultBytes, this)) return;
+	const megabytes = (size / 1e6).toFixed(1);
+	const limit = (_classPrivateFieldGet2(_maxResultBytes, this) / 1e6).toFixed(0);
+	throw new Error(`The screenshot result is ${megabytes} MB, over the ${limit} MB limit on a send result. Capture just the viewport (no captureBeyondViewport or clip larger than the window), or pass format: "jpeg" with quality: 60.`);
+}
+/**
+* Add tabs the page opened during this session to the report. Returns the
+* open tabs, or `undefined` when the browser couldn't be asked.
+*/
+async function _recordNewTabs(state) {
+	let pages;
+	try {
+		pages = await _assertClassBrand(_BrowserSession_brand, this, _pages).call(this, state.connected.cdp);
+	} catch (error) {
+		_assertClassBrand(_BrowserSession_brand, this, _warn).call(this, "list the open tabs", error);
+		return;
+	}
+	const opened = /* @__PURE__ */ new Set();
+	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;
+			}
+		}
+	}
+	state.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 session settled on, forgetting one that has since
+* closed, and return it. Without the list of open tabs, save the choice
+* unchecked: the next session 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)) state.report.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(_BrowserSession_brand, this, _warn).call(this, "save the active tab", error);
+	}
+	return active;
+}
+/** Report when another scope is working in this session's tab too. */
+async function _recordSharedTab(state, active) {
+	try {
+		if ((await state.connected.targetsInOtherScopes()).has(active)) state.report.tabShared = true;
+	} catch (error) {
+		_assertClassBrand(_BrowserSession_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(_BrowserSession_brand, this, _attach).call(this, state, await _assertClassBrand(_BrowserSession_brand, this, _activeTarget).call(this, state));
+	if (isAttachHandle(sessionId)) return _assertClassBrand(_BrowserSession_brand, this, _attach).call(this, state, targetOfHandle(sessionId));
+	return sessionId;
+}
+/**
+* Decide which tab `"active"` means, once per session: 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(_BrowserSession_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)) state.report.tabClosed = true;
+	if (!targetId) targetId = (await connected.cdp.send("Target.createTarget", { url: "about:blank" })).targetId;
+	_assertClassBrand(_BrowserSession_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(_BrowserSession_brand, this, _setActive).call(this, state, created);
+	} else if (method === "Target.attachToTarget" && targetId) {
+		_assertClassBrand(_BrowserSession_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: an expired CDP
+* session id, an event sent 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 browser.attachToTarget({ targetId }) for another tab.`);
+	if (error.code !== -32601) return error;
+	if (await _assertClassBrand(_BrowserSession_brand, this, _isEvent).call(this, state, method)) return /* @__PURE__ */ new Error(`${error.message}. '${method}' is a CDP *event*, not a command, so 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: browser.cdp({ 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);
+}
+const validators = /* @__PURE__ */ new WeakMap();
+/**
+* Check a method's input against its schema before it touches the browser,
+* so the model gets a precise error. An omitted input counts as `{}`.
+*
+* @internal Also used by `browser-functions.ts`.
+*/
+function validate(name, schema, input) {
+	let validator = validators.get(schema);
+	if (!validator) {
+		validator = new Validator(schema, "7", false);
+		validators.set(schema, validator);
+	}
+	const value = input ?? {};
+	const result = validator.validate(value);
+	if (!result.valid) throw new Error(formatValidationError(name, result.errors));
+	return value;
+}
+function formatValidationError(name, errors) {
+	const specific = errors.filter((error) => error.keyword !== "properties");
+	return `Invalid arguments for ${name}${(specific.length > 0 ? specific : errors).map((error) => {
+		const location = error.instanceLocation.replace(/^#\/?/, "").replaceAll("~1", "/").replaceAll("~0", "~").replaceAll("/", ".");
+		return `${location ? ` at ${location}` : ""}: ${error.error}`;
+	}).join(";")}`;
+}
+//#endregion
+export { CdpProtocolError as C, CdpConnection as S, connectUrl as T, deleteBrowserSession as _, DEFAULT_SWEEP_IDLE_MS as a, listBrowserTargets as b, LIVE_VIEW_URL_TTL_MS as c, BrowserRenderingError as d, acquireBrowserSession as f, createBrowserSession as g, connectBrowserSession as h, validate as i, applyLiveViewMode as l, connectBrowser as m, BrowserSession as n, DurableBrowserSessionStore as o, closeBrowserSession as p, DEFAULT_MAX_RESULT_BYTES as r, loadCdpSpec as s, ACTIVE_PAGE_SESSION as t, createLiveView as u, getBrowserRecording as v, CdpSession as w, CDP_METHOD_NOT_FOUND as x, isMissingBrowserSession as y };
 
-//# sourceMappingURL=session-store-yvwq1f9x.js.map
+//# sourceMappingURL=session-7CDgVE0z.js.map