agents 0.26.0 → 0.28.0

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

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

package/dist/browser/tools/pi.js

@@ -0,0 +1,119 @@
+import { n as browserScreenshotOutput, t as browserExecuteModelOutput } from "../../tool-helpers-O5BDVEAY.js";
+import { n as createBrowserToolCore } from "../../browser-tool-4iomavs_.js";
+import { Type } from "@earendil-works/pi-ai";
+//#region src/browser/tools/pi.ts
+const browserToolParameters = Type.Object({ code: Type.String({ description: "An async arrow function that drives the browser with `cdp`" }) });
+function details(output) {
+	return {
+		executionId: output.executionId,
+		status: output.status,
+		...output.restarted ? { restarted: true } : {},
+		...output.newTabs ? { newTabs: output.newTabs.map((tab) => ({
+			targetId: tab.targetId,
+			...tab.url === void 0 ? {} : { url: tab.url },
+			...tab.title === void 0 ? {} : { title: tab.title }
+		})) } : {}
+	};
+}
+function text(value) {
+	return {
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value)
+	};
+}
+/**
+* The tool result pi stores and sends: the model projection of the run as
+* JSON (no `calls` log, bounded `logs`), and a screenshot as an image part
+* after it. pi-ai only sends the image to models that accept images.
+*/
+function browserToolResult(output) {
+	const isError = output.status === "error";
+	const screenshot = browserScreenshotOutput(output);
+	if (!screenshot) return {
+		content: [text(browserExecuteModelOutput(output).value)],
+		details: details(output),
+		...isError ? { isError } : {}
+	};
+	const bytes = Math.floor(screenshot.data.length * 3 / 4).toLocaleString();
+	const summary = browserExecuteModelOutput({
+		...output,
+		result: `Screenshot attached as an image (${screenshot.mediaType}, approximately ${bytes} bytes). If you can't see it, read the page with Runtime.evaluate instead.`
+	}).value;
+	const image = {
+		type: "image",
+		data: screenshot.data,
+		mimeType: screenshot.mediaType
+	};
+	return {
+		content: [text(summary), image],
+		details: details(output)
+	};
+}
+function conversationScope(api) {
+	return `conversation:${api.conversationId}`;
+}
+/**
+* Create a pi-durable tool that lets the model drive a persistent browser
+* with JavaScript and the Chrome DevTools Protocol.
+*
+* Works like `browserTool` in `agents/browser/ai-sdk`: tabs, cookies, and
+* logins carry over between runs, `sessionId: "active"` addresses the tab the
+* model last worked in, and a replaced browser is reported as
+* `restarted: true`. A returned screenshot comes back as an image part that
+* the model sees, when its model accepts images.
+*
+* Each conversation gets its own active tab (see
+* {@link PiBrowserToolOptions.scope}). A conversation's calls run one at a
+* time, since they share its tab, and the tool doesn't rerun after an
+* eviction (its code may have clicked or
+* submitted something): pi gives the model an interrupted result instead.
+* Pass `ctx` unless the tool is built inside an Agent.
+*
+* @example
+* ```ts
+* import { Browser, browserRun } from "agents/browser";
+* import { browserTool } from "agents/browser/pi";
+*
+* export class MyAgent extends DurableObject<Env> {
+*   readonly browser = new Browser({ provider: browserRun(this.env.BROWSER) });
+*   readonly registry = createRegistry();
+*   readonly harness = new PiHarness({
+*     harness: ({ storage, context }) => {
+*       this.registry.install({
+*         name: "browser",
+*         tools: [
+*           browserTool({
+*             ctx: this.ctx,
+*             browser: this.browser,
+*             loader: this.env.LOADER
+*           })
+*         ]
+*       });
+*       return Harness.open(storage, { models, registry: this.registry }, context);
+*     }
+*   });
+*   readonly lifecycle = Lifecycle.install(this)
+*     .use(this.browser)
+*     .use(this.harness);
+* }
+* ```
+*/
+function browserTool(options) {
+	const { scope = conversationScope, ...coreOptions } = options;
+	const core = createBrowserToolCore(coreOptions, { screenshotHint: "To see a screenshot, return { type: 'browser_screenshot', mediaType, data } with data from Page.captureScreenshot and mediaType 'image/png', or 'image/jpeg' if you captured with format: 'jpeg'. The image is attached to the result." });
+	return {
+		name: options.name ?? "browser",
+		description: core.description,
+		parameters: browserToolParameters,
+		executionMode: "sequential",
+		replay: "unsafe",
+		async execute(args, api) {
+			const callScope = typeof scope === "string" ? scope : scope(api);
+			return browserToolResult(await core.execute({ code: args.code }, callScope));
+		}
+	};
+}
+//#endregion
+export { browserTool };
+
+//# sourceMappingURL=pi.js.map

