agents 0.24.0 → 0.26.0

package/dist/browser/index.js

@@ -1,3 +1,362 @@
-import { C as connectUrl, S as CdpSession, _ as connectBrowserSession, a as loadCdpSpec, b as getBrowserRecording, c as browserLinks, d as browserScrape, f as browserScreenshot, g as connectBrowser, h as BrowserRenderingError, i as DurableBrowserSessionStore, l as browserMarkdown, m as runQuickAction, n as DEFAULT_EXEC_SWEEP_IDLE_MS, o as browserContent, p as browserSnapshot, r as DEFAULT_SWEEP_IDLE_MS, s as browserExtract, t as BrowserConnector, u as browserPdf, v as createBrowserSession, x as listBrowserTargets, y as deleteBrowserSession } from "../connector-CptFKzRh.js";
+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 { t as LifecycleCapability } from "../capability-B4WbF81e.js";
+import { C as listBrowserTargets, D as CdpSession, O as connectUrl, S as isMissingBrowserSession, T as CdpConnection, _ as connectBrowser, a as loadCdpSpec, b as deleteBrowserSession, c as browserExtract, d as browserPdf, f as browserScrape, g as BrowserRenderingError, h as runQuickAction, i as DurableBrowserSessionStore, l as browserLinks, m as browserSnapshot, n as DEFAULT_EXEC_SWEEP_IDLE_MS, o as createLiveView, p as browserScreenshot, r as DEFAULT_SWEEP_IDLE_MS, s as browserContent, t as BrowserConnector, u as browserMarkdown, v as connectBrowserSession, x as getBrowserRecording, y as createBrowserSession } from "../connector-58XDGvc3.js";
 import { CodemodeRuntime } from "@cloudflare/codemode";
