agents 0.27.0 → 0.28.0

package/dist/browser/index.d.ts

@@ -1,81 +1,88 @@
 import {
-  $ as CdpConnection,
-  A as DurableBrowserSessionStore,
-  B as BrowserSessionInfo,
+  A as CdpSendOptions,
+  C as createBrowserSession,
+  D as CdpAttachOptions,
+  E as listBrowserTargets,
+  M as connectUrl,
+  O as CdpConnection,
+  S as connectBrowserSession,
+  T as getBrowserRecording,
+  _ as ConnectBrowserOptions,
+  a as ListableBrowserSessionStore,
+  b as ConnectKitesurfBrowserOptions,
+  c as BrowserLiveViewTarget,
+  d as BrowserBinding,
+  f as BrowserRecording,
+  g as BrowserTargetInfo,
+  h as BrowserSessionInfo,
+  i as DurableBrowserSessionStore,
+  j as CdpSession,
+  k as CdpConnectionOptions,
+  l as BrowserLiveViewUrl,
+  m as BrowserSessionGuardrails,
+  n as BrowserSessionStore,
+  o as StoredBrowserSession,
+  p as BrowserRenderingError,
+  r as DEFAULT_SWEEP_IDLE_MS,
+  s as BrowserLiveView,
+  t as BrowserSessionLock,
+  u as LiveViewMode,
+  v as ConnectBrowserSessionOptions,
+  w as deleteBrowserSession,
+  x as connectBrowser,
+  y as ConnectChromiumBrowserOptions
+} from "../session-store-DoPY12xM.js";
+import {
   C as browserScrape,
-  D as BrowserSessionLock,
   E as runQuickAction,
-  F as LiveViewMode,
-  G as ConnectKitesurfBrowserOptions,
-  H as ConnectBrowserOptions,
-  I as BrowserBinding,
-  J as createBrowserSession,
-  K as connectBrowser,
-  L as BrowserRecording,
-  M as BrowserLiveView,
-  N as BrowserLiveViewTarget,
-  O as BrowserSessionStore,
-  P as BrowserLiveViewUrl,
-  Q as CdpAttachOptions,
-  R as BrowserRenderingError,
   S as browserPdf,
   T as browserSnapshot,
-  U as ConnectBrowserSessionOptions,
-  V as BrowserTargetInfo,
-  W as ConnectChromiumBrowserOptions,
-  X as getBrowserRecording,
-  Y as deleteBrowserSession,
-  Z as listBrowserTargets,
   _ as QuickActionSnapshot,
   a as BrowserConnectorSweepResult,
   b as browserLinks,
   c as QuickActionBinary,
   d as QuickActionExtractInput,
-  et as CdpConnectionOptions,
   f as QuickActionInput,
   g as QuickActionScreenshotInput,
   h as QuickActionScrapeResult,
   i as BrowserConnectorSweepOptions,
-  j as StoredBrowserSession,
-  k as DEFAULT_SWEEP_IDLE_MS,
   l as QuickActionBinding,
   m as QuickActionScrapeInput,
   n as BrowserConnectorOptions,
-  nt as CdpSession,
   o as DEFAULT_EXEC_SWEEP_IDLE_MS,
   p as QuickActionPage,
-  q as connectBrowserSession,
   r as BrowserConnectorSessionOptions,
-  rt as connectUrl,
   s as QuickAction,
   t as BrowserConnector,
-  tt as CdpSendOptions,
   u as QuickActionCommonOptions,
   v as browserContent,
   w as browserScreenshot,
   x as browserMarkdown,
-  y as browserExtract,
-  z as BrowserSessionGuardrails
-} from "../connector-Cl-VqPmA.js";
+  y as browserExtract
+} from "../connector-DEXzVoaY.js";
 import {
-  a as BrowserRunOptions,
-  c as browserRun,
-  d as CdpSpecSource,
-  f as SearchableCdpSpec,
-  i as BrowserProvider,
-  l as CdpField,
-  n as BrowserConnection,
-  o as BrowserRunProvider,
-  p as loadCdpSpec,
-  r as BrowserOptions,
-  s as ResolvedBrowser,
+  a as BrowserProvider,
+  c as DEFAULT_BROWSER_SCOPE,
+  d as browserRun,
+  f as CdpField,
+  g as loadCdpSpec,
+  h as SearchableCdpSpec,
+  i as BrowserOptions,
+  l as MAX_BROWSER_SCOPES,
+  m as CdpSpecSource,
+  n as BrowserConnectOptions,
+  o as BrowserRunOptions,
+  p as CdpItems,
+  r as BrowserConnection,
+  s as BrowserRunProvider,
   t as Browser,
-  u as CdpItems
-} from "../browser-tmkcAAI3.js";
+  u as ResolvedBrowser
+} from "../browser-D30VlpcA.js";
 import { CodemodeRuntime } from "@cloudflare/codemode";
 export {
   Browser,
   type BrowserBinding,
+  type BrowserConnectOptions,
   type BrowserConnection,
   BrowserConnector,
   type BrowserConnectorOptions,
@@ -109,10 +116,13 @@ export {
   type ConnectBrowserSessionOptions,
   type ConnectChromiumBrowserOptions,
   type ConnectKitesurfBrowserOptions,
+  DEFAULT_BROWSER_SCOPE,
   DEFAULT_EXEC_SWEEP_IDLE_MS,
   DEFAULT_SWEEP_IDLE_MS,
   DurableBrowserSessionStore,
+  type ListableBrowserSessionStore,
   type LiveViewMode,
+  MAX_BROWSER_SCOPES,
   type QuickAction,
   type QuickActionBinary,
   type QuickActionBinding,

package/dist/browser/index.js

@@ -1,362 +1,5 @@
-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 { _ as CdpConnection, b as connectUrl, c as BrowserRenderingError, d as createBrowserSession, f as deleteBrowserSession, h as listBrowserTargets, l as connectBrowser, n as DurableBrowserSessionStore, p as getBrowserRecording, r as loadCdpSpec, t as DEFAULT_SWEEP_IDLE_MS, u as connectBrowserSession, y as CdpSession } from "../session-store-Do4xkDcf.js";
+import { a as browserLinks, c as browserScrape, d as runQuickAction, i as browserExtract, l as browserScreenshot, n as DEFAULT_EXEC_SWEEP_IDLE_MS, o as browserMarkdown, r as browserContent, s as browserPdf, t as BrowserConnector, u as browserSnapshot } from "../connector-CtZylXdk.js";
+import { i as browserRun, n as DEFAULT_BROWSER_SCOPE, r as MAX_BROWSER_SCOPES, t as Browser } from "../browser-CEdNlsaD.js";
 import { CodemodeRuntime } from "@cloudflare/codemode";
-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
+export { Browser, BrowserConnector, BrowserRenderingError, CdpConnection, CdpSession, CodemodeRuntime, DEFAULT_BROWSER_SCOPE, DEFAULT_EXEC_SWEEP_IDLE_MS, DEFAULT_SWEEP_IDLE_MS, DurableBrowserSessionStore, MAX_BROWSER_SCOPES, browserContent, browserExtract, browserLinks, browserMarkdown, browserPdf, browserRun, browserScrape, browserScreenshot, browserSnapshot, connectBrowser, connectBrowserSession, connectUrl, createBrowserSession, deleteBrowserSession, getBrowserRecording, listBrowserTargets, loadCdpSpec, runQuickAction };

package/dist/browser/{ai-sdk.d.ts → tools/ai-sdk.d.ts}

@@ -1,15 +1,15 @@
+import {
+  i as QuickActionToolName,
+  r as CreateQuickActionToolsOptions,
+  s as createQuickActionTools
+} from "../../ai-ahruGw7e.js";
 import {
   a as BrowserSource,
   i as BrowserNewTab,
   n as BrowserToolOptions,
   r as BrowserToolOutput,
   t as BrowserToolInput
-} from "../browser-tool-Bn-nzJQI.js";
-import {
-  CreateQuickActionToolsOptions,
-  QuickActionToolName,
-  createQuickActionTools
-} from "./ai.js";
+} from "../../browser-tool-vtrPOV8e.js";
 import { FlexibleSchema, JSONValue } from "ai";
 
 //#region src/browser/tool-helpers.d.ts
@@ -24,7 +24,7 @@ type BrowserModelOutput =
       value: JSONValue;
     };
 //#endregion