package/dist/browser/tools/pi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi.js","names":[],"sources":["../../../src/browser/tools/pi.ts"],"sourcesContent":["import {\n  Type,\n  type ImageContent,\n  type TextContent\n} from \"@earendil-works/pi-ai\";\nimport type {\n  ToolExecutionApi,\n  ToolExecutionResult,\n  ToolRegistration\n} from \"@earendil-works/pi-durable\";\nimport {\n  createBrowserToolCore,\n  type BrowserToolOptions,\n  type BrowserToolOutput\n} from \"../browser-tool\";\nimport type { BrowserNewTab } from \"../session-connector\";\nimport {\n  browserExecuteModelOutput,\n  browserScreenshotOutput\n} from \"../tool-helpers\";\n\nexport type {\n  BrowserToolInput,\n  BrowserToolOptions,\n  BrowserToolOutput\n} from \"../browser-tool\";\nexport type { BrowserNewTab, BrowserSource } from \"../session-connector\";\n\nexport interface PiBrowserToolOptions<\n  TName extends string = \"browser\"\n> extends Omit<BrowserToolOptions, \"scope\"> {\n  /** The tool's name. Default `\"browser\"`. */\n  name?: TName;\n  /**\n   * Which calls share an active tab: a string for every call, or a function\n   * of the call. Defaults to `conversation:<id>` for the calling\n   * conversation, so each\n   * conversation (and each fork or subagent) on the Durable Object keeps its\n   * own tab, while cookies and logins stay shared.\n   */\n  scope?: string | ((api: ToolExecutionApi) => string);\n}\n\nconst browserToolParameters = Type.Object({\n  code: Type.String({\n    description: \"An async arrow function that drives the browser with `cdp`\"\n  })\n});\n\n/**\n * What a UI can show about a run without reading the content: the run's\n * outcome and what happened to the browser.\n */\nexport type PiBrowserToolDetails = {\n  executionId: string;\n  status: BrowserToolOutput[\"status\"];\n  restarted?: true;\n  newTabs?: { targetId: string; url?: string; title?: string }[];\n};\n\nexport type PiBrowserTool<TName extends string = \"browser\"> = ToolRegistration<\n  typeof browserToolParameters,\n  PiBrowserToolDetails\n> & {\n  readonly name: TName;\n};\n\nfunction details(output: BrowserToolOutput): PiBrowserToolDetails {\n  return {\n    executionId: output.executionId,\n    status: output.status,\n    ...(output.restarted ? { restarted: true as const } : {}),\n    ...(output.newTabs\n      ? {\n          newTabs: output.newTabs.map((tab: BrowserNewTab) => ({\n            targetId: tab.targetId,\n            ...(tab.url === undefined ? {} : { url: tab.url }),\n            ...(tab.title === undefined ? {} : { title: tab.title })\n          }))\n        }\n      : {})\n  };\n}\n\nfunction text(value: unknown): TextContent {\n  return {\n    type: \"text\",\n    text: typeof value === \"string\" ? value : JSON.stringify(value)\n  };\n}\n\n/**\n * The tool result pi stores and sends: the model projection of the run as\n * JSON (no `calls` log, bounded `logs`), and a screenshot as an image part\n * after it. pi-ai only sends the image to models that accept images.\n */\nfunction browserToolResult(\n  output: BrowserToolOutput\n): ToolExecutionResult<PiBrowserToolDetails> {\n  const isError = output.status === \"error\";\n  const screenshot = browserScreenshotOutput(output);\n  if (!screenshot) {\n    return {\n      content: [text(browserExecuteModelOutput(output).value)],\n      details: details(output),\n      ...(isError ? { isError } : {})\n    };\n  }\n\n  // No size check: a screenshot comes from one cdp.send result, which\n  // codemode caps at 1 MB, well under what model providers accept.\n  const bytes = Math.floor((screenshot.data.length * 3) / 4).toLocaleString();\n  // Keep the rest of the result (status, restarted, notice, newTabs) around\n  // the sentence that replaces the screenshot.\n  const summary = browserExecuteModelOutput({\n    ...output,\n    result: `Screenshot attached as an image (${screenshot.mediaType}, approximately ${bytes} bytes). If you can't see it, read the page with Runtime.evaluate instead.`\n  }).value;\n  const image: ImageContent = {\n    type: \"image\",\n    data: screenshot.data,\n    mimeType: screenshot.mediaType\n  };\n  return {\n    content: [text(summary), image],\n    details: details(output)\n  };\n}\n\nfunction conversationScope(api: ToolExecutionApi): string {\n  return `conversation:${api.conversationId}`;\n}\n\n/**\n * Create a pi-durable tool that lets the model drive a persistent browser\n * with JavaScript and the Chrome DevTools Protocol.\n *\n * Works like `browserTool` in `agents/browser/ai-sdk`: tabs, cookies, and\n * logins carry over between runs, `sessionId: \"active\"` addresses the tab the\n * model last worked in, and a replaced browser is reported as\n * `restarted: true`. A returned screenshot comes back as an image part that\n * the model sees, when its model accepts images.\n *\n * Each conversation gets its own active tab (see\n * {@link PiBrowserToolOptions.scope}). A conversation's calls run one at a\n * time, since they share its tab, and the tool doesn't rerun after an\n * eviction (its code may have clicked or\n * submitted something): pi gives the model an interrupted result instead.\n * Pass `ctx` unless the tool is built inside an Agent.\n *\n * @example\n * ```ts\n * import { Browser, browserRun } from \"agents/browser\";\n * import { browserTool } from \"agents/browser/pi\";\n *\n * export class MyAgent extends DurableObject<Env> {\n *   readonly browser = new Browser({ provider: browserRun(this.env.BROWSER) });\n *   readonly registry = createRegistry();\n *   readonly harness = new PiHarness({\n *     harness: ({ storage, context }) => {\n *       this.registry.install({\n *         name: \"browser\",\n *         tools: [\n *           browserTool({\n *             ctx: this.ctx,\n *             browser: this.browser,\n *             loader: this.env.LOADER\n *           })\n *         ]\n *       });\n *       return Harness.open(storage, { models, registry: this.registry }, context);\n *     }\n *   });\n *   readonly lifecycle = Lifecycle.install(this)\n *     .use(this.browser)\n *     .use(this.harness);\n * }\n * ```\n */\nexport function browserTool<TName extends string = \"browser\">(\n  options: PiBrowserToolOptions<TName>\n): PiBrowserTool<TName> {\n  const { scope = conversationScope, ...coreOptions } = options;\n  const core = createBrowserToolCore(coreOptions, {\n    screenshotHint:\n      \"To see a screenshot, return { type: 'browser_screenshot', mediaType, data } with data from Page.captureScreenshot and mediaType 'image/png', or 'image/jpeg' if you captured with format: 'jpeg'. The image is attached to the result.\"\n  });\n  return {\n    name: options.name ?? (\"browser\" as TName),\n    description: core.description,\n    parameters: browserToolParameters,\n    // A conversation's calls share its tab, so they must not interleave.\n    executionMode: \"sequential\",\n    // The code may have clicked or submitted something; don't run it twice.\n    replay: \"unsafe\",\n    async execute(args, api) {\n      const callScope = typeof scope === \"string\" ? scope : scope(api);\n      return browserToolResult(\n        await core.execute({ code: args.code }, callScope)\n      );\n    }\n  };\n}\n"],"mappings":";;;;AA2CA,MAAM,wBAAwB,KAAK,OAAO,EACxC,MAAM,KAAK,OAAO,EAChB,aAAa,6DACf,CAAC,EACH,CAAC;AAoBD,SAAS,QAAQ,QAAiD;CAChE,OAAO;EACL,aAAa,OAAO;EACpB,QAAQ,OAAO;EACf,GAAI,OAAO,YAAY,EAAE,WAAW,KAAc,IAAI,CAAC;EACvD,GAAI,OAAO,UACP,EACE,SAAS,OAAO,QAAQ,KAAK,SAAwB;GACnD,UAAU,IAAI;GACd,GAAI,IAAI,QAAQ,KAAA,IAAY,CAAC,IAAI,EAAE,KAAK,IAAI,IAAI;GAChD,GAAI,IAAI,UAAU,KAAA,IAAY,CAAC,IAAI,EAAE,OAAO,IAAI,MAAM;EACxD,EAAE,EACJ,IACA,CAAC;CACP;AACF;AAEA,SAAS,KAAK,OAA6B;CACzC,OAAO;EACL,MAAM;EACN,MAAM,OAAO,UAAU,WAAW,QAAQ,KAAK,UAAU,KAAK;CAChE;AACF;;;;;;AAOA,SAAS,kBACP,QAC2C;CAC3C,MAAM,UAAU,OAAO,WAAW;CAClC,MAAM,aAAa,wBAAwB,MAAM;CACjD,IAAI,CAAC,YACH,OAAO;EACL,SAAS,CAAC,KAAK,0BAA0B,MAAM,CAAC,CAAC,KAAK,CAAC;EACvD,SAAS,QAAQ,MAAM;EACvB,GAAI,UAAU,EAAE,QAAQ,IAAI,CAAC;CAC/B;CAKF,MAAM,QAAQ,KAAK,MAAO,WAAW,KAAK,SAAS,IAAK,CAAC,CAAC,CAAC,eAAe;CAG1E,MAAM,UAAU,0BAA0B;EACxC,GAAG;EACH,QAAQ,oCAAoC,WAAW,UAAU,kBAAkB,MAAM;CAC3F,CAAC,CAAC,CAAC;CACH,MAAM,QAAsB;EAC1B,MAAM;EACN,MAAM,WAAW;EACjB,UAAU,WAAW;CACvB;CACA,OAAO;EACL,SAAS,CAAC,KAAK,OAAO,GAAG,KAAK;EAC9B,SAAS,QAAQ,MAAM;CACzB;AACF;AAEA,SAAS,kBAAkB,KAA+B;CACxD,OAAO,gBAAgB,IAAI;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,SAAgB,YACd,SACsB;CACtB,MAAM,EAAE,QAAQ,mBAAmB,GAAG,gBAAgB;CACtD,MAAM,OAAO,sBAAsB,aAAa,EAC9C,gBACE,yOACJ,CAAC;CACD,OAAO;EACL,MAAM,QAAQ,QAAS;EACvB,aAAa,KAAK;EAClB,YAAY;EAEZ,eAAe;EAEf,QAAQ;EACR,MAAM,QAAQ,MAAM,KAAK;GACvB,MAAM,YAAY,OAAO,UAAU,WAAW,QAAQ,MAAM,GAAG;GAC/D,OAAO,kBACL,MAAM,KAAK,QAAQ,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,CACnD;EACF;CACF;AACF"}

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

