agents 0.10.2 → 0.11.0

package/dist/mcp/index.js

@@ -1,6 +1,6 @@
 import { MessageType } from "../types.js";
-import { o as getAgentByName, s as getCurrentAgent, t as Agent } from "../src-f7-4oW_C.js";
 import { a as RPCServerTransport, i as RPCClientTransport, o as RPC_DO_PREFIX } from "../client-QBjFV5de.js";
+import { Agent, getAgentByName, getCurrentAgent } from "../index.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

package/dist/observability/index.d.ts

@@ -1,2 +1,2 @@
-import { a as genericObservability, i as channels, n as Observability, o as subscribe, r as ObservabilityEvent, t as ChannelEventMap } from "../index-DDSX-g7W.js";
+import { a as genericObservability, i as channels, n as Observability, o as subscribe, r as ObservabilityEvent, t as ChannelEventMap } from "../index-Cubsi2Qv.js";
 export { ChannelEventMap, Observability, ObservabilityEvent, channels, genericObservability, subscribe };

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { _ as MCPServersState } from "./index-D2lfljd3.js";
+import { _ as MCPServersState } from "./index-CrOzHA2T.js";
 import {
   AgentPromiseReturnType,
   AgentStub,

package/dist/{retries-B_CN5KM9.d.ts → retries-JlwH9mnV.d.ts}

@@ -76,4 +76,4 @@ export {
   jitterBackoff as r,
   RetryOptions as t
 };
-//# sourceMappingURL=retries-B_CN5KM9.d.ts.map
+//# sourceMappingURL=retries-JlwH9mnV.d.ts.map

package/dist/retries.d.ts

@@ -4,7 +4,7 @@ import {
   n as isErrorRetryable,
   r as jitterBackoff,
   t as RetryOptions
-} from "./retries-B_CN5KM9.js";
+} from "./retries-JlwH9mnV.js";
 export {
   RetryOptions,
   isErrorRetryable,

package/dist/{serializable-DGdO8CDh.d.ts → serializable-Bg8ARWlN.d.ts}

@@ -128,4 +128,4 @@ export {
   SerializableReturnValue as r,
   Method as t
 };
-//# sourceMappingURL=serializable-DGdO8CDh.d.ts.map
+//# sourceMappingURL=serializable-Bg8ARWlN.d.ts.map

package/dist/serializable.d.ts

@@ -3,5 +3,5 @@ import {
   n as RPCMethod,
   r as SerializableReturnValue,
   t as Method
-} from "./serializable-DGdO8CDh.js";
+} from "./serializable-Bg8ARWlN.js";
 export { Method, RPCMethod, SerializableReturnValue, SerializableValue };

package/dist/shared-BUHZFGTk.d.ts

@@ -0,0 +1,34 @@
+//#region src/browser/shared.d.ts
+interface BrowserToolsOptions {
+  /** Browser Rendering binding (Fetcher) — used in production */
+  browser?: Fetcher;
+  /** Optional CDP base URL override (e.g. http://localhost:9222) */
+  cdpUrl?: string;
+  /** Headers to send with CDP URL discovery requests (e.g. Access headers) */
+  cdpHeaders?: Record<string, string>;
+  /** Loader binding for sandboxed code execution */
+  loader: WorkerLoader;
+  /** Execution timeout in milliseconds (default: 30000) */
+  timeout?: number;
+}
+declare const SEARCH_DESCRIPTION =
+  'Search the Chrome DevTools Protocol spec using JavaScript code.\n\nAvailable in your code:\n\ndeclare const spec: {\n  get(): Promise<{\n    domains: Array<{\n      name: string;\n      description?: string;\n      commands: Array<{ name: string; method: string; description?: string }>;\n      events: Array<{ name: string; event: string; description?: string }>;\n      types: Array<{ id: string; name: string; description?: string }>;\n    }>;\n  }>;\n};\n\nWrite an async arrow function in JavaScript. Do NOT use TypeScript syntax.\n\nExample:\nasync () => {\n  const s = await spec.get();\n  return s.domains\n    .find(d => d.name === "Network")\n    .commands.filter(c => c.description?.toLowerCase().includes("intercept"))\n    .map(c => ({ method: c.method, description: c.description }));\n}';
+declare const EXECUTE_DESCRIPTION =
+  'Execute CDP commands against a live browser session using JavaScript code.\n\nAvailable in your code:\n\ndeclare const cdp: {\n  send(method: string, params?: unknown, options?: {\n    timeoutMs?: number;\n    sessionId?: string;\n  }): Promise<unknown>;\n  attachToTarget(targetId: string, options?: {\n    timeoutMs?: number;\n  }): Promise<string>;\n  getDebugLog(limit?: number): Promise<unknown[]>;\n  clearDebugLog(): Promise<void>;\n};\n\nWrite an async arrow function in JavaScript. Do NOT use TypeScript syntax.\n\nFor page-scoped commands such as Page.*, Runtime.*, and DOM.*, first create or select a target, call cdp.attachToTarget(targetId), and pass the returned sessionId in command options.\n\nExample:\nasync () => {\n  return await cdp.send("Browser.getVersion");\n}\n\nPage example:\nasync () => {\n  const { targetId } = await cdp.send("Target.createTarget", {\n    url: "about:blank"\n  });\n  const sessionId = await cdp.attachToTarget(targetId);\n  await cdp.send("Page.enable", {}, { sessionId });\n  await cdp.send(\n    "Page.navigate",\n    { url: "https://example.com" },\n    { sessionId }\n  );\n  const { result } = await cdp.send(\n    "Runtime.evaluate",\n    { expression: "document.title" },\n    { sessionId }\n  );\n  return result.value;\n}';
+interface ToolResult {
+  text: string;
+  isError?: boolean;
+}
+declare function createBrowserToolHandlers(options: BrowserToolsOptions): {
+  search: (code: string) => Promise<ToolResult>;
+  execute: (code: string) => Promise<ToolResult>;
+};
+//#endregion
+export {
+  createBrowserToolHandlers as a,
+  ToolResult as i,
+  EXECUTE_DESCRIPTION as n,
+  SEARCH_DESCRIPTION as r,
+  BrowserToolsOptions as t
+};
+//# sourceMappingURL=shared-BUHZFGTk.d.ts.map

