agents 0.26.0 → 0.28.0

package/dist/web/fetch/index.js

@@ -0,0 +1,20 @@
+import { a as WebFetchError, c as DEFAULT_WEB_FETCH_MAX_REDIRECTS, d as MAX_WEB_FETCH_URL_LENGTH, f as WEB_FETCH_TOOL_DESCRIPTION, g as isPrivateOrLocalHost, h as windowWebFetchPage, i as validateTimeout, l as DEFAULT_WEB_FETCH_PAGE_CHARS, m as renderWebFetchPage, n as fetchWithDeadline, o as createDirectWebFetch, p as WEB_FETCH_TOOL_NAME, s as DEFAULT_WEB_FETCH_MAX_BYTES, u as DEFAULT_WEB_FETCH_TIMEOUT_MS } from "../../tool-CxKsvxjm.js";
+//#region src/web/fetch/index.ts
+/**
+* Fetch one URL directly, without a tool: {@link createDirectWebFetch} plus
+* a deadline. Returns the whole page; to show it to a model a window at a
+* time, as the tool does, pass it to {@link windowWebFetchPage} and
+* {@link renderWebFetchPage}.
+*/
+async function fetchWeb(request, options) {
+	const { timeoutMs, signal, ...sourceOptions } = options;
+	const deadline = validateTimeout(timeoutMs);
+	return fetchWithDeadline(createDirectWebFetch(sourceOptions), request, {
+		timeoutMs: deadline,
+		signal
+	});
+}
+//#endregion
+export { DEFAULT_WEB_FETCH_MAX_BYTES, DEFAULT_WEB_FETCH_MAX_REDIRECTS, DEFAULT_WEB_FETCH_PAGE_CHARS, DEFAULT_WEB_FETCH_TIMEOUT_MS, MAX_WEB_FETCH_URL_LENGTH, WEB_FETCH_TOOL_DESCRIPTION, WEB_FETCH_TOOL_NAME, WebFetchError, createDirectWebFetch, fetchWeb, isPrivateOrLocalHost, renderWebFetchPage, windowWebFetchPage };
+
+//# sourceMappingURL=index.js.map

package/dist/web/fetch/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/web/fetch/index.ts"],"sourcesContent":["/**\n * `agents/webfetch` — read a URL as Markdown, JSON, or text, with\n * host-controlled URL policy and size limits, from a Worker.\n *\n * The tool adapters live beside this entry: `agents/webfetch/pi`,\n * `agents/webfetch/ai-sdk`, and `agents/webfetch/tanstack-ai`. Import from\n * here to fetch without a model in the loop, or to build a source for the\n * tools.\n *\n * @beta\n */\nimport type { WebFetchPage } from \"./contract\";\nimport {\n  createDirectWebFetch,\n  type DirectWebFetchOptions,\n  type WebFetchRequest\n} from \"./source\";\nimport { fetchWithDeadline, validateTimeout } from \"./tool\";\n\nexport {\n  DEFAULT_WEB_FETCH_MAX_BYTES,\n  DEFAULT_WEB_FETCH_MAX_REDIRECTS,\n  DEFAULT_WEB_FETCH_PAGE_CHARS,\n  DEFAULT_WEB_FETCH_TIMEOUT_MS,\n  MAX_WEB_FETCH_URL_LENGTH,\n  WEB_FETCH_TOOL_DESCRIPTION,\n  WEB_FETCH_TOOL_NAME,\n  renderWebFetchPage,\n  windowWebFetchPage,\n  type WebFetchFormat,\n  type WebFetchPage,\n  type WebFetchToolInput,\n  type WebFetchToolOutput,\n  type WebFetchVia,\n  type WindowWebFetchPageOptions\n} from \"./contract\";\nexport {\n  WebFetchError,\n  createDirectWebFetch,\n  type DirectWebFetchOptions,\n  type WebFetchCallOptions,\n  type WebFetchErrorCode,\n  type WebFetchRequest,\n  type WebFetchSource\n} from \"./source\";\nexport { isPrivateOrLocalHost } from \"../url-policy\";\nexport {\n  type WebFetchToolDirectOptions,\n  type WebFetchToolOptions,\n  type WebFetchToolSourceOptions\n} from \"./tool\";\n\n/** Options for {@link fetchWeb}: the direct source's, plus a deadline. */\nexport interface FetchWebOptions extends DirectWebFetchOptions {\n  /**\n   * Give up after this many milliseconds with a `web_fetch_timeout` error.\n   * A positive integer; defaults to 30 seconds.\n   */\n  timeoutMs?: number;\n  /** Abort the fetch; rejects with the signal's reason. */\n  signal?: AbortSignal;\n}\n\n/**\n * Fetch one URL directly, without a tool: {@link createDirectWebFetch} plus\n * a deadline. Returns the whole page; to show it to a model a window at a\n * time, as the tool does, pass it to {@link windowWebFetchPage} and\n * {@link renderWebFetchPage}.\n */\nexport async function fetchWeb(\n  request: WebFetchRequest,\n  options: FetchWebOptions\n): Promise<WebFetchPage> {\n  const { timeoutMs, signal, ...sourceOptions } = options;\n  const deadline = validateTimeout(timeoutMs);\n  const source = createDirectWebFetch(sourceOptions);\n  return fetchWithDeadline(source, request, { timeoutMs: deadline, signal });\n}\n"],"mappings":";;;;;;;;AAqEA,eAAsB,SACpB,SACA,SACuB;CACvB,MAAM,EAAE,WAAW,QAAQ,GAAG,kBAAkB;CAChD,MAAM,WAAW,gBAAgB,SAAS;CAE1C,OAAO,kBADQ,qBAAqB,aACN,GAAG,SAAS;EAAE,WAAW;EAAU;CAAO,CAAC;AAC3E"}