-export { BrowserConnector, BrowserRenderingError, CdpSession, CodemodeRuntime, DEFAULT_EXEC_SWEEP_IDLE_MS, DEFAULT_SWEEP_IDLE_MS, DurableBrowserSessionStore, browserContent, browserExtract, browserLinks, browserMarkdown, browserPdf, browserScrape, browserScreenshot, browserSnapshot, connectBrowser, connectBrowserSession, connectUrl, createBrowserSession, deleteBrowserSession, getBrowserRecording, listBrowserTargets, loadCdpSpec, runQuickAction };
+const NAMED_SESSION_KEY_PREFIX = "browser:session:";
+/** The store key holding the named browser's current record. */
+function namedBrowserSessionKey(name) {
+	return `${NAMED_SESSION_KEY_PREFIX}${name}`;
+}
+/**
+* Where a closed or lost browser's record moves: permanent evidence that the
+* name once owned a browser, so a later resolve reports `restarted: true`.
+* Kept outside {@link NAMED_SESSION_KEY_PREFIX} so listing that prefix
+* yields only names that currently own a browser. Grows with the number of
+* distinct names the host has ever used.
+*/
+const RETIRED_SESSION_KEY_PREFIX = "browser:retired:";
+function retiredBrowserSessionKey(name) {
+	return `${RETIRED_SESSION_KEY_PREFIX}${name}`;
+}
+/**
+* Run the browser on Cloudflare Browser Run.
+*
+* @example
+* ```ts
+* new Browser({ provider: browserRun(env.BROWSER, { recording: true }) });
+* ```
+*/
+function browserRun(binding, options = {}) {
+	return {
+		kind: "browser-run",
+		binding,
+		options
+	};
+}
+var _options = /* @__PURE__ */ new WeakMap();
+var _key = /* @__PURE__ */ new WeakMap();
+var _store = /* @__PURE__ */ new WeakMap();
+var _Browser_brand = /* @__PURE__ */ new WeakSet();
+/**
+* One named, persistent browser.
+*
+* Install it with `Lifecycle.use()` — on an Agent subclass or any Durable
+* Object that composes `Lifecycle` — and it stores its record in the
+* object's own storage. It schedules nothing: Browser Run reclaims idle
+* browsers itself once `keep_alive` elapses, and the next use replaces the
+* lost browser with `restarted: true`.
+*
+* Everything here is host-side. Models never see browser names, Browser Run
+* ids, or Live View URLs through this surface.
+*
+* Store discipline: locks wrap storage operations only — liveness probes and
+* Browser Run create/delete calls always happen outside any lock, with a
+* commit re-check to detect concurrent swaps.
+*
+* @experimental The API surface may change before stabilizing.
+*/
+var Browser = class extends LifecycleCapability {
+	constructor(options) {
+		const name = options.name ?? "default";
+		super(`browser:${name}`);
+		_classPrivateMethodInitSpec(this, _Browser_brand);
+		_classPrivateFieldInitSpec(this, _options, void 0);
+		_classPrivateFieldInitSpec(this, _key, void 0);
+		_classPrivateFieldInitSpec(this, _store, void 0);
+		if (name.trim() === "") throw new Error("Browser names must be non-empty");
+		this.name = name;
+		_classPrivateFieldSet2(_options, this, options);
+		_classPrivateFieldSet2(_key, this, namedBrowserSessionKey(name));
+	}
+	/**
+	* Reattach to the browser when it is still alive, otherwise create a fresh
+	* one. See {@link ResolvedBrowser.restarted} for the mortality signal.
+	*/
+	async resolve() {
+		const { name } = this;
+		const key = _classPrivateFieldGet2(_key, this);
+		for (let attempt = 0; attempt < 4; attempt++) {
+			const existing = await _assertClassBrand(_Browser_brand, this, _readStored).call(this);
+			if (existing === void 0) {
+				const { session, restarted } = await _assertClassBrand(_Browser_brand, this, _createAndCommit).call(this);
+				return {
+					name,
+					restarted,
+					...session
+				};
+			}
+			const alive = await _assertClassBrand(_Browser_brand, this, _isAlive).call(this, existing);
+			const lock = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).acquireLock(key);
+			try {
+				const current = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).get(key);
+				if (current?.sessionId !== existing.sessionId) continue;
+				if (alive) {
+					const refreshed = {
+						...current,
+						updatedAt: Date.now()
+					};
+					await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).set(key, refreshed);
+					return {
+						name,
+						restarted: false,
+						...refreshed
+					};
+				}
+				await _assertClassBrand(_Browser_brand, this, _retire).call(this, current);
+			} finally {
+				await lock.release();
+			}
+		}
+		throw new Error(`Browser "${name}" kept changing concurrently — retry`);
+	}
+	/**
+	* Resolve the browser and open a CDP connection to it. Commands sent over
+	* the connection refresh the record's `updatedAt` (throttled to
+	* {@link SESSION_TOUCH_INTERVAL_MS}), so hosts can tell an actively used
+	* browser from one the platform has likely reclaimed.
+	*
+	* If the browser expires between the liveness probe and the WebSocket
+	* upgrade, the record is retired and the browser resolved once more, so
+	* the caller gets a fresh browser with `restarted: true` instead of an
+	* error.
+	*/
+	async connect() {
+		const resolved = await this.resolve();
+		try {
+			return await _assertClassBrand(_Browser_brand, this, _attach).call(this, resolved);
+		} catch (error) {
+			if (!isMissingBrowserSession(error)) throw error;
+			await _assertClassBrand(_Browser_brand, this, _retireIfCurrent).call(this, resolved.sessionId);
+		}
+		const replaced = await this.resolve();
+		return _assertClassBrand(_Browser_brand, this, _attach).call(this, {
+			...replaced,
+			restarted: true
+		});
+	}
+	/**
+	* Close the browser: retire the record (so the next resolve reports
+	* `restarted: true`) and delete its Browser Run session. Returns `false`
+	* when there was nothing to close.
+	*
+	* The platform delete is best-effort: the retired record is the durable
+	* outcome, and a browser whose delete failed is unreachable through this
+	* store, so the pinned `keep_alive` (≤600s) reclaims it.
+	*/
+	async close() {
+		let stored;
+		const lock = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).acquireLock(_classPrivateFieldGet2(_key, this));
+		try {
+			const current = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).get(_classPrivateFieldGet2(_key, this));
+			if (!current) return false;
+			stored = current;
+			await _assertClassBrand(_Browser_brand, this, _retire).call(this, current);
+		} finally {
+			await lock.release();
+		}
+		try {
+			await deleteBrowserSession(_get_provider.call(_assertClassBrand(_Browser_brand, this)).binding, stored.sessionId);
+		} catch (error) {
+			console.warn(`[agents/browser] Failed to delete closed Browser Run session ${stored.sessionId}`, error);
+		}
+		return true;
+	}
+	/**
+	* Mint Live View URLs for the browser's open tabs, fresh from a target
+	* listing. `undefined` when the browser was never created, is closed, or
+	* is gone. The URLs are bearer credentials with a short connect window
+	* (~5 min) — hand them to a trusted human, never to the model, and never
+	* store them: re-mint instead.
+	*/
+	async liveView(options) {
+		const entry = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).get(_classPrivateFieldGet2(_key, this));
+		if (!entry) return void 0;
+		try {
+			const targets = await listBrowserTargets(_get_provider.call(_assertClassBrand(_Browser_brand, this)).binding, entry.sessionId);
+			try {
+				if (!await _assertClassBrand(_Browser_brand, this, _touch).call(this, entry.sessionId)) return void 0;
+			} catch (error) {
+				console.warn(`[agents/browser] Failed to refresh activity for browser "${this.name}"`, error);
+			}
+			return createLiveView(entry.sessionId, targets, options?.mode);
+		} catch (error) {
+			if (isMissingBrowserSession(error)) return void 0;
+			throw error;
+		}
+	}
+};
+async function _attach(resolved) {
+	let lastTouchAt = Date.now();
+	let touchInFlight = false;
+	const cdp = await connectBrowserSession(_get_provider.call(_assertClassBrand(_Browser_brand, this)).binding, resolved.sessionId, {
+		timeoutMs: _classPrivateFieldGet2(_options, this).timeoutMs,
+		onActivity: () => {
+			const now = Date.now();
+			if (touchInFlight || now - lastTouchAt < _get_touchIntervalMs.call(_assertClassBrand(_Browser_brand, this))) return;
+			touchInFlight = true;
+			lastTouchAt = now;
+			_assertClassBrand(_Browser_brand, this, _touch).call(this, resolved.sessionId).catch((error) => {
+				console.warn(`[agents/browser] Failed to refresh activity for browser "${this.name}"`, error);
+			}).finally(() => {
+				touchInFlight = false;
+			});
+		}
+	});
+	const { binding } = _get_provider.call(_assertClassBrand(_Browser_brand, this));
+	return {
+		name: resolved.name,
+		sessionId: resolved.sessionId,
+		restarted: resolved.restarted,
+		activeTargetId: resolved.activeTargetId,
+		cdp,
+		setActiveTarget: (targetId) => _assertClassBrand(_Browser_brand, this, _update).call(this, resolved.sessionId, (current) => ({
+			...current,
+			activeTargetId: targetId,
+			updatedAt: Date.now()
+		})),
+		spec: () => loadCdpSpec({
+			browser: binding,
+			sessionId: resolved.sessionId
+		})
+	};
+}
+function _get_provider() {
+	return _classPrivateFieldGet2(_options, this).provider;
+}
+/** The platform `keep_alive` every create applies. */
+function _get_keepAliveMs() {
+	return _get_provider.call(_assertClassBrand(_Browser_brand, this)).options.keepAliveMs ?? 6e5;
+}
+/**
+* Capped at half the keep-alive window: a browser with continuous CDP
+* traffic must never look older than the window the platform uses to
+* reclaim it.
+*/
+function _get_touchIntervalMs() {
+	return Math.min(_classPrivateFieldGet2(_options, this).touchIntervalMs ?? 6e4, Math.floor(_get_keepAliveMs.call(_assertClassBrand(_Browser_brand, this)) / 2));
+}
+/** Lazy: `lifecycle.storage` exists only once `Lifecycle.use()` ran. */
+function _get_sessionStore() {
+	_classPrivateFieldGet2(_store, this) ?? _classPrivateFieldSet2(_store, this, _classPrivateFieldGet2(_options, this).store ?? new DurableBrowserSessionStore(this.lifecycle.storage));
+	return _classPrivateFieldGet2(_store, this);
+}
+/**
+* Refresh `updatedAt` while the record still holds `sessionId`. Returns
+* false when a concurrent close or replacement already retired it.
+*/
+function _touch(sessionId) {
+	return _assertClassBrand(_Browser_brand, this, _update).call(this, sessionId, (current) => ({
+		...current,
+		updatedAt: Date.now()
+	}));
+}
+/**
+* Rewrite the record only while it still holds `sessionId`: a replaced or
+* retired record is never resurrected.
+*/
+async function _update(sessionId, change) {
+	const lock = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).acquireLock(_classPrivateFieldGet2(_key, this));
+	try {
+		const current = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).get(_classPrivateFieldGet2(_key, this));
+		if (current?.sessionId !== sessionId) return false;
+		await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).set(_classPrivateFieldGet2(_key, this), change(current));
+		return true;
+	} finally {
+		await lock.release();
+	}
+}
+/** Retire the record if it still holds `sessionId`. */
+async function _retireIfCurrent(sessionId) {
+	const lock = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).acquireLock(_classPrivateFieldGet2(_key, this));
+	try {
+		const current = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).get(_classPrivateFieldGet2(_key, this));
+		if (current?.sessionId === sessionId) await _assertClassBrand(_Browser_brand, this, _retire).call(this, current);
+	} finally {
+		await lock.release();
+	}
+}
+/**
+* Move the record to its retired marker. Callers hold the key lock, so a
+* resolver always sees either the record or the marker.
+*/
+async function _retire(current) {
+	await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).set(retiredBrowserSessionKey(this.name), {
+		...current,
+		closedAt: Date.now()
+	});
+	await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).delete(_classPrivateFieldGet2(_key, this));
+}
+/**
+* Create a Browser Run session (outside any lock) and commit it, applying
+* the provider's creation options. If a concurrent caller committed an
+* entry first, theirs wins and the redundant session is deleted
+* best-effort.
+*
+* `restarted` is read under the commit lock: a retired marker — left by
+* close() or a dead-browser recovery — is evidence a prior browser
+* existed, and only first-ever use of the name is not a restart. Markers
+* are permanent, so reading at commit time also catches a browser that
+* was created and closed while this create was in flight.
+*/
+async function _createAndCommit() {
+	const { binding, options } = _get_provider.call(_assertClassBrand(_Browser_brand, this));
+	const info = await createBrowserSession(binding, {
+		keepAliveMs: _get_keepAliveMs.call(_assertClassBrand(_Browser_brand, this)),
+		recording: options.recording,
+		guardrails: options.guardrails
+	});
+	const now = Date.now();
+	const stored = {
+		sessionId: info.sessionId,
+		createdAt: now,
+		updatedAt: now
+	};
+	let winner;
+	let restarted;
+	const lock = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).acquireLock(_classPrivateFieldGet2(_key, this));
+	try {
+		restarted = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).get(retiredBrowserSessionKey(this.name)) !== void 0;
+		const current = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).get(_classPrivateFieldGet2(_key, this));
+		if (current === void 0) await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).set(_classPrivateFieldGet2(_key, this), stored);
+		else winner = current;
+	} finally {
+		await lock.release();
+	}
+	if (winner) {
+		try {
+			await deleteBrowserSession(binding, stored.sessionId);
+		} catch (error) {
+			console.warn(`[agents/browser] Failed to delete redundant Browser Run session ${stored.sessionId}`, error);
+		}
+		return {
+			session: winner,
+			restarted
+		};
+	}
+	return {
+		session: stored,
+		restarted
+	};
+}
+async function _isAlive(stored) {
+	try {
+		await listBrowserTargets(_get_provider.call(_assertClassBrand(_Browser_brand, this)).binding, stored.sessionId);
+		return true;
+	} catch (error) {
+		if (isMissingBrowserSession(error)) return false;
+		throw error;
+	}
+}
+async function _readStored() {
+	const lock = await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).acquireLock(_classPrivateFieldGet2(_key, this));
+	try {
+		return await _get_sessionStore.call(_assertClassBrand(_Browser_brand, this)).get(_classPrivateFieldGet2(_key, this));
+	} finally {
+		await lock.release();
+	}
+}
+//#endregion
+export { Browser, BrowserConnector, BrowserRenderingError, CdpConnection, CdpSession, CodemodeRuntime, DEFAULT_EXEC_SWEEP_IDLE_MS, DEFAULT_SWEEP_IDLE_MS, DurableBrowserSessionStore, browserContent, browserExtract, browserLinks, browserMarkdown, browserPdf, browserRun, browserScrape, browserScreenshot, browserSnapshot, connectBrowser, connectBrowserSession, connectUrl, createBrowserSession, deleteBrowserSession, getBrowserRecording, listBrowserTargets, loadCdpSpec, runQuickAction };
+
+//# sourceMappingURL=index.js.map

