agents 0.15.0 → 0.16.1

package/dist/{agent-tool-types-VPsjVYL0.d.ts → agent-tool-types-NofdbL9X.d.ts}

@@ -1,10 +1,10 @@
 import { n as AgentEmail } from "./internal_context-Dg4Cgjcu.js";
-import { t as RetryOptions } from "./retries-CF_HKSlJ.js";
+import { t as RetryOptions } from "./retries-CwlpAGet.js";
 import {
   n as Observability,
   r as ObservabilityEvent,
   s as MCPObservabilityEvent
-} from "./index-CPe1OtI0.js";
+} from "./index-B7IbEeze.js";
 import { t as AgentMcpOAuthProvider } from "./do-oauth-client-provider-D4ZwyBDu.js";
 import {
   _ as WorkflowPage,
@@ -2343,7 +2343,15 @@ interface AgentStaticOptions {
   /**
    * Maximum age in milliseconds of an unmanaged interrupted-fiber row before
    * recovery stops retrying a repeatedly-throwing `onFiberRecovered()` hook
-   * and discards the row. Set to `0` to retain rows indefinitely.
+   * and discards the row (emitting `fiber:recovery:skipped` with reason
+   * `max_age_exceeded`). Defaults to 24h.
+   *
+   * Set to `0` to retain rows indefinitely. NOTE: with `0`, a hook that keeps
+   * throwing is retried forever — the recovery alarm backs off exponentially
+   * (capped at 5 minutes) so it is not a busy-loop, but the Durable Object
+   * stays warm (never idle-evicts) for as long as the un-recoverable row
+   * exists. Prefer a finite age unless you intend to inspect/clear such rows
+   * yourself.
    */
   fiberRecoveryMaxAgeMs?: number;
   /**
@@ -2467,6 +2475,13 @@ declare class Agent<
   private _managedFiberTerminalWaiters;
   /** @internal Prevents re-entrant recovery from overlapping alarm ticks. */
   private _runFiberRecoveryInProgress;
+  /**
+   * @internal Consecutive runFiber-recovery scans that made NO forward progress
+   * while work was still pending. Drives the exponential backoff of the
+   * recovery follow-up alarm so a repeatedly-throwing recovery hook does not
+   * busy-loop the DO. Reset to 0 whenever a scan recovers anything.
+   */
+  private _recoveryNoProgressScans;
   /** @internal Single-flight background recovery for parent agent-tool rows. */
   private _agentToolRunRecoveryPromise;
   private _ParentClass;
@@ -3296,6 +3311,18 @@ declare class Agent<
     targetPath: ReadonlyArray<AgentPathStep>
   ): Promise<void>;
   private _executeScheduleCallback;
+  /**
+   * Whether any runFiber recovery work is still outstanding: orphaned
+   * `cf_agents_runs` rows left by a dead process (excluding fibers currently
+   * executing in memory, which already hold a keepAlive ref) or managed
+   * ledger fibers stuck in a non-terminal state with no live run row.
+   *
+   * Used by `_scheduleNextAlarm` to arm a follow-up alarm so multi-pass
+   * recovery (e.g. after a scan-deadline yield, or while retrying a throwing
+   * recovery hook) resumes instead of starving.
+   * @internal
+   */
+  private _hasPendingFiberRecovery;
   private _scheduleNextAlarm;
   /**
    * Override PartyServer's onAlarm hook as a no-op.
@@ -3861,6 +3888,32 @@ declare class Agent<
    * callers should treat it as fire-and-forget.
    */
   destroy(): Promise<void>;
+  /**
+   * @internal Defer this agent's destruction to its own alarm invocation
+   * instead of running it inline (#1625).
+   *
+   * `destroy()` is a multi-step I/O sequence (drop tables, delete alarm,
+   * delete all storage, dispose connections). Running it on the `waitUntil`
+   * of a request whose client has already disconnected — the MCP
+   * Streamable-HTTP session-DELETE path — gives it little to no
+   * post-invocation grace, so the runtime routinely cancels it mid-flight.
+   * This method instead performs two fast storage writes (a durable
+   * "condemned" marker and an immediate alarm) that the caller can await
+   * before responding; the alarm then fires as a fresh invocation with its
+   * own full execution budget and runs `destroy()` there. If even that
+   * invocation is interrupted, the marker survives and the next wake
+   * finishes teardown — see the `alarm()` preamble.
+   *
+   * Unlike `destroy()`, this method does not abort the isolate, so RPC
+   * callers don't need to swallow an abort error.
+   */
+  _cf_scheduleDestroy(): Promise<void>;
+  /**
+   * Whether a (deferred or interrupted) destroy is pending. Reads the
+   * durable marker directly — the in-memory `_isFacet` flag may not be
+   * hydrated yet at the call sites, but facets never write the marker.
+   */
+  private _hasPendingDestroy;
   /** @internal Drop every internal Agents SDK table during top-level destroy. */
   protected _dropInternalTablesForDestroy(): void;
   /**
@@ -4794,4 +4847,4 @@ export {
   MCPServer as z,
   WorkerTransport as zt
 };
-//# sourceMappingURL=agent-tool-types-VPsjVYL0.d.ts.map
+//# sourceMappingURL=agent-tool-types-NofdbL9X.d.ts.map

package/dist/agent-tool-types.d.ts

@@ -16,7 +16,7 @@ import {
   s as AgentToolInterruptedReason,
   t as AgentToolChildAdapter,
   u as AgentToolRunInspection
-} from "./agent-tool-types-VPsjVYL0.js";
+} from "./agent-tool-types-NofdbL9X.js";
 export {
   AgentToolChildAdapter,
   AgentToolDisplayMetadata,

package/dist/{agent-tools-BGpgfpJT.d.ts → agent-tools-DLquv-dp.d.ts}

@@ -1,7 +1,7 @@
 import {
   a as AgentToolEventState,
   i as AgentToolEventMessage
-} from "./agent-tool-types-VPsjVYL0.js";
+} from "./agent-tool-types-NofdbL9X.js";
 
 //#region src/chat/agent-tools.d.ts
 declare function createAgentToolEventState(): AgentToolEventState;
@@ -11,4 +11,4 @@ declare function applyAgentToolEvent(
 ): AgentToolEventState;
 //#endregion
 export { createAgentToolEventState as n, applyAgentToolEvent as t };
-//# sourceMappingURL=agent-tools-BGpgfpJT.d.ts.map
+//# sourceMappingURL=agent-tools-DLquv-dp.d.ts.map

package/dist/agent-tools.d.ts

@@ -16,7 +16,7 @@ import {
   s as AgentToolInterruptedReason,
   t as AgentToolChildAdapter,
   u as AgentToolRunInspection
-} from "./agent-tool-types-VPsjVYL0.js";
+} from "./agent-tool-types-NofdbL9X.js";
 import { Tool } from "ai";
 
 //#region src/agent-tools.d.ts

package/dist/browser/ai.d.ts

@@ -1,21 +1,159 @@
-import { t as BrowserToolsOptions } from "../shared-4CAYLCTO.js";
+import {
+  I as BrowserBinding,
+  f as BrowserSessionStore,
+  r as BrowserConnectorSessionOptions,
+  t as BrowserConnector,
+  v as QuickActionBinding,
+  y as QuickActionCommonOptions
+} from "../connector-v2M1zlZp.js";
 import { ToolSet } from "ai";
+import { CodemodeRuntimeHandle } from "@cloudflare/codemode";
 
 //#region src/browser/ai.d.ts
+interface CreateBrowserToolsOptions {
+  /**
+   * Durable Object state. The codemode runtime that backs the browser tool
+   * lives in a facet of this DO, and browser session ids are stored in its
+   * storage — so the tool must be created from inside a Durable Object
+   * (e.g. an Agent).
+   *
+   * Optional: when omitted, it is resolved from the current Agent via
+   * `getCurrentAgent()`, so inside an Agent method you can just pass `browser`
+   * and `loader`. Pass it explicitly outside an Agent context.
+   *
+   * The worker must export the `CodemodeRuntime` class (the
+   * `@cloudflare/codemode/vite` plugin does this automatically, or add
+   * `export { CodemodeRuntime } from "@cloudflare/codemode"` to your entry).
+   */
+  ctx?: DurableObjectState;
+  /**
+   * WorkerLoader binding for sandboxed code execution.
+   *
+   * Requires `"worker_loaders": [{ "binding": "LOADER" }]` in wrangler.jsonc.
+   */
+  loader: WorkerLoader;
+  /**
+   * Browser Rendering binding (Fetcher).
+   *
+   * This is the primary way to connect — works both locally in
+   * `wrangler dev` and when deployed to Cloudflare Workers.
+   *
+   * Requires `"browser": { "binding": "BROWSER" }` in wrangler.jsonc.
+   */
+  browser?: BrowserBinding;
+  /**
+   * Optional CDP base URL override (e.g. `http://localhost:9222`).
+   *
+   * Use when connecting to a manually managed Chrome instance or
+   * a remote CDP endpoint behind a tunnel.
+   */
+  cdpUrl?: string;
+  /**
+   * Headers to send with CDP URL discovery requests.
+   * Useful when the CDP endpoint requires authentication
+   * (e.g. Cloudflare Access headers).
+   */
+  cdpHeaders?: Record<string, string>;
+  /**
+   * Browser session lifecycle (binding-backed only). Defaults to one fresh
+   * session per codemode execution (`one-shot`).
+   */
+  session?: BrowserConnectorSessionOptions;
+  /**
+   * Durable store for Browser Run session ids. Defaults to a
+   * {@link DurableBrowserSessionStore} over `ctx.storage`.
+   */
+  store?: BrowserSessionStore;
+  /**
+   * Sandbox execution timeout in milliseconds. Defaults to 30000 (30s).
+   * Also used as the per-CDP-command timeout.
+   */
+  timeout?: number;
+  /**
+   * Codemode runtime name — the durable identity of the tool's executions
+   * and snippets. Defaults to `"browser"`.
+   */
+  name?: string;
+  /**
+   * Also expose stateless {@link createQuickActionTools | Quick Action} tools
+   * (`browser_markdown`, `browser_extract`, …) alongside the durable
+   * `browser_execute` tool.
+   *
+   * Enabled by default whenever a Browser Run `browser` binding is available
+   * (they share it). Pass an object to configure them, or `false` to disable.
+   * The Quick Action binding defaults to `browser`; override it via
+   * `quickActions.browser`. When only `cdpUrl` is set (no binding), the
+   * defaults are skipped silently — pass `quickActions: { browser }` to force
+   * them.
+   */
+  quickActions?:
+    | boolean
+    | {
+        browser?: QuickActionBinding;
+        actions?: QuickActionToolName[];
+        maxChars?: number;
+        options?: QuickActionCommonOptions;
+      };
+}
+/**
+ * The browser tool's moving parts, for hosts that need more than the tools:
+ *
+ * - `runtime` — the codemode runtime handle (approve/reject paused runs,
+ *   `expirePaused`, audit via `executions()`, snippets).
+ * - `connector` — host-side session helpers: `sessionInfo()`,
+ *   `closeSession()`, and `sweep()` for a recurring cleanup task.
+ * - `tools` — what `createBrowserTools` returns.
+ */
+interface BrowserRuntime {
+  runtime: CodemodeRuntimeHandle;
+  connector: BrowserConnector;
+  tools: ToolSet;
+}
+/**
+ * Create the browser codemode runtime: the `browser_execute` tool plus the
+ * runtime handle and connector for host-side wiring (approvals, session info,
+ * sweeps).
+ *
+ * @example
+ * ```ts
+ * export class MyAgent extends Agent<Env> {
+ *   get browser() {
+ *     return createBrowserRuntime({
+ *       ctx: this.ctx,
+ *       browser: this.env.BROWSER,
+ *       loader: this.env.LOADER,
+ *       session: { mode: "dynamic" }
+ *     });
+ *   }
+ *
+ *   @callable()
+ *   async closeBrowserSession() {
+ *     await this.browser.connector.closeSession();
+ *   }
+ * }
+ * ```
+ */
+declare function createBrowserRuntime(
+  options: CreateBrowserToolsOptions
+): BrowserRuntime;
 /**
  * Create AI SDK tools for browser automation via CDP code mode.
  *
- * Returns a `ToolSet` with `search` (query the CDP spec) and
- * `execute` (run CDP commands against a live browser).
+ * Returns a `ToolSet` with a single durable `browser_execute` tool backed by
+ * a codemode runtime: the model writes TypeScript against the `cdp` connector
+ * (`cdp.send`, `cdp.attachToTarget`, `cdp.spec`, …), executions are recorded
+ * for abort-and-replay, and browser sessions survive pauses.
  *
  * @example
  * ```ts
  * import { createBrowserTools } from "agents/browser/ai";
  * import { generateText } from "ai";
  *
+ * // inside a Durable Object / Agent:
  * const browserTools = createBrowserTools({
- *   browser: env.BROWSER,
- *   loader: env.LOADER,
+ *   ctx: this.ctx,
+ *   browser: this.env.BROWSER,
+ *   loader: this.env.LOADER,
  * });
  *
  * const result = await generateText({
@@ -25,7 +163,73 @@ import { ToolSet } from "ai";
  * });
  * ```
  */