package/dist/web/fetch/tools/ai-sdk.d.ts

@@ -0,0 +1,80 @@
+import {
+  S as WebFetchVia,
+  b as WebFetchToolInput,
+  c as WebFetchRequest,
+  l as WebFetchSource,
+  n as WebFetchToolOptions,
+  o as WebFetchError,
+  s as WebFetchErrorCode,
+  v as WebFetchFormat,
+  x as WebFetchToolOutput,
+  y as WebFetchPage
+} from "../../../tool-DoVberpN.js";
+import { FlexibleSchema } from "ai";
+
+//#region src/web/fetch/tools/ai-sdk.d.ts
+/**
+ * The part of the AI SDK's tool execution options the tool reads. Spelled
+ * out rather than imported so it fits every supported `ai` major.
+ */
+interface WebFetchToolExecuteOptions {
+  abortSignal?: AbortSignal;
+}
+/**
+ * The AI SDK tool {@link webFetchTool} returns. Assignable to the AI SDK's
+ * `Tool`; `execute` and `toModelOutput` are always present.
+ */
+interface WebFetchTool {
+  description: string;
+  inputSchema: FlexibleSchema<WebFetchToolInput>;
+  execute(
+    input: WebFetchToolInput,
+    options: WebFetchToolExecuteOptions
+  ): Promise<WebFetchToolOutput>;
+  toModelOutput(options: { output: WebFetchToolOutput }): {
+    type: "text";
+    value: string;
+  };
+}
+/**
+ * Create an AI SDK tool that reads a URL as Markdown, JSON, or text. The
+ * tool's output is the window the model read plus the page's metadata
+ * (status, headers, redirects, total length), so it stays small in stored
+ * messages; `toModelOutput` renders it for the model. A failed fetch throws a `WebFetchError`, which
+ * the AI SDK reports to the model as a tool error: its `message` is written
+ * for the model, and its `cause` is the source's error with the detail.
+ *
+ * `toModelOutput` only applies to earlier turns when the tools are passed to
+ * `convertToModelMessages(messages, { tools })`; otherwise the AI SDK sends
+ * the output back to the model as JSON, without the header or the
+ * untrusted-content wrapper. `AiSdkHarness` passes them.
+ *
+ * @example
+ * ```ts
+ * import { webFetchTool } from "agents/webfetch/ai-sdk";
+ *
+ * const result = streamText({
+ *   model,
+ *   tools: { web_fetch: webFetchTool({ binding: env.AI }) },
+ *   messages
+ * });
+ * ```
+ */
+declare function webFetchTool(options: WebFetchToolOptions): WebFetchTool;
+//#endregion
+export {
+  WebFetchError,
+  type WebFetchErrorCode,
+  type WebFetchFormat,
+  type WebFetchPage,
+  type WebFetchRequest,
+  type WebFetchSource,
+  WebFetchTool,
+  WebFetchToolExecuteOptions,
+  type WebFetchToolInput,
+  type WebFetchToolOptions,
+  type WebFetchToolOutput,
+  type WebFetchVia,
+  webFetchTool
+};
+//# sourceMappingURL=ai-sdk.d.ts.map

package/dist/web/fetch/tools/ai-sdk.js

@@ -0,0 +1,47 @@
+import { a as WebFetchError, r as toolFailure, t as createWebFetchToolCore } from "../../../tool-CxKsvxjm.js";
+import { t as webFetchInputSchema } from "../../../input-schema-BQykTEp_.js";
+//#region src/web/fetch/tools/ai-sdk.ts
+/**
+* Create an AI SDK tool that reads a URL as Markdown, JSON, or text. The
+* tool's output is the window the model read plus the page's metadata
+* (status, headers, redirects, total length), so it stays small in stored
+* messages; `toModelOutput` renders it for the model. A failed fetch throws a `WebFetchError`, which
+* the AI SDK reports to the model as a tool error: its `message` is written
+* for the model, and its `cause` is the source's error with the detail.
+*
+* `toModelOutput` only applies to earlier turns when the tools are passed to
+* `convertToModelMessages(messages, { tools })`; otherwise the AI SDK sends
+* the output back to the model as JSON, without the header or the
+* untrusted-content wrapper. `AiSdkHarness` passes them.
+*
+* @example
+* ```ts
+* import { webFetchTool } from "agents/webfetch/ai-sdk";
+*
+* const result = streamText({
+*   model,
+*   tools: { web_fetch: webFetchTool({ binding: env.AI }) },
+*   messages
+* });
+* ```
+*/
+function webFetchTool(options) {
+	const core = createWebFetchToolCore(options);
+	return {
+		description: core.description,
+		inputSchema: webFetchInputSchema(),
+		async execute(input, { abortSignal }) {
+			const run = await core.run(input, { signal: abortSignal });
+			if (!run.ok) throw toolFailure(run);
+			return run.output;
+		},
+		toModelOutput: ({ output }) => ({
+			type: "text",
+			value: core.render(output)
+		})
+	};
+}
+//#endregion
+export { WebFetchError, webFetchTool };
+
+//# sourceMappingURL=ai-sdk.js.map