-//#region src/browser/ai-sdk.d.ts
+//#region src/browser/tools/ai-sdk.d.ts
 /**
  * The AI SDK tool {@link browserTool} returns. Assignable to the AI SDK's
  * `Tool`, and `execute` / `toModelOutput` are always present.

package/dist/browser/{ai-sdk.js → tools/ai-sdk.js}

@@ -1,6 +1,7 @@
-import { n as createBrowserToolCore, t as browserReportNotes } from "../browser-tool-CBqs6hqa.js";
-import { i as browserExecuteModelOutput, r as createQuickActionTools } from "../ai-fm7xx1BK.js";
-//#region src/browser/ai-sdk.ts
+import { t as browserExecuteModelOutput } from "../../tool-helpers-O5BDVEAY.js";
+import { createQuickActionTools } from "../ai.js";
+import { n as createBrowserToolCore, t as browserReportNotes } from "../../browser-tool-4iomavs_.js";
+//#region src/browser/tools/ai-sdk.ts
 /**
 * Create an AI SDK tool that lets the model drive a persistent browser with
 * JavaScript and the Chrome DevTools Protocol.
@@ -41,7 +42,7 @@ function browserTool(options) {
 	return {
 		description: core.description,
 		inputSchema: core.inputSchema,
-		execute: core.execute,
+		execute: (input) => core.execute(input),
 		toModelOutput: ({ output }) => browserExecuteModelOutput(output, browserReportNotes(output))
 	};
 }

package/dist/browser/tools/ai-sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-sdk.js","names":[],"sources":["../../../src/browser/tools/ai-sdk.ts"],"sourcesContent":["/**\n * `agents/browser/ai-sdk` — the AI SDK tool for a persistent `Browser`.\n *\n * The older `createBrowserTools` stays in `agents/browser/ai`.\n */\nimport type { FlexibleSchema } from \"ai\";\nimport {\n  browserReportNotes,\n  createBrowserToolCore,\n  type BrowserToolInput,\n  type BrowserToolOptions,\n  type BrowserToolOutput\n} from \"../browser-tool\";\nimport {\n  browserExecuteModelOutput,\n  type BrowserModelOutput\n} from \"../tool-helpers\";\n\nexport type {\n  BrowserToolInput,\n  BrowserToolOptions,\n  BrowserToolOutput\n} from \"../browser-tool\";\nexport type { BrowserNewTab, BrowserSource } from \"../session-connector\";\n\n// Stateless Quick Action tools, so one import covers both.\nexport {\n  createQuickActionTools,\n  type CreateQuickActionToolsOptions,\n  type QuickActionToolName\n} from \"../ai\";\n\n/**\n * The AI SDK tool {@link browserTool} returns. Assignable to the AI SDK's\n * `Tool`, and `execute` / `toModelOutput` are always present.\n */\nexport interface BrowserTool {\n  description: string;\n  inputSchema: FlexibleSchema<BrowserToolInput>;\n  execute(\n    input: BrowserToolInput,\n    options: unknown\n  ): Promise<BrowserToolOutput>;\n  toModelOutput(options: { output: BrowserToolOutput }): BrowserModelOutput;\n}\n\n/**\n * Create an AI SDK tool that lets the model drive a persistent browser with\n * JavaScript and the Chrome DevTools Protocol.\n *\n * The browser outlives each run: tabs, cookies, and logins carry over. The\n * model never starts, closes, or resets it, and `sessionId: \"active\"`\n * addresses the tab it last worked in. If the browser had to be replaced\n * (it expired or was closed), the code still runs in the new browser and the\n * result says `restarted: true`.\n *\n * Browser Run only (Chromium). Guardrails, `keepAliveMs`, and recording are\n * set on the `Browser`'s provider.\n *\n * @example\n * ```ts\n * import { Browser, browserRun } from \"agents/browser\";\n * import { browserTool } from \"agents/browser/ai-sdk\";\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 tools = {\n *       browser: browserTool({ browser: this.browser, loader: this.env.LOADER })\n *     };\n *     // …pass `tools` to streamText / generateText\n *   }\n * }\n * ```\n */\nexport function browserTool(options: BrowserToolOptions): BrowserTool {\n  const core = createBrowserToolCore(options, {\n    screenshotHint:\n      \"To show a screenshot, return { type: 'browser_screenshot', mediaType, data } with data from Page.captureScreenshot and mediaType 'image/png', or 'image/jpeg' if you captured with format: 'jpeg'. The user sees the image; you get a short text summary.\"\n  });\n  return {\n    description: core.description,\n    inputSchema: core.inputSchema,\n    execute: (input) => core.execute(input),\n    toModelOutput: ({ output }) =>\n      browserExecuteModelOutput(output, browserReportNotes(output))\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFA,SAAgB,YAAY,SAA0C;CACpE,MAAM,OAAO,sBAAsB,SAAS,EAC1C,gBACE,4PACJ,CAAC;CACD,OAAO;EACL,aAAa,KAAK;EAClB,aAAa,KAAK;EAClB,UAAU,UAAU,KAAK,QAAQ,KAAK;EACtC,gBAAgB,EAAE,aAChB,0BAA0B,QAAQ,mBAAmB,MAAM,CAAC;CAChE;AACF"}