@@ -1,14 +1,50 @@
+import { n as CreateBrowserToolsOptions } from "../../ai-ahruGw7e.js";
 import {
   a as BrowserSource,
   i as BrowserNewTab,
   n as BrowserToolOptions,
   r as BrowserToolOutput,
   t as BrowserToolInput
-} from "../browser-tool-DuNdlwZ9.js";
-import { CreateBrowserToolsOptions } from "./ai.js";
+} from "../../browser-tool-vtrPOV8e.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 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({
+ *   ctx: this.ctx,
+ *   browser: this.env.BROWSER,
+ *   loader: this.env.LOADER,
+ * });
+ *
+ * const stream = chat({
+ *   adapter: openaiText("gpt-4o"),
+ *   tools: [...browserTools, ...otherTools],
+ *   messages,
+ * });
+ * ```
+ */
+declare function createBrowserTools(
+  options: CreateBrowserToolsOptions
+): ServerTool[];
+//#endregion
+//#region src/browser/tools/tanstack-ai.d.ts
 interface TanStackBrowserToolOptions<
   TName extends string = "browser"
 > extends BrowserToolOptions {
@@ -54,7 +90,7 @@ interface TanStackBrowserToolOptions<
  */
 declare function browserTool<TName extends string = "browser">(
   options: TanStackBrowserToolOptions<TName>
-): ServerTool<
+): import("@tanstack/ai").ServerTool<
   {
     readonly "~standard": {
       readonly version: 1;
@@ -87,40 +123,6 @@ declare function browserTool<TName extends string = "browser">(
   TName,
   unknown
 >;
-/**
- * Create TanStack AI tools for browser automation via CDP code mode.
- *
- * 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({
- *   ctx: this.ctx,
- *   browser: this.env.BROWSER,
- *   loader: this.env.LOADER,
- * });
- *
- * const stream = chat({
- *   adapter: openaiText("gpt-4o"),
- *   tools: [...browserTools, ...otherTools],
- *   messages,
- * });
- * ```
- */
-declare function createBrowserTools(
-  options: CreateBrowserToolsOptions
-): ServerTool[];
 //#endregion
 export {
   type BrowserNewTab,

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

@@ -1,67 +1,13 @@
-import { n as createBrowserToolCore } from "../browser-tool-CQ10e6Kj.js";
-import { a as browserScreenshotOutput, i as browserExecuteModelOutput, t as createBrowserRuntime } from "../ai-fm7xx1BK.js";
+import { n as browserScreenshotOutput, t as browserExecuteModelOutput } from "../../tool-helpers-O5BDVEAY.js";
+import { createBrowserRuntime } from "../ai.js";
+import { n as createBrowserToolCore } from "../../browser-tool-4iomavs_.js";
 import { z } from "zod";
 import { toolDefinition } from "@tanstack/ai";
 //#region src/browser/tanstack-ai.ts
 /**
-* What the model sees from one run. TanStack AI has one return channel, so
-* the host gets this too: no `calls` log, bounded `logs`, and a screenshot
-* replaced by a sentence saying it was left out.
-*/
-function browserToolModelResult(output) {
-	const screenshot = browserScreenshotOutput(output);
-	if (!screenshot) return browserExecuteModelOutput(output).value;
-	const bytes = Math.floor(screenshot.data.length * 3 / 4);
-	return browserExecuteModelOutput({
-		...output,
-		result: `Screenshot captured (${screenshot.mediaType}, approximately ${bytes.toLocaleString()} bytes), but this tool can't return images, so neither you nor the user can see it. Read the page with Runtime.evaluate instead.`
-	}).value;
-}
-/**
-* Create a TanStack AI tool that lets the model drive a persistent browser
-* with JavaScript and the Chrome DevTools Protocol.
-*
-* Works like `browserTool` in `agents/browser/ai-sdk`: tabs, cookies, and
-* logins carry over between runs, `sessionId: "active"` addresses the tab the
-* model last worked in, and a replaced browser is reported as
-* `restarted: true`. The tool is named `browser` unless you pass `name`.
-*
-* Unlike the AI SDK tool, the host gets the same output as the model, and
-* screenshots aren't supported: a returned screenshot is replaced by a
-* sentence saying it was left out.
-*
-* @example
-* ```ts
-* import { Browser, browserRun } from "agents/browser";
-* import { browserTool } from "agents/browser/tanstack-ai";
-* import { chat } from "@tanstack/ai";
-*
-* export class MyAgent extends Agent<Env> {
-*   browser = new Browser({ provider: browserRun(this.env.BROWSER) });
-*
-*   constructor(ctx: AgentContext, env: Env) {
-*     super(ctx, env);
-*     this.lifecycle.use(this.browser);
-*   }
-*
-*   async onChatMessage() {
-*     const stream = chat({
-*       adapter,
-*       tools: [browserTool({ browser: this.browser, loader: this.env.LOADER })],
-*       messages
-*     });
-*   }
-* }
-* ```
+* The legacy TanStack AI `createBrowserTools`. `agents/browser/tanstack-ai`
+* (`tools/tanstack-ai.ts`) re-exports it until it's retired.
 */
-function browserTool(options) {
-	const core = createBrowserToolCore(options, { screenshotHint: "This tool can't return images, so don't take screenshots; read the page with Runtime.evaluate (for example document.body.innerText) instead." });
-	return toolDefinition({
-		name: options.name ?? "browser",
-		description: core.description,
-		inputSchema: core.inputSchema
-	}).server(async (input) => browserToolModelResult(await core.execute(input)));
-}
 /**
 * Create TanStack AI tools for browser automation via CDP code mode.
 *
@@ -125,6 +71,74 @@ function createBrowserTools(options) {
 	})];
 }
 //#endregion
+//#region src/browser/tools/tanstack-ai.ts
+/**
+* `agents/browser/tanstack-ai` — the TanStack AI tool for a persistent
+* `Browser`.
+*
+* The older `createBrowserTools` lives in `../tanstack-ai.ts` and is
+* re-exported here until it's retired.
+*/
+/**
+* What the model sees from one run. TanStack AI has one return channel, so
+* the host gets this too: no `calls` log, bounded `logs`, and a screenshot
+* replaced by a sentence saying it was left out.
+*/
+function browserToolModelResult(output) {
+	const screenshot = browserScreenshotOutput(output);
+	if (!screenshot) return browserExecuteModelOutput(output).value;
+	const bytes = Math.floor(screenshot.data.length * 3 / 4);
+	return browserExecuteModelOutput({
+		...output,
+		result: `Screenshot captured (${screenshot.mediaType}, approximately ${bytes.toLocaleString()} bytes), but this tool can't return images, so neither you nor the user can see it. Read the page with Runtime.evaluate instead.`
+	}).value;
+}
+/**
+* Create a TanStack AI tool that lets the model drive a persistent browser
+* with JavaScript and the Chrome DevTools Protocol.
+*
+* Works like `browserTool` in `agents/browser/ai-sdk`: tabs, cookies, and
+* logins carry over between runs, `sessionId: "active"` addresses the tab the
+* model last worked in, and a replaced browser is reported as
+* `restarted: true`. The tool is named `browser` unless you pass `name`.
+*
+* Unlike the AI SDK tool, the host gets the same output as the model, and
+* screenshots aren't supported: a returned screenshot is replaced by a
+* sentence saying it was left out.
+*
+* @example
+* ```ts
+* import { Browser, browserRun } from "agents/browser";
+* import { browserTool } from "agents/browser/tanstack-ai";
+* import { chat } from "@tanstack/ai";
+*
+* export class MyAgent extends Agent<Env> {
+*   browser = new Browser({ provider: browserRun(this.env.BROWSER) });
+*
+*   constructor(ctx: AgentContext, env: Env) {
+*     super(ctx, env);
+*     this.lifecycle.use(this.browser);
+*   }
+*
+*   async onChatMessage() {
+*     const stream = chat({
+*       adapter,
+*       tools: [browserTool({ browser: this.browser, loader: this.env.LOADER })],
+*       messages
+*     });
+*   }
+* }
+* ```
+*/
+function browserTool(options) {
+	const core = createBrowserToolCore(options, { screenshotHint: "This tool can't return images, so don't take screenshots; read the page with Runtime.evaluate (for example document.body.innerText) instead." });
+	return toolDefinition({
+		name: options.name ?? "browser",
+		description: core.description,
+		inputSchema: core.inputSchema
+	}).server(async (input) => browserToolModelResult(await core.execute(input)));
+}
+//#endregion
 export { browserTool, createBrowserTools };
 
 //# sourceMappingURL=tanstack-ai.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../../src/browser/tanstack-ai.ts","../../../src/browser/tools/tanstack-ai.ts"],"sourcesContent":["/**\n * The legacy TanStack AI `createBrowserTools`. `agents/browser/tanstack-ai`\n * (`tools/tanstack-ai.ts`) re-exports it until it's retired.\n */\nimport { 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:\n      typeof executeTool.description === \"function\"\n        ? \"\"\n        : (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({ code }, {\n      toolCallId: crypto.randomUUID(),\n      messages: [],\n      context: {}\n    } as never)) as ProxyToolOutput;\n    // TanStack has a single return channel, so what the host sees is what the\n    // model sees: apply the AI SDK path's `toModelOutput` projection so a\n    // screenshot's base64 cannot reach the model and the durable `calls` log\n    // stays out of its context. The execution envelope (status, executionId)\n    // is preserved either way.\n    const modelOutput = await executeTool.toModelOutput?.({\n      toolCallId: crypto.randomUUID(),\n      input: { code },\n      output: result\n    });\n    if (modelOutput?.type === \"error-text\") {\n      throw new Error(modelOutput.value);\n    }\n    if (modelOutput?.type === \"text\") {\n      return { ...result, result: modelOutput.value };\n    }\n    if (modelOutput?.type === \"json\") {\n      return modelOutput.value;\n    }\n    return result;\n  });\n\n  return [execute];\n}\n","/**\n * `agents/browser/tanstack-ai` — the TanStack AI tool for a persistent\n * `Browser`.\n *\n * The older `createBrowserTools` lives in `../tanstack-ai.ts` and is\n * re-exported here until it's retired.\n */\nimport { toolDefinition } from \"@tanstack/ai\";\nimport {\n  createBrowserToolCore,\n  type BrowserToolOptions,\n  type BrowserToolOutput\n} from \"../browser-tool\";\nimport {\n  browserExecuteModelOutput,\n  browserScreenshotOutput\n} from \"../tool-helpers\";\n\nexport type {\n  BrowserToolInput,\n  BrowserToolOptions,\n  BrowserToolOutput\n} from \"../browser-tool\";\nexport type { BrowserNewTab, BrowserSource } from \"../session-connector\";\n\nexport interface TanStackBrowserToolOptions<\n  TName extends string = \"browser\"\n> extends BrowserToolOptions {\n  /** The tool's name. TanStack AI tools carry it in the definition. */\n  name?: TName;\n}\n\n/**\n * What the model sees from one run. TanStack AI has one return channel, so\n * the host gets this too: no `calls` log, bounded `logs`, and a screenshot\n * replaced by a sentence saying it was left out.\n */\nfunction browserToolModelResult(output: BrowserToolOutput): unknown {\n  const screenshot = browserScreenshotOutput(output);\n  if (!screenshot) return browserExecuteModelOutput(output).value;\n  const bytes = Math.floor((screenshot.data.length * 3) / 4);\n  // Keep the rest of the result (status, restarted, notice, newTabs).\n  return browserExecuteModelOutput({\n    ...output,\n    result: `Screenshot captured (${screenshot.mediaType}, approximately ${bytes.toLocaleString()} bytes), but this tool can't return images, so neither you nor the user can see it. Read the page with Runtime.evaluate instead.`\n  }).value;\n}\n\n/**\n * Create a TanStack AI tool that lets the model drive a persistent browser\n * with JavaScript and the Chrome DevTools Protocol.\n *\n * Works like `browserTool` in `agents/browser/ai-sdk`: tabs, cookies, and\n * logins carry over between runs, `sessionId: \"active\"` addresses the tab the\n * model last worked in, and a replaced browser is reported as\n * `restarted: true`. The tool is named `browser` unless you pass `name`.\n *\n * Unlike the AI SDK tool, the host gets the same output as the model, and\n * screenshots aren't supported: a returned screenshot is replaced by a\n * sentence saying it was left out.\n *\n * @example\n * ```ts\n * import { Browser, browserRun } from \"agents/browser\";\n * import { browserTool } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * export class MyAgent extends Agent<Env> {\n *   browser = new Browser({ provider: browserRun(this.env.BROWSER) });\n *\n *   constructor(ctx: AgentContext, env: Env) {\n *     super(ctx, env);\n *     this.lifecycle.use(this.browser);\n *   }\n *\n *   async onChatMessage() {\n *     const stream = chat({\n *       adapter,\n *       tools: [browserTool({ browser: this.browser, loader: this.env.LOADER })],\n *       messages\n *     });\n *   }\n * }\n * ```\n */\nexport function browserTool<TName extends string = \"browser\">(\n  options: TanStackBrowserToolOptions<TName>\n) {\n  const core = createBrowserToolCore(options, {\n    screenshotHint:\n      \"This tool can't return images, so don't take screenshots; read the page with Runtime.evaluate (for example document.body.innerText) instead.\"\n  });\n  return toolDefinition({\n    name: options.name ?? (\"browser\" as TName),\n    description: core.description,\n    inputSchema: core.inputSchema\n  }).server(async (input) => browserToolModelResult(await core.execute(input)));\n}\n\nexport {\n  createBrowserTools,\n  type CreateBrowserToolsOptions\n} from \"../tanstack-ai\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,SAAgB,mBACd,SACc;CAGd,MAAM,EAAE,UAAU,qBAAqB;EAAE,GAAG;EAAS,cAAc;CAAM,CAAC;CAC1E,MAAM,cAAc,MAAM;CA6C1B,OAAO,CA3CS,eAAe;EAC7B,MAAM;EACN,aACE,OAAO,YAAY,gBAAgB,aAC/B,KACC,YAAY,eAAe;EAClC,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;EAE1D,MAAM,SAAU,MAAM,YAAY,QAAQ,EAAE,KAAK,GAAG;GAClD,YAAY,OAAO,WAAW;GAC9B,UAAU,CAAC;GACX,SAAS,CAAC;EACZ,CAAU;EAMV,MAAM,cAAc,MAAM,YAAY,gBAAgB;GACpD,YAAY,OAAO,WAAW;GAC9B,OAAO,EAAE,KAAK;GACd,QAAQ;EACV,CAAC;EACD,IAAI,aAAa,SAAS,cACxB,MAAM,IAAI,MAAM,YAAY,KAAK;EAEnC,IAAI,aAAa,SAAS,QACxB,OAAO;GAAE,GAAG;GAAQ,QAAQ,YAAY;EAAM;EAEhD,IAAI,aAAa,SAAS,QACxB,OAAO,YAAY;EAErB,OAAO;CACT,CAEc,CAAC;AACjB;;;;;;;;;;;;;;;AC1DA,SAAS,uBAAuB,QAAoC;CAClE,MAAM,aAAa,wBAAwB,MAAM;CACjD,IAAI,CAAC,YAAY,OAAO,0BAA0B,MAAM,CAAC,CAAC;CAC1D,MAAM,QAAQ,KAAK,MAAO,WAAW,KAAK,SAAS,IAAK,CAAC;CAEzD,OAAO,0BAA0B;EAC/B,GAAG;EACH,QAAQ,wBAAwB,WAAW,UAAU,kBAAkB,MAAM,eAAe,EAAE;CAChG,CAAC,CAAC,CAAC;AACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,YACd,SACA;CACA,MAAM,OAAO,sBAAsB,SAAS,EAC1C,gBACE,+IACJ,CAAC;CACD,OAAO,eAAe;EACpB,MAAM,QAAQ,QAAS;EACvB,aAAa,KAAK;EAClB,aAAa,KAAK;CACpB,CAAC,CAAC,CAAC,OAAO,OAAO,UAAU,uBAAuB,MAAM,KAAK,QAAQ,KAAK,CAAC,CAAC;AAC9E"}