package/dist/web/fetch/tools/ai-sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-sdk.js","names":[],"sources":["../../../../src/web/fetch/tools/ai-sdk.ts"],"sourcesContent":["/**\n * `agents/webfetch/ai-sdk` — the `web_fetch` tool for the AI SDK.\n *\n * @beta\n */\nimport type { FlexibleSchema } from \"ai\";\nimport type { WebFetchToolInput, WebFetchToolOutput } from \"../contract\";\nimport {\n  createWebFetchToolCore,\n  toolFailure,\n  type WebFetchToolOptions\n} from \"../tool\";\nimport { webFetchInputSchema } from \"./input-schema\";\n\nexport type {\n  WebFetchFormat,\n  WebFetchPage,\n  WebFetchToolInput,\n  WebFetchToolOutput,\n  WebFetchVia\n} from \"../contract\";\nexport {\n  WebFetchError,\n  type WebFetchErrorCode,\n  type WebFetchRequest,\n  type WebFetchSource\n} from \"../source\";\nexport type { WebFetchToolOptions } from \"../tool\";\n\n/**\n * The part of the AI SDK's tool execution options the tool reads. Spelled\n * out rather than imported so it fits every supported `ai` major.\n */\nexport interface WebFetchToolExecuteOptions {\n  abortSignal?: AbortSignal;\n}\n\n/**\n * The AI SDK tool {@link webFetchTool} returns. Assignable to the AI SDK's\n * `Tool`; `execute` and `toModelOutput` are always present.\n */\nexport interface WebFetchTool {\n  description: string;\n  inputSchema: FlexibleSchema<WebFetchToolInput>;\n  execute(\n    input: WebFetchToolInput,\n    options: WebFetchToolExecuteOptions\n  ): Promise<WebFetchToolOutput>;\n  toModelOutput(options: { output: WebFetchToolOutput }): {\n    type: \"text\";\n    value: string;\n  };\n}\n\n/**\n * Create an AI SDK tool that reads a URL as Markdown, JSON, or text. The\n * tool's output is the window the model read plus the page's metadata\n * (status, headers, redirects, total length), so it stays small in stored\n * messages; `toModelOutput` renders it for the model. A failed fetch throws a `WebFetchError`, which\n * the AI SDK reports to the model as a tool error: its `message` is written\n * for the model, and its `cause` is the source's error with the detail.\n *\n * `toModelOutput` only applies to earlier turns when the tools are passed to\n * `convertToModelMessages(messages, { tools })`; otherwise the AI SDK sends\n * the output back to the model as JSON, without the header or the\n * untrusted-content wrapper. `AiSdkHarness` passes them.\n *\n * @example\n * ```ts\n * import { webFetchTool } from \"agents/webfetch/ai-sdk\";\n *\n * const result = streamText({\n *   model,\n *   tools: { web_fetch: webFetchTool({ binding: env.AI }) },\n *   messages\n * });\n * ```\n */\nexport function webFetchTool(options: WebFetchToolOptions): WebFetchTool {\n  const core = createWebFetchToolCore(options);\n  return {\n    description: core.description,\n    inputSchema: webFetchInputSchema(),\n    async execute(input, { abortSignal }) {\n      const run = await core.run(input, { signal: abortSignal });\n      if (!run.ok) throw toolFailure(run);\n      return run.output;\n    },\n    toModelOutput: ({ output }) => ({\n      type: \"text\",\n      value: core.render(output)\n    })\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8EA,SAAgB,aAAa,SAA4C;CACvE,MAAM,OAAO,uBAAuB,OAAO;CAC3C,OAAO;EACL,aAAa,KAAK;EAClB,aAAa,oBAAoB;EACjC,MAAM,QAAQ,OAAO,EAAE,eAAe;GACpC,MAAM,MAAM,MAAM,KAAK,IAAI,OAAO,EAAE,QAAQ,YAAY,CAAC;GACzD,IAAI,CAAC,IAAI,IAAI,MAAM,YAAY,GAAG;GAClC,OAAO,IAAI;EACb;EACA,gBAAgB,EAAE,cAAc;GAC9B,MAAM;GACN,OAAO,KAAK,OAAO,MAAM;EAC3B;CACF;AACF"}

package/dist/web/fetch/tools/pi.d.ts

@@ -0,0 +1,84 @@
+import {
+  S as WebFetchVia,
+  b as WebFetchToolInput,
+  c as WebFetchRequest,
+  l as WebFetchSource,
+  n as WebFetchToolOptions,
+  o as WebFetchError,
+  s as WebFetchErrorCode,
+  v as WebFetchFormat,
+  x as WebFetchToolOutput,
+  y as WebFetchPage
+} from "../../../tool-DoVberpN.js";
+import { Type } from "@earendil-works/pi-ai";
+import { ToolRegistration } from "@earendil-works/pi-durable";
+
+//#region src/web/fetch/tools/pi.d.ts
+/** The model's input schema. pi already coerces `"20000"` to `20000`. */
+declare function webFetchParameters(): Type.TObject<{
+  url: Type.TString;
+  offset: Type.TOptional<Type.TInteger>;
+  format: Type.TOptional<
+    Type.TUnion<[Type.TLiteral<"auto">, Type.TLiteral<"raw">]>
+  >;
+}>;
+type WebFetchParameters = ReturnType<typeof webFetchParameters>;
+/**
+ * Host-side details pi stores with each `web_fetch` result: the output (the
+ * window the model read, with the page's metadata) or the failure.
+ */
+type WebFetchToolDetails =
+  | {
+      ok: true;
+      output: WebFetchToolOutput;
+    }
+  | {
+      ok: false /** The source's error message, with the detail for the host. */;
+      message: string;
+      status: number;
+      code: WebFetchErrorCode;
+      retryable: boolean;
+      url?: string /** The response's media type, when a response was read. */;
+      contentType?: string;
+    };
+/**
+ * Create a pi tool that reads a URL as Markdown, JSON, or text. Install it
+ * on a registry like any other pi tool.
+ *
+ * The model chooses the URL, the window (`offset`), and the format; the
+ * host chooses the URL policy, size limits, and window size. The tool is
+ * `replay: "safe"`: a fetch interrupted mid-call (say, by an eviction) runs
+ * again when the session recovers. Completed results are stored and not
+ * fetched again.
+ *
+ * @example
+ * ```ts
+ * import { createRegistry } from "@earendil-works/pi-durable";
+ * import { webFetchTool } from "agents/webfetch/pi";
+ *
+ * const registry = createRegistry();
+ * registry.install({
+ *   name: "tools",
+ *   tools: [webFetchTool({ binding: env.AI })]
+ * });
+ * ```
+ */
+declare function webFetchTool(
+  options: WebFetchToolOptions
+): ToolRegistration<WebFetchParameters, WebFetchToolDetails>;
+//#endregion
+export {
+  WebFetchError,
+  type WebFetchErrorCode,
+  type WebFetchFormat,
+  type WebFetchPage,
+  type WebFetchRequest,
+  type WebFetchSource,
+  WebFetchToolDetails,
+  type WebFetchToolInput,
+  type WebFetchToolOptions,
+  type WebFetchToolOutput,
+  type WebFetchVia,
+  webFetchTool
+};
+//# sourceMappingURL=pi.d.ts.map