package/dist/browser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/browser/browser.ts"],"sourcesContent":["/**\n * `Browser`: one named, persistent browser for an agent or Durable Object.\n *\n * Its tabs and logins survive between agent runs. When the browser is lost\n * (closed, idle past `keep_alive`, or crashed), the next use starts a fresh\n * one and reports `restarted: true` so the model knows its earlier state is\n * gone.\n *\n * Browser Run is the only provider today; see {@link browserRun}.\n */\n\nimport { LifecycleCapability } from \"../lifecycle/capability\";\nimport type { CdpConnection } from \"./cdp-connection\";\nimport {\n  type BrowserBinding,\n  type BrowserSessionGuardrails,\n  connectBrowserSession,\n  createBrowserSession,\n  deleteBrowserSession,\n  isMissingBrowserSession,\n  listBrowserTargets\n} from \"./browser-run\";\nimport {\n  createLiveView,\n  type BrowserLiveView,\n  type LiveViewMode\n} from \"./live-view\";\nimport {\n  DurableBrowserSessionStore,\n  type BrowserSessionStore,\n  type StoredBrowserSession\n} from \"./session-store\";\nimport { loadCdpSpec, type SearchableCdpSpec } from \"./spec\";\n\n/**\n * Browser Run's server-side `keep_alive` maximum (600 seconds). A `Browser`\n * pins keep-alive here by default so it survives quiet spells between agent\n * turns; the platform reclaims it only after this long idle.\n */\nexport const BROWSER_SESSION_KEEP_ALIVE_MAX_MS = 600_000;\n\n/**\n * Minimum interval between store `updatedAt` refreshes driven by CDP traffic\n * on connections returned by {@link Browser.connect}.\n */\nexport const SESSION_TOUCH_INTERVAL_MS = 60_000;\n\n/** The browser name used when a host doesn't pick one. */\nexport const DEFAULT_BROWSER_NAME = \"default\";\n\nconst NAMED_SESSION_KEY_PREFIX = \"browser:session:\";\n\n/** The store key holding the named browser's current record. */\nexport function namedBrowserSessionKey(name: string): string {\n  return `${NAMED_SESSION_KEY_PREFIX}${name}`;\n}\n\n/**\n * Where a closed or lost browser's record moves: permanent evidence that the\n * name once owned a browser, so a later resolve reports `restarted: true`.\n * Kept outside {@link NAMED_SESSION_KEY_PREFIX} so listing that prefix\n * yields only names that currently own a browser. Grows with the number of\n * distinct names the host has ever used.\n */\nconst RETIRED_SESSION_KEY_PREFIX = \"browser:retired:\";\n\nfunction retiredBrowserSessionKey(name: string): string {\n  return `${RETIRED_SESSION_KEY_PREFIX}${name}`;\n}\n\n/**\n * Browser Run settings applied every time a browser is created — including\n * when a lost browser is replaced — so options like guardrails survive a\n * restart.\n */\nexport interface BrowserRunOptions {\n  /**\n   * Platform `keep_alive` in milliseconds: how long an idle browser lives.\n   * Defaults to {@link BROWSER_SESSION_KEEP_ALIVE_MAX_MS} (the platform\n   * maximum).\n   */\n  keepAliveMs?: number;\n  /** Opt into Browser Run session recording (rrweb capture). */\n  recording?: boolean;\n  /** Hostname guardrails, fixed at launch for every connection. */\n  guardrails?: BrowserSessionGuardrails;\n}\n\n/** A {@link Browser} provider backed by Cloudflare Browser Run. */\nexport interface BrowserRunProvider {\n  readonly kind: \"browser-run\";\n  readonly binding: BrowserBinding;\n  readonly options: BrowserRunOptions;\n}\n\n/** Where a {@link Browser} gets its browser from. */\nexport type BrowserProvider = BrowserRunProvider;\n\n/**\n * Run the browser on Cloudflare Browser Run.\n *\n * @example\n * ```ts\n * new Browser({ provider: browserRun(env.BROWSER, { recording: true }) });\n * ```\n */\nexport function browserRun(\n  binding: BrowserBinding,\n  options: BrowserRunOptions = {}\n): BrowserRunProvider {\n  return { kind: \"browser-run\", binding, options };\n}\n\nexport interface BrowserOptions {\n  /** Where the browser runs. Create one with {@link browserRun}. */\n  provider: BrowserProvider;\n  /**\n   * Which browser this is. Two `Browser` objects on the same Durable Object\n   * need different names. Defaults to {@link DEFAULT_BROWSER_NAME}.\n   */\n  name?: string;\n  /**\n   * Where the browser's record lives. Defaults to a\n   * {@link DurableBrowserSessionStore} over the host object's storage, which\n   * requires installing the `Browser` with `Lifecycle.use()`. Passing a store\n   * lets the `Browser` work without Lifecycle.\n   */\n  store?: BrowserSessionStore;\n  /** Default CDP command timeout for {@link Browser.connect}. */\n  timeoutMs?: number;\n  /**\n   * Minimum interval between activity-driven `updatedAt` refreshes.\n   * Defaults to {@link SESSION_TOUCH_INTERVAL_MS}, capped at half the\n   * keep-alive window.\n   *\n   * @internal For tests.\n   */\n  touchIntervalMs?: number;\n}\n\nexport interface ResolvedBrowser {\n  name: string;\n  /** The Browser Run session id — host-side only, never model-visible. */\n  sessionId: string;\n  /**\n   * `true` when this resolution had to create a fresh browser to replace one\n   * that previously existed (was closed, or expired or died upstream). Page\n   * state from the prior browser is gone; surface this loudly to the model.\n   * `false` only on first-ever use of the name — nothing was lost.\n   */\n  restarted: boolean;\n  createdAt: number;\n  updatedAt: number;\n  /**\n   * The tab the agent last worked in, when one was recorded for this\n   * browser. Absent on a browser this resolution created; a replacement a\n   * concurrent caller already created and used may carry one.\n   */\n  activeTargetId?: string;\n}\n\nexport interface BrowserConnection {\n  name: string;\n  sessionId: string;\n  /**\n   * `true` when the browser this caller resolved is gone, even if a\n   * concurrent caller already replaced it. See\n   * {@link ResolvedBrowser.restarted}.\n   */\n  restarted: boolean;\n  /** See {@link ResolvedBrowser.activeTargetId}. */\n  activeTargetId?: string;\n  /** Closing this connection does NOT close the browser. */\n  cdp: CdpConnection;\n  /**\n   * Record the tab the agent is working in (or clear it with `undefined`).\n   * Never resurrects: returns `false` when the browser was closed or\n   * replaced since this connection resolved it.\n   */\n  setActiveTarget(targetId: string | undefined): Promise<boolean>;\n  /**\n   * The Chrome DevTools Protocol description this browser serves, read from\n   * the browser itself (cached per binding).\n   */\n  spec(): Promise<SearchableCdpSpec>;\n}\n\n/**\n * One named, persistent browser.\n *\n * Install it with `Lifecycle.use()` — on an Agent subclass or any Durable\n * Object that composes `Lifecycle` — and it stores its record in the\n * object's own storage. It schedules nothing: Browser Run reclaims idle\n * browsers itself once `keep_alive` elapses, and the next use replaces the\n * lost browser with `restarted: true`.\n *\n * Everything here is host-side. Models never see browser names, Browser Run\n * ids, or Live View URLs through this surface.\n *\n * Store discipline: locks wrap storage operations only — liveness probes and\n * Browser Run create/delete calls always happen outside any lock, with a\n * commit re-check to detect concurrent swaps.\n *\n * @experimental The API surface may change before stabilizing.\n */\nexport class Browser extends LifecycleCapability {\n  /** Which browser this is; see {@link BrowserOptions.name}. */\n  readonly name: string;\n  readonly #options: BrowserOptions;\n  readonly #key: string;\n  #store?: BrowserSessionStore;\n\n  constructor(options: BrowserOptions) {\n    const name = options.name ?? DEFAULT_BROWSER_NAME;\n    super(`browser:${name}`);\n    if (name.trim() === \"\") {\n      throw new Error(\"Browser names must be non-empty\");\n    }\n    this.name = name;\n    this.#options = options;\n    this.#key = namedBrowserSessionKey(name);\n  }\n\n  /**\n   * Reattach to the browser when it is still alive, otherwise create a fresh\n   * one. See {@link ResolvedBrowser.restarted} for the mortality signal.\n   */\n  async resolve(): Promise<ResolvedBrowser> {\n    const { name } = this;\n    const key = this.#key;\n\n    // Dead-browser recovery consumes two attempts (retire, then create).\n    for (let attempt = 0; attempt < 4; attempt++) {\n      const existing = await this.#readStored();\n\n      if (existing === undefined) {\n        // No browser on record: create one. The commit reports whether the\n        // name was ever used before (see #createAndCommit).\n        const { session, restarted } = await this.#createAndCommit();\n        return { name, restarted, ...session };\n      }\n\n      // Live entry on record — probe it outside any lock.\n      const alive = await this.#isAlive(existing);\n      const lock = await this.#sessionStore.acquireLock(key);\n      try {\n        const current = await this.#sessionStore.get(key);\n        if (current?.sessionId !== existing.sessionId) {\n          continue; // swapped or retired while we probed — revalidate\n        }\n        if (alive) {\n          const refreshed = { ...current, updatedAt: Date.now() };\n          await this.#sessionStore.set(key, refreshed);\n          return { name, restarted: false, ...refreshed };\n        }\n        // The browser died upstream (expired or reclaimed). Retire the\n        // record under this lock, so any resolver that reads it during the\n        // replacement window sees the marker and reports restarted: true\n        // too.\n        await this.#retire(current);\n      } finally {\n        await lock.release();\n      }\n      // Re-enter the loop: the next attempt takes the create path.\n    }\n\n    throw new Error(`Browser \"${name}\" kept changing concurrently — retry`);\n  }\n\n  /**\n   * Resolve the browser and open a CDP connection to it. Commands sent over\n   * the connection refresh the record's `updatedAt` (throttled to\n   * {@link SESSION_TOUCH_INTERVAL_MS}), so hosts can tell an actively used\n   * browser from one the platform has likely reclaimed.\n   *\n   * If the browser expires between the liveness probe and the WebSocket\n   * upgrade, the record is retired and the browser resolved once more, so\n   * the caller gets a fresh browser with `restarted: true` instead of an\n   * error.\n   */\n  async connect(): Promise<BrowserConnection> {\n    const resolved = await this.resolve();\n    try {\n      return await this.#attach(resolved);\n    } catch (error) {\n      if (!isMissingBrowserSession(error)) throw error;\n      await this.#retireIfCurrent(resolved.sessionId);\n    }\n    // The browser this caller resolved is gone, so report a restart even\n    // when a concurrent resolver already replaced it and this resolve\n    // reattaches to that replacement.\n    const replaced = await this.resolve();\n    return this.#attach({ ...replaced, restarted: true });\n  }\n\n  async #attach(resolved: ResolvedBrowser): Promise<BrowserConnection> {\n    let lastTouchAt = Date.now();\n    let touchInFlight = false;\n    const cdp = await connectBrowserSession(\n      this.#provider.binding,\n      resolved.sessionId,\n      {\n        timeoutMs: this.#options.timeoutMs,\n        onActivity: () => {\n          const now = Date.now();\n          if (touchInFlight || now - lastTouchAt < this.#touchIntervalMs) {\n            return;\n          }\n          touchInFlight = true;\n          lastTouchAt = now;\n          void this.#touch(resolved.sessionId)\n            .catch((error: unknown) => {\n              console.warn(\n                `[agents/browser] Failed to refresh activity for browser \"${this.name}\"`,\n                error\n              );\n            })\n            .finally(() => {\n              touchInFlight = false;\n            });\n        }\n      }\n    );\n    const { binding } = this.#provider;\n    return {\n      name: resolved.name,\n      sessionId: resolved.sessionId,\n      restarted: resolved.restarted,\n      activeTargetId: resolved.activeTargetId,\n      cdp,\n      setActiveTarget: (targetId) =>\n        this.#update(resolved.sessionId, (current) => ({\n          ...current,\n          activeTargetId: targetId,\n          updatedAt: Date.now()\n        })),\n      spec: () =>\n        loadCdpSpec({ browser: binding, sessionId: resolved.sessionId })\n    };\n  }\n\n  /**\n   * Close the browser: retire the record (so the next resolve reports\n   * `restarted: true`) and delete its Browser Run session. Returns `false`\n   * when there was nothing to close.\n   *\n   * The platform delete is best-effort: the retired record is the durable\n   * outcome, and a browser whose delete failed is unreachable through this\n   * store, so the pinned `keep_alive` (≤600s) reclaims it.\n   */\n  async close(): Promise<boolean> {\n    let stored: StoredBrowserSession | undefined;\n    const lock = await this.#sessionStore.acquireLock(this.#key);\n    try {\n      const current = await this.#sessionStore.get(this.#key);\n      if (!current) return false;\n      stored = current;\n      await this.#retire(current);\n    } finally {\n      await lock.release();\n    }\n    try {\n      await deleteBrowserSession(this.#provider.binding, stored.sessionId);\n    } catch (error) {\n      console.warn(\n        `[agents/browser] Failed to delete closed Browser Run session ${stored.sessionId}`,\n        error\n      );\n    }\n    return true;\n  }\n\n  /**\n   * Mint Live View URLs for the browser's open tabs, fresh from a target\n   * listing. `undefined` when the browser was never created, is closed, or\n   * is gone. The URLs are bearer credentials with a short connect window\n   * (~5 min) — hand them to a trusted human, never to the model, and never\n   * store them: re-mint instead.\n   */\n  async liveView(options?: {\n    mode?: LiveViewMode;\n  }): Promise<BrowserLiveView | undefined> {\n    const entry = await this.#sessionStore.get(this.#key);\n    if (!entry) return undefined;\n    try {\n      const targets = await listBrowserTargets(\n        this.#provider.binding,\n        entry.sessionId\n      );\n      // A human is about to look: minting counts as activity. Target\n      // listing yields to the network, so a concurrent close or replacement\n      // can retire the browser mid-mint — the touch and the retire\n      // serialize on the key lock, and a lost touch means the listed\n      // targets are already dead: report the browser gone rather than\n      // minting doomed links. Touch *errors* stay best effort — a store\n      // blip must not break minting.\n      try {\n        if (!(await this.#touch(entry.sessionId))) return undefined;\n      } catch (error) {\n        console.warn(\n          `[agents/browser] Failed to refresh activity for browser \"${this.name}\"`,\n          error\n        );\n      }\n      return createLiveView(entry.sessionId, targets, options?.mode);\n    } catch (error) {\n      if (isMissingBrowserSession(error)) return undefined;\n      throw error;\n    }\n  }\n\n  // ── Internals ────────────────────────────────────────────────────────────\n\n  get #provider(): BrowserRunProvider {\n    return this.#options.provider;\n  }\n\n  /** The platform `keep_alive` every create applies. */\n  get #keepAliveMs(): number {\n    return (\n      this.#provider.options.keepAliveMs ?? BROWSER_SESSION_KEEP_ALIVE_MAX_MS\n    );\n  }\n\n  /**\n   * Capped at half the keep-alive window: a browser with continuous CDP\n   * traffic must never look older than the window the platform uses to\n   * reclaim it.\n   */\n  get #touchIntervalMs(): number {\n    return Math.min(\n      this.#options.touchIntervalMs ?? SESSION_TOUCH_INTERVAL_MS,\n      Math.floor(this.#keepAliveMs / 2)\n    );\n  }\n\n  /** Lazy: `lifecycle.storage` exists only once `Lifecycle.use()` ran. */\n  get #sessionStore(): BrowserSessionStore {\n    this.#store ??=\n      this.#options.store ??\n      new DurableBrowserSessionStore(this.lifecycle.storage);\n    return this.#store;\n  }\n\n  /**\n   * Refresh `updatedAt` while the record still holds `sessionId`. Returns\n   * false when a concurrent close or replacement already retired it.\n   */\n  #touch(sessionId: string): Promise<boolean> {\n    return this.#update(sessionId, (current) => ({\n      ...current,\n      updatedAt: Date.now()\n    }));\n  }\n\n  /**\n   * Rewrite the record only while it still holds `sessionId`: a replaced or\n   * retired record is never resurrected.\n   */\n  async #update(\n    sessionId: string,\n    change: (current: StoredBrowserSession) => StoredBrowserSession\n  ): Promise<boolean> {\n    const lock = await this.#sessionStore.acquireLock(this.#key);\n    try {\n      const current = await this.#sessionStore.get(this.#key);\n      if (current?.sessionId !== sessionId) {\n        return false; // replaced or gone — the caller's view is stale\n      }\n      await this.#sessionStore.set(this.#key, change(current));\n      return true;\n    } finally {\n      await lock.release();\n    }\n  }\n\n  /** Retire the record if it still holds `sessionId`. */\n  async #retireIfCurrent(sessionId: string): Promise<void> {\n    const lock = await this.#sessionStore.acquireLock(this.#key);\n    try {\n      const current = await this.#sessionStore.get(this.#key);\n      if (current?.sessionId === sessionId) await this.#retire(current);\n    } finally {\n      await lock.release();\n    }\n  }\n\n  /**\n   * Move the record to its retired marker. Callers hold the key lock, so a\n   * resolver always sees either the record or the marker.\n   */\n  async #retire(current: StoredBrowserSession): Promise<void> {\n    await this.#sessionStore.set(retiredBrowserSessionKey(this.name), {\n      ...current,\n      closedAt: Date.now()\n    });\n    await this.#sessionStore.delete(this.#key);\n  }\n\n  /**\n   * Create a Browser Run session (outside any lock) and commit it, applying\n   * the provider's creation options. If a concurrent caller committed an\n   * entry first, theirs wins and the redundant session is deleted\n   * best-effort.\n   *\n   * `restarted` is read under the commit lock: a retired marker — left by\n   * close() or a dead-browser recovery — is evidence a prior browser\n   * existed, and only first-ever use of the name is not a restart. Markers\n   * are permanent, so reading at commit time also catches a browser that\n   * was created and closed while this create was in flight.\n   */\n  async #createAndCommit(): Promise<{\n    session: StoredBrowserSession;\n    restarted: boolean;\n  }> {\n    const { binding, options } = this.#provider;\n    const info = await createBrowserSession(binding, {\n      keepAliveMs: this.#keepAliveMs,\n      recording: options.recording,\n      guardrails: options.guardrails\n    });\n    const now = Date.now();\n    const stored: StoredBrowserSession = {\n      sessionId: info.sessionId,\n      createdAt: now,\n      updatedAt: now\n    };\n\n    let winner: StoredBrowserSession | undefined;\n    let restarted: boolean;\n    const lock = await this.#sessionStore.acquireLock(this.#key);\n    try {\n      restarted =\n        (await this.#sessionStore.get(retiredBrowserSessionKey(this.name))) !==\n        undefined;\n      const current = await this.#sessionStore.get(this.#key);\n      if (current === undefined) {\n        await this.#sessionStore.set(this.#key, stored);\n      } else {\n        winner = current;\n      }\n    } finally {\n      await lock.release();\n    }\n\n    if (winner) {\n      try {\n        await deleteBrowserSession(binding, stored.sessionId);\n      } catch (error) {\n        console.warn(\n          `[agents/browser] Failed to delete redundant Browser Run session ${stored.sessionId}`,\n          error\n        );\n      }\n      return { session: winner, restarted };\n    }\n    return { session: stored, restarted };\n  }\n\n  async #isAlive(stored: StoredBrowserSession): Promise<boolean> {\n    try {\n      await listBrowserTargets(this.#provider.binding, stored.sessionId);\n      return true;\n    } catch (error) {\n      if (isMissingBrowserSession(error)) return false;\n      throw error;\n    }\n  }\n\n  async #readStored(): Promise<StoredBrowserSession | undefined> {\n    const lock = await this.#sessionStore.acquireLock(this.#key);\n    try {\n      return await this.#sessionStore.get(this.#key);\n    } finally {\n      await lock.release();\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/browser/tanstack-ai.d.ts

