agents 0.15.0 → 0.16.1

package/dist/browser/ai.js.map

@@ -1 +1 @@
-{"version":3,"file":"ai.js","names":[],"sources":["../../src/browser/ai.ts"],"sourcesContent":["import { tool } from \"ai\";\nimport type { ToolSet } from \"ai\";\nimport { z } from \"zod\";\nimport {\n  createBrowserToolHandlers,\n  SEARCH_DESCRIPTION,\n  EXECUTE_DESCRIPTION,\n  type BrowserToolsOptions\n} from \"./shared\";\n\nexport type { BrowserToolsOptions } from \"./shared\";\n\n/**\n * Create AI SDK tools for browser automation via CDP code mode.\n *\n * Returns a `ToolSet` with `search` (query the CDP spec) and\n * `execute` (run CDP commands against a live browser).\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/ai\";\n * import { generateText } from \"ai\";\n *\n * const browserTools = createBrowserTools({\n *   browser: env.BROWSER,\n *   loader: env.LOADER,\n * });\n *\n * const result = await generateText({\n *   model,\n *   tools: { ...browserTools, ...otherTools },\n *   messages,\n * });\n * ```\n */\nexport function createBrowserTools(options: BrowserToolsOptions): ToolSet {\n  const handlers = createBrowserToolHandlers(options);\n\n  return {\n    browser_search: tool({\n      description: SEARCH_DESCRIPTION,\n      inputSchema: z.object({\n        code: z\n          .string()\n          .describe(\"JavaScript async arrow function that queries the CDP spec\")\n      }),\n      execute: async ({ code }) => {\n        const result = await handlers.search(code);\n        if (result.isError) {\n          throw new Error(result.text);\n        }\n        return result.text;\n      }\n    }),\n\n    browser_execute: tool({\n      description: EXECUTE_DESCRIPTION,\n      inputSchema: z.object({\n        code: z\n          .string()\n          .describe(\"JavaScript async arrow function that uses the cdp helper\")\n      }),\n      execute: async ({ code }) => {\n        const result = await handlers.execute(code);\n        if (result.isError) {\n          throw new Error(result.text);\n        }\n        return result.text;\n      }\n    })\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,mBAAmB,SAAuC;CACxE,MAAM,WAAW,0BAA0B,OAAO;CAElD,OAAO;EACL,gBAAgB,KAAK;GACnB,aAAa;GACb,aAAa,EAAE,OAAO,EACpB,MAAM,EACH,OAAO,CAAC,CACR,SAAS,2DAA2D,EACzE,CAAC;GACD,SAAS,OAAO,EAAE,WAAW;IAC3B,MAAM,SAAS,MAAM,SAAS,OAAO,IAAI;IACzC,IAAI,OAAO,SACT,MAAM,IAAI,MAAM,OAAO,IAAI;IAE7B,OAAO,OAAO;GAChB;EACF,CAAC;EAED,iBAAiB,KAAK;GACpB,aAAa;GACb,aAAa,EAAE,OAAO,EACpB,MAAM,EACH,OAAO,CAAC,CACR,SAAS,0DAA0D,EACxE,CAAC;GACD,SAAS,OAAO,EAAE,WAAW;IAC3B,MAAM,SAAS,MAAM,SAAS,QAAQ,IAAI;IAC1C,IAAI,OAAO,SACT,MAAM,IAAI,MAAM,OAAO,IAAI;IAE7B,OAAO,OAAO;GAChB;EACF,CAAC;CACH;AACF"}
+{"version":3,"file":"ai.js","names":["agentContext"],"sources":["../../src/browser/ai.ts"],"sourcesContent":["import { tool, type ToolSet } from \"ai\";\nimport { z } from \"zod\";\nimport {\n  createCodemodeRuntime,\n  DynamicWorkerExecutor,\n  truncateResult,\n  type CodemodeRuntimeHandle\n} from \"@cloudflare/codemode\";\nimport { __DO_NOT_USE_WILL_BREAK__agentContext as agentContext } from \"../internal_context\";\nimport type { BrowserBinding } from \"./browser-run\";\nimport {\n  browserContent,\n  browserExtract,\n  browserLinks,\n  browserMarkdown,\n  browserScrape,\n  type QuickActionBinding,\n  type QuickActionCommonOptions,\n  type QuickActionPage\n} from \"./quick-actions\";\nimport {\n  BrowserConnector,\n  type BrowserConnectorOptions,\n  type BrowserConnectorSessionOptions\n} from \"./connector\";\nimport {\n  DurableBrowserSessionStore,\n  type BrowserSessionStore\n} from \"./session-manager\";\n\nexport interface CreateBrowserToolsOptions {\n  /**\n   * Durable Object state. The codemode runtime that backs the browser tool\n   * lives in a facet of this DO, and browser session ids are stored in its\n   * storage — so the tool must be created from inside a Durable Object\n   * (e.g. an Agent).\n   *\n   * Optional: when omitted, it is resolved from the current Agent via\n   * `getCurrentAgent()`, so inside an Agent method you can just pass `browser`\n   * and `loader`. Pass it explicitly outside an Agent context.\n   *\n   * The worker must export the `CodemodeRuntime` class (the\n   * `@cloudflare/codemode/vite` plugin does this automatically, or add\n   * `export { CodemodeRuntime } from \"@cloudflare/codemode\"` to your entry).\n   */\n  ctx?: DurableObjectState;\n\n  /**\n   * WorkerLoader binding for sandboxed code execution.\n   *\n   * Requires `\"worker_loaders\": [{ \"binding\": \"LOADER\" }]` in wrangler.jsonc.\n   */\n  loader: WorkerLoader;\n\n  /**\n   * Browser Rendering binding (Fetcher).\n   *\n   * This is the primary way to connect — works both locally in\n   * `wrangler dev` and when deployed to Cloudflare Workers.\n   *\n   * Requires `\"browser\": { \"binding\": \"BROWSER\" }` in wrangler.jsonc.\n   */\n  browser?: BrowserBinding;\n\n  /**\n   * Optional CDP base URL override (e.g. `http://localhost:9222`).\n   *\n   * Use when connecting to a manually managed Chrome instance or\n   * a remote CDP endpoint behind a tunnel.\n   */\n  cdpUrl?: string;\n\n  /**\n   * Headers to send with CDP URL discovery requests.\n   * Useful when the CDP endpoint requires authentication\n   * (e.g. Cloudflare Access headers).\n   */\n  cdpHeaders?: Record<string, string>;\n\n  /**\n   * Browser session lifecycle (binding-backed only). Defaults to one fresh\n   * session per codemode execution (`one-shot`).\n   */\n  session?: BrowserConnectorSessionOptions;\n\n  /**\n   * Durable store for Browser Run session ids. Defaults to a\n   * {@link DurableBrowserSessionStore} over `ctx.storage`.\n   */\n  store?: BrowserSessionStore;\n\n  /**\n   * Sandbox execution timeout in milliseconds. Defaults to 30000 (30s).\n   * Also used as the per-CDP-command timeout.\n   */\n  timeout?: number;\n\n  /**\n   * Codemode runtime name — the durable identity of the tool's executions\n   * and snippets. Defaults to `\"browser\"`.\n   */\n  name?: string;\n\n  /**\n   * Also expose stateless {@link createQuickActionTools | Quick Action} tools\n   * (`browser_markdown`, `browser_extract`, …) alongside the durable\n   * `browser_execute` tool.\n   *\n   * Enabled by default whenever a Browser Run `browser` binding is available\n   * (they share it). Pass an object to configure them, or `false` to disable.\n   * The Quick Action binding defaults to `browser`; override it via\n   * `quickActions.browser`. When only `cdpUrl` is set (no binding), the\n   * defaults are skipped silently — pass `quickActions: { browser }` to force\n   * them.\n   */\n  quickActions?:\n    | boolean\n    | {\n        browser?: QuickActionBinding;\n        actions?: QuickActionToolName[];\n        maxChars?: number;\n        options?: QuickActionCommonOptions;\n      };\n}\n\n/**\n * The browser tool's moving parts, for hosts that need more than the tools:\n *\n * - `runtime` — the codemode runtime handle (approve/reject paused runs,\n *   `expirePaused`, audit via `executions()`, snippets).\n * - `connector` — host-side session helpers: `sessionInfo()`,\n *   `closeSession()`, and `sweep()` for a recurring cleanup task.\n * - `tools` — what `createBrowserTools` returns.\n */\nexport interface BrowserRuntime {\n  runtime: CodemodeRuntimeHandle;\n  connector: BrowserConnector;\n  tools: ToolSet;\n}\n\nlet didWarnExperimental = false;\nlet didDebugQuickActionSkip = false;\n\n/**\n * The Durable Object state to build the runtime in: the explicit `ctx` if\n * given, otherwise the current Agent's `ctx` (via `getCurrentAgent()`), so\n * `createBrowserRuntime` can be called from an Agent method without threading\n * `this.ctx` through.\n */\nfunction resolveCtx(\n  options: CreateBrowserToolsOptions\n): DurableObjectState | undefined {\n  if (options.ctx) return options.ctx;\n  const agent = agentContext.getStore()?.agent as\n    | { ctx?: DurableObjectState }\n    | undefined;\n  return agent?.ctx;\n}\n\nfunction connectorOptions(\n  options: CreateBrowserToolsOptions,\n  ctx: DurableObjectState\n): BrowserConnectorOptions {\n  if (options.cdpUrl) {\n    return {\n      cdpUrl: options.cdpUrl,\n      cdpHeaders: options.cdpHeaders,\n      timeout: options.timeout\n    };\n  }\n  if (!options.browser) {\n    throw new Error(\n      \"Either 'browser' (Fetcher binding) or 'cdpUrl' must be provided\"\n    );\n  }\n  return {\n    browser: options.browser,\n    store: options.store ?? new DurableBrowserSessionStore(ctx.storage),\n    session: options.session,\n    timeout: options.timeout\n  };\n}\n\n/**\n * Create the browser codemode runtime: the `browser_execute` tool plus the\n * runtime handle and connector for host-side wiring (approvals, session info,\n * sweeps).\n *\n * @example\n * ```ts\n * export class MyAgent extends Agent<Env> {\n *   get browser() {\n *     return createBrowserRuntime({\n *       ctx: this.ctx,\n *       browser: this.env.BROWSER,\n *       loader: this.env.LOADER,\n *       session: { mode: \"dynamic\" }\n *     });\n *   }\n *\n *   @callable()\n *   async closeBrowserSession() {\n *     await this.browser.connector.closeSession();\n *   }\n * }\n * ```\n */\nexport function createBrowserRuntime(\n  options: CreateBrowserToolsOptions\n): BrowserRuntime {\n  if (!didWarnExperimental) {\n    didWarnExperimental = true;\n    console.warn(\n      \"[agents/browser] Browser tools are experimental and may change in a future release.\"\n    );\n  }\n\n  const ctx = resolveCtx(options);\n  if (!ctx) {\n    throw new Error(\n      \"createBrowserRuntime requires a Durable Object 'ctx' — pass it explicitly, or call from within an Agent so it can be resolved via getCurrentAgent()\"\n    );\n  }\n\n  const connector = new BrowserConnector(ctx, connectorOptions(options, ctx));\n  const runtime = createCodemodeRuntime({\n    ctx,\n    executor: new DynamicWorkerExecutor({\n      loader: options.loader,\n      timeout: options.timeout\n    }),\n    connectors: [connector],\n    name: options.name ?? \"browser\",\n    transformResult: truncateResult\n  });\n\n  const tools: ToolSet = { browser_execute: runtime.tool() };\n\n  // Quick Actions ride the same `browser` binding, so they are on by default.\n  // `env.BROWSER` satisfies both the CDP `BrowserBinding` (fetch) and the\n  // `QuickActionBinding` (quickAction) surfaces; our narrower option type only\n  // sees the former, so reuse it here unless an explicit binding wins.\n  if (options.quickActions !== false) {\n    const qa =\n      options.quickActions == null || options.quickActions === true\n        ? {}\n        : options.quickActions;\n    const quickActionBrowser =\n      qa.browser ??\n      (options.browser as unknown as QuickActionBinding | undefined);\n    if (quickActionBrowser) {\n      Object.assign(\n        tools,\n        createQuickActionTools({\n          browser: quickActionBrowser,\n          actions: qa.actions,\n          maxChars: qa.maxChars,\n          options: qa.options\n        })\n      );\n    } else if (options.quickActions) {\n      // Explicitly requested but no binding to back them.\n      throw new Error(\n        \"quickActions requires a Browser Run binding — set 'browser' (env.BROWSER) or 'quickActions.browser'\"\n      );\n    } else if (!didDebugQuickActionSkip) {\n      // Defaulted on, but only `cdpUrl` is set: there is no binding to call\n      // Quick Actions through, so they are skipped. Surface it once so a user\n      // expecting `browser_markdown` et al. isn't left wondering.\n      didDebugQuickActionSkip = true;\n      console.debug(\n        \"[agents/browser] Quick Action tools skipped — no Browser Run binding (only 'cdpUrl' is set). Pass 'browser' or 'quickActions.browser' to enable them.\"\n      );\n    }\n  }\n\n  return { runtime, connector, tools };\n}\n\n/**\n * Create AI SDK tools for browser automation via CDP code mode.\n *\n * Returns a `ToolSet` with a single durable `browser_execute` tool backed by\n * a codemode runtime: the model writes TypeScript against the `cdp` connector\n * (`cdp.send`, `cdp.attachToTarget`, `cdp.spec`, …), executions are recorded\n * for abort-and-replay, and browser sessions survive pauses.\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/ai\";\n * import { generateText } from \"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 result = await generateText({\n *   model,\n *   tools: { ...browserTools, ...otherTools },\n *   messages,\n * });\n * ```\n */\nexport function createBrowserTools(\n  options: CreateBrowserToolsOptions\n): ToolSet {\n  return createBrowserRuntime(options).tools;\n}\n\n/** A Quick Action exposed as an AI SDK tool. */\nexport type QuickActionToolName =\n  | \"markdown\"\n  | \"extract\"\n  | \"links\"\n  | \"scrape\"\n  | \"content\";\n\nexport interface CreateQuickActionToolsOptions {\n  /**\n   * Browser Run binding with Quick Actions support (`env.BROWSER`). Requires a\n   * Worker `compatibility_date` of `2026-03-24`+ and `remote: true` for local\n   * `wrangler dev`.\n   */\n  browser: QuickActionBinding;\n\n  /**\n   * Which tools to expose. Defaults to the text-returning, model-friendly set\n   * (`markdown`, `extract`, `links`, `scrape`). `content` (raw HTML) is opt-in\n   * since it is large and rarely what a model wants.\n   */\n  actions?: QuickActionToolName[];\n\n  /**\n   * Bound every result to roughly this many characters before returning it to\n   * the model, to protect the context window, preserving each result's shape:\n   * text (markdown/content) is truncated to a string, oversized arrays\n   * (links/scrape) are trimmed but stay arrays, and only an opaque oversized\n   * object degrades to a truncated-preview summary. Set to `0` to disable.\n   * Defaults to 50000.\n   */\n  maxChars?: number;\n\n  /**\n   * Common Browser Run options merged into every request — e.g. `cookies`,\n   * `authenticate`, or `setExtraHTTPHeaders` for authenticated pages, and\n   * `gotoOptions` / `viewport` for JavaScript-heavy pages. The model only ever\n   * supplies the page (`url`/`html`) and action-specific fields; these\n   * host-supplied options are never exposed to it.\n   */\n  options?: QuickActionCommonOptions;\n}\n\nconst DEFAULT_QUICK_ACTION_TOOLS: QuickActionToolName[] = [\n  \"markdown\",\n  \"extract\",\n  \"links\",\n  \"scrape\"\n];\n\nconst DEFAULT_QUICK_ACTION_MAX_CHARS = 50_000;\n\nconst pageInputSchema = z\n  .object({\n    url: z.string().url().optional().describe(\"URL of the page to load\"),\n    html: z\n      .string()\n      .optional()\n      .describe(\"Raw HTML to render instead of loading a URL\")\n  })\n  .refine((value) => Boolean(value.url) || Boolean(value.html), {\n    message: \"Provide either 'url' or 'html'\"\n  });\n\nfunction toPage(\n  input: { url?: string; html?: string },\n  options?: QuickActionCommonOptions\n): QuickActionPage {\n  const page = input.url ? { url: input.url } : { html: input.html as string };\n  return { ...options, ...page } as QuickActionPage;\n}\n\nfunction truncate(text: string, maxChars: number): string {\n  if (maxChars <= 0 || text.length <= maxChars) return text;\n  return `${text.slice(0, maxChars)}\\n\\n[truncated ${text.length - maxChars} characters]`;\n}\n\n/**\n * Keep a tool result within a rough character budget so a single browse cannot\n * blow the model's context window — while preserving the result's shape so the\n * model sees a consistent type across calls:\n *\n * - strings (markdown/content) are truncated to a string;\n * - arrays (links/scrape) are trimmed from the end but stay arrays;\n * - only an opaque oversized object (e.g. a sprawling `extract`) degrades to a\n *   `{ truncated, note, preview }` summary, since it cannot be trimmed safely.\n */\nfunction boundResult(value: unknown, maxChars: number): unknown {\n  if (maxChars <= 0) return value;\n  if (typeof value === \"string\") return truncate(value, maxChars);\n  let json: string;\n  try {\n    json = JSON.stringify(value);\n  } catch {\n    return value;\n  }\n  if (json.length <= maxChars) return value;\n  if (Array.isArray(value)) {\n    const trimmed = boundArray(value, maxChars);\n    // If even the first element overflows the budget, `trimmed` is empty —\n    // returning `[]` would read as \"no results\" rather than \"too large\", so\n    // fall through to the explicit truncated-preview summary instead.\n    if (trimmed.length > 0) return trimmed;\n  }\n  return {\n    truncated: true,\n    note: `Result is too large (${json.length} characters); narrow the request.`,\n    preview: `${json.slice(0, maxChars)}…`\n  };\n}\n\n/**\n * Take as many leading items as fit within `maxChars` (measured against their\n * JSON length), returning a trimmed array of the same element type. Silent by\n * design: the model gets fewer, valid items rather than a reshaped result.\n */\nfunction boundArray(value: unknown[], maxChars: number): unknown[] {\n  const out: unknown[] = [];\n  let size = 2; // the enclosing \"[]\"\n  for (const item of value) {\n    const itemSize = JSON.stringify(item).length + 1; // + a separating comma\n    if (size + itemSize > maxChars) break;\n    out.push(item);\n    size += itemSize;\n  }\n  return out;\n}\n\n/**\n * Create AI SDK tools for Browser Run [Quick Actions](https://developers.cloudflare.com/browser-run/quick-actions/):\n * stateless one-shot browsing (read a page as Markdown, extract structured\n * data with AI, list links, scrape elements). Unlike `createBrowserTools`,\n * these need only the `browser` binding — no Durable Object, loader, or\n * sandbox — so they work from any Worker.\n *\n * @example\n * ```ts\n * import { createQuickActionTools } from \"agents/browser/ai\";\n *\n * const tools = createQuickActionTools({ browser: this.env.BROWSER });\n * const result = await generateText({ model, tools, messages });\n * ```\n */\nexport function createQuickActionTools(\n  options: CreateQuickActionToolsOptions\n): ToolSet {\n  const { browser } = options;\n  const requestOptions = options.options;\n  const enabled = new Set(options.actions ?? DEFAULT_QUICK_ACTION_TOOLS);\n  const maxChars = options.maxChars ?? DEFAULT_QUICK_ACTION_MAX_CHARS;\n  const tools: ToolSet = {};\n\n  if (enabled.has(\"markdown\")) {\n    tools.browser_markdown = tool({\n      description:\n        \"Load a web page (or render raw HTML) and return its content as Markdown. Best for reading articles, docs, or any page as text.\",\n      inputSchema: pageInputSchema,\n      execute: async (input) =>\n        boundResult(\n          await browserMarkdown(browser, toPage(input, requestOptions)),\n          maxChars\n        )\n    });\n  }\n\n  if (enabled.has(\"extract\")) {\n    tools.browser_extract = tool({\n      description:\n        \"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.\",\n      inputSchema: z\n        .object({\n          url: z.string().url().optional().describe(\"URL of the page to load\"),\n          html: z\n            .string()\n            .optional()\n            .describe(\"Raw HTML to render instead of loading a URL\"),\n          prompt: z\n            .string()\n            .optional()\n            .describe(\"What to extract, in natural language\"),\n          schema: z\n            .unknown()\n            .optional()\n            .describe(\"Optional JSON Schema describing the desired output\")\n        })\n        .refine((value) => Boolean(value.url) || Boolean(value.html), {\n          message: \"Provide either 'url' or 'html'\"\n        })\n        .refine((value) => Boolean(value.prompt) || Boolean(value.schema), {\n          message: \"Provide either 'prompt' or 'schema'\"\n        }),\n      execute: async (input) =>\n        boundResult(\n          await browserExtract(browser, {\n            ...toPage(input, requestOptions),\n            prompt: input.prompt,\n            response_format: input.schema\n              ? { type: \"json_schema\", schema: input.schema }\n              : undefined\n          }),\n          maxChars\n        )\n    });\n  }\n\n  if (enabled.has(\"links\")) {\n    tools.browser_links = tool({\n      description:\n        \"Return every link found on a web page (including ones not visible). Useful for discovering pages to follow.\",\n      inputSchema: pageInputSchema,\n      execute: async (input) =>\n        boundResult(\n          await browserLinks(browser, toPage(input, requestOptions)),\n          maxChars\n        )\n    });\n  }\n\n  if (enabled.has(\"scrape\")) {\n    tools.browser_scrape = tool({\n      description:\n        \"Scrape specific elements from a web page by CSS selector. Returns the matched elements' text, HTML, and attributes.\",\n      inputSchema: z\n        .object({\n          url: z.string().url().optional().describe(\"URL of the page to load\"),\n          html: z\n            .string()\n            .optional()\n            .describe(\"Raw HTML to render instead of loading a URL\"),\n          selectors: z\n            .array(z.string())\n            .min(1)\n            .describe(\"CSS selectors to extract\")\n        })\n        .refine((value) => Boolean(value.url) || Boolean(value.html), {\n          message: \"Provide either 'url' or 'html'\"\n        }),\n      execute: async (input) =>\n        boundResult(\n          await browserScrape(browser, {\n            ...toPage(input, requestOptions),\n            elements: input.selectors.map((selector) => ({ selector }))\n          }),\n          maxChars\n        )\n    });\n  }\n\n  if (enabled.has(\"content\")) {\n    tools.browser_content = tool({\n      description:\n        \"Load a web page and return its fully rendered HTML (after JavaScript runs). Prefer 'browser_markdown' unless you need the raw HTML.\",\n      inputSchema: pageInputSchema,\n      execute: async (input) =>\n        boundResult(\n          await browserContent(browser, toPage(input, requestOptions)),\n          maxChars\n        )\n    });\n  }\n\n  return tools;\n}\n"],"mappings":";;;;;;AA4IA,IAAI,sBAAsB;AAC1B,IAAI,0BAA0B;;;;;;;AAQ9B,SAAS,WACP,SACgC;CAChC,IAAI,QAAQ,KAAK,OAAO,QAAQ;CAIhC,QAHcA,sCAAa,SAAS,CAAC,EAAE,MAAA,EAGzB;AAChB;AAEA,SAAS,iBACP,SACA,KACyB;CACzB,IAAI,QAAQ,QACV,OAAO;EACL,QAAQ,QAAQ;EAChB,YAAY,QAAQ;EACpB,SAAS,QAAQ;CACnB;CAEF,IAAI,CAAC,QAAQ,SACX,MAAM,IAAI,MACR,iEACF;CAEF,OAAO;EACL,SAAS,QAAQ;EACjB,OAAO,QAAQ,SAAS,IAAI,2BAA2B,IAAI,OAAO;EAClE,SAAS,QAAQ;EACjB,SAAS,QAAQ;CACnB;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,qBACd,SACgB;CAChB,IAAI,CAAC,qBAAqB;EACxB,sBAAsB;EACtB,QAAQ,KACN,qFACF;CACF;CAEA,MAAM,MAAM,WAAW,OAAO;CAC9B,IAAI,CAAC,KACH,MAAM,IAAI,MACR,qJACF;CAGF,MAAM,YAAY,IAAI,iBAAiB,KAAK,iBAAiB,SAAS,GAAG,CAAC;CAC1E,MAAM,UAAU,sBAAsB;EACpC;EACA,UAAU,IAAI,sBAAsB;GAClC,QAAQ,QAAQ;GAChB,SAAS,QAAQ;EACnB,CAAC;EACD,YAAY,CAAC,SAAS;EACtB,MAAM,QAAQ,QAAQ;EACtB,iBAAiB;CACnB,CAAC;CAED,MAAM,QAAiB,EAAE,iBAAiB,QAAQ,KAAK,EAAE;CAMzD,IAAI,QAAQ,iBAAiB,OAAO;EAClC,MAAM,KACJ,QAAQ,gBAAgB,QAAQ,QAAQ,iBAAiB,OACrD,CAAC,IACD,QAAQ;EACd,MAAM,qBACJ,GAAG,WACF,QAAQ;EACX,IAAI,oBACF,OAAO,OACL,OACA,uBAAuB;GACrB,SAAS;GACT,SAAS,GAAG;GACZ,UAAU,GAAG;GACb,SAAS,GAAG;EACd,CAAC,CACH;OACK,IAAI,QAAQ,cAEjB,MAAM,IAAI,MACR,qGACF;OACK,IAAI,CAAC,yBAAyB;GAInC,0BAA0B;GAC1B,QAAQ,MACN,uJACF;EACF;CACF;CAEA,OAAO;EAAE;EAAS;EAAW;CAAM;AACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,mBACd,SACS;CACT,OAAO,qBAAqB,OAAO,CAAC,CAAC;AACvC;AA6CA,MAAM,6BAAoD;CACxD;CACA;CACA;CACA;AACF;AAEA,MAAM,iCAAiC;AAEvC,MAAM,kBAAkB,EACrB,OAAO;CACN,KAAK,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,yBAAyB;CACnE,MAAM,EACH,OAAO,CAAC,CACR,SAAS,CAAC,CACV,SAAS,6CAA6C;AAC3D,CAAC,CAAC,CACD,QAAQ,UAAU,QAAQ,MAAM,GAAG,KAAK,QAAQ,MAAM,IAAI,GAAG,EAC5D,SAAS,iCACX,CAAC;AAEH,SAAS,OACP,OACA,SACiB;CACjB,MAAM,OAAO,MAAM,MAAM,EAAE,KAAK,MAAM,IAAI,IAAI,EAAE,MAAM,MAAM,KAAe;CAC3E,OAAO;EAAE,GAAG;EAAS,GAAG;CAAK;AAC/B;AAEA,SAAS,SAAS,MAAc,UAA0B;CACxD,IAAI,YAAY,KAAK,KAAK,UAAU,UAAU,OAAO;CACrD,OAAO,GAAG,KAAK,MAAM,GAAG,QAAQ,EAAE,iBAAiB,KAAK,SAAS,SAAS;AAC5E;;;;;;;;;;;AAYA,SAAS,YAAY,OAAgB,UAA2B;CAC9D,IAAI,YAAY,GAAG,OAAO;CAC1B,IAAI,OAAO,UAAU,UAAU,OAAO,SAAS,OAAO,QAAQ;CAC9D,IAAI;CACJ,IAAI;EACF,OAAO,KAAK,UAAU,KAAK;CAC7B,QAAQ;EACN,OAAO;CACT;CACA,IAAI,KAAK,UAAU,UAAU,OAAO;CACpC,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,MAAM,UAAU,WAAW,OAAO,QAAQ;EAI1C,IAAI,QAAQ,SAAS,GAAG,OAAO;CACjC;CACA,OAAO;EACL,WAAW;EACX,MAAM,wBAAwB,KAAK,OAAO;EAC1C,SAAS,GAAG,KAAK,MAAM,GAAG,QAAQ,EAAE;CACtC;AACF;;;;;;AAOA,SAAS,WAAW,OAAkB,UAA6B;CACjE,MAAM,MAAiB,CAAC;CACxB,IAAI,OAAO;CACX,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,WAAW,KAAK,UAAU,IAAI,CAAC,CAAC,SAAS;EAC/C,IAAI,OAAO,WAAW,UAAU;EAChC,IAAI,KAAK,IAAI;EACb,QAAQ;CACV;CACA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,uBACd,SACS;CACT,MAAM,EAAE,YAAY;CACpB,MAAM,iBAAiB,QAAQ;CAC/B,MAAM,UAAU,IAAI,IAAI,QAAQ,WAAW,0BAA0B;CACrE,MAAM,WAAW,QAAQ,YAAY;CACrC,MAAM,QAAiB,CAAC;CAExB,IAAI,QAAQ,IAAI,UAAU,GACxB,MAAM,mBAAmB,KAAK;EAC5B,aACE;EACF,aAAa;EACb,SAAS,OAAO,UACd,YACE,MAAM,gBAAgB,SAAS,OAAO,OAAO,cAAc,CAAC,GAC5D,QACF;CACJ,CAAC;CAGH,IAAI,QAAQ,IAAI,SAAS,GACvB,MAAM,kBAAkB,KAAK;EAC3B,aACE;EACF,aAAa,EACV,OAAO;GACN,KAAK,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,yBAAyB;GACnE,MAAM,EACH,OAAO,CAAC,CACR,SAAS,CAAC,CACV,SAAS,6CAA6C;GACzD,QAAQ,EACL,OAAO,CAAC,CACR,SAAS,CAAC,CACV,SAAS,sCAAsC;GAClD,QAAQ,EACL,QAAQ,CAAC,CACT,SAAS,CAAC,CACV,SAAS,oDAAoD;EAClE,CAAC,CAAC,CACD,QAAQ,UAAU,QAAQ,MAAM,GAAG,KAAK,QAAQ,MAAM,IAAI,GAAG,EAC5D,SAAS,iCACX,CAAC,CAAC,CACD,QAAQ,UAAU,QAAQ,MAAM,MAAM,KAAK,QAAQ,MAAM,MAAM,GAAG,EACjE,SAAS,sCACX,CAAC;EACH,SAAS,OAAO,UACd,YACE,MAAM,eAAe,SAAS;GAC5B,GAAG,OAAO,OAAO,cAAc;GAC/B,QAAQ,MAAM;GACd,iBAAiB,MAAM,SACnB;IAAE,MAAM;IAAe,QAAQ,MAAM;GAAO,IAC5C,KAAA;EACN,CAAC,GACD,QACF;CACJ,CAAC;CAGH,IAAI,QAAQ,IAAI,OAAO,GACrB,MAAM,gBAAgB,KAAK;EACzB,aACE;EACF,aAAa;EACb,SAAS,OAAO,UACd,YACE,MAAM,aAAa,SAAS,OAAO,OAAO,cAAc,CAAC,GACzD,QACF;CACJ,CAAC;CAGH,IAAI,QAAQ,IAAI,QAAQ,GACtB,MAAM,iBAAiB,KAAK;EAC1B,aACE;EACF,aAAa,EACV,OAAO;GACN,KAAK,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,yBAAyB;GACnE,MAAM,EACH,OAAO,CAAC,CACR,SAAS,CAAC,CACV,SAAS,6CAA6C;GACzD,WAAW,EACR,MAAM,EAAE,OAAO,CAAC,CAAC,CACjB,IAAI,CAAC,CAAC,CACN,SAAS,0BAA0B;EACxC,CAAC,CAAC,CACD,QAAQ,UAAU,QAAQ,MAAM,GAAG,KAAK,QAAQ,MAAM,IAAI,GAAG,EAC5D,SAAS,iCACX,CAAC;EACH,SAAS,OAAO,UACd,YACE,MAAM,cAAc,SAAS;GAC3B,GAAG,OAAO,OAAO,cAAc;GAC/B,UAAU,MAAM,UAAU,KAAK,cAAc,EAAE,SAAS,EAAE;EAC5D,CAAC,GACD,QACF;CACJ,CAAC;CAGH,IAAI,QAAQ,IAAI,SAAS,GACvB,MAAM,kBAAkB,KAAK;EAC3B,aACE;EACF,aAAa;EACb,SAAS,OAAO,UACd,YACE,MAAM,eAAe,SAAS,OAAO,OAAO,cAAc,CAAC,GAC3D,QACF;CACJ,CAAC;CAGH,OAAO;AACT"}

package/dist/browser/index.d.ts

@@ -1,82 +1,146 @@
 import {
-  a as createBrowserToolHandlers,
-  i as ToolResult,
-  n as EXECUTE_DESCRIPTION,
-  r as SEARCH_DESCRIPTION,
-  t as BrowserToolsOptions
-} from "../shared-4CAYLCTO.js";
+  A as browserMarkdown,
+  B as BrowserTargetInfo,
+  C as QuickActionScrapeInput,
+  D as browserContent,
+  E as QuickActionSnapshot,
+  F as runQuickAction,
+  G as deleteBrowserSession,
+  H as connectBrowser,
+  I as BrowserBinding,
+  J as CdpAttachOptions,
+  K as getBrowserRecording,
+  L as BrowserRecording,
+  M as browserScrape,
+  N as browserScreenshot,
+  O as browserExtract,
+  P as browserSnapshot,
+  R as BrowserRenderingError,
+  S as QuickActionPage,
+  T as QuickActionScreenshotInput,
+  U as connectBrowserSession,
+  V as ConnectBrowserOptions,
+  W as createBrowserSession,
+  X as CdpSession,
+  Y as CdpSendOptions,
+  Z as connectUrl,
+  _ as QuickActionBinary,
+  a as BrowserConnectorSweepResult,
+  b as QuickActionExtractInput,
+  c as BrowserLiveViewUrl,
+  d as BrowserSessionLock,
+  f as BrowserSessionStore,
+  g as QuickAction,
+  h as StoredBrowserSession,
+  i as BrowserConnectorSweepOptions,
+  j as browserPdf,
+  k as browserLinks,
+  l as DEFAULT_EXEC_SWEEP_IDLE_MS,
+  m as DurableBrowserSessionStore,
+  n as BrowserConnectorOptions,
+  o as BrowserLiveView,
+  p as DEFAULT_SWEEP_IDLE_MS,
+  q as listBrowserTargets,
+  r as BrowserConnectorSessionOptions,
+  s as BrowserLiveViewTarget,
+  t as BrowserConnector,
+  u as LiveViewMode,
+  v as QuickActionBinding,
+  w as QuickActionScrapeResult,
+  x as QuickActionInput,
+  y as QuickActionCommonOptions,
+  z as BrowserSessionInfo
+} from "../connector-v2M1zlZp.js";
+import { CodemodeRuntime } from "@cloudflare/codemode";
 