package/dist/web/fetch/tools/pi.js

@@ -0,0 +1,88 @@
+import { a as WebFetchError, d as MAX_WEB_FETCH_URL_LENGTH, t as createWebFetchToolCore } from "../../../tool-CxKsvxjm.js";
+import { Type } from "@earendil-works/pi-ai";
+//#region src/web/fetch/tools/pi.ts
+/**
+* `agents/webfetch/pi` — the `web_fetch` tool for the pi harness.
+*
+* @beta
+*/
+/** The model's input schema. pi already coerces `"20000"` to `20000`. */
+function webFetchParameters() {
+	return Type.Object({
+		url: Type.String({
+			minLength: 1,
+			maxLength: MAX_WEB_FETCH_URL_LENGTH,
+			description: "The http(s) URL to read."
+		}),
+		offset: Type.Optional(Type.Integer({
+			minimum: 0,
+			description: "Character offset into the content, to continue a long page from the previous result's offset. Default 0."
+		})),
+		format: Type.Optional(Type.Union([Type.Literal("auto"), Type.Literal("raw")], { description: "\"auto\" (default) converts to the most readable form; \"raw\" returns the body as served." }))
+	});
+}
+/**
+* Create a pi tool that reads a URL as Markdown, JSON, or text. Install it
+* on a registry like any other pi tool.
+*
+* The model chooses the URL, the window (`offset`), and the format; the
+* host chooses the URL policy, size limits, and window size. The tool is
+* `replay: "safe"`: a fetch interrupted mid-call (say, by an eviction) runs
+* again when the session recovers. Completed results are stored and not
+* fetched again.
+*
+* @example
+* ```ts
+* import { createRegistry } from "@earendil-works/pi-durable";
+* import { webFetchTool } from "agents/webfetch/pi";
+*
+* const registry = createRegistry();
+* registry.install({
+*   name: "tools",
+*   tools: [webFetchTool({ binding: env.AI })]
+* });
+* ```
+*/
+function webFetchTool(options) {
+	const core = createWebFetchToolCore(options);
+	return {
+		name: core.name,
+		description: core.description,
+		parameters: webFetchParameters(),
+		replay: "safe",
+		async execute(input, _api, context) {
+			const run = await core.run(input, { signal: context.abortSignal });
+			if (run.ok) return {
+				content: [{
+					type: "text",
+					text: run.text
+				}],
+				details: {
+					ok: true,
+					output: run.output
+				}
+			};
+			const details = {
+				ok: false,
+				message: run.error.message,
+				status: run.error.status,
+				code: run.error.code,
+				retryable: run.error.retryable
+			};
+			if (run.error.url !== void 0) details.url = run.error.url;
+			if (run.error.contentType !== void 0) details.contentType = run.error.contentType;
+			return {
+				content: [{
+					type: "text",
+					text: run.text
+				}],
+				isError: true,
+				details
+			};
+		}
+	};
+}
+//#endregion
+export { WebFetchError, webFetchTool };
+
+//# sourceMappingURL=pi.js.map

