agents 0.15.0 → 0.16.0

package/dist/retries.js.map

@@ -1 +1 @@
-{"version":3,"file":"retries.js","names":[],"sources":["../src/retries.ts"],"sourcesContent":["/**\n * Retry options for schedule(), scheduleEvery(), queue(), and this.retry().\n */\nexport interface RetryOptions {\n  /** Max number of attempts (including the first). Default: 3 */\n  maxAttempts?: number;\n  /** Base delay in ms for exponential backoff. Default: 100 */\n  baseDelayMs?: number;\n  /** Max delay cap in ms. Default: 3000 */\n  maxDelayMs?: number;\n}\n\n/**\n * Internal options for tryN -- extends RetryOptions with a shouldRetry predicate.\n */\ninterface TryNOptions extends RetryOptions {\n  /**\n   * Predicate to determine if an error should be retried.\n   * Receives the error and the next attempt number (so callers can\n   * make attempt-aware decisions).\n   * If not provided, all errors are retried.\n   */\n  shouldRetry?: (err: unknown, nextAttempt: number) => boolean;\n}\n\n/**\n * Validate retry options eagerly so invalid config fails at enqueue/schedule time\n * rather than at execution time. Checks individual field ranges, enforces integer\n * maxAttempts, and validates cross-field constraints after resolving against\n * defaults when provided.\n */\nexport function validateRetryOptions(\n  options: RetryOptions,\n  defaults?: Required<RetryOptions>\n): void {\n  if (options.maxAttempts !== undefined) {\n    if (!Number.isFinite(options.maxAttempts) || options.maxAttempts < 1) {\n      throw new Error(\"retry.maxAttempts must be >= 1\");\n    }\n    if (!Number.isInteger(options.maxAttempts)) {\n      throw new Error(\"retry.maxAttempts must be an integer\");\n    }\n  }\n  if (options.baseDelayMs !== undefined) {\n    if (!Number.isFinite(options.baseDelayMs) || options.baseDelayMs <= 0) {\n      throw new Error(\"retry.baseDelayMs must be > 0\");\n    }\n  }\n  if (options.maxDelayMs !== undefined) {\n    if (!Number.isFinite(options.maxDelayMs) || options.maxDelayMs <= 0) {\n      throw new Error(\"retry.maxDelayMs must be > 0\");\n    }\n  }\n\n  // Resolve against defaults (when provided) so that cross-field checks\n  // catch e.g. { baseDelayMs: 5000 } against default maxDelayMs: 3000.\n  const resolvedBase = options.baseDelayMs ?? defaults?.baseDelayMs;\n  const resolvedMax = options.maxDelayMs ?? defaults?.maxDelayMs;\n  if (\n    resolvedBase !== undefined &&\n    resolvedMax !== undefined &&\n    resolvedBase > resolvedMax\n  ) {\n    throw new Error(\"retry.baseDelayMs must be <= retry.maxDelayMs\");\n  }\n}\n\n/**\n * Returns the number of milliseconds to wait before retrying a request.\n * Uses the \"Full Jitter\" approach from\n * https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/\n *\n * @param attempt The current attempt number (1-indexed).\n * @param baseDelayMs Base delay multiplier in ms.\n * @param maxDelayMs Maximum delay cap in ms.\n * @returns Milliseconds to wait before retrying.\n */\nexport function jitterBackoff(\n  attempt: number,\n  baseDelayMs: number,\n  maxDelayMs: number\n): number {\n  const upperBoundMs = Math.min(2 ** attempt * baseDelayMs, maxDelayMs);\n  return Math.floor(Math.random() * upperBoundMs);\n}\n\n/**\n * Retry an async function up to `n` total attempts with jittered exponential backoff.\n *\n * @param n Total number of attempts (must be a finite integer >= 1).\n * @param fn The async function to retry. Receives the current attempt number (1-indexed).\n * @param options Retry configuration.\n * @returns The result of `fn` on success.\n * @throws The last error if all attempts fail or `shouldRetry` returns false.\n */\nexport async function tryN<T>(\n  n: number,\n  fn: (attempt: number) => Promise<T>,\n  options?: TryNOptions\n): Promise<T> {\n  if (!Number.isFinite(n) || n < 1) {\n    throw new Error(\"retry.maxAttempts must be >= 1\");\n  }\n  n = Math.floor(n);\n\n  const rawBase = options?.baseDelayMs ?? 100;\n  const rawMax = options?.maxDelayMs ?? 3000;\n\n  if (!Number.isFinite(rawBase) || rawBase <= 0) {\n    throw new Error(\"retry.baseDelayMs must be > 0\");\n  }\n  if (!Number.isFinite(rawMax) || rawMax <= 0) {\n    throw new Error(\"retry.maxDelayMs must be > 0\");\n  }\n\n  const baseDelayMs = Math.floor(rawBase);\n  const maxDelayMs = Math.floor(rawMax);\n\n  if (baseDelayMs > maxDelayMs) {\n    throw new Error(\"retry.baseDelayMs must be <= retry.maxDelayMs\");\n  }\n\n  let attempt = 1;\n  while (true) {\n    try {\n      return await fn(attempt);\n    } catch (err) {\n      const nextAttempt = attempt + 1;\n      if (\n        nextAttempt > n ||\n        (options?.shouldRetry && !options.shouldRetry(err, nextAttempt))\n      ) {\n        throw err;\n      }\n      const delay = jitterBackoff(attempt, baseDelayMs, maxDelayMs);\n      await new Promise((resolve) => setTimeout(resolve, delay));\n      attempt = nextAttempt;\n    }\n  }\n}\n\n/**\n * Returns true if the given error is retryable according to Durable Object error handling.\n * See https://developers.cloudflare.com/durable-objects/best-practices/error-handling/\n *\n * An error is retryable if it has `retryable: true` but is NOT an overloaded error.\n */\nexport function isErrorRetryable(err: unknown): boolean {\n  if (typeof err !== \"object\" || err === null) {\n    return false;\n  }\n  const msg = String(err);\n  const typed = err as { retryable?: boolean; overloaded?: boolean };\n  return (\n    Boolean(typed.retryable) &&\n    !typed.overloaded &&\n    !msg.includes(\"Durable Object is overloaded\")\n  );\n}\n"],"mappings":";;;;;;;AA+BA,SAAgB,qBACd,SACA,UACM;CACN,IAAI,QAAQ,gBAAgB,KAAA,GAAW;EACrC,IAAI,CAAC,OAAO,SAAS,QAAQ,WAAW,KAAK,QAAQ,cAAc,GACjE,MAAM,IAAI,MAAM,gCAAgC;EAElD,IAAI,CAAC,OAAO,UAAU,QAAQ,WAAW,GACvC,MAAM,IAAI,MAAM,sCAAsC;CAE1D;CACA,IAAI,QAAQ,gBAAgB,KAAA;MACtB,CAAC,OAAO,SAAS,QAAQ,WAAW,KAAK,QAAQ,eAAe,GAClE,MAAM,IAAI,MAAM,+BAA+B;CAAA;CAGnD,IAAI,QAAQ,eAAe,KAAA;MACrB,CAAC,OAAO,SAAS,QAAQ,UAAU,KAAK,QAAQ,cAAc,GAChE,MAAM,IAAI,MAAM,8BAA8B;CAAA;CAMlD,MAAM,eAAe,QAAQ,eAAe,UAAU;CACtD,MAAM,cAAc,QAAQ,cAAc,UAAU;CACpD,IACE,iBAAiB,KAAA,KACjB,gBAAgB,KAAA,KAChB,eAAe,aAEf,MAAM,IAAI,MAAM,+CAA+C;AAEnE;;;;;;;;;;;AAYA,SAAgB,cACd,SACA,aACA,YACQ;CACR,MAAM,eAAe,KAAK,IAAI,KAAK,UAAU,aAAa,UAAU;CACpE,OAAO,KAAK,MAAM,KAAK,OAAO,IAAI,YAAY;AAChD;;;;;;;;;;AAWA,eAAsB,KACpB,GACA,IACA,SACY;CACZ,IAAI,CAAC,OAAO,SAAS,CAAC,KAAK,IAAI,GAC7B,MAAM,IAAI,MAAM,gCAAgC;CAElD,IAAI,KAAK,MAAM,CAAC;CAEhB,MAAM,UAAU,SAAS,eAAe;CACxC,MAAM,SAAS,SAAS,cAAc;CAEtC,IAAI,CAAC,OAAO,SAAS,OAAO,KAAK,WAAW,GAC1C,MAAM,IAAI,MAAM,+BAA+B;CAEjD,IAAI,CAAC,OAAO,SAAS,MAAM,KAAK,UAAU,GACxC,MAAM,IAAI,MAAM,8BAA8B;CAGhD,MAAM,cAAc,KAAK,MAAM,OAAO;CACtC,MAAM,aAAa,KAAK,MAAM,MAAM;CAEpC,IAAI,cAAc,YAChB,MAAM,IAAI,MAAM,+CAA+C;CAGjE,IAAI,UAAU;CACd,OAAO,MACL,IAAI;EACF,OAAO,MAAM,GAAG,OAAO;CACzB,SAAS,KAAK;EACZ,MAAM,cAAc,UAAU;EAC9B,IACE,cAAc,KACb,SAAS,eAAe,CAAC,QAAQ,YAAY,KAAK,WAAW,GAE9D,MAAM;EAER,MAAM,QAAQ,cAAc,SAAS,aAAa,UAAU;EAC5D,MAAM,IAAI,SAAS,YAAY,WAAW,SAAS,KAAK,CAAC;EACzD,UAAU;CACZ;AAEJ;;;;;;;AAQA,SAAgB,iBAAiB,KAAuB;CACtD,IAAI,OAAO,QAAQ,YAAY,QAAQ,MACrC,OAAO;CAET,MAAM,MAAM,OAAO,GAAG;CACtB,MAAM,QAAQ;CACd,OACE,QAAQ,MAAM,SAAS,KACvB,CAAC,MAAM,cACP,CAAC,IAAI,SAAS,8BAA8B;AAEhD"}
+{"version":3,"file":"retries.js","names":[],"sources":["../src/retries.ts"],"sourcesContent":["/**\n * Retry options for schedule(), scheduleEvery(), queue(), and this.retry().\n */\nexport interface RetryOptions {\n  /** Max number of attempts (including the first). Default: 3 */\n  maxAttempts?: number;\n  /** Base delay in ms for exponential backoff. Default: 100 */\n  baseDelayMs?: number;\n  /** Max delay cap in ms. Default: 3000 */\n  maxDelayMs?: number;\n}\n\n/**\n * Internal options for tryN -- extends RetryOptions with a shouldRetry predicate.\n */\ninterface TryNOptions extends RetryOptions {\n  /**\n   * Predicate to determine if an error should be retried.\n   * Receives the error and the next attempt number (so callers can\n   * make attempt-aware decisions).\n   * If not provided, all errors are retried.\n   */\n  shouldRetry?: (err: unknown, nextAttempt: number) => boolean;\n}\n\n/**\n * Validate retry options eagerly so invalid config fails at enqueue/schedule time\n * rather than at execution time. Checks individual field ranges, enforces integer\n * maxAttempts, and validates cross-field constraints after resolving against\n * defaults when provided.\n */\nexport function validateRetryOptions(\n  options: RetryOptions,\n  defaults?: Required<RetryOptions>\n): void {\n  if (options.maxAttempts !== undefined) {\n    if (!Number.isFinite(options.maxAttempts) || options.maxAttempts < 1) {\n      throw new Error(\"retry.maxAttempts must be >= 1\");\n    }\n    if (!Number.isInteger(options.maxAttempts)) {\n      throw new Error(\"retry.maxAttempts must be an integer\");\n    }\n  }\n  if (options.baseDelayMs !== undefined) {\n    if (!Number.isFinite(options.baseDelayMs) || options.baseDelayMs <= 0) {\n      throw new Error(\"retry.baseDelayMs must be > 0\");\n    }\n  }\n  if (options.maxDelayMs !== undefined) {\n    if (!Number.isFinite(options.maxDelayMs) || options.maxDelayMs <= 0) {\n      throw new Error(\"retry.maxDelayMs must be > 0\");\n    }\n  }\n\n  // Resolve against defaults (when provided) so that cross-field checks\n  // catch e.g. { baseDelayMs: 5000 } against default maxDelayMs: 3000.\n  const resolvedBase = options.baseDelayMs ?? defaults?.baseDelayMs;\n  const resolvedMax = options.maxDelayMs ?? defaults?.maxDelayMs;\n  if (\n    resolvedBase !== undefined &&\n    resolvedMax !== undefined &&\n    resolvedBase > resolvedMax\n  ) {\n    throw new Error(\"retry.baseDelayMs must be <= retry.maxDelayMs\");\n  }\n}\n\n/**\n * Returns the number of milliseconds to wait before retrying a request.\n * Uses the \"Full Jitter\" approach from\n * https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/\n *\n * @param attempt The current attempt number (1-indexed).\n * @param baseDelayMs Base delay multiplier in ms.\n * @param maxDelayMs Maximum delay cap in ms.\n * @returns Milliseconds to wait before retrying.\n */\nexport function jitterBackoff(\n  attempt: number,\n  baseDelayMs: number,\n  maxDelayMs: number\n): number {\n  const upperBoundMs = Math.min(2 ** attempt * baseDelayMs, maxDelayMs);\n  return Math.floor(Math.random() * upperBoundMs);\n}\n\n/**\n * Retry an async function up to `n` total attempts with jittered exponential backoff.\n *\n * @param n Total number of attempts (must be a finite integer >= 1).\n * @param fn The async function to retry. Receives the current attempt number (1-indexed).\n * @param options Retry configuration.\n * @returns The result of `fn` on success.\n * @throws The last error if all attempts fail or `shouldRetry` returns false.\n */\nexport async function tryN<T>(\n  n: number,\n  fn: (attempt: number) => Promise<T>,\n  options?: TryNOptions\n): Promise<T> {\n  if (!Number.isFinite(n) || n < 1) {\n    throw new Error(\"retry.maxAttempts must be >= 1\");\n  }\n  n = Math.floor(n);\n\n  const rawBase = options?.baseDelayMs ?? 100;\n  const rawMax = options?.maxDelayMs ?? 3000;\n\n  if (!Number.isFinite(rawBase) || rawBase <= 0) {\n    throw new Error(\"retry.baseDelayMs must be > 0\");\n  }\n  if (!Number.isFinite(rawMax) || rawMax <= 0) {\n    throw new Error(\"retry.maxDelayMs must be > 0\");\n  }\n\n  const baseDelayMs = Math.floor(rawBase);\n  const maxDelayMs = Math.floor(rawMax);\n\n  if (baseDelayMs > maxDelayMs) {\n    throw new Error(\"retry.baseDelayMs must be <= retry.maxDelayMs\");\n  }\n\n  let attempt = 1;\n  while (true) {\n    try {\n      return await fn(attempt);\n    } catch (err) {\n      const nextAttempt = attempt + 1;\n      if (\n        nextAttempt > n ||\n        (options?.shouldRetry && !options.shouldRetry(err, nextAttempt))\n      ) {\n        throw err;\n      }\n      const delay = jitterBackoff(attempt, baseDelayMs, maxDelayMs);\n      await new Promise((resolve) => setTimeout(resolve, delay));\n      attempt = nextAttempt;\n    }\n  }\n}\n\n/**\n * Returns true if the given error is retryable according to Durable Object error handling.\n * See https://developers.cloudflare.com/durable-objects/best-practices/error-handling/\n *\n * An error is retryable if it has `retryable: true` but is NOT an overloaded error.\n */\nexport function isErrorRetryable(err: unknown): boolean {\n  if (typeof err !== \"object\" || err === null) {\n    return false;\n  }\n  const msg = String(err);\n  const typed = err as { retryable?: boolean; overloaded?: boolean };\n  return (\n    Boolean(typed.retryable) &&\n    !typed.overloaded &&\n    !msg.includes(\"Durable Object is overloaded\")\n  );\n}\n\n/**\n * The \"superseded isolate\" platform messages — the invocation is running on an\n * isolate the platform has replaced with a new version (a deploy / code\n * update). For the rest of that invocation every operation throws the same\n * error (code never reloads mid-invocation), so in-process retries are futile;\n * but the next fresh invocation runs the new code and succeeds.\n *\n * workerd surfaces this as a plain `Error` with one of a few messages, all the\n * same failure class — a message match is the only signal:\n *   - \"Durable Object reset because its code was updated.\"  (DO storage op on a\n *     superseded isolate / deploy bounce)\n *   - \"This script has been upgraded. Please send a new request to connect to\n *     the new version.\"  (a stub/connection to a superseded script; the message\n *     literally instructs the caller to retry on the new version)\n *\n * The match stays close to the verbatim platform strings (rather than a loose\n * \"upgraded\"/\"reset\" substring) so an ordinary application error that happens\n * to mention those words is NOT misclassified as a supersede.\n */\nconst SUPERSEDED_ISOLATE_PATTERN =\n  /reset because its code was updated|this script has been upgraded/i;\n\n/**\n * The \"Network connection lost.\" platform transient — the connection between\n * the isolate and its storage (or another DO) dropped. Unlike a supersede this\n * MAY succeed on an in-process retry (a momentary blip), so it must not skip\n * the in-process retry budget — but during a deploy-reset window it never\n * succeeds in-process and surfaces interleaved with the supersede messages\n * (SQL ops throw `SqlError: SQL query failed: Network connection lost.` while\n * KV ops throw the reset message), so on retry exhaustion it must be treated\n * as the platform's failure, not the callback's.\n */\nconst CONNECTION_LOST_PATTERN = /network connection lost/i;\n\nfunction errorMessageOf(error: unknown): string {\n  return error instanceof Error\n    ? error.message\n    : typeof error === \"string\"\n      ? error\n      : \"\";\n}\n\n/**\n * Iterate an error and its `cause` chain (depth-limited so a cyclic chain\n * can't spin). Wrappers like `SqlError` carry the original platform error in\n * `cause` and may not propagate signal properties (e.g. the CF `retryable`\n * flag), so classification must look through them.\n */\nfunction* selfAndCauses(error: unknown): Generator<unknown> {\n  let current = error;\n  for (let depth = 0; depth < 8 && current != null; depth++) {\n    yield current;\n    current =\n      typeof current === \"object\"\n        ? (current as { cause?: unknown }).cause\n        : undefined;\n  }\n}\n\n/**\n * Whether an error (or anything in its `cause` chain) is a transient\n * \"superseded isolate\" failure — see `SUPERSEDED_ISOLATE_PATTERN`. In-process\n * retries are futile for this class; the work must be deferred to a fresh\n * invocation, which runs the new code and succeeds.\n */\nexport function isDurableObjectCodeUpdateReset(error: unknown): boolean {\n  for (const e of selfAndCauses(error)) {\n    if (SUPERSEDED_ISOLATE_PATTERN.test(errorMessageOf(e))) return true;\n  }\n  return false;\n}\n\n/**\n * Whether an error (or anything in its `cause` chain) is a transient failure\n * of the PLATFORM rather than of the code that threw it:\n *\n *   - a superseded-isolate reset (\"reset because its code was updated\" /\n *     \"this script has been upgraded\") — a deploy replaced the isolate;\n *   - an error the platform itself flags `retryable: true` (excluding\n *     overloaded errors, where retrying the same object won't help) — see\n *     `isErrorRetryable`;\n *   - \"Network connection lost.\" — the storage/stub connection dropped. The\n *     CF `retryable` flag does not survive error wrappers (e.g. `SqlError`\n *     copies only the message + `cause`) and is absent in some local-dev\n *     shapes, so the verbatim message is matched as well.\n *\n * Used to decide whether failed work should be RE-RUN LATER (platform\n * transient — the same work succeeds once the platform recovers, typically\n * seconds after a deploy) versus ABANDONED as genuinely failing (application\n * error — re-running yields the same failure). A genuine application error\n * carries none of these signals, so it is never misclassified by this check.\n */\nexport function isPlatformTransientError(error: unknown): boolean {\n  for (const e of selfAndCauses(error)) {\n    const message = errorMessageOf(e);\n    if (SUPERSEDED_ISOLATE_PATTERN.test(message)) return true;\n    if (CONNECTION_LOST_PATTERN.test(message)) return true;\n    if (isErrorRetryable(e)) return true;\n  }\n  return false;\n}\n"],"mappings":"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"}