-declare function createBrowserTools(options: BrowserToolsOptions): ToolSet;
+declare function createBrowserTools(
+  options: CreateBrowserToolsOptions
+): ToolSet;
+/** A Quick Action exposed as an AI SDK tool. */
+type QuickActionToolName =
+  | "markdown"
+  | "extract"
+  | "links"
+  | "scrape"
+  | "content";
+interface CreateQuickActionToolsOptions {
+  /**
+   * Browser Run binding with Quick Actions support (`env.BROWSER`). Requires a
+   * Worker `compatibility_date` of `2026-03-24`+ and `remote: true` for local
+   * `wrangler dev`.
+   */
+  browser: QuickActionBinding;
+  /**
+   * Which tools to expose. Defaults to the text-returning, model-friendly set
+   * (`markdown`, `extract`, `links`, `scrape`). `content` (raw HTML) is opt-in
+   * since it is large and rarely what a model wants.
+   */
+  actions?: QuickActionToolName[];
+  /**
+   * Bound every result to roughly this many characters before returning it to
+   * the model, to protect the context window, preserving each result's shape:
+   * text (markdown/content) is truncated to a string, oversized arrays
+   * (links/scrape) are trimmed but stay arrays, and only an opaque oversized
+   * object degrades to a truncated-preview summary. Set to `0` to disable.
+   * Defaults to 50000.
+   */
+  maxChars?: number;
+  /**
+   * Common Browser Run options merged into every request — e.g. `cookies`,
+   * `authenticate`, or `setExtraHTTPHeaders` for authenticated pages, and
+   * `gotoOptions` / `viewport` for JavaScript-heavy pages. The model only ever
+   * supplies the page (`url`/`html`) and action-specific fields; these
+   * host-supplied options are never exposed to it.
+   */
+  options?: QuickActionCommonOptions;
+}
+/**
+ * Create AI SDK tools for Browser Run [Quick Actions](https://developers.cloudflare.com/browser-run/quick-actions/):
+ * stateless one-shot browsing (read a page as Markdown, extract structured
+ * data with AI, list links, scrape elements). Unlike `createBrowserTools`,
+ * these need only the `browser` binding — no Durable Object, loader, or
+ * sandbox — so they work from any Worker.
+ *
+ * @example
+ * ```ts
+ * import { createQuickActionTools } from "agents/browser/ai";
+ *
+ * const tools = createQuickActionTools({ browser: this.env.BROWSER });
+ * const result = await generateText({ model, tools, messages });
+ * ```
+ */
+declare function createQuickActionTools(
+  options: CreateQuickActionToolsOptions
+): ToolSet;
 //#endregion