package/dist/web/fetch/tools/pi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi.js","names":[],"sources":["../../../../src/web/fetch/tools/pi.ts"],"sourcesContent":["/**\n * `agents/webfetch/pi` — the `web_fetch` tool for the pi harness.\n *\n * @beta\n */\nimport { Type } from \"@earendil-works/pi-ai\";\nimport type { ToolRegistration } from \"@earendil-works/pi-durable\";\nimport { MAX_WEB_FETCH_URL_LENGTH, type WebFetchToolOutput } from \"../contract\";\nimport type { WebFetchErrorCode } from \"../source\";\nimport { createWebFetchToolCore, type WebFetchToolOptions } from \"../tool\";\n\nexport type {\n  WebFetchFormat,\n  WebFetchPage,\n  WebFetchToolInput,\n  WebFetchToolOutput,\n  WebFetchVia\n} from \"../contract\";\nexport {\n  WebFetchError,\n  type WebFetchErrorCode,\n  type WebFetchRequest,\n  type WebFetchSource\n} from \"../source\";\nexport type { WebFetchToolOptions } from \"../tool\";\n\n/** The model's input schema. pi already coerces `\"20000\"` to `20000`. */\nfunction webFetchParameters() {\n  return Type.Object({\n    url: Type.String({\n      minLength: 1,\n      maxLength: MAX_WEB_FETCH_URL_LENGTH,\n      description: \"The http(s) URL to read.\"\n    }),\n    offset: Type.Optional(\n      Type.Integer({\n        minimum: 0,\n        description:\n          \"Character offset into the content, to continue a long page from the previous result's offset. Default 0.\"\n      })\n    ),\n    format: Type.Optional(\n      Type.Union([Type.Literal(\"auto\"), Type.Literal(\"raw\")], {\n        description:\n          '\"auto\" (default) converts to the most readable form; \"raw\" returns the body as served.'\n      })\n    )\n  });\n}\n\ntype WebFetchParameters = ReturnType<typeof webFetchParameters>;\n\n/**\n * Host-side details pi stores with each `web_fetch` result: the output (the\n * window the model read, with the page's metadata) or the failure.\n */\nexport type WebFetchToolDetails =\n  | { ok: true; output: WebFetchToolOutput }\n  | {\n      ok: false;\n      /** The source's error message, with the detail for the host. */\n      message: string;\n      status: number;\n      code: WebFetchErrorCode;\n      retryable: boolean;\n      url?: string;\n      /** The response's media type, when a response was read. */\n      contentType?: string;\n    };\n\n/**\n * Create a pi tool that reads a URL as Markdown, JSON, or text. Install it\n * on a registry like any other pi tool.\n *\n * The model chooses the URL, the window (`offset`), and the format; the\n * host chooses the URL policy, size limits, and window size. The tool is\n * `replay: \"safe\"`: a fetch interrupted mid-call (say, by an eviction) runs\n * again when the session recovers. Completed results are stored and not\n * fetched again.\n *\n * @example\n * ```ts\n * import { createRegistry } from \"@earendil-works/pi-durable\";\n * import { webFetchTool } from \"agents/webfetch/pi\";\n *\n * const registry = createRegistry();\n * registry.install({\n *   name: \"tools\",\n *   tools: [webFetchTool({ binding: env.AI })]\n * });\n * ```\n */\nexport function webFetchTool(\n  options: WebFetchToolOptions\n): ToolRegistration<WebFetchParameters, WebFetchToolDetails> {\n  const core = createWebFetchToolCore(options);\n  return {\n    name: core.name,\n    description: core.description,\n    parameters: webFetchParameters(),\n    replay: \"safe\",\n    async execute(input, _api, context) {\n      const run = await core.run(input, { signal: context.abortSignal });\n      if (run.ok) {\n        return {\n          content: [{ type: \"text\", text: run.text }],\n          details: { ok: true, output: run.output }\n        };\n      }\n      const details: WebFetchToolDetails = {\n        ok: false,\n        message: run.error.message,\n        status: run.error.status,\n        code: run.error.code,\n        retryable: run.error.retryable\n      };\n      if (run.error.url !== undefined) details.url = run.error.url;\n      if (run.error.contentType !== undefined) {\n        details.contentType = run.error.contentType;\n      }\n      return {\n        content: [{ type: \"text\", text: run.text }],\n        isError: true,\n        details\n      };\n    }\n  };\n}\n"],"mappings":";;;;;;;;;AA2BA,SAAS,qBAAqB;CAC5B,OAAO,KAAK,OAAO;EACjB,KAAK,KAAK,OAAO;GACf,WAAW;GACX,WAAW;GACX,aAAa;EACf,CAAC;EACD,QAAQ,KAAK,SACX,KAAK,QAAQ;GACX,SAAS;GACT,aACE;EACJ,CAAC,CACH;EACA,QAAQ,KAAK,SACX,KAAK,MAAM,CAAC,KAAK,QAAQ,MAAM,GAAG,KAAK,QAAQ,KAAK,CAAC,GAAG,EACtD,aACE,6FACJ,CAAC,CACH;CACF,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,aACd,SAC2D;CAC3D,MAAM,OAAO,uBAAuB,OAAO;CAC3C,OAAO;EACL,MAAM,KAAK;EACX,aAAa,KAAK;EAClB,YAAY,mBAAmB;EAC/B,QAAQ;EACR,MAAM,QAAQ,OAAO,MAAM,SAAS;GAClC,MAAM,MAAM,MAAM,KAAK,IAAI,OAAO,EAAE,QAAQ,QAAQ,YAAY,CAAC;GACjE,IAAI,IAAI,IACN,OAAO;IACL,SAAS,CAAC;KAAE,MAAM;KAAQ,MAAM,IAAI;IAAK,CAAC;IAC1C,SAAS;KAAE,IAAI;KAAM,QAAQ,IAAI;IAAO;GAC1C;GAEF,MAAM,UAA+B;IACnC,IAAI;IACJ,SAAS,IAAI,MAAM;IACnB,QAAQ,IAAI,MAAM;IAClB,MAAM,IAAI,MAAM;IAChB,WAAW,IAAI,MAAM;GACvB;GACA,IAAI,IAAI,MAAM,QAAQ,KAAA,GAAW,QAAQ,MAAM,IAAI,MAAM;GACzD,IAAI,IAAI,MAAM,gBAAgB,KAAA,GAC5B,QAAQ,cAAc,IAAI,MAAM;GAElC,OAAO;IACL,SAAS,CAAC;KAAE,MAAM;KAAQ,MAAM,IAAI;IAAK,CAAC;IAC1C,SAAS;IACT;GACF;EACF;CACF;AACF"}

