agents 0.20.1 → 0.21.0

package/dist/chat/transport.d.ts

@@ -0,0 +1,10 @@
+import {
+  n as WebSocketChatTransport,
+  r as WebSocketChatTransportOptions,
+  t as AgentConnection
+} from "../ws-chat-transport-UNRIS2xl.js";
+export {
+  type AgentConnection,
+  WebSocketChatTransport,
+  type WebSocketChatTransportOptions
+};

package/dist/chat/transport.js

@@ -0,0 +1,2 @@
+import { t as WebSocketChatTransport } from "../ws-chat-transport-CIoOBbO7.js";
+export { WebSocketChatTransport };

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

@@ -2,7 +2,7 @@ import {
   O as Agent,
   ct as SubAgentClass,
   lt as SubAgentStub
-} from "../agent-tool-types-BC-WFlsz.js";
+} from "../agent-tool-types-CzGGB-20.js";
 import { Lock, QueueEntry, StateAdapter } from "chat";
 
 //#region src/chat-sdk/agent.d.ts

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { O as Agent } from "./agent-tool-types-BC-WFlsz.js";
+import { O as Agent } from "./agent-tool-types-CzGGB-20.js";
 import {
   ClientParameters,
   Method,

package/dist/{connector-v2M1zlZp.d.ts → connector-CkQD4MK3.d.ts}

@@ -1,5 +1,6 @@
 import {
   CodemodeConnector,
+  ConnectorTool,
   ConnectorTools,
   ExecutionEndStatus,
   PassEndStatus
@@ -95,6 +96,11 @@ interface ConnectBrowserOptions {
    * {@link getBrowserRecording}.
    */
   recording?: boolean;
+  /**
+   * Select the browser engine. Defaults to Chromium. Use `"kitesurf"` for
+   * Cloudflare's connection-scoped, agent-first browser engine.
+   */
+  browser?: "kitesurf";
 }
 /** An rrweb session recording for a closed Browser Run session. */
 interface BrowserRecording {
@@ -228,7 +234,7 @@ type QuickActionExtractInput = QuickActionPage & {
   /** Natural-language instruction for what to extract. */ prompt?: string /** A JSON Schema describing the desired output shape. */;
   response_format?: {
     type: "json_schema";
-    schema: unknown;
+    json_schema: unknown;
   } /** Bring-your-own model(s), tried in order, for extraction. */;
   custom_ai?: {
     model: string;
@@ -432,6 +438,12 @@ interface BrowserConnectorSessionOptions {
    * {@link BrowserConnector.liveView}/`sessionInfo()`.
    */
   recording?: boolean;
+  /**
+   * Select the browser engine. Defaults to Chromium. Kitesurf is scoped to
+   * one CDP WebSocket, so it supports only one-shot execution without
+   * pause/resume, Live View, recording, or keep-alive.
+   */
+  browser?: "kitesurf";
 }
 type BrowserConnectorOptions = (
   | {
@@ -554,13 +566,14 @@ declare class BrowserConnector extends CodemodeConnector {
   );
   name(): string;
   protected instructions(): string;
+  protected tool(name: string, tool: ConnectorTool): ConnectorTool;
   protected tools(): ConnectorTools;
   /**
    * A pass is over (completed, errored, or paused awaiting approval) — drop
    * the CDP socket. The Browser Run session itself stays alive; a resume
    * reconnects from the durably stored session id.
    */
-  onPassEnd(executionId: string, _status: PassEndStatus): Promise<void>;
+  onPassEnd(executionId: string, status: PassEndStatus): Promise<void>;
   /**
    * The execution is terminal — delete its Browser Run session unless it was
    * promoted to the shared slot via `cdp.startSession()`.
@@ -597,6 +610,10 @@ declare class BrowserConnector extends CodemodeConnector {
    * deleted, so a later resume fails with a clear "session expired" error
    * instead of silently continuing in a fresh browser; tombstones are
    * deleted once they age past the threshold again.
+   *
+   * Kitesurf entries are reclaimed the same way, minus the Browser Run
+   * delete: their stored id is a synthetic per-execution marker, not a
+   * session, and the connection died with the execution.
    */
   sweep(
     options?: BrowserConnectorSweepOptions
@@ -656,4 +673,4 @@ export {
   QuickActionCommonOptions as y,
   BrowserSessionInfo as z
 };
-//# sourceMappingURL=connector-v2M1zlZp.d.ts.map
+//# sourceMappingURL=connector-CkQD4MK3.d.ts.map

package/dist/{connector-KEJnl6e5.js → connector-CptFKzRh.js}

@@ -1,6 +1,7 @@
 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 { CodemodeConnector } from "@cloudflare/codemode";
+import { Validator } from "@cfworker/json-schema";
 //#region src/browser/cdp-session.ts
 const DEFAULT_TIMEOUT_MS = 1e4;
 const MAX_DEBUG_ENTRIES = 400;
@@ -207,6 +208,7 @@ function browserSessionEndpoint(sessionId, options) {
 	if (options?.keepAliveMs !== void 0) url.searchParams.set("keep_alive", String(options.keepAliveMs));
 	if (options?.includeTargets) url.searchParams.set("targets", "true");
 	if (options?.recording) url.searchParams.set("recording", "true");
+	if (options?.browser) url.searchParams.set("browser", options.browser);
 	return url.toString();
 }
 async function parseBrowserSessionInfo(response) {
@@ -239,13 +241,20 @@ async function deleteBrowserSession(browser, sessionId) {
 */
 async function connectBrowser(browser, options) {
 	const normalizedOptions = typeof options === "number" ? { timeoutMs: options } : options ?? {};
+	const isKitesurf = normalizedOptions.browser === "kitesurf";
+	if (isKitesurf && (normalizedOptions.keepAliveMs || normalizedOptions.includeTargets || normalizedOptions.recording)) throw new Error("Kitesurf does not support keepAliveMs, includeTargets, or recording");
 	const response = await browser.fetch(browserSessionEndpoint(void 0, {
-		keepAliveMs: normalizedOptions.keepAliveMs,
+		keepAliveMs: isKitesurf ? void 0 : normalizedOptions.keepAliveMs,
 		includeTargets: normalizedOptions.includeTargets,
-		recording: normalizedOptions.recording
+		recording: normalizedOptions.recording,
+		browser: normalizedOptions.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.");
+	if (normalizedOptions.browser === "kitesurf") {
+		ws.accept();
+		return new CdpSession(ws, normalizedOptions.timeoutMs);
+	}
 	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();
@@ -495,6 +504,12 @@ const DEFAULT_SWEEP_IDLE_MS = 600 * 1e3;
 //#endregion
 //#region src/browser/connector.ts
 const EXEC_KEY_PREFIX = "cdp:exec:";
+/**
+* Prefix of the synthetic session id stored for a Kitesurf execution: the
+* connection is scoped to its execution, so the entry is a marker rather than
+* a Browser Run session that can be reconnected to or deleted.
+*/
+const KITESURF_SESSION_PREFIX = "kitesurf:";
 const REUSE_KEY_PREFIX = "cdp:reuse:";
 /**
 * Default idle window before {@link BrowserConnector.sweep} reclaims a
@@ -518,6 +533,13 @@ const LIVE_VIEW_URL_TTL_MS = 300 * 1e3;
 function isMissingBrowserSession(error) {
 	return error instanceof BrowserRenderingError && (error.status === 404 || error.status === 410);
 }
+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(";")}`;
+}
 /**
 * Rewrite the hosted Live View UI's `mode` query param (`tab` | `devtools`).
 * The raw `devtoolsFrontendUrl` is returned unchanged when no mode is asked
@@ -575,6 +597,11 @@ var BrowserConnector = class extends CodemodeConnector {
 		_classPrivateFieldInitSpec(this, _connecting, /* @__PURE__ */ new Map());
 		if (!options.cdpUrl && !options.browser) throw new Error("BrowserConnector requires either 'browser' (Fetcher binding) or 'cdpUrl'");
 		if (options.browser && !options.store) throw new Error("BrowserConnector requires 'store' when using the Browser Rendering binding");
+		if (options.session?.browser === "kitesurf") {
+			if (options.session.mode !== void 0 && options.session.mode !== "one-shot") throw new Error("Kitesurf only supports session mode \"one-shot\"");
+			if (options.session.keepAliveMs) throw new Error("Kitesurf does not support keepAliveMs");
+			if (options.session.recording) throw new Error("Kitesurf does not support session recording");
+		}
 		_classPrivateFieldSet2(_options, this, options);
 	}
 	name() {
@@ -584,21 +611,36 @@ var BrowserConnector = class extends CodemodeConnector {
 		const mode = _assertClassBrand(_BrowserConnector_brand, this, _mode).call(this);
 		const lines = [
 			"Issue CDP calls sequentially — never in parallel (no Promise.all): call order is recorded for durable replay.",
-			"Browser-/Target-scoped commands (Target.createTarget, Target.getTargets) need no sessionId. Page-scoped commands (Page.navigate, Runtime.evaluate) require one: `const { sessionId } = await cdp.attachToTarget({ targetId });` then pass it to every page-scoped send.",
-			"Write large outputs (screenshots, page dumps) to a file or workspace immediately and pass around small references — large return values fail to record.",
-			"Use cdp.spec() to discover commands, events, and types when unsure.",
-			"If a command fails or times out, check cdp.getDebugLog() for recent protocol traffic.",
-			"When a step needs a human (login, MFA, CAPTCHA, sensitive input), call cdp.getLiveViewUrl() to get a link they can open to control the browser live — surface it, then make an approval-gated call so the run pauses until they're done."
+			"cdp.send returns the CDP method result directly, not the outer JSON-RPC envelope: Target.createTarget returns { targetId }, Runtime.evaluate returns { result: { value } }, and Page.captureScreenshot returns { data }.",
+			"Browser-/Target-scoped commands (Target.createTarget, Target.getTargets) need no sessionId. Page-scoped commands (Page.navigate, Runtime.evaluate) require one: `const { sessionId } = await cdp.attachToTarget({ targetId });` then pass it to every page-scoped send. Use this helper instead of sending Target.attachToTarget manually.",
+			"Write large textual outputs such as page dumps to a file or workspace and pass around small references. For screenshots, follow the host tool's documented screenshot result format.",
+			"If a command fails or times out, check cdp.getDebugLog() for recent protocol traffic."
 		];
+		if (_assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this)) lines.push("Kitesurf implements a subset of CDP and does not expose protocol discovery.", "Kitesurf is scoped to this connection. Complete the whole browser task in one execution and do not pause for approval: the browser cannot reconnect when execution resumes.", "Kitesurf Page.navigate may resolve before layout and paint. Before a screenshot: call Page.enable; navigate; poll Runtime.evaluate with returnByValue: true until result.value reports document.readyState === 'complete' and non-empty body text; then wait 1000ms before Page.captureScreenshot. Do not capture if readiness fails.");
+		else lines.push("Use cdp.spec() to discover commands, events, and types when unsure.", "When a step needs a human (login, MFA, CAPTCHA, sensitive input), call cdp.getLiveViewUrl() to get a link they can open to control the browser live — surface it, then make an approval-gated call so the run pauses until they're done.");
 		if (mode === "one-shot") lines.push("The browser session lasts for this execution only and is closed when it ends.");
 		else if (mode === "reuse") lines.push("The browser session is shared and persists across executions — tabs and state you leave behind will still be there next time.");
 		else lines.push("The browser session is one-shot by default. If browser state must persist after this execution (e.g. a logged-in page), call cdp.startSession() to keep it alive for later executions.");
 		return lines.join("\n");
 	}
+	tool(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(this.name(), name, result.errors));
+				return await tool.execute(input, ctx);
+			}
+		};
+	}
 	tools() {
 		const tools = {
 			send: {
-				description: "Send a CDP command and return its result. Page-scoped commands require a sessionId — pass the handle returned by attachToTarget.",
+				description: "Send a CDP command and return its method result directly (the outer JSON-RPC envelope is removed). Page-scoped commands require a sessionId — pass the handle returned by attachToTarget.",
 				inputSchema: {
 					type: "object",
 					properties: {
@@ -641,7 +683,7 @@ var BrowserConnector = class extends CodemodeConnector {
 				}
 			},
 			attachToTarget: {
-				description: "Attach to a target (tab) and return { sessionId } — a stable session handle to pass as sessionId in page-scoped send calls. The handle stays valid across pauses/resumes.",
+				description: _assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this) ? "Attach to a target (tab) and return { sessionId } to pass to page-scoped send calls for this connection." : "Attach to a target (tab) and return { sessionId } — a stable session handle to pass as sessionId in page-scoped send calls. The handle stays valid across pauses/resumes.",
 				inputSchema: {
 					type: "object",
 					properties: {
@@ -657,7 +699,7 @@ var BrowserConnector = class extends CodemodeConnector {
 					type: "object",
 					properties: { sessionId: {
 						type: "string",
-						description: "Stable session handle for page-scoped send calls (valid across pauses/resumes)"
+						description: _assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this) ? "Session handle for page-scoped send calls on this connection" : "Stable session handle for page-scoped send calls (valid across pauses/resumes)"
 					} },
 					required: ["sessionId"]
 				},
@@ -675,7 +717,10 @@ var BrowserConnector = class extends CodemodeConnector {
 					type: "object",
 					properties: {}
 				},
-				execute: async () => loadCdpSpec(_classPrivateFieldGet2(_options, this))
+				execute: async () => {
+					if (_assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this)) throw new Error("Kitesurf does not expose a CDP protocol specification");
+					return loadCdpSpec(_classPrivateFieldGet2(_options, this));
+				}
 			},
 			getDebugLog: {
 				description: "Return recent CDP protocol traffic (sends, receives, warnings) for this execution's connection — useful to diagnose failures and timeouts.",
@@ -702,31 +747,32 @@ var BrowserConnector = class extends CodemodeConnector {
 					(await _assertClassBrand(_BrowserConnector_brand, this, _socket).call(this, _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx))).clearDebugLog();
 					return null;
 				}
-			},
-			getLiveViewUrl: {
-				description: "Return a Live View URL for a tab — a link a human can open in a browser to watch and control this session in real time. Use it for human-in-the-loop steps (login, MFA, CAPTCHA, sensitive input): get the URL, surface it to the user, then make a call that pauses for approval so they can act before the run continues. The URL is valid for ~5 minutes.",
-				replay: "reexecute",
-				inputSchema: {
-					type: "object",
-					properties: {
-						targetId: {
-							type: "string",
-							description: "Target (tab) id to view; defaults to the first open page"
-						},
-						mode: {
-							type: "string",
-							enum: ["tab", "devtools"],
-							description: "tab = standalone interactive page view (best for handoff); devtools = full DevTools inspector panel"
-						}
+			}
+		};
+		if (_assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this)) delete tools.spec;
+		else tools.getLiveViewUrl = {
+			description: "Return a Live View URL for a tab — a link a human can open in a browser to watch and control this session in real time. Use it for human-in-the-loop steps (login, MFA, CAPTCHA, sensitive input): get the URL, surface it to the user, then make a call that pauses for approval so they can act before the run continues. The URL is valid for ~5 minutes.",
+			replay: "reexecute",
+			inputSchema: {
+				type: "object",
+				properties: {
+					targetId: {
+						type: "string",
+						description: "Target (tab) id to view; defaults to the first open page"
+					},
+					mode: {
+						type: "string",
+						enum: ["tab", "devtools"],
+						description: "tab = standalone interactive page view (best for handoff); devtools = full DevTools inspector panel"
 					}
-				},
-				execute: async (args, ctx) => {
-					const { targetId, mode } = args ?? {};
-					return _assertClassBrand(_BrowserConnector_brand, this, _liveViewUrl).call(this, _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx), {
-						targetId,
-						mode
-					});
 				}
+			},
+			execute: async (args, ctx) => {
+				const { targetId, mode } = args ?? {};
+				return _assertClassBrand(_BrowserConnector_brand, this, _liveViewUrl).call(this, _assertClassBrand(_BrowserConnector_brand, this, _executionId).call(this, ctx), {
+					targetId,
+					mode
+				});
 			}
 		};
 		const mode = _assertClassBrand(_BrowserConnector_brand, this, _mode).call(this);
@@ -775,8 +821,20 @@ var BrowserConnector = class extends CodemodeConnector {
 	* the CDP socket. The Browser Run session itself stays alive; a resume
 	* reconnects from the durably stored session id.
 	*/
-	async onPassEnd(executionId, _status) {
+	async onPassEnd(executionId, status) {
 		_assertClassBrand(_BrowserConnector_brand, this, _dropSocket).call(this, executionId);
+		if (!_assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this) || status !== "paused") return;
+		const key = _assertClassBrand(_BrowserConnector_brand, this, _execKey).call(this, executionId);
+		const lock = await _get_store.call(_assertClassBrand(_BrowserConnector_brand, this)).acquireLock(key);
+		try {
+			const stored = await _get_store.call(_assertClassBrand(_BrowserConnector_brand, this)).get(key);
+			if (stored?.sessionId.startsWith(KITESURF_SESSION_PREFIX)) await _get_store.call(_assertClassBrand(_BrowserConnector_brand, this)).set(key, {
+				...stored,
+				closedAt: Date.now()
+			});
+		} finally {
+			await lock.release();
+		}
 	}
 	/**
 	* The execution is terminal — delete its Browser Run session unless it was
@@ -785,6 +843,24 @@ var BrowserConnector = class extends CodemodeConnector {
 	async disposeExecution(executionId, _status) {
 		_assertClassBrand(_BrowserConnector_brand, this, _dropSocket).call(this, executionId);
 		if (!_classPrivateFieldGet2(_options, this).browser) return;
+		if (_assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this)) {
+			const key = _assertClassBrand(_BrowserConnector_brand, this, _execKey).call(this, executionId);
+			const lock = await _get_store.call(_assertClassBrand(_BrowserConnector_brand, this)).acquireLock(key);
+			let stale;
+			try {
+				const stored = await _get_store.call(_assertClassBrand(_BrowserConnector_brand, this)).get(key);
+				if (stored && stored.closedAt === void 0 && !stored.sessionId.startsWith(KITESURF_SESSION_PREFIX)) stale = stored;
+				await _get_store.call(_assertClassBrand(_BrowserConnector_brand, this)).delete(key);
+			} finally {
+				await lock.release();
+			}
+			if (stale) try {
+				await deleteBrowserSession(_classPrivateFieldGet2(_options, this).browser, stale.sessionId);
+			} catch (error) {
+				console.warn(`[agents/browser] Failed to delete Browser Run session ${stale.sessionId} for execution ${executionId}`, error);
+			}
+			return;
+		}
 		const store = _classPrivateFieldGet2(_options, this).store;
 		const execKey = _assertClassBrand(_BrowserConnector_brand, this, _execKey).call(this, executionId);
 		const lock = await store.acquireLock(execKey);
@@ -807,7 +883,7 @@ var BrowserConnector = class extends CodemodeConnector {
 	}
 	/** Info about the shared (reuse/promoted) session, if one exists. */
 	async sessionInfo() {
-		if (!_classPrivateFieldGet2(_options, this).browser) return void 0;
+		if (!_classPrivateFieldGet2(_options, this).browser || _assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this)) return void 0;
 		const store = _classPrivateFieldGet2(_options, this).store;
 		const key = _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this);
 		const lock = await store.acquireLock(key);
@@ -858,7 +934,7 @@ var BrowserConnector = class extends CodemodeConnector {
 	}
 	/** Close the shared (reuse/promoted) session, if one exists. */
 	async closeSession() {
-		if (!_classPrivateFieldGet2(_options, this).browser) return;
+		if (!_classPrivateFieldGet2(_options, this).browser || _assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this)) return;
 		await _assertClassBrand(_BrowserConnector_brand, this, _closeStoredSession).call(this, _assertClassBrand(_BrowserConnector_brand, this, _reuseKey).call(this));
 	}
 	/**
@@ -873,9 +949,14 @@ var BrowserConnector = class extends CodemodeConnector {
 	* deleted, so a later resume fails with a clear "session expired" error
 	* instead of silently continuing in a fresh browser; tombstones are
 	* deleted once they age past the threshold again.
+	*
+	* Kitesurf entries are reclaimed the same way, minus the Browser Run
+	* delete: their stored id is a synthetic per-execution marker, not a
+	* session, and the connection died with the execution.
 	*/
 	async sweep(options) {
 		if (!_classPrivateFieldGet2(_options, this).browser) return { swept: [] };
+		const browser = _classPrivateFieldGet2(_options, this).browser;
 		const store = _classPrivateFieldGet2(_options, this).store;
 		const maxIdleMs = options?.maxIdleMs ?? _classPrivateFieldGet2(_options, this).session?.keepAliveMs ?? 6e5;
 		const maxExecIdleMs = options?.maxExecIdleMs ?? 864e5;
@@ -905,8 +986,8 @@ var BrowserConnector = class extends CodemodeConnector {
 			} finally {
 				await lock.release();
 			}
-			try {
-				await deleteBrowserSession(_classPrivateFieldGet2(_options, this).browser, toClose.sessionId);
+			if (!toClose.sessionId.startsWith(KITESURF_SESSION_PREFIX)) try {
+				await deleteBrowserSession(browser, toClose.sessionId);
 			} catch (error) {
 				console.warn(`[agents/browser] Sweep failed to delete Browser Run session ${toClose.sessionId}`, error);
 			}
@@ -918,6 +999,9 @@ var BrowserConnector = class extends CodemodeConnector {
 		return { swept };
 	}
 };
+function _isKitesurf() {
+	return _classPrivateFieldGet2(_options, this).session?.browser === "kitesurf";
+}
 function _mode() {
 	return _classPrivateFieldGet2(_options, this).session?.mode ?? "one-shot";
 }
@@ -964,6 +1048,7 @@ async function _liveTargets(executionId) {
 	}
 	const browser = _classPrivateFieldGet2(_options, this).browser;
 	if (!browser) throw new Error("BrowserConnector has no browser binding");
+	if (_assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this)) throw new Error("Kitesurf does not support Browser Run Live View");
 	await _assertClassBrand(_BrowserConnector_brand, this, _socket).call(this, executionId);
 	const sessionId = _classPrivateFieldGet2(_sockets, this).get(executionId)?.browserSessionId;
 	if (!sessionId) return [];
@@ -993,6 +1078,7 @@ async function _liveViewUrl(executionId, options) {
 */
 async function _isSpecEvent(method) {
 	try {
+		if (_assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this)) return false;
 		const spec = await loadCdpSpec(_classPrivateFieldGet2(_options, this));
 		const domain = method.split(".")[0];
 		return spec.domains.some((d) => d.name === domain && d.events.some((e) => e.event === method));
@@ -1036,6 +1122,38 @@ async function _socketInner(executionId) {
 	}
 	const browser = _classPrivateFieldGet2(_options, this).browser;
 	if (!browser) throw new Error("BrowserConnector has no browser binding");
+	if (_assertClassBrand(_BrowserConnector_brand, this, _isKitesurf).call(this)) {
+		const cached = _classPrivateFieldGet2(_sockets, this).get(executionId);
+		if (cached) return cached.session;
+		const key = _assertClassBrand(_BrowserConnector_brand, this, _execKey).call(this, executionId);
+		const lock = await _get_store.call(_assertClassBrand(_BrowserConnector_brand, this)).acquireLock(key);
+		try {
+			if (await _get_store.call(_assertClassBrand(_BrowserConnector_brand, this)).get(key)) throw new Error("Kitesurf's connection was closed and cannot be resumed; start a new execution");
+			const now = Date.now();
+			await _get_store.call(_assertClassBrand(_BrowserConnector_brand, this)).set(key, {
+				sessionId: `${KITESURF_SESSION_PREFIX}${crypto.randomUUID()}`,
+				createdAt: now,
+				updatedAt: now
+			});
+		} finally {
+			await lock.release();
+		}
+		try {
+			const session = await connectBrowser(browser, {
+				browser: "kitesurf",
+				timeoutMs: _classPrivateFieldGet2(_options, this).timeout
+			});
+			_classPrivateFieldGet2(_sockets, this).set(executionId, {
+				session,
+				attached: /* @__PURE__ */ new Map()
+			});
+			return session;
+		} catch (error) {
+			const failed = await _assertClassBrand(_BrowserConnector_brand, this, _readStored).call(this, key);
+			if (failed) await _assertClassBrand(_BrowserConnector_brand, this, _deleteStoredEntry).call(this, key, failed.sessionId);
+			throw error;
+		}
+	}
 	const stored = await _assertClassBrand(_BrowserConnector_brand, this, _resolveSession).call(this, executionId);
 	const cached = _classPrivateFieldGet2(_sockets, this).get(executionId);
 	if (cached?.browserSessionId === stored.sessionId) return cached.session;
@@ -1288,4 +1406,4 @@ async function _closeStoredSession(key) {
 //#endregion
 export { connectUrl as C, CdpSession as S, connectBrowserSession as _, loadCdpSpec as a, getBrowserRecording as b, browserLinks as c, browserScrape as d, browserScreenshot as f, connectBrowser as g, BrowserRenderingError as h, DurableBrowserSessionStore as i, browserMarkdown as l, runQuickAction as m, DEFAULT_EXEC_SWEEP_IDLE_MS as n, browserContent as o, browserSnapshot as p, DEFAULT_SWEEP_IDLE_MS as r, browserExtract as s, BrowserConnector as t, browserPdf as u, createBrowserSession as v, listBrowserTargets as x, deleteBrowserSession as y };
 
-//# sourceMappingURL=connector-KEJnl6e5.js.map
+//# sourceMappingURL=connector-CptFKzRh.js.map