-export { type BrowserToolsOptions, createBrowserTools };
+export {
+  BrowserRuntime,
+  CreateBrowserToolsOptions,
+  CreateQuickActionToolsOptions,
+  QuickActionToolName,
+  createBrowserRuntime,
+  createBrowserTools,
+  createQuickActionTools
+};
 //# sourceMappingURL=ai.d.ts.map

package/dist/browser/ai.js

@@ -1,21 +1,117 @@
-import { n as SEARCH_DESCRIPTION, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-wyII629d.js";
+import { __DO_NOT_USE_WILL_BREAK__agentContext } from "../internal_context.js";
+import { c as browserLinks, d as browserScrape, i as DurableBrowserSessionStore, l as browserMarkdown, o as browserContent, s as browserExtract, t as BrowserConnector } from "../connector-CrKhowfD.js";
 import { tool } from "ai";
 import { z } from "zod";
+import { DynamicWorkerExecutor, createCodemodeRuntime, truncateResult } from "@cloudflare/codemode";
 //#region src/browser/ai.ts
+let didWarnExperimental = false;
+let didDebugQuickActionSkip = false;
+/**
+* The Durable Object state to build the runtime in: the explicit `ctx` if
+* given, otherwise the current Agent's `ctx` (via `getCurrentAgent()`), so
+* `createBrowserRuntime` can be called from an Agent method without threading
+* `this.ctx` through.
+*/
+function resolveCtx(options) {
+	if (options.ctx) return options.ctx;
+	return (__DO_NOT_USE_WILL_BREAK__agentContext.getStore()?.agent)?.ctx;
+}
+function connectorOptions(options, ctx) {
+	if (options.cdpUrl) return {
+		cdpUrl: options.cdpUrl,
+		cdpHeaders: options.cdpHeaders,
+		timeout: options.timeout
+	};
+	if (!options.browser) throw new Error("Either 'browser' (Fetcher binding) or 'cdpUrl' must be provided");
+	return {
+		browser: options.browser,
+		store: options.store ?? new DurableBrowserSessionStore(ctx.storage),
+		session: options.session,
+		timeout: options.timeout
+	};
+}
+/**
+* Create the browser codemode runtime: the `browser_execute` tool plus the
+* runtime handle and connector for host-side wiring (approvals, session info,
+* sweeps).
+*
+* @example
+* ```ts
+* export class MyAgent extends Agent<Env> {
+*   get browser() {
+*     return createBrowserRuntime({
+*       ctx: this.ctx,
+*       browser: this.env.BROWSER,
+*       loader: this.env.LOADER,
+*       session: { mode: "dynamic" }
+*     });
+*   }
+*
+*   @callable()
+*   async closeBrowserSession() {
+*     await this.browser.connector.closeSession();
+*   }
+* }
+* ```
+*/
+function createBrowserRuntime(options) {
+	if (!didWarnExperimental) {
+		didWarnExperimental = true;
+		console.warn("[agents/browser] Browser tools are experimental and may change in a future release.");
+	}
+	const ctx = resolveCtx(options);
+	if (!ctx) throw new Error("createBrowserRuntime requires a Durable Object 'ctx' — pass it explicitly, or call from within an Agent so it can be resolved via getCurrentAgent()");
+	const connector = new BrowserConnector(ctx, connectorOptions(options, ctx));
+	const runtime = createCodemodeRuntime({
+		ctx,
+		executor: new DynamicWorkerExecutor({
+			loader: options.loader,
+			timeout: options.timeout
+		}),
+		connectors: [connector],
+		name: options.name ?? "browser",
+		transformResult: truncateResult
+	});
+	const tools = { browser_execute: runtime.tool() };
+	if (options.quickActions !== false) {
+		const qa = options.quickActions == null || options.quickActions === true ? {} : options.quickActions;
+		const quickActionBrowser = qa.browser ?? options.browser;
+		if (quickActionBrowser) Object.assign(tools, createQuickActionTools({
+			browser: quickActionBrowser,
+			actions: qa.actions,
+			maxChars: qa.maxChars,
+			options: qa.options
+		}));
+		else if (options.quickActions) throw new Error("quickActions requires a Browser Run binding — set 'browser' (env.BROWSER) or 'quickActions.browser'");
+		else if (!didDebugQuickActionSkip) {
+			didDebugQuickActionSkip = true;
+			console.debug("[agents/browser] Quick Action tools skipped — no Browser Run binding (only 'cdpUrl' is set). Pass 'browser' or 'quickActions.browser' to enable them.");
+		}
+	}
+	return {
+		runtime,
+		connector,
+		tools
+	};
+}
 /**
 * Create AI SDK tools for browser automation via CDP code mode.
 *
-* Returns a `ToolSet` with `search` (query the CDP spec) and
-* `execute` (run CDP commands against a live browser).
+* Returns a `ToolSet` with a single durable `browser_execute` tool backed by
+* a codemode runtime: the model writes TypeScript against the `cdp` connector
+* (`cdp.send`, `cdp.attachToTarget`, `cdp.spec`, …), executions are recorded
+* for abort-and-replay, and browser sessions survive pauses.
 *
 * @example
 * ```ts
 * import { createBrowserTools } from "agents/browser/ai";
 * import { generateText } from "ai";
 *
+* // inside a Durable Object / Agent:
 * const browserTools = createBrowserTools({
-*   browser: env.BROWSER,
-*   loader: env.LOADER,
+*   ctx: this.ctx,
+*   browser: this.env.BROWSER,
+*   loader: this.env.LOADER,
 * });
 *
 * const result = await generateText({
@@ -26,29 +122,144 @@ import { z } from "zod";
 * ```
 */
 function createBrowserTools(options) {
-	const handlers = createBrowserToolHandlers(options);
+	return createBrowserRuntime(options).tools;
+}
+const DEFAULT_QUICK_ACTION_TOOLS = [
+	"markdown",
+	"extract",
+	"links",
+	"scrape"
+];
+const DEFAULT_QUICK_ACTION_MAX_CHARS = 5e4;
+const pageInputSchema = z.object({
+	url: z.string().url().optional().describe("URL of the page to load"),
+	html: z.string().optional().describe("Raw HTML to render instead of loading a URL")
+}).refine((value) => Boolean(value.url) || Boolean(value.html), { message: "Provide either 'url' or 'html'" });
+function toPage(input, options) {
+	const page = input.url ? { url: input.url } : { html: input.html };
 	return {
-		browser_search: tool({
-			description: SEARCH_DESCRIPTION,
-			inputSchema: z.object({ code: z.string().describe("JavaScript async arrow function that queries the CDP spec") }),
-			execute: async ({ code }) => {
-				const result = await handlers.search(code);
-				if (result.isError) throw new Error(result.text);
-				return result.text;
-			}
-		}),
-		browser_execute: tool({
-			description: EXECUTE_DESCRIPTION,
-			inputSchema: z.object({ code: z.string().describe("JavaScript async arrow function that uses the cdp helper") }),
-			execute: async ({ code }) => {
-				const result = await handlers.execute(code);
-				if (result.isError) throw new Error(result.text);
-				return result.text;
-			}
-		})
+		...options,
+		...page
+	};
+}
+function truncate(text, maxChars) {
+	if (maxChars <= 0 || text.length <= maxChars) return text;
+	return `${text.slice(0, maxChars)}\n\n[truncated ${text.length - maxChars} characters]`;
+}
+/**
+* Keep a tool result within a rough character budget so a single browse cannot
+* blow the model's context window — while preserving the result's shape so the
+* model sees a consistent type across calls:
+*
+* - strings (markdown/content) are truncated to a string;
+* - arrays (links/scrape) are trimmed from the end but stay arrays;
+* - only an opaque oversized object (e.g. a sprawling `extract`) degrades to a
+*   `{ truncated, note, preview }` summary, since it cannot be trimmed safely.
+*/
+function boundResult(value, maxChars) {
+	if (maxChars <= 0) return value;
+	if (typeof value === "string") return truncate(value, maxChars);
+	let json;
+	try {
+		json = JSON.stringify(value);
+	} catch {
+		return value;
+	}
+	if (json.length <= maxChars) return value;
+	if (Array.isArray(value)) {
+		const trimmed = boundArray(value, maxChars);
+		if (trimmed.length > 0) return trimmed;
+	}
+	return {
+		truncated: true,
+		note: `Result is too large (${json.length} characters); narrow the request.`,
+		preview: `${json.slice(0, maxChars)}…`
 	};
 }
+/**
+* Take as many leading items as fit within `maxChars` (measured against their
+* JSON length), returning a trimmed array of the same element type. Silent by
+* design: the model gets fewer, valid items rather than a reshaped result.
+*/
+function boundArray(value, maxChars) {
+	const out = [];
+	let size = 2;
+	for (const item of value) {
+		const itemSize = JSON.stringify(item).length + 1;
+		if (size + itemSize > maxChars) break;
+		out.push(item);
+		size += itemSize;
+	}
+	return out;
+}
+/**
+* Create AI SDK tools for Browser Run [Quick Actions](https://developers.cloudflare.com/browser-run/quick-actions/):
+* stateless one-shot browsing (read a page as Markdown, extract structured
+* data with AI, list links, scrape elements). Unlike `createBrowserTools`,
+* these need only the `browser` binding — no Durable Object, loader, or
+* sandbox — so they work from any Worker.
+*
+* @example
+* ```ts
+* import { createQuickActionTools } from "agents/browser/ai";
+*
+* const tools = createQuickActionTools({ browser: this.env.BROWSER });
+* const result = await generateText({ model, tools, messages });
+* ```
+*/
+function createQuickActionTools(options) {
+	const { browser } = options;
+	const requestOptions = options.options;
+	const enabled = new Set(options.actions ?? DEFAULT_QUICK_ACTION_TOOLS);
+	const maxChars = options.maxChars ?? DEFAULT_QUICK_ACTION_MAX_CHARS;
+	const tools = {};
+	if (enabled.has("markdown")) tools.browser_markdown = tool({
+		description: "Load a web page (or render raw HTML) and return its content as Markdown. Best for reading articles, docs, or any page as text.",
+		inputSchema: pageInputSchema,
+		execute: async (input) => boundResult(await browserMarkdown(browser, toPage(input, requestOptions)), maxChars)
+	});
+	if (enabled.has("extract")) tools.browser_extract = tool({
+		description: "Extract structured data from a web page using AI. Describe what you want in 'prompt'. Passing a JSON Schema in 'schema' is strongly recommended — without one the extractor often fails to produce JSON.",
+		inputSchema: z.object({
+			url: z.string().url().optional().describe("URL of the page to load"),
+			html: z.string().optional().describe("Raw HTML to render instead of loading a URL"),
+			prompt: z.string().optional().describe("What to extract, in natural language"),
+			schema: z.unknown().optional().describe("Optional JSON Schema describing the desired output")
+		}).refine((value) => Boolean(value.url) || Boolean(value.html), { message: "Provide either 'url' or 'html'" }).refine((value) => Boolean(value.prompt) || Boolean(value.schema), { message: "Provide either 'prompt' or 'schema'" }),
+		execute: async (input) => boundResult(await browserExtract(browser, {
+			...toPage(input, requestOptions),
+			prompt: input.prompt,
+			response_format: input.schema ? {
+				type: "json_schema",
+				schema: input.schema
+			} : void 0
+		}), maxChars)
+	});
+	if (enabled.has("links")) tools.browser_links = tool({
+		description: "Return every link found on a web page (including ones not visible). Useful for discovering pages to follow.",
+		inputSchema: pageInputSchema,
+		execute: async (input) => boundResult(await browserLinks(browser, toPage(input, requestOptions)), maxChars)
+	});
+	if (enabled.has("scrape")) tools.browser_scrape = tool({
+		description: "Scrape specific elements from a web page by CSS selector. Returns the matched elements' text, HTML, and attributes.",
+		inputSchema: z.object({
+			url: z.string().url().optional().describe("URL of the page to load"),
+			html: z.string().optional().describe("Raw HTML to render instead of loading a URL"),
+			selectors: z.array(z.string()).min(1).describe("CSS selectors to extract")
+		}).refine((value) => Boolean(value.url) || Boolean(value.html), { message: "Provide either 'url' or 'html'" }),
+		execute: async (input) => boundResult(await browserScrape(browser, {
+			...toPage(input, requestOptions),
+			elements: input.selectors.map((selector) => ({ selector }))
+		}), maxChars)
+	});
+	if (enabled.has("content")) tools.browser_content = tool({
+		description: "Load a web page and return its fully rendered HTML (after JavaScript runs). Prefer 'browser_markdown' unless you need the raw HTML.",
+		inputSchema: pageInputSchema,
+		execute: async (input) => boundResult(await browserContent(browser, toPage(input, requestOptions)), maxChars)
+	});
+	return tools;
+}
 //#endregion
-export { createBrowserTools };
+export { createBrowserRuntime, createBrowserTools, createQuickActionTools };
 
 //# sourceMappingURL=ai.js.map