package/dist/web/fetch/tools/tanstack-ai.d.ts

@@ -0,0 +1,78 @@
+import {
+  S as WebFetchVia,
+  _ as WEB_FETCH_TOOL_NAME,
+  b as WebFetchToolInput,
+  c as WebFetchRequest,
+  l as WebFetchSource,
+  n as WebFetchToolOptions,
+  o as WebFetchError,
+  s as WebFetchErrorCode,
+  v as WebFetchFormat,
+  x as WebFetchToolOutput,
+  y as WebFetchPage
+} from "../../../tool-DoVberpN.js";
+
+//#region src/web/fetch/tools/tanstack-ai.d.ts
+type TanStackWebFetchToolOptions<
+  TName extends string = typeof WEB_FETCH_TOOL_NAME
+> = WebFetchToolOptions & {
+  /** The tool's name. TanStack AI tools carry it in the definition. */ name?: TName;
+};
+/**
+ * Create a TanStack AI tool that reads a URL as Markdown, JSON, or text.
+ * TanStack AI has one return channel, so the model and the host both get
+ * the rendered window. A failed fetch throws a `WebFetchError`, which
+ * TanStack AI reports as an error result: its `message` is written for the
+ * model, and its `cause` is the source's error with the detail. The tool is
+ * named `web_fetch` unless you pass `name`.
+ *
+ * @example
+ * ```ts
+ * import { webFetchTool } from "agents/webfetch/tanstack-ai";
+ * import { chat } from "@tanstack/ai";
+ *
+ * const stream = chat({
+ *   adapter,
+ *   tools: [webFetchTool({ binding: env.AI })],
+ *   messages
+ * });
+ * ```
+ */
+declare function webFetchTool<
+  TName extends string = typeof WEB_FETCH_TOOL_NAME
+>(
+  options: TanStackWebFetchToolOptions<TName>
+): import("@tanstack/ai").ServerTool<
+  import("zod").ZodObject<
+    {
+      url: import("zod").ZodString;
+      offset: import("zod").ZodOptional<import("zod").ZodNumber>;
+      format: import("zod").ZodOptional<
+        import("zod").ZodEnum<{
+          auto: "auto";
+          raw: "raw";
+        }>
+      >;
+    },
+    import("zod/v4/core").$strip
+  >,
+  import("@tanstack/ai").SchemaInput,
+  TName,
+  unknown
+>;
+//#endregion
+export {
+  TanStackWebFetchToolOptions,
+  WebFetchError,
+  type WebFetchErrorCode,
+  type WebFetchFormat,
+  type WebFetchPage,
+  type WebFetchRequest,
+  type WebFetchSource,
+  type WebFetchToolInput,
+  type WebFetchToolOptions,
+  type WebFetchToolOutput,
+  type WebFetchVia,
+  webFetchTool
+};
+//# sourceMappingURL=tanstack-ai.d.ts.map

package/dist/web/fetch/tools/tanstack-ai.js

@@ -0,0 +1,45 @@
+import { a as WebFetchError, r as toolFailure, t as createWebFetchToolCore } from "../../../tool-CxKsvxjm.js";
+import { t as webFetchInputSchema } from "../../../input-schema-BQykTEp_.js";
+import { toolDefinition } from "@tanstack/ai";
+//#region src/web/fetch/tools/tanstack-ai.ts
+/**
+* `agents/webfetch/tanstack-ai` — the `web_fetch` tool for TanStack AI.
+*
+* @beta
+*/
+/**
+* Create a TanStack AI tool that reads a URL as Markdown, JSON, or text.
+* TanStack AI has one return channel, so the model and the host both get
+* the rendered window. A failed fetch throws a `WebFetchError`, which
+* TanStack AI reports as an error result: its `message` is written for the
+* model, and its `cause` is the source's error with the detail. The tool is
+* named `web_fetch` unless you pass `name`.
+*
+* @example
+* ```ts
+* import { webFetchTool } from "agents/webfetch/tanstack-ai";
+* import { chat } from "@tanstack/ai";
+*
+* const stream = chat({
+*   adapter,
+*   tools: [webFetchTool({ binding: env.AI })],
+*   messages
+* });
+* ```
+*/
+function webFetchTool(options) {
+	const core = createWebFetchToolCore(options);
+	return toolDefinition({
+		name: options.name ?? core.name,
+		description: core.description,
+		inputSchema: webFetchInputSchema()
+	}).server(async (input, context) => {
+		const run = await core.run(input, { signal: context?.abortSignal });
+		if (!run.ok) throw toolFailure(run);
+		return run.text;
+	});
+}
+//#endregion
+export { WebFetchError, webFetchTool };
+
+//# sourceMappingURL=tanstack-ai.js.map