@@ -1,7 +1,92 @@
+import {
+  a as BrowserSource,
+  i as BrowserNewTab,
+  n as BrowserToolOptions,
+  r as BrowserToolOutput,
+  t as BrowserToolInput
+} from "../browser-tool-DuNdlwZ9.js";
 import { CreateBrowserToolsOptions } from "./ai.js";
 import { ServerTool } from "@tanstack/ai";
 
 //#region src/browser/tanstack-ai.d.ts
+interface TanStackBrowserToolOptions<
+  TName extends string = "browser"
+> extends BrowserToolOptions {
+  /** The tool's name. TanStack AI tools carry it in the definition. */
+  name?: TName;
+}
+/**
+ * Create a TanStack AI tool that lets the model drive a persistent browser
+ * with JavaScript and the Chrome DevTools Protocol.
+ *
+ * Works like `browserTool` in `agents/browser/ai-sdk`: tabs, cookies, and
+ * logins carry over between runs, `sessionId: "active"` addresses the tab the
+ * model last worked in, and a replaced browser is reported as
+ * `restarted: true`. The tool is named `browser` unless you pass `name`.
+ *
+ * Unlike the AI SDK tool, the host gets the same output as the model, and
+ * screenshots aren't supported: a returned screenshot is replaced by a
+ * sentence saying it was left out.
+ *
+ * @example
+ * ```ts
+ * import { Browser, browserRun } from "agents/browser";
+ * import { browserTool } from "agents/browser/tanstack-ai";
+ * import { chat } from "@tanstack/ai";
+ *
+ * export class MyAgent extends Agent<Env> {
+ *   browser = new Browser({ provider: browserRun(this.env.BROWSER) });
+ *
+ *   constructor(ctx: AgentContext, env: Env) {
+ *     super(ctx, env);
+ *     this.lifecycle.use(this.browser);
+ *   }
+ *
+ *   async onChatMessage() {
+ *     const stream = chat({
+ *       adapter,
+ *       tools: [browserTool({ browser: this.browser, loader: this.env.LOADER })],
+ *       messages
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare function browserTool<TName extends string = "browser">(
+  options: TanStackBrowserToolOptions<TName>
+): ServerTool<
+  {
+    readonly "~standard": {
+      readonly version: 1;
+      readonly vendor: "@cloudflare/codemode";
+      readonly types?: {
+        readonly input: import("@cloudflare/codemode").ProxyToolInput;
+        readonly output: import("@cloudflare/codemode").ProxyToolInput;
+      };
+      readonly validate: (value: unknown) =>
+        | {
+            readonly value: import("@cloudflare/codemode").ProxyToolInput;
+          }
+        | {
+            readonly issues: ReadonlyArray<{
+              readonly message: string;
+              readonly path?: ReadonlyArray<PropertyKey>;
+            }>;
+          };
+      readonly jsonSchema: {
+        readonly input: (options: {
+          readonly target: string;
+        }) => Record<string, unknown>;
+        readonly output: (options: {
+          readonly target: string;
+        }) => Record<string, unknown>;
+      };
+    };
+  },
+  import("@tanstack/ai").SchemaInput,
+  TName,
+  unknown
+>;
 /**
  * Create TanStack AI tools for browser automation via CDP code mode.
  *
@@ -37,5 +122,15 @@ declare function createBrowserTools(
   options: CreateBrowserToolsOptions
 ): ServerTool[];
 //#endregion
-export { type CreateBrowserToolsOptions, createBrowserTools };
+export {
+  type BrowserNewTab,
+  type BrowserSource,
+  type BrowserToolInput,
+  type BrowserToolOptions,
+  type BrowserToolOutput,
+  type CreateBrowserToolsOptions,
+  TanStackBrowserToolOptions,
+  browserTool,
+  createBrowserTools
+};
 //# sourceMappingURL=tanstack-ai.d.ts.map

package/dist/browser/tanstack-ai.js

@@ -1,8 +1,68 @@
-import { createBrowserRuntime } from "./ai.js";
+import { n as createBrowserToolCore } from "../browser-tool-CQ10e6Kj.js";
+import { a as browserScreenshotOutput, i as browserExecuteModelOutput, t as createBrowserRuntime } from "../ai-fm7xx1BK.js";
 import { z } from "zod";
 import { toolDefinition } from "@tanstack/ai";
 //#region src/browser/tanstack-ai.ts
 /**
+* What the model sees from one run. TanStack AI has one return channel, so
+* the host gets this too: no `calls` log, bounded `logs`, and a screenshot
+* replaced by a sentence saying it was left out.
+*/
+function browserToolModelResult(output) {
+	const screenshot = browserScreenshotOutput(output);
+	if (!screenshot) return browserExecuteModelOutput(output).value;
+	const bytes = Math.floor(screenshot.data.length * 3 / 4);
+	return browserExecuteModelOutput({
+		...output,
+		result: `Screenshot captured (${screenshot.mediaType}, approximately ${bytes.toLocaleString()} bytes), but this tool can't return images, so neither you nor the user can see it. Read the page with Runtime.evaluate instead.`
+	}).value;
+}
+/**
+* Create a TanStack AI tool that lets the model drive a persistent browser
+* with JavaScript and the Chrome DevTools Protocol.
+*
+* Works like `browserTool` in `agents/browser/ai-sdk`: tabs, cookies, and
+* logins carry over between runs, `sessionId: "active"` addresses the tab the
+* model last worked in, and a replaced browser is reported as
+* `restarted: true`. The tool is named `browser` unless you pass `name`.
+*
+* Unlike the AI SDK tool, the host gets the same output as the model, and
+* screenshots aren't supported: a returned screenshot is replaced by a
+* sentence saying it was left out.
+*
+* @example
+* ```ts
+* import { Browser, browserRun } from "agents/browser";
+* import { browserTool } from "agents/browser/tanstack-ai";
+* import { chat } from "@tanstack/ai";
+*
+* export class MyAgent extends Agent<Env> {
+*   browser = new Browser({ provider: browserRun(this.env.BROWSER) });
+*
+*   constructor(ctx: AgentContext, env: Env) {
+*     super(ctx, env);
+*     this.lifecycle.use(this.browser);
+*   }
+*
+*   async onChatMessage() {
+*     const stream = chat({
+*       adapter,
+*       tools: [browserTool({ browser: this.browser, loader: this.env.LOADER })],
+*       messages
+*     });
+*   }
+* }
+* ```
+*/
+function browserTool(options) {
+	const core = createBrowserToolCore(options, { screenshotHint: "This tool can't return images, so don't take screenshots; read the page with Runtime.evaluate (for example document.body.innerText) instead." });
+	return toolDefinition({
+		name: options.name ?? "browser",
+		description: core.description,
+		inputSchema: core.inputSchema
+	}).server(async (input) => browserToolModelResult(await core.execute(input)));
+}
+/**
 * Create TanStack AI tools for browser automation via CDP code mode.
 *
 * Returns an array with a single durable `browser_execute` `ServerTool`
@@ -65,6 +125,6 @@ function createBrowserTools(options) {
 	})];
 }
 //#endregion
-export { createBrowserTools };
+export { browserTool, createBrowserTools };
 
 //# sourceMappingURL=tanstack-ai.js.map

package/dist/browser/tanstack-ai.js.map

@@ -1 +1 @@
-{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../src/browser/tanstack-ai.ts"],"sourcesContent":["import { toolDefinition } from \"@tanstack/ai\";\nimport type { ServerTool } from \"@tanstack/ai\";\nimport type { ProxyToolOutput } from \"@cloudflare/codemode\";\nimport { z } from \"zod\";\nimport { createBrowserRuntime, type CreateBrowserToolsOptions } from \"./ai\";\n\nexport type { CreateBrowserToolsOptions } from \"./ai\";\n\n/**\n * Create TanStack AI tools for browser automation via CDP code mode.\n *\n * Returns an array with a single durable `browser_execute` `ServerTool`\n * backed by the same codemode runtime as `agents/browser/ai` — the model\n * writes TypeScript against the `cdp` connector and browser sessions\n * survive pauses.\n *\n * The stateless Quick Action tools are not surfaced through this TanStack\n * wrapper (it exposes only `browser_execute`); use `createQuickActionTools`\n * from `agents/browser/ai` if you want them.\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * // inside a Durable Object / Agent:\n * const browserTools = createBrowserTools({\n *   ctx: this.ctx,\n *   browser: this.env.BROWSER,\n *   loader: this.env.LOADER,\n * });\n *\n * const stream = chat({\n *   adapter: openaiText(\"gpt-4o\"),\n *   tools: [...browserTools, ...otherTools],\n *   messages,\n * });\n * ```\n */\nexport function createBrowserTools(\n  options: CreateBrowserToolsOptions\n): ServerTool[] {\n  // This wrapper only surfaces `browser_execute`, so don't build the default-on\n  // Quick Action tools just to discard them.\n  const { tools } = createBrowserRuntime({ ...options, quickActions: false });\n  const executeTool = tools.browser_execute;\n\n  const execute = toolDefinition({\n    name: \"browser_execute\" as const,\n    description:\n      typeof executeTool.description === \"function\"\n        ? \"\"\n        : (executeTool.description ?? \"\"),\n    inputSchema: z.object({\n      code: z.string().meta({\n        description:\n          \"TypeScript async arrow function that uses the cdp connector\"\n      })\n    })\n  }).server(async ({ code }) => {\n    if (!executeTool.execute) {\n      throw new Error(\"browser_execute tool is not executable\");\n    }\n    const result = (await executeTool.execute({ code }, {\n      toolCallId: crypto.randomUUID(),\n      messages: [],\n      context: {}\n    } as never)) as ProxyToolOutput;\n    // TanStack has a single return channel, so what the host sees is what the\n    // model sees: apply the AI SDK path's `toModelOutput` projection so a\n    // screenshot's base64 cannot reach the model and the durable `calls` log\n    // stays out of its context. The execution envelope (status, executionId)\n    // is preserved either way.\n    const modelOutput = await executeTool.toModelOutput?.({\n      toolCallId: crypto.randomUUID(),\n      input: { code },\n      output: result\n    });\n    if (modelOutput?.type === \"error-text\") {\n      throw new Error(modelOutput.value);\n    }\n    if (modelOutput?.type === \"text\") {\n      return { ...result, result: modelOutput.value };\n    }\n    if (modelOutput?.type === \"json\") {\n      return modelOutput.value;\n    }\n    return result;\n  });\n\n  return [execute];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,mBACd,SACc;CAGd,MAAM,EAAE,UAAU,qBAAqB;EAAE,GAAG;EAAS,cAAc;CAAM,CAAC;CAC1E,MAAM,cAAc,MAAM;CA6C1B,OAAO,CA3CS,eAAe;EAC7B,MAAM;EACN,aACE,OAAO,YAAY,gBAAgB,aAC/B,KACC,YAAY,eAAe;EAClC,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,EACpB,aACE,8DACJ,CAAC,EACH,CAAC;CACH,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,IAAI,CAAC,YAAY,SACf,MAAM,IAAI,MAAM,wCAAwC;EAE1D,MAAM,SAAU,MAAM,YAAY,QAAQ,EAAE,KAAK,GAAG;GAClD,YAAY,OAAO,WAAW;GAC9B,UAAU,CAAC;GACX,SAAS,CAAC;EACZ,CAAU;EAMV,MAAM,cAAc,MAAM,YAAY,gBAAgB;GACpD,YAAY,OAAO,WAAW;GAC9B,OAAO,EAAE,KAAK;GACd,QAAQ;EACV,CAAC;EACD,IAAI,aAAa,SAAS,cACxB,MAAM,IAAI,MAAM,YAAY,KAAK;EAEnC,IAAI,aAAa,SAAS,QACxB,OAAO;GAAE,GAAG;GAAQ,QAAQ,YAAY;EAAM;EAEhD,IAAI,aAAa,SAAS,QACxB,OAAO,YAAY;EAErB,OAAO;CACT,CAEc,CAAC;AACjB"}
+{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../src/browser/tanstack-ai.ts"],"sourcesContent":["import { toolDefinition } from \"@tanstack/ai\";\nimport type { ServerTool } from \"@tanstack/ai\";\nimport type { ProxyToolOutput } from \"@cloudflare/codemode\";\nimport { z } from \"zod\";\nimport { createBrowserRuntime, type CreateBrowserToolsOptions } from \"./ai\";\nimport {\n  createBrowserToolCore,\n  type BrowserToolOptions,\n  type BrowserToolOutput\n} from \"./browser-tool\";\nimport {\n  browserExecuteModelOutput,\n  browserScreenshotOutput\n} from \"./tool-helpers\";\n\nexport type { CreateBrowserToolsOptions } from \"./ai\";\nexport type {\n  BrowserToolInput,\n  BrowserToolOptions,\n  BrowserToolOutput\n} from \"./browser-tool\";\nexport type { BrowserNewTab, BrowserSource } from \"./session-connector\";\n\nexport interface TanStackBrowserToolOptions<\n  TName extends string = \"browser\"\n> extends BrowserToolOptions {\n  /** The tool's name. TanStack AI tools carry it in the definition. */\n  name?: TName;\n}\n\n/**\n * What the model sees from one run. TanStack AI has one return channel, so\n * the host gets this too: no `calls` log, bounded `logs`, and a screenshot\n * replaced by a sentence saying it was left out.\n */\nfunction browserToolModelResult(output: BrowserToolOutput): unknown {\n  const screenshot = browserScreenshotOutput(output);\n  if (!screenshot) return browserExecuteModelOutput(output).value;\n  const bytes = Math.floor((screenshot.data.length * 3) / 4);\n  // Keep the rest of the result (status, restarted, notice, newTabs).\n  return browserExecuteModelOutput({\n    ...output,\n    result: `Screenshot captured (${screenshot.mediaType}, approximately ${bytes.toLocaleString()} bytes), but this tool can't return images, so neither you nor the user can see it. Read the page with Runtime.evaluate instead.`\n  }).value;\n}\n\n/**\n * Create a TanStack AI tool that lets the model drive a persistent browser\n * with JavaScript and the Chrome DevTools Protocol.\n *\n * Works like `browserTool` in `agents/browser/ai-sdk`: tabs, cookies, and\n * logins carry over between runs, `sessionId: \"active\"` addresses the tab the\n * model last worked in, and a replaced browser is reported as\n * `restarted: true`. The tool is named `browser` unless you pass `name`.\n *\n * Unlike the AI SDK tool, the host gets the same output as the model, and\n * screenshots aren't supported: a returned screenshot is replaced by a\n * sentence saying it was left out.\n *\n * @example\n * ```ts\n * import { Browser, browserRun } from \"agents/browser\";\n * import { browserTool } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * export class MyAgent extends Agent<Env> {\n *   browser = new Browser({ provider: browserRun(this.env.BROWSER) });\n *\n *   constructor(ctx: AgentContext, env: Env) {\n *     super(ctx, env);\n *     this.lifecycle.use(this.browser);\n *   }\n *\n *   async onChatMessage() {\n *     const stream = chat({\n *       adapter,\n *       tools: [browserTool({ browser: this.browser, loader: this.env.LOADER })],\n *       messages\n *     });\n *   }\n * }\n * ```\n */\nexport function browserTool<TName extends string = \"browser\">(\n  options: TanStackBrowserToolOptions<TName>\n) {\n  const core = createBrowserToolCore(options, {\n    screenshotHint:\n      \"This tool can't return images, so don't take screenshots; read the page with Runtime.evaluate (for example document.body.innerText) instead.\"\n  });\n  return toolDefinition({\n    name: options.name ?? (\"browser\" as TName),\n    description: core.description,\n    inputSchema: core.inputSchema\n  }).server(async (input) => browserToolModelResult(await core.execute(input)));\n}\n\n/**\n * Create TanStack AI tools for browser automation via CDP code mode.\n *\n * Returns an array with a single durable `browser_execute` `ServerTool`\n * backed by the same codemode runtime as `agents/browser/ai` — the model\n * writes TypeScript against the `cdp` connector and browser sessions\n * survive pauses.\n *\n * The stateless Quick Action tools are not surfaced through this TanStack\n * wrapper (it exposes only `browser_execute`); use `createQuickActionTools`\n * from `agents/browser/ai` if you want them.\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * // inside a Durable Object / Agent:\n * const browserTools = createBrowserTools({\n *   ctx: this.ctx,\n *   browser: this.env.BROWSER,\n *   loader: this.env.LOADER,\n * });\n *\n * const stream = chat({\n *   adapter: openaiText(\"gpt-4o\"),\n *   tools: [...browserTools, ...otherTools],\n *   messages,\n * });\n * ```\n */\nexport function createBrowserTools(\n  options: CreateBrowserToolsOptions\n): ServerTool[] {\n  // This wrapper only surfaces `browser_execute`, so don't build the default-on\n  // Quick Action tools just to discard them.\n  const { tools } = createBrowserRuntime({ ...options, quickActions: false });\n  const executeTool = tools.browser_execute;\n\n  const execute = toolDefinition({\n    name: \"browser_execute\" as const,\n    description:\n      typeof executeTool.description === \"function\"\n        ? \"\"\n        : (executeTool.description ?? \"\"),\n    inputSchema: z.object({\n      code: z.string().meta({\n        description:\n          \"TypeScript async arrow function that uses the cdp connector\"\n      })\n    })\n  }).server(async ({ code }) => {\n    if (!executeTool.execute) {\n      throw new Error(\"browser_execute tool is not executable\");\n    }\n    const result = (await executeTool.execute({ code }, {\n      toolCallId: crypto.randomUUID(),\n      messages: [],\n      context: {}\n    } as never)) as ProxyToolOutput;\n    // TanStack has a single return channel, so what the host sees is what the\n    // model sees: apply the AI SDK path's `toModelOutput` projection so a\n    // screenshot's base64 cannot reach the model and the durable `calls` log\n    // stays out of its context. The execution envelope (status, executionId)\n    // is preserved either way.\n    const modelOutput = await executeTool.toModelOutput?.({\n      toolCallId: crypto.randomUUID(),\n      input: { code },\n      output: result\n    });\n    if (modelOutput?.type === \"error-text\") {\n      throw new Error(modelOutput.value);\n    }\n    if (modelOutput?.type === \"text\") {\n      return { ...result, result: modelOutput.value };\n    }\n    if (modelOutput?.type === \"json\") {\n      return modelOutput.value;\n    }\n    return result;\n  });\n\n  return [execute];\n}\n"],"mappings":";;;;;;;;;;AAmCA,SAAS,uBAAuB,QAAoC;CAClE,MAAM,aAAa,wBAAwB,MAAM;CACjD,IAAI,CAAC,YAAY,OAAO,0BAA0B,MAAM,CAAC,CAAC;CAC1D,MAAM,QAAQ,KAAK,MAAO,WAAW,KAAK,SAAS,IAAK,CAAC;CAEzD,OAAO,0BAA0B;EAC/B,GAAG;EACH,QAAQ,wBAAwB,WAAW,UAAU,kBAAkB,MAAM,eAAe,EAAE;CAChG,CAAC,CAAC,CAAC;AACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,YACd,SACA;CACA,MAAM,OAAO,sBAAsB,SAAS,EAC1C,gBACE,+IACJ,CAAC;CACD,OAAO,eAAe;EACpB,MAAM,QAAQ,QAAS;EACvB,aAAa,KAAK;EAClB,aAAa,KAAK;CACpB,CAAC,CAAC,CAAC,OAAO,OAAO,UAAU,uBAAuB,MAAM,KAAK,QAAQ,KAAK,CAAC,CAAC;AAC9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,mBACd,SACc;CAGd,MAAM,EAAE,UAAU,qBAAqB;EAAE,GAAG;EAAS,cAAc;CAAM,CAAC;CAC1E,MAAM,cAAc,MAAM;CA6C1B,OAAO,CA3CS,eAAe;EAC7B,MAAM;EACN,aACE,OAAO,YAAY,gBAAgB,aAC/B,KACC,YAAY,eAAe;EAClC,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,EACpB,aACE,8DACJ,CAAC,EACH,CAAC;CACH,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,IAAI,CAAC,YAAY,SACf,MAAM,IAAI,MAAM,wCAAwC;EAE1D,MAAM,SAAU,MAAM,YAAY,QAAQ,EAAE,KAAK,GAAG;GAClD,YAAY,OAAO,WAAW;GAC9B,UAAU,CAAC;GACX,SAAS,CAAC;EACZ,CAAU;EAMV,MAAM,cAAc,MAAM,YAAY,gBAAgB;GACpD,YAAY,OAAO,WAAW;GAC9B,OAAO,EAAE,KAAK;GACd,QAAQ;EACV,CAAC;EACD,IAAI,aAAa,SAAS,cACxB,MAAM,IAAI,MAAM,YAAY,KAAK;EAEnC,IAAI,aAAa,SAAS,QACxB,OAAO;GAAE,GAAG;GAAQ,QAAQ,YAAY;EAAM;EAEhD,IAAI,aAAa,SAAS,QACxB,OAAO,YAAY;EAErB,OAAO;CACT,CAEc,CAAC;AACjB"}