package/dist/serializable.d.ts

@@ -1,4 +1,4 @@
-import { $ as StreamingResponse } from "./agent-tool-types-VPsjVYL0.js";
+import { $ as StreamingResponse } from "./agent-tool-types-NofdbL9X.js";
 
 //#region src/serializable.d.ts
 type SerializablePrimitive = undefined | null | string | number | boolean;

package/dist/skills/index.js

@@ -1,5 +1,5 @@
-import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "../classPrivateFieldGet2-Beqsfu2Z.js";
-import { t as _classPrivateMethodInitSpec } from "../classPrivateMethodInitSpec-B5ko1s2R.js";
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "../classPrivateFieldGet2-CZ7QjTXN.js";
+import { t as _classPrivateMethodInitSpec } from "../classPrivateMethodInitSpec-D-0__zd9.js";
 import { tool } from "ai";
 import { RpcTarget } from "cloudflare:workers";
 import { z } from "zod";

package/dist/sub-routing.d.ts

@@ -4,7 +4,7 @@ import {
   Kt as SubAgentPathMatch,
   Yt as routeSubAgentRequest,
   qt as getSubAgentByName
-} from "./agent-tool-types-VPsjVYL0.js";
+} from "./agent-tool-types-NofdbL9X.js";
 export {
   SUB_PREFIX,
   SubAgentPathMatch,

package/dist/workflows.d.ts

@@ -1,4 +1,4 @@
-import { b as Agent } from "./agent-tool-types-VPsjVYL0.js";
+import { b as Agent } from "./agent-tool-types-NofdbL9X.js";
 import {
   S as WorkflowTrackingRow,
   _ as WorkflowPage,

package/package.json

@@ -9,7 +9,7 @@
     "durable objects"
   ],
   "type": "module",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "license": "MIT",
   "repository": {
     "directory": "packages/agents",
@@ -26,36 +26,36 @@
   "dependencies": {
     "@babel/plugin-proposal-decorators": "^7.29.7",
     "@cfworker/json-schema": "^4.1.1",
-    "@cloudflare/codemode": "^0.3.8",
+    "@cloudflare/codemode": "^0.4.0",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@rolldown/plugin-babel": "^0.2.3",
     "cron-schedule": "^6.0.0",
-    "esbuild": "^0.28.0",
+    "esbuild": "^0.28.1",
     "just-bash": "^3.0.1",
     "mimetext": "^3.0.28",
     "nanoid": "^5.1.11",
     "partyserver": "^0.5.6",
-    "partysocket": "1.1.19",
+    "partysocket": "1.2.0",
     "yaml": "^2.9.0",
     "yargs": "^18.0.0"
   },
   "devDependencies": {
-    "@ai-sdk/react": "^3.0.198",
-    "@tanstack/ai": "^0.27.0",
-    "@types/react": "^19.2.16",
+    "@ai-sdk/react": "^3.0.204",
+    "@tanstack/ai": "^0.28.0",
+    "@types/react": "^19.2.17",
     "@types/yargs": "^17.0.35",
     "@vitest/browser-playwright": "^4.1.8",
     "@x402/core": "^2.14.0",
     "@x402/evm": "^2.14.0",
-    "ai": "^6.0.196",
+    "ai": "^6.0.202",
     "chat": "^4.30.0",
-    "glob": "^11.1.0",
+    "glob": "^13.0.6",
     "react": "^19.2.7",
     "vitest-browser-react": "^2.2.0",
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@cloudflare/ai-chat": ">=0.8.0 <1.0.0",
+    "@cloudflare/ai-chat": ">=0.8.5 <1.0.0",
     "@tanstack/ai": ">=0.10.2 <1.0.0",
     "@x402/core": "^2.0.0",
     "@x402/evm": "^2.0.0",

package/dist/shared-4CAYLCTO.d.ts

@@ -1,34 +0,0 @@
-//#region src/browser/shared.d.ts
-interface BrowserToolsOptions {
-  /** Browser Rendering binding (Fetcher) — used in production */
-  browser?: Fetcher;
-  /** Optional CDP base URL override (e.g. http://localhost:9222) */
-  cdpUrl?: string;
-  /** Headers to send with CDP URL discovery requests (e.g. Access headers) */
-  cdpHeaders?: Record<string, string>;
-  /** Loader binding for sandboxed code execution */
-  loader: WorkerLoader;
-  /** Execution timeout in milliseconds (default: 30000) */
-  timeout?: number;
-}
-declare const SEARCH_DESCRIPTION =
-  'Search the Chrome DevTools Protocol spec using JavaScript code.\n\nAvailable in your code:\n\ndeclare const spec: {\n  get(): Promise<{\n    domains: Array<{\n      name: string;\n      description?: string;\n      commands: Array<{ name: string; method: string; description?: string }>;\n      events: Array<{ name: string; event: string; description?: string }>;\n      types: Array<{ id: string; name: string; description?: string }>;\n    }>;\n  }>;\n};\n\nWrite an async arrow function in JavaScript. Do NOT use TypeScript syntax.\n\nExample:\nasync () => {\n  const s = await spec.get();\n  return s.domains\n    .find(d => d.name === "Network")\n    .commands.filter(c => c.description?.toLowerCase().includes("intercept"))\n    .map(c => ({ method: c.method, description: c.description }));\n}';
-declare const EXECUTE_DESCRIPTION =
-  'Execute CDP commands against a live browser session using JavaScript code.\n\nAvailable in your code:\n\ndeclare const cdp: {\n  send(method: string, params?: unknown, options?: {\n    timeoutMs?: number;\n    sessionId?: string;\n  }): Promise<unknown>;\n  attachToTarget(targetId: string, options?: {\n    timeoutMs?: number;\n  }): Promise<string>;\n  getDebugLog(limit?: number): Promise<unknown[]>;\n  clearDebugLog(): Promise<void>;\n};\n\nWrite an async arrow function in JavaScript. Do NOT use TypeScript syntax.\n\nFor page-scoped commands such as Page.*, Runtime.*, and DOM.*, first create or select a target, call cdp.attachToTarget(targetId), and pass the returned sessionId in command options.\n\nExample:\nasync () => {\n  return await cdp.send("Browser.getVersion");\n}\n\nPage example:\nasync () => {\n  const { targetId } = await cdp.send("Target.createTarget", {\n    url: "about:blank"\n  });\n  const sessionId = await cdp.attachToTarget(targetId);\n  await cdp.send("Page.enable", {}, { sessionId });\n  await cdp.send(\n    "Page.navigate",\n    { url: "https://example.com" },\n    { sessionId }\n  );\n  const { result } = await cdp.send(\n    "Runtime.evaluate",\n    { expression: "document.title" },\n    { sessionId }\n  );\n  return result.value;\n}';
-interface ToolResult {
-  text: string;
-  isError?: boolean;
-}
-declare function createBrowserToolHandlers(options: BrowserToolsOptions): {
-  search: (code: string) => Promise<ToolResult>;
-  execute: (code: string) => Promise<ToolResult>;
-};
-//#endregion
-export {
-  createBrowserToolHandlers as a,
-  ToolResult as i,
-  EXECUTE_DESCRIPTION as n,
-  SEARCH_DESCRIPTION as r,
-  BrowserToolsOptions as t
-};
-//# sourceMappingURL=shared-4CAYLCTO.d.ts.map

package/dist/shared-wyII629d.js

@@ -1,432 +0,0 @@
-import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "./classPrivateFieldGet2-Beqsfu2Z.js";
-import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-B5ko1s2R.js";
-import { DynamicWorkerExecutor } from "@cloudflare/codemode";
-//#region src/browser/cdp-session.ts
-const DEFAULT_TIMEOUT_MS = 1e4;
-const MAX_DEBUG_ENTRIES = 400;
-var _socket = /* @__PURE__ */ new WeakMap();
-var _nextId = /* @__PURE__ */ new WeakMap();
-var _pending = /* @__PURE__ */ new WeakMap();
-var _debugLog = /* @__PURE__ */ new WeakMap();
-var _defaultTimeoutMs = /* @__PURE__ */ new WeakMap();
-var _dispose = /* @__PURE__ */ new WeakMap();
-var _CdpSession_brand = /* @__PURE__ */ new WeakSet();
-/**
-* 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.
-*/
-var CdpSession = class {
-	constructor(socket, defaultTimeoutMs = DEFAULT_TIMEOUT_MS, dispose) {
-		_classPrivateMethodInitSpec(this, _CdpSession_brand);
-		_classPrivateFieldInitSpec(this, _socket, void 0);
-		_classPrivateFieldInitSpec(this, _nextId, 1);
-		_classPrivateFieldInitSpec(this, _pending, /* @__PURE__ */ new Map());
-		_classPrivateFieldInitSpec(this, _debugLog, []);
-		_classPrivateFieldInitSpec(this, _defaultTimeoutMs, void 0);
-		_classPrivateFieldInitSpec(this, _dispose, void 0);
-		_classPrivateFieldSet2(_socket, this, socket);
-		_classPrivateFieldSet2(_defaultTimeoutMs, this, defaultTimeoutMs);
-		_classPrivateFieldSet2(_dispose, this, dispose);
-		socket.addEventListener("message", (event) => _assertClassBrand(_CdpSession_brand, this, _handleMessage).call(this, event));
-		socket.addEventListener("error", () => {
-			_assertClassBrand(_CdpSession_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP socket error"));
-		});
-		socket.addEventListener("close", () => {
-			_assertClassBrand(_CdpSession_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP connection closed"));
-		});
-	}
-	send(method, params, options = {}) {
-		var _this$nextId, _this$nextId2;
-		const id = (_classPrivateFieldSet2(_nextId, this, (_this$nextId = _classPrivateFieldGet2(_nextId, this), _this$nextId2 = _this$nextId++, _this$nextId)), _this$nextId2);
-		const timeoutMs = options.timeoutMs ?? _classPrivateFieldGet2(_defaultTimeoutMs, this);
-		const sessionId = typeof options.sessionId === "string" && options.sessionId.length > 0 ? options.sessionId : void 0;
-		const domain = typeof method === "string" ? method.split(".")[0] : "";
-		if (!sessionId && domain && !["Browser", "Target"].includes(domain)) _assertClassBrand(_CdpSession_brand, this, _recordDebug).call(this, "warning", {
-			id,
-			method,
-			reason: "target-scoped method sent without sessionId"
-		});
-		const result = new Promise((resolve, reject) => {
-			const startedAt = performance.now();
-			const timeoutId = setTimeout(() => {
-				_classPrivateFieldGet2(_pending, this).delete(id);
-				reject(/* @__PURE__ */ new Error(`CDP command timed out after ${timeoutMs}ms: ${method}`));
-			}, timeoutMs);
-			_classPrivateFieldGet2(_pending, this).set(id, {
-				resolve,
-				reject,
-				timeoutId,
-				method,
-				sessionId,
-				startedAt
-			});
-		});
-		_assertClassBrand(_CdpSession_brand, this, _recordDebug).call(this, "send", {
-			id,
-			method,
-			sessionId,
-			timeoutMs
-		});
-		_classPrivateFieldGet2(_socket, this).send(JSON.stringify({
-			id,
-			method,
-			params,
-			sessionId
-		}));
-		return result;
-	}
-	async attachToTarget(targetId, options = {}) {
-		if (typeof targetId !== "string" || !targetId) throw new Error("attachToTarget requires a targetId");
-		const sessionId = (await this.send("Target.attachToTarget", {
-			targetId,
-			flatten: true
-		}, { timeoutMs: options.timeoutMs }))?.sessionId ?? "";
-		if (!sessionId) throw new Error(`Target.attachToTarget did not return a sessionId for target ${targetId}`);
-		_assertClassBrand(_CdpSession_brand, this, _recordDebug).call(this, "attach", {
-			targetId,
-			sessionId
-		});
-		return sessionId;
-	}
-	getDebugLog(limit = 50) {
-		const normalized = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 50;
-		return _classPrivateFieldGet2(_debugLog, this).slice(-normalized);
-	}
-	clearDebugLog() {
-		_classPrivateFieldSet2(_debugLog, this, []);
-	}
-	close() {
-		_assertClassBrand(_CdpSession_brand, this, _rejectAll).call(this, /* @__PURE__ */ new Error("CDP session closed"));
-		try {
-			_classPrivateFieldGet2(_socket, this).close(1e3, "Done");
-		} catch {}
-		_classPrivateFieldGet2(_dispose, this)?.call(this);
-	}
-};
-function _rejectAll(error) {
-	for (const [id, pending] of _classPrivateFieldGet2(_pending, this).entries()) {
-		clearTimeout(pending.timeoutId);
-		_classPrivateFieldGet2(_pending, this).delete(id);
-		pending.reject(error);
-	}
-}
-function _handleMessage(event) {
-	if (typeof event.data !== "string") return;
-	let payload;
-	try {
-		payload = JSON.parse(event.data);
-	} catch {
-		return;
-	}
-	_assertClassBrand(_CdpSession_brand, this, _recordDebug).call(this, "receive", {
-		id: payload.id,
-		method: payload.method,
-		sessionId: payload.sessionId,
-		hasError: !!payload.error
-	});
-	if (typeof payload.id !== "number") return;
-	const pending = _classPrivateFieldGet2(_pending, this).get(payload.id);
-	if (!pending) return;
-	clearTimeout(pending.timeoutId);
-	_classPrivateFieldGet2(_pending, this).delete(payload.id);
-	if (payload.error) {
-		const err = payload.error;
-		const code = err.code ?? "unknown";
-		const message = err.message ?? "CDP error";
-		pending.reject(/* @__PURE__ */ new Error(`CDP error ${code}: ${message} for ${pending.method}`));
-		return;
-	}
-	pending.resolve(payload.result);
-}
-function _recordDebug(type, data) {
-	_classPrivateFieldGet2(_debugLog, this).push({
-		at: (/* @__PURE__ */ new Date()).toISOString(),
-		type,
-		...data
-	});
-	if (_classPrivateFieldGet2(_debugLog, this).length > MAX_DEBUG_ENTRIES) _classPrivateFieldGet2(_debugLog, this).splice(0, _classPrivateFieldGet2(_debugLog, this).length - MAX_DEBUG_ENTRIES);
-}
-/**
-* Connect to a browser via the Browser Rendering binding (Fetcher).
-* Establishes a CDP WebSocket through the binding's fetch interface.
-*/
-async function connectBrowser(browser, timeoutMs) {
-	const response = await browser.fetch("https://localhost/v1/devtools/browser", { headers: { Upgrade: "websocket" } });
-	const ws = response.webSocket;
-	if (!ws) throw new Error("Browser Rendering binding did not return a WebSocket. Ensure the 'browser' binding is configured in wrangler.jsonc.");
-	const sessionId = response.headers.get("cf-browser-session-id");
-	if (!sessionId) throw new Error("Browser Rendering binding did not include a session ID when opening the CDP WebSocket");
-	ws.accept();
-	return new CdpSession(ws, timeoutMs, () => {
-		browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}`, { method: "DELETE" });
-	});
-}
-const LOCALHOST_HOSTS = new Set([
-	"localhost",
-	"127.0.0.1",
-	"0.0.0.0",
-	"::1",
-	"[::1]"
-]);
-/**
-* 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.
-*/
-async function connectUrl(baseUrl, options) {
-	const endpoint = new URL("/json/version", baseUrl).toString();
-	const response = await fetch(endpoint, { headers: options?.headers });
-	if (!response.ok) throw new Error(`Failed to discover CDP endpoint at ${endpoint}: ${response.status}`);
-	const payload = await response.json();
-	if (!payload.webSocketDebuggerUrl) throw new Error("CDP /json/version did not include webSocketDebuggerUrl");
-	let wsUrl = payload.webSocketDebuggerUrl;
-	const parsed = new URL(wsUrl);
-	if (LOCALHOST_HOSTS.has(parsed.hostname)) {
-		const base = new URL(baseUrl);
-		parsed.hostname = base.hostname;
-		parsed.port = base.port;
-		parsed.protocol = base.protocol;
-	} else parsed.protocol = parsed.protocol === "wss:" ? "https:" : "http:";
-	const fetchUrl = parsed.toString();
-	const wsResponse = await fetch(fetchUrl, { headers: {
-		...options?.headers,
-		Upgrade: "websocket"
-	} });
-	const ws = wsResponse.webSocket;
-	if (!ws) throw new Error(`Failed to establish CDP WebSocket at ${fetchUrl} (status ${wsResponse.status})`);
-	ws.accept();
-	return new CdpSession(ws, options?.timeoutMs);
-}
-//#endregion
-//#region src/browser/truncate.ts
-const CHARS_PER_TOKEN = 4;
-const MAX_TOKENS = 6e3;
-const MAX_CHARS = CHARS_PER_TOKEN * MAX_TOKENS;
-function truncateResponse(content) {
-	const text = typeof content === "string" ? content : JSON.stringify(content, null, 2) ?? "null";
-	if (text.length <= MAX_CHARS) return text;
-	const estimatedTokens = Math.ceil(text.length / CHARS_PER_TOKEN);
-	return `${text.slice(0, MAX_CHARS)}\n\n--- TRUNCATED ---\nResponse was ~${estimatedTokens.toLocaleString()} tokens (limit: ${MAX_TOKENS.toLocaleString()}). Use more specific queries to reduce response size.`;
-}
-//#endregion
-//#region src/browser/shared.ts
-const specCache = /* @__PURE__ */ new Map();
-const CACHE_TTL_MS = 300 * 1e3;
-const SEARCH_DESCRIPTION = `Search the Chrome DevTools Protocol spec using JavaScript code.
-
-Available in your code:
-
-declare const spec: {
-  get(): Promise<{
-    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 }>;
-    }>;
-  }>;
-};
-
-Write an async arrow function in JavaScript. Do NOT use TypeScript syntax.
-
-Example:
-async () => {
-  const s = await spec.get();
-  return s.domains
-    .find(d => d.name === "Network")
-    .commands.filter(c => c.description?.toLowerCase().includes("intercept"))
-    .map(c => ({ method: c.method, description: c.description }));
-}`;
-function normalizeCdpSpec(spec) {
-	return { domains: (spec.domains ?? []).map((domain) => ({
-		name: domain.domain,
-		description: domain.description,
-		commands: (domain.commands ?? []).map((command) => ({
-			name: command.name,
-			method: `${domain.domain}.${command.name}`,
-			description: command.description
-		})),
-		events: (domain.events ?? []).map((event) => ({
-			name: event.name,
-			event: `${domain.domain}.${event.name}`,
-			description: event.description
-		})),
-		types: (domain.types ?? []).map((type) => ({
-			id: type.id,
-			name: `${domain.domain}.${type.id}`,
-			description: type.description
-		}))
-	})) };
-}
-function getSpecCacheKey(source, headers) {
-	const headerEntries = Object.entries(headers ?? {}).sort(([a], [b]) => a.localeCompare(b));
-	return `${source}:${JSON.stringify(headerEntries)}`;
-}
-async function getCachedSpec(key, load) {
-	const cached = specCache.get(key);
-	if (cached && Date.now() - cached.cachedAt < CACHE_TTL_MS) return cached.spec;
-	const spec = normalizeCdpSpec(await load());
-	specCache.set(key, {
-		spec,
-		cachedAt: Date.now()
-	});
-	return spec;
-}
-async function fetchCdpSpecFromUrl(cdpBaseUrl, headers) {
-	const endpoint = new URL("/json/protocol", cdpBaseUrl).toString();
-	return getCachedSpec(getSpecCacheKey(endpoint, headers), async () => {
-		const response = await fetch(endpoint, { headers });
-		if (!response.ok) throw new Error(`Failed to fetch CDP spec from ${endpoint}: ${response.status}`);
-		return await response.json();
-	});
-}
-async function fetchCdpSpecFromBrowser(browser) {
-	return getCachedSpec("browser-binding", async () => {
-		const createResponse = await browser.fetch("https://localhost/v1/devtools/browser", { method: "POST" });
-		if (!createResponse.ok) throw new Error(`Failed to create Browser Rendering session for protocol fetch: ${createResponse.status}`);
-		const sessionId = (await createResponse.json()).sessionId;
-		if (!sessionId) throw new Error("Browser Rendering session response did not include a sessionId");
-		try {
-			const response = await browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}/json/protocol`);
-			if (!response.ok) throw new Error(`Failed to fetch CDP spec from Browser Rendering: ${response.status}`);
-			return await response.json();
-		} finally {
-			try {
-				await browser.fetch(`https://localhost/v1/devtools/browser/${sessionId}`, { method: "DELETE" });
-			} catch {}
-		}
-	});
-}
-const EXECUTE_DESCRIPTION = `Execute CDP commands against a live browser session using JavaScript code.
-
-Available in your code:
-
-declare const cdp: {
-  send(method: string, params?: unknown, options?: {
-    timeoutMs?: number;
-    sessionId?: string;
-  }): Promise<unknown>;
-  attachToTarget(targetId: string, options?: {
-    timeoutMs?: number;
-  }): Promise<string>;
-  getDebugLog(limit?: number): Promise<unknown[]>;
-  clearDebugLog(): Promise<void>;
-};
-
-Write an async arrow function in JavaScript. Do NOT use TypeScript syntax.
-
-For page-scoped commands such as Page.*, Runtime.*, and DOM.*, first create or select a target, call cdp.attachToTarget(targetId), and pass the returned sessionId in command options.
-
-Example:
-async () => {
-  return await cdp.send("Browser.getVersion");
-}
-
-Page example:
-async () => {
-  const { targetId } = await cdp.send("Target.createTarget", {
-    url: "about:blank"
-  });
-  const sessionId = await cdp.attachToTarget(targetId);
-  await cdp.send("Page.enable", {}, { sessionId });
-  await cdp.send(
-    "Page.navigate",
-    { url: "https://example.com" },
-    { sessionId }
-  );
-  const { result } = await cdp.send(
-    "Runtime.evaluate",
-    { expression: "document.title" },
-    { sessionId }
-  );
-  return result.value;
-}`;
-function formatError(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-let didWarnExperimental = false;
-function createBrowserToolHandlers(options) {
-	if (!didWarnExperimental) {
-		didWarnExperimental = true;
-		console.warn("[agents/browser] Browser tools are experimental and may change in a future release.");
-	}
-	const executor = new DynamicWorkerExecutor({
-		loader: options.loader,
-		timeout: options.timeout
-	});
-	async function search(code) {
-		try {
-			let specSource;
-			if (options.cdpUrl) specSource = await fetchCdpSpecFromUrl(options.cdpUrl, options.cdpHeaders);
-			else if (options.browser) specSource = await fetchCdpSpecFromBrowser(options.browser);
-			else return {
-				text: "Either 'browser' (Fetcher binding) or 'cdpUrl' must be provided",
-				isError: true
-			};
-			const result = await executor.execute(code, [{
-				name: "spec",
-				fns: { get: async () => specSource }
-			}]);
-			if (result.error) return {
-				text: result.error,
-				isError: true
-			};
-			return { text: truncateResponse(result.result) };
-		} catch (error) {
-			return {
-				text: formatError(error),
-				isError: true
-			};
-		}
-	}
-	async function execute(code) {
-		let session;
-		try {
-			if (options.cdpUrl) session = await connectUrl(options.cdpUrl, {
-				timeoutMs: options.timeout,
-				headers: options.cdpHeaders
-			});
-			else if (options.browser) session = await connectBrowser(options.browser, options.timeout);
-			else return {
-				text: "Either 'browser' (Fetcher binding) or 'cdpUrl' must be provided",
-				isError: true
-			};
-			const result = await executor.execute(code, [{
-				name: "cdp",
-				fns: {
-					send: async (method, params, opts) => session.send(method, params, opts),
-					attachToTarget: async (targetId, opts) => session.attachToTarget(targetId, opts),
-					getDebugLog: async (limit) => session.getDebugLog(limit),
-					clearDebugLog: async () => session.clearDebugLog()
-				}
-			}]);
-			if (result.error) return {
-				text: result.error,
-				isError: true
-			};
-			return { text: truncateResponse(result.result) };
-		} catch (error) {
-			return {
-				text: formatError(error),
-				isError: true
-			};
-		} finally {
-			session?.close();
-		}
-	}
-	return {
-		search,
-		execute
-	};
-}
-//#endregion
-export { connectBrowser as a, CdpSession as i, SEARCH_DESCRIPTION as n, connectUrl as o, createBrowserToolHandlers as r, EXECUTE_DESCRIPTION as t };
-
-//# sourceMappingURL=shared-wyII629d.js.map