package/dist/web/fetch/tools/tanstack-ai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../../../src/web/fetch/tools/tanstack-ai.ts"],"sourcesContent":["/**\n * `agents/webfetch/tanstack-ai` — the `web_fetch` tool for TanStack AI.\n *\n * @beta\n */\nimport { toolDefinition } from \"@tanstack/ai\";\nimport type { WEB_FETCH_TOOL_NAME } from \"../contract\";\nimport {\n  createWebFetchToolCore,\n  toolFailure,\n  type WebFetchToolOptions\n} from \"../tool\";\nimport { webFetchInputSchema } from \"./input-schema\";\n\nexport type {\n  WebFetchFormat,\n  WebFetchPage,\n  WebFetchToolInput,\n  WebFetchToolOutput,\n  WebFetchVia\n} from \"../contract\";\nexport {\n  WebFetchError,\n  type WebFetchErrorCode,\n  type WebFetchRequest,\n  type WebFetchSource\n} from \"../source\";\nexport type { WebFetchToolOptions } from \"../tool\";\n\nexport type TanStackWebFetchToolOptions<\n  TName extends string = typeof WEB_FETCH_TOOL_NAME\n> = WebFetchToolOptions & {\n  /** The tool's name. TanStack AI tools carry it in the definition. */\n  name?: TName;\n};\n\n/**\n * Create a TanStack AI tool that reads a URL as Markdown, JSON, or text.\n * TanStack AI has one return channel, so the model and the host both get\n * the rendered window. A failed fetch throws a `WebFetchError`, which\n * TanStack AI reports as an error result: its `message` is written for the\n * model, and its `cause` is the source's error with the detail. The tool is\n * named `web_fetch` unless you pass `name`.\n *\n * @example\n * ```ts\n * import { webFetchTool } from \"agents/webfetch/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * const stream = chat({\n *   adapter,\n *   tools: [webFetchTool({ binding: env.AI })],\n *   messages\n * });\n * ```\n */\nexport function webFetchTool<TName extends string = typeof WEB_FETCH_TOOL_NAME>(\n  options: TanStackWebFetchToolOptions<TName>\n) {\n  const core = createWebFetchToolCore(options);\n  return toolDefinition({\n    name: options.name ?? (core.name as TName),\n    description: core.description,\n    inputSchema: webFetchInputSchema()\n  }).server(async (input, context) => {\n    const run = await core.run(input, { signal: context?.abortSignal });\n    if (!run.ok) throw toolFailure(run);\n    return run.text;\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,SAAgB,aACd,SACA;CACA,MAAM,OAAO,uBAAuB,OAAO;CAC3C,OAAO,eAAe;EACpB,MAAM,QAAQ,QAAS,KAAK;EAC5B,aAAa,KAAK;EAClB,aAAa,oBAAoB;CACnC,CAAC,CAAC,CAAC,OAAO,OAAO,OAAO,YAAY;EAClC,MAAM,MAAM,MAAM,KAAK,IAAI,OAAO,EAAE,QAAQ,SAAS,YAAY,CAAC;EAClE,IAAI,CAAC,IAAI,IAAI,MAAM,YAAY,GAAG;EAClC,OAAO,IAAI;CACb,CAAC;AACH"}

package/dist/web/search/index.d.ts

@@ -0,0 +1,58 @@
+import {
+  C as WebSearchResponse,
+  D as renderWebSearchResults,
+  E as WebSearchToolOutput,
+  S as WEB_SEARCH_TOOL_NAME,
+  T as WebSearchToolInput,
+  _ as DEFAULT_WEB_SEARCH_LIMIT,
+  a as AIWebSearchOptions,
+  b as RenderWebSearchResultsOptions,
+  c as WebSearchError,
+  d as WebSearchProvider,
+  f as WebSearchRequest,
+  g as DEFAULT_WEB_SEARCH_DESCRIPTION_CHARS,
+  h as createHTTPWebSearch,
+  i as WebSearchToolSourceOptions,
+  l as WebSearchErrorCode,
+  m as createAIWebSearch,
+  n as WebSearchToolBindingOptions,
+  o as HTTPWebSearchOptions,
+  p as WebSearchSource,
+  r as WebSearchToolOptions,
+  s as WebSearchCallOptions,
+  t as DEFAULT_WEB_SEARCH_TIMEOUT_MS,
+  u as WebSearchGatewayOptions,
+  v as MAX_WEB_SEARCH_LIMIT,
+  w as WebSearchResult,
+  x as WEB_SEARCH_TOOL_DESCRIPTION,
+  y as MAX_WEB_SEARCH_QUERY_LENGTH
+} from "../../tool-CTp72Jb_.js";
+export {
+  type AIWebSearchOptions,
+  DEFAULT_WEB_SEARCH_DESCRIPTION_CHARS,
+  DEFAULT_WEB_SEARCH_LIMIT,
+  DEFAULT_WEB_SEARCH_TIMEOUT_MS,
+  type HTTPWebSearchOptions,
+  MAX_WEB_SEARCH_LIMIT,
+  MAX_WEB_SEARCH_QUERY_LENGTH,
+  type RenderWebSearchResultsOptions,
+  WEB_SEARCH_TOOL_DESCRIPTION,
+  WEB_SEARCH_TOOL_NAME,
+  type WebSearchCallOptions,
+  WebSearchError,
+  type WebSearchErrorCode,
+  type WebSearchGatewayOptions,
+  type WebSearchProvider,
+  type WebSearchRequest,
+  type WebSearchResponse,
+  type WebSearchResult,
+  type WebSearchSource,
+  type WebSearchToolBindingOptions,
+  type WebSearchToolInput,
+  type WebSearchToolOptions,
+  type WebSearchToolOutput,
+  type WebSearchToolSourceOptions,
+  createAIWebSearch,
+  createHTTPWebSearch,
+  renderWebSearchResults
+};

package/dist/web/search/index.js