package/dist/shared-BtPEbm_U.js

@@ -0,0 +1,437 @@
+import { a as _checkPrivateRedeclaration, i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-BVdP0e3Z.js";
+import { DynamicWorkerExecutor } from "@cloudflare/codemode";
+//#region \0@oxc-project+runtime@0.124.0/helpers/classPrivateMethodInitSpec.js
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+//#endregion
+//#region src/browser/cdp-session.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+const MAX_DEBUG_ENTRIES = 400;
+var _socket = /* @__PURE__ */ new WeakMap();
+var _nextId = /* @__PURE__ */ new WeakMap();
+var _pending = /* @__PURE__ */ new WeakMap();
+var _debugLog = /* @__PURE__ */ new WeakMap();
+var _defaultTimeoutMs = /* @__PURE__ */ new WeakMap();
+var _dispose = /* @__PURE__ */ new WeakMap();
+var _CdpSession_brand = /* @__PURE__ */ new WeakSet();
+/**
+* A CDP session over an open WebSocket. Manages command correlation,
+* timeouts, target sessions, and a debug event ring buffer.
+*
+* Used host-side (not in the sandbox) — the sandbox calls into this
+* via DynamicWorkerExecutor's ToolDispatcher RPC.
+*/
+var CdpSession = class {
+	constructor(socket, defaultTimeoutMs = DEFAULT_TIMEOUT_MS, dispose) {
+		_classPrivateMethodInitSpec(this, _CdpSession_brand);
+		_classPrivateFieldInitSpec(this, _socket, void 0);
+		_classPrivateFieldInitSpec(this, _nextId, 1);
+		_classPrivateFieldInitSpec(this, _pending, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _debugLog, []);
+		_classPrivateFieldInitSpec(this, _defaultTimeoutMs, void 0);
+		_classPrivateFieldInitSpec(this, _dispose, void 0);
+		_classPrivateFieldSet2(_socket, this, socket);
+		_classPrivateFieldSet2(_defaultTimeoutMs, this, defaultTimeoutMs);
+		_classPrivateFieldSet2(_dispose, this, dispose);
+		socket.addEventListener("message", (event) => _assertClassBrand(_CdpSession_brand, this, _handleMessage).call(this, event));
+		socket.addEventListener("error", () => {
+			_assertClassBrand(_CdpSession_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP socket error"));
+		});
+		socket.addEventListener("close", () => {
+			_assertClassBrand(_CdpSession_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP connection closed"));
+		});
+	}
+	send(method, params, options = {}) {
+		var _this$nextId, _this$nextId2;
+		const id = (_classPrivateFieldSet2(_nextId, this, (_this$nextId = _classPrivateFieldGet2(_nextId, this), _this$nextId2 = _this$nextId++, _this$nextId)), _this$nextId2);
+		const timeoutMs = options.timeoutMs ?? _classPrivateFieldGet2(_defaultTimeoutMs, this);
+		const sessionId = typeof options.sessionId === "string" && options.sessionId.length > 0 ? options.sessionId : void 0;
+		const domain = typeof method === "string" ? method.split(".")[0] : "";
+		if (!sessionId && domain && !["Browser", "Target"].includes(domain)) _assertClassBrand(_CdpSession_brand, this, _recordDebug).call(this, "warning", {
+			id,
+			method,
+			reason: "target-scoped method sent without sessionId"
+		});
+		const result = new Promise((resolve, reject) => {
+			const startedAt = performance.now();
+			const timeoutId = setTimeout(() => {
+				_classPrivateFieldGet2(_pending, this).delete(id);
+				reject(/* @__PURE__ */ new Error(`CDP command timed out after ${timeoutMs}ms: ${method}`));
+			}, timeoutMs);
+			_classPrivateFieldGet2(_pending, this).set(id, {
+				resolve,
+				reject,
+				timeoutId,
+				method,
+				sessionId,
+				startedAt
+			});
+		});
+		_assertClassBrand(_CdpSession_brand, this, _recordDebug).call(this, "send", {
+			id,
+			method,
+			sessionId,
+			timeoutMs
+		});
+		_classPrivateFieldGet2(_socket, this).send(JSON.stringify({
+			id,
+			method,
+			params,
+			sessionId
+		}));
+		return result;
+	}
+	async attachToTarget(targetId, options = {}) {
+		if (typeof targetId !== "string" || !targetId) throw new Error("attachToTarget requires a targetId");
+		const sessionId = (await this.send("Target.attachToTarget", {
+			targetId,
+			flatten: true
+		}, { timeoutMs: options.timeoutMs }))?.sessionId ?? "";
+		if (!sessionId) throw new Error(`Target.attachToTarget did not return a sessionId for target ${targetId}`);
+		_assertClassBrand(_CdpSession_brand, this, _recordDebug).call(this, "attach", {
+			targetId,
+			sessionId
+		});
+		return sessionId;
+	}
+	getDebugLog(limit = 50) {
+		const normalized = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 50;
+		return _classPrivateFieldGet2(_debugLog, this).slice(-normalized);
+	}
+	clearDebugLog() {
+		_classPrivateFieldSet2(_debugLog, this, []);
+	}
+	close() {
+		_assertClassBrand(_CdpSession_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP session closed"));
+		try {
+			_classPrivateFieldGet2(_socket, this).close(1e3, "Done");
+		} catch {}
+		_classPrivateFieldGet2(_dispose, this)?.call(this);
+	}
+};
+function _rejectAll(error) {
+	for (const [id, pending] of _classPrivateFieldGet2(_pending, this).entries()) {
+		clearTimeout(pending.timeoutId);
+		_classPrivateFieldGet2(_pending, this).delete(id);
+		pending.reject(error);
+	}
+}
+function _handleMessage(event) {
+	if (typeof event.data !== "string") return;
+	let payload;
+	try {
+		payload = JSON.parse(event.data);
+	} catch {
+		return;
+	}
+	_assertClassBrand(_CdpSession_brand, this, _recordDebug).call(this, "receive", {
+		id: payload.id,
+		method: payload.method,
+		sessionId: payload.sessionId,
+		hasError: !!payload.error
+	});
+	if (typeof payload.id !== "number") return;
+	const pending = _classPrivateFieldGet2(_pending, this).get(payload.id);
+	if (!pending) return;
+	clearTimeout(pending.timeoutId);
+	_classPrivateFieldGet2(_pending, this).delete(payload.id);
+	if (payload.error) {
+		const err = payload.error;
+		const code = err.code ?? "unknown";
+		const message = err.message ?? "CDP error";
+		pending.reject(/* @__PURE__ */ new Error(`CDP error ${code}: ${message} for ${pending.method}`));
+		return;
+	}
+	pending.resolve(payload.result);
+}
+function _recordDebug(type, data) {
+	_classPrivateFieldGet2(_debugLog, this).push({
+		at: (/* @__PURE__ */ new Date()).toISOString(),
+		type,
+		...data
+	});
+	if (_classPrivateFieldGet2(_debugLog, this).length > MAX_DEBUG_ENTRIES) _classPrivateFieldGet2(_debugLog, this).splice(0, _classPrivateFieldGet2(_debugLog, this).length - MAX_DEBUG_ENTRIES);
+}
+/**
+* Connect to a browser via the Browser Rendering binding (Fetcher).
+* Establishes a CDP WebSocket through the binding's fetch interface.
+*/
+async function connectBrowser(browser, timeoutMs) {
+	const response = await browser.fetch("https://localhost/v1/devtools/browser", { headers: { Upgrade: "websocket" } });
+	const ws = response.webSocket;
+	if (!ws) throw new Error("Browser Rendering binding did not return a WebSocket. Ensure the 'browser' binding is configured in wrangler.jsonc.");
+	const sessionId = response.headers.get("cf-browser-session-id");
+	if (!sessionId) throw new Error("Browser Rendering binding did not include a session ID when opening the CDP WebSocket");
+	ws.accept();
+	return new CdpSession(ws, timeoutMs, () => {
+		browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}`, { method: "DELETE" });
+	});
+}
+const LOCALHOST_HOSTS = new Set([
+	"localhost",
+	"127.0.0.1",
+	"0.0.0.0",
+	"::1",
+	"[::1]"
+]);
+/**
+* Connect to a browser via a CDP base URL (e.g. http://localhost:9222).
+* Discovers the WebSocket debugger URL via /json/version,
+* rewrites localhost URLs to the base URL host, and opens the WebSocket.
+*
+* Useful for local development with `chrome --remote-debugging-port=9222`
+* or when connecting through a tunnel.
+*/
+async function connectUrl(baseUrl, options) {
+	const endpoint = new URL("/json/version", baseUrl).toString();
+	const response = await fetch(endpoint, { headers: options?.headers });
+	if (!response.ok) throw new Error(`Failed to discover CDP endpoint at ${endpoint}: ${response.status}`);
+	const payload = await response.json();
+	if (!payload.webSocketDebuggerUrl) throw new Error("CDP /json/version did not include webSocketDebuggerUrl");
+	let wsUrl = payload.webSocketDebuggerUrl;
+	const parsed = new URL(wsUrl);
+	if (LOCALHOST_HOSTS.has(parsed.hostname)) {
+		const base = new URL(baseUrl);
+		parsed.hostname = base.hostname;
+		parsed.port = base.port;
+		parsed.protocol = base.protocol;
+	} else parsed.protocol = parsed.protocol === "wss:" ? "https:" : "http:";
+	const fetchUrl = parsed.toString();
+	const wsResponse = await fetch(fetchUrl, { headers: {
+		...options?.headers,
+		Upgrade: "websocket"
+	} });
+	const ws = wsResponse.webSocket;
+	if (!ws) throw new Error(`Failed to establish CDP WebSocket at ${fetchUrl} (status ${wsResponse.status})`);
+	ws.accept();
+	return new CdpSession(ws, options?.timeoutMs);
+}
+//#endregion
+//#region src/browser/truncate.ts
+const CHARS_PER_TOKEN = 4;
+const MAX_TOKENS = 6e3;
+const MAX_CHARS = CHARS_PER_TOKEN * MAX_TOKENS;
+function truncateResponse(content) {
+	const text = typeof content === "string" ? content : JSON.stringify(content, null, 2) ?? "null";
+	if (text.length <= MAX_CHARS) return text;
+	const estimatedTokens = Math.ceil(text.length / CHARS_PER_TOKEN);
+	return `${text.slice(0, MAX_CHARS)}\n\n--- TRUNCATED ---\nResponse was ~${estimatedTokens.toLocaleString()} tokens (limit: ${MAX_TOKENS.toLocaleString()}). Use more specific queries to reduce response size.`;
+}
+//#endregion
+//#region src/browser/shared.ts
+const specCache = /* @__PURE__ */ new Map();
+const CACHE_TTL_MS = 300 * 1e3;
+const SEARCH_DESCRIPTION = `Search the Chrome DevTools Protocol spec using JavaScript code.
+
+Available in your code:
+
+declare const spec: {
+  get(): Promise<{
+    domains: Array<{
+      name: string;
+      description?: string;
+      commands: Array<{ name: string; method: string; description?: string }>;
+      events: Array<{ name: string; event: string; description?: string }>;
+      types: Array<{ id: string; name: string; description?: string }>;
+    }>;
+  }>;
+};
+
+Write an async arrow function in JavaScript. Do NOT use TypeScript syntax.
+
+Example:
+async () => {
+  const s = await spec.get();
+  return s.domains
+    .find(d => d.name === "Network")
+    .commands.filter(c => c.description?.toLowerCase().includes("intercept"))
+    .map(c => ({ method: c.method, description: c.description }));
+}`;
+function normalizeCdpSpec(spec) {
+	return { domains: (spec.domains ?? []).map((domain) => ({
+		name: domain.domain,
+		description: domain.description,
+		commands: (domain.commands ?? []).map((command) => ({
+			name: command.name,
+			method: `${domain.domain}.${command.name}`,
+			description: command.description
+		})),
+		events: (domain.events ?? []).map((event) => ({
+			name: event.name,
+			event: `${domain.domain}.${event.name}`,
+			description: event.description
+		})),
+		types: (domain.types ?? []).map((type) => ({
+			id: type.id,
+			name: `${domain.domain}.${type.id}`,
+			description: type.description
+		}))
+	})) };
+}
+function getSpecCacheKey(source, headers) {
+	const headerEntries = Object.entries(headers ?? {}).sort(([a], [b]) => a.localeCompare(b));
+	return `${source}:${JSON.stringify(headerEntries)}`;
+}
+async function getCachedSpec(key, load) {
+	const cached = specCache.get(key);
+	if (cached && Date.now() - cached.cachedAt < CACHE_TTL_MS) return cached.spec;
+	const spec = normalizeCdpSpec(await load());
+	specCache.set(key, {
+		spec,
+		cachedAt: Date.now()
+	});
+	return spec;
+}
+async function fetchCdpSpecFromUrl(cdpBaseUrl, headers) {
+	const endpoint = new URL("/json/protocol", cdpBaseUrl).toString();
+	return getCachedSpec(getSpecCacheKey(endpoint, headers), async () => {
+		const response = await fetch(endpoint, { headers });
+		if (!response.ok) throw new Error(`Failed to fetch CDP spec from ${endpoint}: ${response.status}`);
+		return await response.json();
+	});
+}
+async function fetchCdpSpecFromBrowser(browser) {
+	return getCachedSpec("browser-binding", async () => {
+		const createResponse = await browser.fetch("https://localhost/v1/devtools/browser", { method: "POST" });
+		if (!createResponse.ok) throw new Error(`Failed to create Browser Rendering session for protocol fetch: ${createResponse.status}`);
+		const sessionId = (await createResponse.json()).sessionId;
+		if (!sessionId) throw new Error("Browser Rendering session response did not include a sessionId");
+		try {
+			const response = await browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}/json/protocol`);
+			if (!response.ok) throw new Error(`Failed to fetch CDP spec from Browser Rendering: ${response.status}`);
+			return await response.json();
+		} finally {
+			try {
+				await browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}`, { method: "DELETE" });
+			} catch {}
+		}
+	});
+}
+const EXECUTE_DESCRIPTION = `Execute CDP commands against a live browser session using JavaScript code.
+
+Available in your code:
+
+declare const cdp: {
+  send(method: string, params?: unknown, options?: {
+    timeoutMs?: number;
+    sessionId?: string;
+  }): Promise<unknown>;
+  attachToTarget(targetId: string, options?: {
+    timeoutMs?: number;
+  }): Promise<string>;
+  getDebugLog(limit?: number): Promise<unknown[]>;
+  clearDebugLog(): Promise<void>;
+};
+
+Write an async arrow function in JavaScript. Do NOT use TypeScript syntax.
+
+For page-scoped commands such as Page.*, Runtime.*, and DOM.*, first create or select a target, call cdp.attachToTarget(targetId), and pass the returned sessionId in command options.
+
+Example:
+async () => {
+  return await cdp.send("Browser.getVersion");
+}
+
+Page example:
+async () => {
+  const { targetId } = await cdp.send("Target.createTarget", {
+    url: "about:blank"
+  });
+  const sessionId = await cdp.attachToTarget(targetId);
+  await cdp.send("Page.enable", {}, { sessionId });
+  await cdp.send(
+    "Page.navigate",
+    { url: "https://example.com" },
+    { sessionId }
+  );
+  const { result } = await cdp.send(
+    "Runtime.evaluate",
+    { expression: "document.title" },
+    { sessionId }
+  );
+  return result.value;
+}`;
+function formatError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+let didWarnExperimental = false;
+function createBrowserToolHandlers(options) {
+	if (!didWarnExperimental) {
+		didWarnExperimental = true;
+		console.warn("[agents/browser] Browser tools are experimental and may change in a future release.");
+	}
+	const executor = new DynamicWorkerExecutor({
+		loader: options.loader,
+		timeout: options.timeout
+	});
+	async function search(code) {
+		try {
+			let specSource;
+			if (options.cdpUrl) specSource = await fetchCdpSpecFromUrl(options.cdpUrl, options.cdpHeaders);
+			else if (options.browser) specSource = await fetchCdpSpecFromBrowser(options.browser);
+			else return {
+				text: "Either 'browser' (Fetcher binding) or 'cdpUrl' must be provided",
+				isError: true
+			};
+			const result = await executor.execute(code, [{
+				name: "spec",
+				fns: { get: async () => specSource }
+			}]);
+			if (result.error) return {
+				text: result.error,
+				isError: true
+			};
+			return { text: truncateResponse(result.result) };
+		} catch (error) {
+			return {
+				text: formatError(error),
+				isError: true
+			};
+		}
+	}
+	async function execute(code) {
+		let session;
+		try {
+			if (options.cdpUrl) session = await connectUrl(options.cdpUrl, {
+				timeoutMs: options.timeout,
+				headers: options.cdpHeaders
+			});
+			else if (options.browser) session = await connectBrowser(options.browser, options.timeout);
+			else return {
+				text: "Either 'browser' (Fetcher binding) or 'cdpUrl' must be provided",
+				isError: true
+			};
+			const result = await executor.execute(code, [{
+				name: "cdp",
+				fns: {
+					send: async (method, params, opts) => session.send(method, params, opts),
+					attachToTarget: async (targetId, opts) => session.attachToTarget(targetId, opts),
+					getDebugLog: async (limit) => session.getDebugLog(limit),
+					clearDebugLog: async () => session.clearDebugLog()
+				},
+				positionalArgs: true
+			}]);
+			if (result.error) return {
+				text: result.error,
+				isError: true
+			};
+			return { text: truncateResponse(result.result) };
+		} catch (error) {
+			return {
+				text: formatError(error),
+				isError: true
+			};
+		} finally {
+			session?.close();
+		}
+	}
+	return {
+		search,
+		execute
+	};
+}
+//#endregion
+export { connectBrowser as a, CdpSession as i, SEARCH_DESCRIPTION as n, connectUrl as o, createBrowserToolHandlers as r, EXECUTE_DESCRIPTION as t };
+
+//# sourceMappingURL=shared-BtPEbm_U.js.map

package/dist/shared-BtPEbm_U.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-BtPEbm_U.js","names":[],"sources":["../src/browser/cdp-session.ts","../src/browser/truncate.ts","../src/browser/shared.ts"],"sourcesContent":["interface PendingCommand {\n  resolve: (result: unknown) => void;\n  reject: (error: Error) => void;\n  timeoutId: ReturnType<typeof setTimeout>;\n  method: string;\n  sessionId?: string;\n  startedAt: number;\n}\n\ninterface DebugEntry {\n  at: string;\n  type: string;\n  [key: string]: unknown;\n}\n\nexport interface CdpSendOptions {\n  timeoutMs?: number;\n  sessionId?: string;\n}\n\nexport interface CdpAttachOptions {\n  timeoutMs?: number;\n}\n\nconst DEFAULT_TIMEOUT_MS = 10_000;\nconst MAX_DEBUG_ENTRIES = 400;\n\n/**\n * A CDP session over an open WebSocket. Manages command correlation,\n * timeouts, target sessions, and a debug event ring buffer.\n *\n * Used host-side (not in the sandbox) — the sandbox calls into this\n * via DynamicWorkerExecutor's ToolDispatcher RPC.\n */\nexport class CdpSession {\n  #socket: WebSocket;\n  #nextId = 1;\n  #pending = new Map<number, PendingCommand>();\n  #debugLog: DebugEntry[] = [];\n  #defaultTimeoutMs: number;\n  #dispose?: () => void;\n\n  constructor(\n    socket: WebSocket,\n    defaultTimeoutMs = DEFAULT_TIMEOUT_MS,\n    dispose?: () => void\n  ) {\n    this.#socket = socket;\n    this.#defaultTimeoutMs = defaultTimeoutMs;\n    this.#dispose = dispose;\n\n    socket.addEventListener(\"message\", (event) => this.#handleMessage(event));\n    socket.addEventListener(\"error\", () => {\n      this.#rejectAll(new Error(\"CDP socket error\"));\n    });\n    socket.addEventListener(\"close\", () => {\n      this.#rejectAll(new Error(\"CDP connection closed\"));\n    });\n  }\n\n  send(\n    method: string,\n    params?: unknown,\n    options: CdpSendOptions = {}\n  ): Promise<unknown> {\n    const id = this.#nextId++;\n    const timeoutMs = options.timeoutMs ?? this.#defaultTimeoutMs;\n    const sessionId =\n      typeof options.sessionId === \"string\" && options.sessionId.length > 0\n        ? options.sessionId\n        : undefined;\n\n    const domain = typeof method === \"string\" ? method.split(\".\")[0] : \"\";\n    if (!sessionId && domain && ![\"Browser\", \"Target\"].includes(domain)) {\n      this.#recordDebug(\"warning\", {\n        id,\n        method,\n        reason: \"target-scoped method sent without sessionId\"\n      });\n    }\n\n    const result = new Promise<unknown>((resolve, reject) => {\n      const startedAt = performance.now();\n      const timeoutId = setTimeout(() => {\n        this.#pending.delete(id);\n        reject(\n          new Error(`CDP command timed out after ${timeoutMs}ms: ${method}`)\n        );\n      }, timeoutMs);\n      this.#pending.set(id, {\n        resolve,\n        reject,\n        timeoutId,\n        method,\n        sessionId,\n        startedAt\n      });\n    });\n\n    this.#recordDebug(\"send\", { id, method, sessionId, timeoutMs });\n    this.#socket.send(JSON.stringify({ id, method, params, sessionId }));\n    return result;\n  }\n\n  async attachToTarget(\n    targetId: string,\n    options: CdpAttachOptions = {}\n  ): Promise<string> {\n    if (typeof targetId !== \"string\" || !targetId) {\n      throw new Error(\"attachToTarget requires a targetId\");\n    }\n\n    const result = (await this.send(\n      \"Target.attachToTarget\",\n      {\n        targetId,\n        flatten: true\n      },\n      { timeoutMs: options.timeoutMs }\n    )) as { sessionId?: string };\n\n    const sessionId = result?.sessionId ?? \"\";\n    if (!sessionId) {\n      throw new Error(\n        `Target.attachToTarget did not return a sessionId for target ${targetId}`\n      );\n    }\n\n    this.#recordDebug(\"attach\", { targetId, sessionId });\n    return sessionId;\n  }\n\n  getDebugLog(limit = 50): DebugEntry[] {\n    const normalized = Number.isFinite(limit)\n      ? Math.max(1, Math.floor(limit))\n      : 50;\n    return this.#debugLog.slice(-normalized);\n  }\n\n  clearDebugLog(): void {\n    this.#debugLog = [];\n  }\n\n  close(): void {\n    this.#rejectAll(new Error(\"CDP session closed\"));\n    try {\n      this.#socket.close(1000, \"Done\");\n    } catch {\n      // socket may already be closed\n    }\n    this.#dispose?.();\n  }\n\n  #rejectAll(error: Error): void {\n    for (const [id, pending] of this.#pending.entries()) {\n      clearTimeout(pending.timeoutId);\n      this.#pending.delete(id);\n      pending.reject(error);\n    }\n  }\n\n  #handleMessage(event: MessageEvent): void {\n    if (typeof event.data !== \"string\") {\n      return;\n    }\n\n    let payload: Record<string, unknown>;\n    try {\n      payload = JSON.parse(event.data) as Record<string, unknown>;\n    } catch {\n      return;\n    }\n\n    this.#recordDebug(\"receive\", {\n      id: payload.id,\n      method: payload.method,\n      sessionId: payload.sessionId,\n      hasError: !!payload.error\n    });\n\n    if (typeof payload.id !== \"number\") {\n      return;\n    }\n\n    const pending = this.#pending.get(payload.id);\n    if (!pending) {\n      return;\n    }\n\n    clearTimeout(pending.timeoutId);\n    this.#pending.delete(payload.id);\n\n    if (payload.error) {\n      const err = payload.error as { code?: unknown; message?: string };\n      const code = err.code ?? \"unknown\";\n      const message = err.message ?? \"CDP error\";\n      pending.reject(\n        new Error(`CDP error ${code}: ${message} for ${pending.method}`)\n      );\n      return;\n    }\n\n    pending.resolve(payload.result);\n  }\n\n  #recordDebug(type: string, data: Record<string, unknown>): void {\n    this.#debugLog.push({\n      at: new Date().toISOString(),\n      type,\n      ...data\n    });\n    if (this.#debugLog.length > MAX_DEBUG_ENTRIES) {\n      this.#debugLog.splice(0, this.#debugLog.length - MAX_DEBUG_ENTRIES);\n    }\n  }\n}\n\n/**\n * Connect to a browser via the Browser Rendering binding (Fetcher).\n * Establishes a CDP WebSocket through the binding's fetch interface.\n */\nexport async function connectBrowser(\n  browser: Fetcher,\n  timeoutMs?: number\n): Promise<CdpSession> {\n  const response = await browser.fetch(\n    \"https://localhost/v1/devtools/browser\",\n    {\n      headers: { Upgrade: \"websocket\" }\n    }\n  );\n\n  const ws = response.webSocket;\n  if (!ws) {\n    throw new Error(\n      \"Browser Rendering binding did not return a WebSocket. \" +\n        \"Ensure the 'browser' binding is configured in wrangler.jsonc.\"\n    );\n  }\n\n  const sessionId = response.headers.get(\"cf-browser-session-id\");\n  if (!sessionId) {\n    throw new Error(\n      \"Browser Rendering binding did not include a session ID when opening the CDP WebSocket\"\n    );\n  }\n\n  ws.accept();\n  return new CdpSession(ws, timeoutMs, () => {\n    void browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}`, {\n      method: \"DELETE\"\n    });\n  });\n}\n\nconst LOCALHOST_HOSTS = new Set([\n  \"localhost\",\n  \"127.0.0.1\",\n  \"0.0.0.0\",\n  \"::1\",\n  \"[::1]\"\n]);\n\n/**\n * Connect to a browser via a CDP base URL (e.g. http://localhost:9222).\n * Discovers the WebSocket debugger URL via /json/version,\n * rewrites localhost URLs to the base URL host, and opens the WebSocket.\n *\n * Useful for local development with `chrome --remote-debugging-port=9222`\n * or when connecting through a tunnel.\n */\nexport async function connectUrl(\n  baseUrl: string,\n  options?: { timeoutMs?: number; headers?: Record<string, string> }\n): Promise<CdpSession> {\n  const endpoint = new URL(\"/json/version\", baseUrl).toString();\n  const response = await fetch(endpoint, {\n    headers: options?.headers\n  });\n  if (!response.ok) {\n    throw new Error(\n      `Failed to discover CDP endpoint at ${endpoint}: ${response.status}`\n    );\n  }\n\n  const payload = (await response.json()) as {\n    webSocketDebuggerUrl?: string;\n  };\n  if (!payload.webSocketDebuggerUrl) {\n    throw new Error(\"CDP /json/version did not include webSocketDebuggerUrl\");\n  }\n\n  let wsUrl = payload.webSocketDebuggerUrl;\n  const parsed = new URL(wsUrl);\n  if (LOCALHOST_HOSTS.has(parsed.hostname)) {\n    const base = new URL(baseUrl);\n    parsed.hostname = base.hostname;\n    parsed.port = base.port;\n    parsed.protocol = base.protocol;\n  } else {\n    // Workers runtime requires fetch + Upgrade header for outbound WebSockets\n    parsed.protocol = parsed.protocol === \"wss:\" ? \"https:\" : \"http:\";\n  }\n  const fetchUrl = parsed.toString();\n\n  const wsResponse = await fetch(fetchUrl, {\n    headers: { ...options?.headers, Upgrade: \"websocket\" }\n  });\n  const ws = wsResponse.webSocket;\n  if (!ws) {\n    throw new Error(\n      `Failed to establish CDP WebSocket at ${fetchUrl} (status ${wsResponse.status})`\n    );\n  }\n  ws.accept();\n\n  return new CdpSession(ws, options?.timeoutMs);\n}\n","const CHARS_PER_TOKEN = 4;\nconst MAX_TOKENS = 6000;\nconst MAX_CHARS = CHARS_PER_TOKEN * MAX_TOKENS;\n\nexport function truncateResponse(content: unknown): string {\n  const text =\n    typeof content === \"string\"\n      ? content\n      : (JSON.stringify(content, null, 2) ?? \"null\");\n  if (text.length <= MAX_CHARS) {\n    return text;\n  }\n\n  const estimatedTokens = Math.ceil(text.length / CHARS_PER_TOKEN);\n  return `${text.slice(0, MAX_CHARS)}\\n\\n--- TRUNCATED ---\\nResponse was ~${estimatedTokens.toLocaleString()} tokens (limit: ${MAX_TOKENS.toLocaleString()}). Use more specific queries to reduce response size.`;\n}\n","import type { ResolvedProvider } from \"@cloudflare/codemode\";\nimport { DynamicWorkerExecutor } from \"@cloudflare/codemode\";\nimport { CdpSession, connectBrowser, connectUrl } from \"./cdp-session\";\nimport { truncateResponse } from \"./truncate\";\n\nexport interface BrowserToolsOptions {\n  /** Browser Rendering binding (Fetcher) — used in production */\n  browser?: Fetcher;\n  /** Optional CDP base URL override (e.g. http://localhost:9222) */\n  cdpUrl?: string;\n  /** Headers to send with CDP URL discovery requests (e.g. Access headers) */\n  cdpHeaders?: Record<string, string>;\n  /** Loader binding for sandboxed code execution */\n  loader: WorkerLoader;\n  /** Execution timeout in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\ninterface RawCdpCommand {\n  name: string;\n  description?: string;\n}\n\ninterface RawCdpEvent {\n  name: string;\n  description?: string;\n}\n\ninterface RawCdpType {\n  id: string;\n  description?: string;\n}\n\n/** Raw CDP protocol domain from `/json/protocol` */\ninterface RawCdpDomain {\n  domain: string;\n  description?: string;\n  commands?: RawCdpCommand[];\n  events?: RawCdpEvent[];\n  types?: RawCdpType[];\n}\n\ninterface SearchableCdpSpec {\n  domains: Array<{\n    name: string;\n    description?: string;\n    commands: Array<{ name: string; method: string; description?: string }>;\n    events: Array<{ name: string; event: string; description?: string }>;\n    types: Array<{ id: string; name: string; description?: string }>;\n  }>;\n}\n\nconst specCache = new Map<\n  string,\n  { spec: SearchableCdpSpec; cachedAt: number }\n>();\n\nconst CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes\n\nexport const SEARCH_DESCRIPTION = `Search the Chrome DevTools Protocol spec using JavaScript code.\n\nAvailable in your code:\n\ndeclare const spec: {\n  get(): Promise<{\n    domains: Array<{\n      name: string;\n      description?: string;\n      commands: Array<{ name: string; method: string; description?: string }>;\n      events: Array<{ name: string; event: string; description?: string }>;\n      types: Array<{ id: string; name: string; description?: string }>;\n    }>;\n  }>;\n};\n\nWrite an async arrow function in JavaScript. Do NOT use TypeScript syntax.\n\nExample:\nasync () => {\n  const s = await spec.get();\n  return s.domains\n    .find(d => d.name === \"Network\")\n    .commands.filter(c => c.description?.toLowerCase().includes(\"intercept\"))\n    .map(c => ({ method: c.method, description: c.description }));\n}`;\n\nfunction normalizeCdpSpec(spec: {\n  domains?: RawCdpDomain[];\n}): SearchableCdpSpec {\n  return {\n    domains: (spec.domains ?? []).map((domain) => ({\n      name: domain.domain,\n      description: domain.description,\n      commands: (domain.commands ?? []).map((command) => ({\n        name: command.name,\n        method: `${domain.domain}.${command.name}`,\n        description: command.description\n      })),\n      events: (domain.events ?? []).map((event) => ({\n        name: event.name,\n        event: `${domain.domain}.${event.name}`,\n        description: event.description\n      })),\n      types: (domain.types ?? []).map((type) => ({\n        id: type.id,\n        name: `${domain.domain}.${type.id}`,\n        description: type.description\n      }))\n    }))\n  };\n}\n\nfunction getSpecCacheKey(\n  source: string,\n  headers?: Record<string, string>\n): string {\n  const headerEntries = Object.entries(headers ?? {}).sort(([a], [b]) =>\n    a.localeCompare(b)\n  );\n  return `${source}:${JSON.stringify(headerEntries)}`;\n}\n\nasync function getCachedSpec(\n  key: string,\n  load: () => Promise<{ domains?: RawCdpDomain[] }>\n): Promise<SearchableCdpSpec> {\n  const cached = specCache.get(key);\n  if (cached && Date.now() - cached.cachedAt < CACHE_TTL_MS) {\n    return cached.spec;\n  }\n\n  const spec = normalizeCdpSpec(await load());\n  specCache.set(key, { spec, cachedAt: Date.now() });\n  return spec;\n}\n\nasync function fetchCdpSpecFromUrl(\n  cdpBaseUrl: string,\n  headers?: Record<string, string>\n): Promise<SearchableCdpSpec> {\n  const endpoint = new URL(\"/json/protocol\", cdpBaseUrl).toString();\n\n  return getCachedSpec(getSpecCacheKey(endpoint, headers), async () => {\n    const response = await fetch(endpoint, { headers });\n\n    if (!response.ok) {\n      throw new Error(\n        `Failed to fetch CDP spec from ${endpoint}: ${response.status}`\n      );\n    }\n\n    return (await response.json()) as { domains?: RawCdpDomain[] };\n  });\n}\n\nasync function fetchCdpSpecFromBrowser(\n  browser: Fetcher\n): Promise<SearchableCdpSpec> {\n  return getCachedSpec(\"browser-binding\", async () => {\n    const createResponse = await browser.fetch(\n      \"https://localhost/v1/devtools/browser\",\n      {\n        method: \"POST\"\n      }\n    );\n\n    if (!createResponse.ok) {\n      throw new Error(\n        \"Failed to create Browser Rendering session for protocol fetch: \" +\n          `${createResponse.status}`\n      );\n    }\n\n    const payload = (await createResponse.json()) as { sessionId?: string };\n    const sessionId = payload.sessionId;\n    if (!sessionId) {\n      throw new Error(\n        \"Browser Rendering session response did not include a sessionId\"\n      );\n    }\n\n    try {\n      const response = await browser.fetch(\n        `https://localhost/v1/devtools/browser/${sessionId}/json/protocol`\n      );\n\n      if (!response.ok) {\n        throw new Error(\n          \"Failed to fetch CDP spec from Browser Rendering: \" +\n            `${response.status}`\n        );\n      }\n\n      return (await response.json()) as { domains?: RawCdpDomain[] };\n    } finally {\n      try {\n        await browser.fetch(\n          `https://localhost/v1/devtools/browser/${sessionId}`,\n          {\n            method: \"DELETE\"\n          }\n        );\n      } catch {\n        // Cleanup failure should not mask the original result or error\n      }\n    }\n  });\n}\n\nexport const EXECUTE_DESCRIPTION = `Execute CDP commands against a live browser session using JavaScript code.\n\nAvailable in your code:\n\ndeclare const cdp: {\n  send(method: string, params?: unknown, options?: {\n    timeoutMs?: number;\n    sessionId?: string;\n  }): Promise<unknown>;\n  attachToTarget(targetId: string, options?: {\n    timeoutMs?: number;\n  }): Promise<string>;\n  getDebugLog(limit?: number): Promise<unknown[]>;\n  clearDebugLog(): Promise<void>;\n};\n\nWrite an async arrow function in JavaScript. Do NOT use TypeScript syntax.\n\nFor page-scoped commands such as Page.*, Runtime.*, and DOM.*, first create or select a target, call cdp.attachToTarget(targetId), and pass the returned sessionId in command options.\n\nExample:\nasync () => {\n  return await cdp.send(\"Browser.getVersion\");\n}\n\nPage example:\nasync () => {\n  const { targetId } = await cdp.send(\"Target.createTarget\", {\n    url: \"about:blank\"\n  });\n  const sessionId = await cdp.attachToTarget(targetId);\n  await cdp.send(\"Page.enable\", {}, { sessionId });\n  await cdp.send(\n    \"Page.navigate\",\n    { url: \"https://example.com\" },\n    { sessionId }\n  );\n  const { result } = await cdp.send(\n    \"Runtime.evaluate\",\n    { expression: \"document.title\" },\n    { sessionId }\n  );\n  return result.value;\n}`;\n\nfunction formatError(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nexport interface ToolResult {\n  text: string;\n  isError?: boolean;\n}\n\nlet didWarnExperimental = false;\n\nexport function createBrowserToolHandlers(options: BrowserToolsOptions) {\n  if (!didWarnExperimental) {\n    didWarnExperimental = true;\n    console.warn(\n      \"[agents/browser] Browser tools are experimental and may change in a future release.\"\n    );\n  }\n  const executor = new DynamicWorkerExecutor({\n    loader: options.loader,\n    timeout: options.timeout\n  });\n\n  async function search(code: string): Promise<ToolResult> {\n    try {\n      let specSource: SearchableCdpSpec;\n\n      if (options.cdpUrl) {\n        specSource = await fetchCdpSpecFromUrl(\n          options.cdpUrl,\n          options.cdpHeaders\n        );\n      } else if (options.browser) {\n        specSource = await fetchCdpSpecFromBrowser(options.browser);\n      } else {\n        return {\n          text: \"Either 'browser' (Fetcher binding) or 'cdpUrl' must be provided\",\n          isError: true\n        };\n      }\n\n      const providers: ResolvedProvider[] = [\n        {\n          name: \"spec\",\n          fns: { get: async () => specSource }\n        }\n      ];\n      const result = await executor.execute(code, providers);\n      if (result.error) {\n        return { text: result.error, isError: true };\n      }\n      return { text: truncateResponse(result.result) };\n    } catch (error) {\n      return { text: formatError(error), isError: true };\n    }\n  }\n\n  async function execute(code: string): Promise<ToolResult> {\n    let session: CdpSession | undefined;\n    try {\n      if (options.cdpUrl) {\n        session = await connectUrl(options.cdpUrl, {\n          timeoutMs: options.timeout,\n          headers: options.cdpHeaders\n        });\n      } else if (options.browser) {\n        session = await connectBrowser(options.browser, options.timeout);\n      } else {\n        return {\n          text: \"Either 'browser' (Fetcher binding) or 'cdpUrl' must be provided\",\n          isError: true\n        };\n      }\n\n      const providers: ResolvedProvider[] = [\n        {\n          name: \"cdp\",\n          fns: {\n            send: async (method: unknown, params: unknown, opts: unknown) =>\n              session!.send(\n                method as string,\n                params,\n                opts as { timeoutMs?: number; sessionId?: string }\n              ),\n            attachToTarget: async (targetId: unknown, opts: unknown) =>\n              session!.attachToTarget(\n                targetId as string,\n                opts as { timeoutMs?: number }\n              ),\n            getDebugLog: async (limit: unknown) =>\n              session!.getDebugLog(limit as number | undefined),\n            clearDebugLog: async () => session!.clearDebugLog()\n          },\n          positionalArgs: true\n        }\n      ];\n\n      const result = await executor.execute(code, providers);\n      if (result.error) {\n        return { text: result.error, isError: true };\n      }\n      return { text: truncateResponse(result.result) };\n    } catch (error) {\n      return { text: formatError(error), isError: true };\n    } finally {\n      session?.close();\n    }\n  }\n\n  return { search, execute };\n}\n"],"mappings":"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"}

package/dist/{types-B9A8AU7B.d.ts → types-DAHCZC_W.d.ts}

@@ -14,4 +14,4 @@ declare enum MessageType {
 }
 //#endregion
 export { MessageType as t };
-//# sourceMappingURL=types-B9A8AU7B.d.ts.map
+//# sourceMappingURL=types-DAHCZC_W.d.ts.map

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { t as MessageType } from "./types-B9A8AU7B.js";
+import { t as MessageType } from "./types-DAHCZC_W.js";
 export { MessageType };

package/dist/{workflow-types-XmOkuI7A.d.ts → workflow-types-DHs0L0KP.d.ts}

@@ -257,4 +257,4 @@ export {
   WorkflowStatus as x,
   WorkflowQueryCriteria as y
 };
-//# sourceMappingURL=workflow-types-XmOkuI7A.d.ts.map
+//# sourceMappingURL=workflow-types-DHs0L0KP.d.ts.map

package/dist/workflow-types.d.ts

@@ -21,7 +21,7 @@ import {
   v as WorkflowProgressCallback,
   x as WorkflowStatus,
   y as WorkflowQueryCriteria
-} from "./workflow-types-XmOkuI7A.js";
+} from "./workflow-types-DHs0L0KP.js";
 export {
   AgentWorkflowEvent,
   AgentWorkflowInternalParams,

package/dist/workflows.d.ts

@@ -1,4 +1,4 @@
-import { r as Agent } from "./index-D2lfljd3.js";
+import { r as Agent } from "./index-CrOzHA2T.js";
 import {
   S as WorkflowTrackingRow,
   _ as WorkflowPage,
@@ -20,7 +20,7 @@ import {
   v as WorkflowProgressCallback,
   x as WorkflowStatus,
   y as WorkflowQueryCriteria
-} from "./workflow-types-XmOkuI7A.js";
+} from "./workflow-types-DHs0L0KP.js";
 import { WorkflowEntrypoint } from "cloudflare:workers";
 
 //#region src/workflows.d.ts

package/dist/workflows.js

@@ -1,4 +1,4 @@
-import { o as getAgentByName } from "./src-f7-4oW_C.js";
+import { getAgentByName } from "./index.js";
 import { WorkflowRejectedError } from "./workflow-types.js";
 import { WorkflowEntrypoint } from "cloudflare:workers";
 //#region src/workflows.ts