package/dist/browser/tools/pi.d.ts

@@ -0,0 +1,111 @@
+import {
+  a as BrowserSource,
+  i as BrowserNewTab,
+  n as BrowserToolOptions,
+  r as BrowserToolOutput,
+  t as BrowserToolInput
+} from "../../browser-tool-vtrPOV8e.js";
+import { Type } from "@earendil-works/pi-ai";
+import { ToolExecutionApi, ToolRegistration } from "@earendil-works/pi-durable";
+
+//#region src/browser/tools/pi.d.ts
+interface PiBrowserToolOptions<TName extends string = "browser"> extends Omit<
+  BrowserToolOptions,
+  "scope"
+> {
+  /** The tool's name. Default `"browser"`. */
+  name?: TName;
+  /**
+   * Which calls share an active tab: a string for every call, or a function
+   * of the call. Defaults to `conversation:<id>` for the calling
+   * conversation, so each
+   * conversation (and each fork or subagent) on the Durable Object keeps its
+   * own tab, while cookies and logins stay shared.
+   */
+  scope?: string | ((api: ToolExecutionApi) => string);
+}
+declare const browserToolParameters: Type.TObject<{
+  code: Type.TString;
+}>;
+/**
+ * What a UI can show about a run without reading the content: the run's
+ * outcome and what happened to the browser.
+ */
+type PiBrowserToolDetails = {
+  executionId: string;
+  status: BrowserToolOutput["status"];
+  restarted?: true;
+  newTabs?: {
+    targetId: string;
+    url?: string;
+    title?: string;
+  }[];
+};
+type PiBrowserTool<TName extends string = "browser"> = ToolRegistration<
+  typeof browserToolParameters,
+  PiBrowserToolDetails
+> & {
+  readonly name: TName;
+};
+/**
+ * Create a pi-durable 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`. A returned screenshot comes back as an image part that
+ * the model sees, when its model accepts images.
+ *
+ * Each conversation gets its own active tab (see
+ * {@link PiBrowserToolOptions.scope}). A conversation's calls run one at a
+ * time, since they share its tab, and the tool doesn't rerun after an
+ * eviction (its code may have clicked or
+ * submitted something): pi gives the model an interrupted result instead.
+ * Pass `ctx` unless the tool is built inside an Agent.
+ *
+ * @example
+ * ```ts
+ * import { Browser, browserRun } from "agents/browser";
+ * import { browserTool } from "agents/browser/pi";
+ *
+ * export class MyAgent extends DurableObject<Env> {
+ *   readonly browser = new Browser({ provider: browserRun(this.env.BROWSER) });
+ *   readonly registry = createRegistry();
+ *   readonly harness = new PiHarness({
+ *     harness: ({ storage, context }) => {
+ *       this.registry.install({
+ *         name: "browser",
+ *         tools: [
+ *           browserTool({
+ *             ctx: this.ctx,
+ *             browser: this.browser,
+ *             loader: this.env.LOADER
+ *           })
+ *         ]
+ *       });
+ *       return Harness.open(storage, { models, registry: this.registry }, context);
+ *     }
+ *   });
+ *   readonly lifecycle = Lifecycle.install(this)
+ *     .use(this.browser)
+ *     .use(this.harness);
+ * }
+ * ```
+ */
+declare function browserTool<TName extends string = "browser">(
+  options: PiBrowserToolOptions<TName>
+): PiBrowserTool<TName>;
+//#endregion
+export {
+  type BrowserNewTab,
+  type BrowserSource,
+  type BrowserToolInput,
+  type BrowserToolOptions,
+  type BrowserToolOutput,
+  PiBrowserTool,
+  PiBrowserToolDetails,
+  PiBrowserToolOptions,
+  browserTool
+};
+//# sourceMappingURL=pi.d.ts.map