@@ -0,0 +1,2 @@
+import { a as createAIWebSearch, c as DEFAULT_WEB_SEARCH_LIMIT, d as WEB_SEARCH_TOOL_DESCRIPTION, f as WEB_SEARCH_TOOL_NAME, i as WebSearchError, l as MAX_WEB_SEARCH_LIMIT, o as createHTTPWebSearch, p as renderWebSearchResults, s as DEFAULT_WEB_SEARCH_DESCRIPTION_CHARS, t as DEFAULT_WEB_SEARCH_TIMEOUT_MS, u as MAX_WEB_SEARCH_QUERY_LENGTH } from "../../tool-cQRkwSZZ.js";
+export { DEFAULT_WEB_SEARCH_DESCRIPTION_CHARS, DEFAULT_WEB_SEARCH_LIMIT, DEFAULT_WEB_SEARCH_TIMEOUT_MS, MAX_WEB_SEARCH_LIMIT, MAX_WEB_SEARCH_QUERY_LENGTH, WEB_SEARCH_TOOL_DESCRIPTION, WEB_SEARCH_TOOL_NAME, WebSearchError, createAIWebSearch, createHTTPWebSearch, renderWebSearchResults };

package/dist/web/search/tools/ai-sdk.d.ts

@@ -0,0 +1,77 @@
+import {
+  C as WebSearchResponse,
+  E as WebSearchToolOutput,
+  T as WebSearchToolInput,
+  c as WebSearchError,
+  d as WebSearchProvider,
+  l as WebSearchErrorCode,
+  p as WebSearchSource,
+  r as WebSearchToolOptions,
+  w as WebSearchResult
+} from "../../../tool-CTp72Jb_.js";
+import { FlexibleSchema } from "ai";
+
+//#region src/web/search/tools/ai-sdk.d.ts
+/**
+ * The part of the AI SDK's tool execution options the tool reads. Spelled
+ * out rather than imported so it fits every supported `ai` major.
+ */
+interface WebSearchToolExecuteOptions {
+  abortSignal?: AbortSignal;
+}
+/**
+ * The AI SDK tool {@link webSearchTool} returns. Assignable to the AI SDK's
+ * `Tool`; `execute` and `toModelOutput` are always present.
+ */
+interface WebSearchTool {
+  description: string;
+  inputSchema: FlexibleSchema<WebSearchToolInput>;
+  execute(
+    input: WebSearchToolInput,
+    options: WebSearchToolExecuteOptions
+  ): Promise<WebSearchToolOutput>;
+  toModelOutput(options: { output: WebSearchToolOutput }): {
+    type: "text";
+    value: string;
+  };
+}
+/**
+ * Create an AI SDK tool that searches the web through Cloudflare's Web
+ * Search API. The host gets the full response as the tool's output (whole
+ * descriptions, provider metadata); the model gets a trimmed text rendering
+ * via `toModelOutput`. A failed search throws a `WebSearchError`, which the
+ * AI SDK reports to the model as a tool error: its `message` is written for
+ * the model, and its `cause` is the source's error with the API's detail.
+ *
+ * `toModelOutput` only applies to earlier turns when the tools are passed to
+ * `convertToModelMessages(messages, { tools })`; otherwise the AI SDK sends
+ * the full response back to the model as JSON. `AiSdkHarness` passes them.
+ *
+ * @example
+ * ```ts
+ * import { webSearchTool } from "agents/websearch/ai-sdk";
+ *
+ * const result = streamText({
+ *   model,
+ *   tools: { web_search: webSearchTool({ binding: env.AI }) },
+ *   messages
+ * });
+ * ```
+ */
+declare function webSearchTool(options: WebSearchToolOptions): WebSearchTool;
+//#endregion
+export {
+  WebSearchError,
+  type WebSearchErrorCode,
+  type WebSearchProvider,
+  type WebSearchResponse,
+  type WebSearchResult,
+  type WebSearchSource,
+  WebSearchTool,
+  WebSearchToolExecuteOptions,
+  type WebSearchToolInput,
+  type WebSearchToolOptions,
+  type WebSearchToolOutput,
+  webSearchTool
+};
+//# sourceMappingURL=ai-sdk.d.ts.map

package/dist/web/search/tools/ai-sdk.js

@@ -0,0 +1,46 @@
+import { i as WebSearchError, n as createWebSearchToolCore, r as toolFailure } from "../../../tool-cQRkwSZZ.js";
+import { t as webSearchInputSchema } from "../../../input-schema-D2QAtHZH.js";
+//#region src/web/search/tools/ai-sdk.ts
+/**
+* Create an AI SDK tool that searches the web through Cloudflare's Web
+* Search API. The host gets the full response as the tool's output (whole
+* descriptions, provider metadata); the model gets a trimmed text rendering
+* via `toModelOutput`. A failed search throws a `WebSearchError`, which the
+* AI SDK reports to the model as a tool error: its `message` is written for
+* the model, and its `cause` is the source's error with the API's detail.
+*
+* `toModelOutput` only applies to earlier turns when the tools are passed to
+* `convertToModelMessages(messages, { tools })`; otherwise the AI SDK sends
+* the full response back to the model as JSON. `AiSdkHarness` passes them.
+*
+* @example
+* ```ts
+* import { webSearchTool } from "agents/websearch/ai-sdk";
+*
+* const result = streamText({
+*   model,
+*   tools: { web_search: webSearchTool({ binding: env.AI }) },
+*   messages
+* });
+* ```
+*/
+function webSearchTool(options) {
+	const core = createWebSearchToolCore(options);
+	return {
+		description: core.description,
+		inputSchema: webSearchInputSchema(core.limit),
+		async execute(input, { abortSignal }) {
+			const run = await core.run(input, { signal: abortSignal });
+			if (!run.ok) throw toolFailure(run);
+			return run.output;
+		},
+		toModelOutput: ({ output }) => ({
+			type: "text",
+			value: core.render(output)
+		})
+	};
+}
+//#endregion
+export { WebSearchError, webSearchTool };
+
+//# sourceMappingURL=ai-sdk.js.map