-//#region src/browser/cdp-session.d.ts
-interface DebugEntry {
-  at: string;
-  type: string;
-  [key: string]: unknown;
+//#region src/browser/spec.d.ts
+interface SearchableCdpSpec {
+  domains: Array<{
+    name: string;
+    description?: string;
+    commands: Array<{
+      name: string;
+      method: string;
+      description?: string;
+    }>;
+    events: Array<{
+      name: string;
+      event: string;
+      description?: string;
+    }>;
+    types: Array<{
+      id: string;
+      name: string;
+      description?: string;
+    }>;
+  }>;
 }
-interface CdpSendOptions {
-  timeoutMs?: number;
-  sessionId?: string;
+interface CdpSpecSource {
+  /** Browser Rendering binding (Fetcher) — used in production */
+  browser?: BrowserBinding;
+  /** CDP base URL override (e.g. http://localhost:9222) */
+  cdpUrl?: string;
+  /** Headers to send with CDP URL discovery requests */
+  cdpHeaders?: Record<string, string>;
 }
-interface CdpAttachOptions {
-  timeoutMs?: number;
-}
-/**
- * A CDP session over an open WebSocket. Manages command correlation,
- * timeouts, target sessions, and a debug event ring buffer.
- *
- * Used host-side (not in the sandbox) — the sandbox calls into this
- * via DynamicWorkerExecutor's ToolDispatcher RPC.
- */
-declare class CdpSession {
-  #private;
-  constructor(
-    socket: WebSocket,
-    defaultTimeoutMs?: number,
-    dispose?: () => void
-  );
-  send(
-    method: string,
-    params?: unknown,
-    options?: CdpSendOptions
-  ): Promise<unknown>;
-  attachToTarget(targetId: string, options?: CdpAttachOptions): Promise<string>;
-  getDebugLog(limit?: number): DebugEntry[];
-  clearDebugLog(): void;
-  close(): void;
-}
-/**
- * Connect to a browser via the Browser Rendering binding (Fetcher).
- * Establishes a CDP WebSocket through the binding's fetch interface.
- */
-declare function connectBrowser(
-  browser: Fetcher,
-  timeoutMs?: number
-): Promise<CdpSession>;
-/**
- * Connect to a browser via a CDP base URL (e.g. http://localhost:9222).
- * Discovers the WebSocket debugger URL via /json/version,
- * rewrites localhost URLs to the base URL host, and opens the WebSocket.
- *
- * Useful for local development with `chrome --remote-debugging-port=9222`
- * or when connecting through a tunnel.
- */
-declare function connectUrl(
-  baseUrl: string,
-  options?: {
-    timeoutMs?: number;
-    headers?: Record<string, string>;
-  }
-): Promise<CdpSession>;
+/** Load the (cached) searchable CDP spec for a browser source. */
+declare function loadCdpSpec(source: CdpSpecSource): Promise<SearchableCdpSpec>;
 //#endregion
 export {
-  type BrowserToolsOptions,
+  type BrowserBinding,
+  BrowserConnector,
+  type BrowserConnectorOptions,
+  type BrowserConnectorSessionOptions,
+  type BrowserConnectorSweepOptions,
+  type BrowserConnectorSweepResult,
+  type BrowserLiveView,
+  type BrowserLiveViewTarget,
+  type BrowserLiveViewUrl,
+  type BrowserRecording,
+  BrowserRenderingError,
+  type BrowserSessionInfo,
+  type BrowserSessionLock,
+  type BrowserSessionStore,
+  type BrowserTargetInfo,
   type CdpAttachOptions,
   type CdpSendOptions,
   CdpSession,
-  EXECUTE_DESCRIPTION,
-  SEARCH_DESCRIPTION,
-  type ToolResult,
+  type CdpSpecSource,
+  CodemodeRuntime,
+  type ConnectBrowserOptions,
+  DEFAULT_EXEC_SWEEP_IDLE_MS,
+  DEFAULT_SWEEP_IDLE_MS,
+  DurableBrowserSessionStore,
+  type LiveViewMode,
+  type QuickAction,
+  type QuickActionBinary,
+  type QuickActionBinding,
+  type QuickActionCommonOptions,
+  type QuickActionExtractInput,
+  type QuickActionInput,
+  type QuickActionPage,
+  type QuickActionScrapeInput,
+  type QuickActionScrapeResult,
+  type QuickActionScreenshotInput,
+  type QuickActionSnapshot,
+  type SearchableCdpSpec,
+  type StoredBrowserSession,
+  browserContent,
+  browserExtract,
+  browserLinks,
+  browserMarkdown,
+  browserPdf,
+  browserScrape,
+  browserScreenshot,
+  browserSnapshot,
   connectBrowser,
+  connectBrowserSession,
   connectUrl,
-  createBrowserToolHandlers
+  createBrowserSession,
+  deleteBrowserSession,
+  getBrowserRecording,
+  listBrowserTargets,
+  loadCdpSpec,
+  runQuickAction
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/browser/index.js

@@ -1,2 +1,3 @@
-import { a as connectBrowser, i as CdpSession, n as SEARCH_DESCRIPTION, o as connectUrl, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-wyII629d.js";
-export { CdpSession, EXECUTE_DESCRIPTION, SEARCH_DESCRIPTION, connectBrowser, connectUrl, createBrowserToolHandlers };
+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-CrKhowfD.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 };

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

@@ -1,21 +1,29 @@
-import { t as BrowserToolsOptions } from "../shared-4CAYLCTO.js";
+import { CreateBrowserToolsOptions } from "./ai.js";
 import { ServerTool } from "@tanstack/ai";
 
 //#region src/browser/tanstack-ai.d.ts
 /**
  * Create TanStack AI tools for browser automation via CDP code mode.
  *
- * Returns an array of `ServerTool`s: `browser_search` (query the CDP spec)
- * and `browser_execute` (run CDP commands against a live browser).
+ * Returns an array with a single durable `browser_execute` `ServerTool`
+ * backed by the same codemode runtime as `agents/browser/ai` — the model
+ * writes TypeScript against the `cdp` connector and browser sessions
+ * survive pauses.
+ *
+ * The stateless Quick Action tools are not surfaced through this TanStack
+ * wrapper (it exposes only `browser_execute`); use `createQuickActionTools`
+ * from `agents/browser/ai` if you want them.
  *
  * @example
  * ```ts
  * import { createBrowserTools } from "agents/browser/tanstack-ai";
  * import { chat } from "@tanstack/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 stream = chat({
@@ -25,7 +33,9 @@ import { ServerTool } from "@tanstack/ai";
  * });
  * ```
  */
-declare function createBrowserTools(options: BrowserToolsOptions): ServerTool[];
+declare function createBrowserTools(
+  options: CreateBrowserToolsOptions
+): ServerTool[];
 //#endregion
-export { type BrowserToolsOptions, createBrowserTools };
+export { type CreateBrowserToolsOptions, createBrowserTools };
 //# sourceMappingURL=tanstack-ai.d.ts.map

package/dist/browser/tanstack-ai.js

@@ -1,21 +1,29 @@
-import { n as SEARCH_DESCRIPTION, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-wyII629d.js";
+import { createBrowserRuntime } from "./ai.js";
 import { z } from "zod";
 import { toolDefinition } from "@tanstack/ai";
 //#region src/browser/tanstack-ai.ts
 /**
 * Create TanStack AI tools for browser automation via CDP code mode.
 *
-* Returns an array of `ServerTool`s: `browser_search` (query the CDP spec)
-* and `browser_execute` (run CDP commands against a live browser).
+* Returns an array with a single durable `browser_execute` `ServerTool`
+* backed by the same codemode runtime as `agents/browser/ai` — the model
+* writes TypeScript against the `cdp` connector and browser sessions
+* survive pauses.
+*
+* The stateless Quick Action tools are not surfaced through this TanStack
+* wrapper (it exposes only `browser_execute`); use `createQuickActionTools`
+* from `agents/browser/ai` if you want them.
 *
 * @example
 * ```ts
 * import { createBrowserTools } from "agents/browser/tanstack-ai";
 * import { chat } from "@tanstack/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 stream = chat({
@@ -26,23 +34,21 @@ import { toolDefinition } from "@tanstack/ai";
 * ```
 */
 function createBrowserTools(options) {
-	const handlers = createBrowserToolHandlers(options);
+	const { tools } = createBrowserRuntime({
+		...options,
+		quickActions: false
+	});
+	const executeTool = tools.browser_execute;
 	return [toolDefinition({
-		name: "browser_search",
-		description: SEARCH_DESCRIPTION,
-		inputSchema: z.object({ code: z.string().meta({ description: "JavaScript async arrow function that queries the CDP spec" }) })
-	}).server(async ({ code }) => {
-		const result = await handlers.search(code);
-		if (result.isError) throw new Error(result.text);
-		return { text: result.text };
-	}), toolDefinition({
 		name: "browser_execute",
-		description: EXECUTE_DESCRIPTION,
-		inputSchema: z.object({ code: z.string().meta({ description: "JavaScript async arrow function that uses the cdp helper" }) })
+		description: executeTool.description ?? "",
+		inputSchema: z.object({ code: z.string().meta({ description: "TypeScript async arrow function that uses the cdp connector" }) })
 	}).server(async ({ code }) => {
-		const result = await handlers.execute(code);
-		if (result.isError) throw new Error(result.text);
-		return { text: result.text };
+		if (!executeTool.execute) throw new Error("browser_execute tool is not executable");
+		return await executeTool.execute({ code }, {
+			toolCallId: crypto.randomUUID(),
+			messages: []
+		});
 	})];
 }
 //#endregion

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 { z } from \"zod\";\nimport {\n  createBrowserToolHandlers,\n  SEARCH_DESCRIPTION,\n  EXECUTE_DESCRIPTION,\n  type BrowserToolsOptions\n} from \"./shared\";\n\nexport type { BrowserToolsOptions } from \"./shared\";\n\n/**\n * Create TanStack AI tools for browser automation via CDP code mode.\n *\n * Returns an array of `ServerTool`s: `browser_search` (query the CDP spec)\n * and `browser_execute` (run CDP commands against a live browser).\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * const browserTools = createBrowserTools({\n *   browser: env.BROWSER,\n *   loader: 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(options: BrowserToolsOptions): ServerTool[] {\n  const handlers = createBrowserToolHandlers(options);\n\n  const search = toolDefinition({\n    name: \"browser_search\" as const,\n    description: SEARCH_DESCRIPTION,\n    inputSchema: z.object({\n      code: z.string().meta({\n        description: \"JavaScript async arrow function that queries the CDP spec\"\n      })\n    })\n  }).server(async ({ code }) => {\n    const result = await handlers.search(code);\n    if (result.isError) {\n      throw new Error(result.text);\n    }\n    return { text: result.text };\n  });\n\n  const execute = toolDefinition({\n    name: \"browser_execute\" as const,\n    description: EXECUTE_DESCRIPTION,\n    inputSchema: z.object({\n      code: z.string().meta({\n        description: \"JavaScript async arrow function that uses the cdp helper\"\n      })\n    })\n  }).server(async ({ code }) => {\n    const result = await handlers.execute(code);\n    if (result.isError) {\n      throw new Error(result.text);\n    }\n    return { text: result.text };\n  });\n\n  return [search, execute];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,mBAAmB,SAA4C;CAC7E,MAAM,WAAW,0BAA0B,OAAO;CAkClD,OAAO,CAhCQ,eAAe;EAC5B,MAAM;EACN,aAAa;EACb,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,EACpB,aAAa,4DACf,CAAC,EACH,CAAC;CACH,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,MAAM,SAAS,MAAM,SAAS,OAAO,IAAI;EACzC,IAAI,OAAO,SACT,MAAM,IAAI,MAAM,OAAO,IAAI;EAE7B,OAAO,EAAE,MAAM,OAAO,KAAK;CAC7B,CAkBa,GAhBG,eAAe;EAC7B,MAAM;EACN,aAAa;EACb,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,EACpB,aAAa,2DACf,CAAC,EACH,CAAC;CACH,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,MAAM,SAAS,MAAM,SAAS,QAAQ,IAAI;EAC1C,IAAI,OAAO,SACT,MAAM,IAAI,MAAM,OAAO,IAAI;EAE7B,OAAO,EAAE,MAAM,OAAO,KAAK;CAC7B,CAEsB,CAAC;AACzB"}
+{"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: 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(\n      { code },\n      { toolCallId: crypto.randomUUID(), messages: [] }\n    )) as ProxyToolOutput;\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;CAsB1B,OAAO,CApBS,eAAe;EAC7B,MAAM;EACN,aAAa,YAAY,eAAe;EACxC,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;EAM1D,OAAO,MAJe,YAAY,QAChC,EAAE,KAAK,GACP;GAAE,YAAY,OAAO,WAAW;GAAG,UAAU,CAAC;EAAE,CAClD;CAEF,CAEc,CAAC;AACjB"}

package/dist/chat/index.d.ts

@@ -3,11 +3,11 @@ import {
   d as AgentToolRunState,
   i as AgentToolEventMessage,
   r as AgentToolEvent
-} from "../agent-tool-types-VPsjVYL0.js";
+} from "../agent-tool-types-NofdbL9X.js";
 import {
   n as createAgentToolEventState,
   t as applyAgentToolEvent
-} from "../agent-tools-BGpgfpJT.js";
+} from "../agent-tools-DLquv-dp.js";
 import { JSONSchema7, Tool, ToolSet, UIMessage } from "ai";
 import { Connection } from "agents";
 
@@ -277,17 +277,38 @@ type ClientToolSchema = {
   description?: Tool["description"] /** JSON Schema defining the tool's input parameters */;
   parameters?: JSONSchema7;
 };
+/**
+ * Executes a client-defined tool and returns its output.
+ *
+ * Used for the RPC path (e.g. a parent agent delegating to a Think sub-agent)
+ * where the caller can run the client tools itself, rather than the
+ * browser/WebSocket path where results are sent back asynchronously.
+ */
+type ClientToolExecutor = (call: {
+  /** The name of the client tool the model called. */ toolName: string /** The model-generated input for the tool call. */;
+  input: unknown /** The AI SDK tool-call id for the invocation. */;
+  toolCallId: string;
+}) => unknown | Promise<unknown>;
 /**
  * Converts client tool schemas to AI SDK tool format.
  *
- * These tools have no `execute` function — when the AI model calls them,
- * the tool call is sent back to the client for execution.
+ * By default these tools have no `execute` function — when the AI model calls
+ * them, the tool call is sent back to the client for execution.
+ *
+ * When `options.execute` is provided, each tool is built WITH an `execute` that
+ * delegates to it. This is used by the RPC path (e.g. a parent agent driving a
+ * Think sub-agent) so the model's client-tool call is resolved inline within
+ * the same turn.
  *
  * @param clientTools - Array of tool schemas from the client
+ * @param options - Optional `execute` delegate to run the tools inline
  * @returns Record of AI SDK tools that can be spread into your tools object
  */
 declare function createToolsFromClientSchemas(
-  clientTools?: ClientToolSchema[]
+  clientTools?: ClientToolSchema[],
+  options?: {
+    execute?: ClientToolExecutor;
+  }
 ): ToolSet;
 //#endregion
 //#region src/chat/lifecycle.d.ts
@@ -672,6 +693,12 @@ declare class ResumableStream {
    * DO was evicted.
    */
   private _isLive;
+  /**
+   * Whether the active stream is a continuation. Mirrors the durable
+   * `is_continuation` column so replay frames can carry the flag without a
+   * per-replay query; restored from SQLite after hibernation in restore().
+   */
+  private _activeIsContinuation;
   private _chunkBuffer;
   private _chunkBufferBytes;
   private _isFlushingChunks;
@@ -702,6 +729,7 @@ declare class ResumableStream {
     requestId: string,
     options?: {
       messageId?: string;
+      continuation?: boolean;
     }
   ): string;
   /**
@@ -768,6 +796,33 @@ declare class ResumableStream {
     connection: Connection,
     requestId: string
   ): boolean;
+  /**
+   * Replay the stored chunks of an errored stream for a request, WITHOUT a
+   * terminal frame — the caller follows up with the `done: true, error: true`
+   * frame carrying the durable terminal record's error text, mirroring what a
+   * live client observed (content chunks, then the error). Without this, a
+   * client that missed broadcast frames while disconnected has no other
+   * channel to the pre-error partial content: the server does not push
+   * messages on connect, and {@link replayCompletedChunksByRequestId} only
+   * serves `completed` streams (#1575).
+   *
+   * Returns true when the caller should proceed to send its terminal frame:
+   * either no errored stream existed (nothing to replay) or its chunks were
+   * replayed successfully. Returns false only when a send failed mid-replay,
+   * signalling the caller to skip the terminal frame — the connection is gone
+   * and the next reconnect retries the whole sequence.
+   */
+  replayErroredChunksByRequestId(
+    connection: Connection,
+    requestId: string
+  ): boolean;
+  /** Latest stream row for a request with the given terminal status. */
+  private _latestStreamForRequest;
+  /**
+   * Send a finished stream's stored chunks to a connection as replay frames.
+   * Returns false if the connection closed mid-replay.
+   */
+  private _replayStoredChunks;
   /**
    * Restore active stream state if the agent was restarted during streaming.
    * All streams are restored regardless of age — stale cleanup happens
@@ -782,7 +837,26 @@ declare class ResumableStream {
    * Drop all stream tables (called on destroy).
    */
   destroy(): void;
+  /**
+   * Force a sweep of aged stream buffers now, bypassing the lazy interval
+   * gate used by {@link _maybeCleanupOldStreams}. Intended to be driven by an
+   * alarm so idle/hibernated chat DOs still reclaim buffers even when no
+   * further stream ever completes to trigger the lazy path.
+   */
+  cleanup(now?: number): void;
+  /**
+   * True if any stream rows remain at all. Used by alarm-driven cleanup to
+   * decide whether to re-arm: once no rows remain there is nothing left to
+   * sweep, so the DO can stop waking itself.
+   */
+  hasReclaimableStreams(): boolean;
   private _maybeCleanupOldStreams;
+  /** Delete completed/errored buffers past the completion grace window, plus
+   *  abandoned "streaming" rows past the stale-in-flight window. The two use
+   *  different retentions: a completed buffer is redundant with the persisted
+   *  message and needs only a brief replay grace, whereas an in-flight buffer
+   *  must outlive resume/recovery before it is presumed dead. */
+  private _sweepOldStreams;
   /**
    * Return the stored chunks for a stream as individual chunk bodies in order,
    * unpacking packed segment rows. The returned `chunk_index` is a running
@@ -807,6 +881,13 @@ declare class ResumableStream {
   }>;
   /** @internal For testing only */
   insertStaleStream(streamId: string, requestId: string, ageMs: number): void;
+  /**
+   * Append a chunk to a stream dated `ageMs` in the past. Used to exercise the
+   * last-activity sweep threshold: a long-running streaming row with a *recent*
+   * chunk must survive even when its start time is older than the cutoff.
+   * @internal For testing only
+   */
+  insertChunkAt(streamId: string, body: string, ageMs: number): void;
 }
 //#endregion
 //#region src/chat/sql-batch.d.ts
@@ -1083,6 +1164,29 @@ declare function crossMessageToolResultUpdate(
   errorText?: string,
   preliminary?: boolean
 ): ToolPartUpdate;
+/**
+ * Build an update descriptor that replaces the output of a *paused durable
+ * execution* tool part (e.g. a codemode runtime tool that paused for
+ * approval).
+ *
+ * A paused execution completes its tool call normally — the part is already
+ * `output-available` with an output of `{ status: "paused", executionId }`.
+ * When the host later approves/rejects the execution, the new outcome
+ * (completed / rejected / paused-again) must replace that output in place.
+ *
+ * Matching is deliberately narrow and idempotent:
+ *
+ * - only `output-available` parts are considered;
+ * - the existing output must be a paused-execution object carrying the same
+ *   `executionId` — anything else (already replaced, different execution)
+ *   returns the *same part reference*, which callers treat as a no-op signal
+ *   (skip persist + broadcast), mirroring {@link crossMessageToolResultUpdate}.
+ */
+declare function pausedExecutionUpdate(
+  toolCallId: string,
+  executionId: string,
+  output: unknown
+): ToolPartUpdate;
 /**
  * Build an update descriptor for applying a tool approval.
  *
@@ -1278,6 +1382,7 @@ export {
   type ChatResponseResult,
   type ChunkAction,
   type ChunkResult,
+  type ClientToolExecutor,
   type ClientToolSchema,
   type ContinuationConnection,
   type ContinuationDeferred,
@@ -1318,6 +1423,7 @@ export {
   isReplayChunk,
   normalizeToolInput,
   parseProtocolMessage,
+  pausedExecutionUpdate,
   reconcileMessages,
   resolveToolMergeId,
   sanitizeMessage,