agents 0.15.0 → 0.16.0

package/dist/browser/tanstack-ai.js

@@ -1,21 +1,25 @@
-import { n as SEARCH_DESCRIPTION, r as createBrowserToolHandlers, t as EXECUTE_DESCRIPTION } from "../shared-wyII629d.js";
+import { createBrowserRuntime } from "./ai.js";
 import { z } from "zod";
 import { toolDefinition } from "@tanstack/ai";
 //#region src/browser/tanstack-ai.ts
 /**
 * Create TanStack AI tools for browser automation via CDP code mode.
 *
-* Returns an array of `ServerTool`s: `browser_search` (query the CDP spec)
-* and `browser_execute` (run CDP commands against a live browser).
+* Returns an array with a single durable `browser_execute` `ServerTool`
+* backed by the same codemode runtime as `agents/browser/ai` — the model
+* writes TypeScript against the `cdp` connector and browser sessions
+* survive pauses.
 *
 * @example
 * ```ts
 * import { createBrowserTools } from "agents/browser/tanstack-ai";
 * import { chat } from "@tanstack/ai";
 *
+* // inside a Durable Object / Agent:
 * const browserTools = createBrowserTools({
-*   browser: env.BROWSER,
-*   loader: env.LOADER,
+*   ctx: this.ctx,
+*   browser: this.env.BROWSER,
+*   loader: this.env.LOADER,
 * });
 *
 * const stream = chat({
@@ -26,23 +30,18 @@ import { toolDefinition } from "@tanstack/ai";
 * ```
 */
 function createBrowserTools(options) {
-	const handlers = createBrowserToolHandlers(options);
+	const { tools } = createBrowserRuntime(options);
+	const executeTool = tools.browser_execute;
 	return [toolDefinition({
-		name: "browser_search",
-		description: SEARCH_DESCRIPTION,
-		inputSchema: z.object({ code: z.string().meta({ description: "JavaScript async arrow function that queries the CDP spec" }) })
-	}).server(async ({ code }) => {
-		const result = await handlers.search(code);
-		if (result.isError) throw new Error(result.text);
-		return { text: result.text };
-	}), toolDefinition({
 		name: "browser_execute",
-		description: EXECUTE_DESCRIPTION,
-		inputSchema: z.object({ code: z.string().meta({ description: "JavaScript async arrow function that uses the cdp helper" }) })
+		description: executeTool.description ?? "",
+		inputSchema: z.object({ code: z.string().meta({ description: "TypeScript async arrow function that uses the cdp connector" }) })
 	}).server(async ({ code }) => {
-		const result = await handlers.execute(code);
-		if (result.isError) throw new Error(result.text);
-		return { text: result.text };
+		if (!executeTool.execute) throw new Error("browser_execute tool is not executable");
+		return await executeTool.execute({ code }, {
+			toolCallId: crypto.randomUUID(),
+			messages: []
+		});
 	})];
 }
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../src/browser/tanstack-ai.ts"],"sourcesContent":["import { toolDefinition } from \"@tanstack/ai\";\nimport type { ServerTool } from \"@tanstack/ai\";\nimport { z } from \"zod\";\nimport {\n  createBrowserToolHandlers,\n  SEARCH_DESCRIPTION,\n  EXECUTE_DESCRIPTION,\n  type BrowserToolsOptions\n} from \"./shared\";\n\nexport type { BrowserToolsOptions } from \"./shared\";\n\n/**\n * Create TanStack AI tools for browser automation via CDP code mode.\n *\n * Returns an array of `ServerTool`s: `browser_search` (query the CDP spec)\n * and `browser_execute` (run CDP commands against a live browser).\n *\n * @example\n * ```ts\n * import { createBrowserTools } from \"agents/browser/tanstack-ai\";\n * import { chat } from \"@tanstack/ai\";\n *\n * const browserTools = createBrowserTools({\n *   browser: env.BROWSER,\n *   loader: env.LOADER,\n * });\n *\n * const stream = chat({\n *   adapter: openaiText(\"gpt-4o\"),\n *   tools: [...browserTools, ...otherTools],\n *   messages,\n * });\n * ```\n */\nexport function createBrowserTools(options: BrowserToolsOptions): ServerTool[] {\n  const handlers = createBrowserToolHandlers(options);\n\n  const search = toolDefinition({\n    name: \"browser_search\" as const,\n    description: SEARCH_DESCRIPTION,\n    inputSchema: z.object({\n      code: z.string().meta({\n        description: \"JavaScript async arrow function that queries the CDP spec\"\n      })\n    })\n  }).server(async ({ code }) => {\n    const result = await handlers.search(code);\n    if (result.isError) {\n      throw new Error(result.text);\n    }\n    return { text: result.text };\n  });\n\n  const execute = toolDefinition({\n    name: \"browser_execute\" as const,\n    description: EXECUTE_DESCRIPTION,\n    inputSchema: z.object({\n      code: z.string().meta({\n        description: \"JavaScript async arrow function that uses the cdp helper\"\n      })\n    })\n  }).server(async ({ code }) => {\n    const result = await handlers.execute(code);\n    if (result.isError) {\n      throw new Error(result.text);\n    }\n    return { text: result.text };\n  });\n\n  return [search, execute];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,mBAAmB,SAA4C;CAC7E,MAAM,WAAW,0BAA0B,OAAO;CAkClD,OAAO,CAhCQ,eAAe;EAC5B,MAAM;EACN,aAAa;EACb,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,EACpB,aAAa,4DACf,CAAC,EACH,CAAC;CACH,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,MAAM,SAAS,MAAM,SAAS,OAAO,IAAI;EACzC,IAAI,OAAO,SACT,MAAM,IAAI,MAAM,OAAO,IAAI;EAE7B,OAAO,EAAE,MAAM,OAAO,KAAK;CAC7B,CAkBa,GAhBG,eAAe;EAC7B,MAAM;EACN,aAAa;EACb,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,EACpB,aAAa,2DACf,CAAC,EACH,CAAC;CACH,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,MAAM,SAAS,MAAM,SAAS,QAAQ,IAAI;EAC1C,IAAI,OAAO,SACT,MAAM,IAAI,MAAM,OAAO,IAAI;EAE7B,OAAO,EAAE,MAAM,OAAO,KAAK;CAC7B,CAEsB,CAAC;AACzB"}
+{"version":3,"file":"tanstack-ai.js","names":[],"sources":["../../src/browser/tanstack-ai.ts"],"sourcesContent":["import { toolDefinition } from \"@tanstack/ai\";\nimport type { ServerTool } from \"@tanstack/ai\";\nimport type { ProxyToolOutput } from \"@cloudflare/codemode\";\nimport { z } from \"zod\";\nimport { createBrowserRuntime, type CreateBrowserToolsOptions } from \"./ai\";\n\nexport type { CreateBrowserToolsOptions } from \"./ai\";\n\n/**\n * Create TanStack AI tools for browser automation via CDP code mode.\n *\n * Returns an array with a single durable `browser_execute` `ServerTool`\n * backed by the same codemode runtime as `agents/browser/ai` — the model\n * writes TypeScript against the `cdp` connector and browser sessions\n * survive pauses.\n *\n * @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  const { tools } = createBrowserRuntime(options);\n  const executeTool = tools.browser_execute;\n\n  const execute = toolDefinition({\n    name: \"browser_execute\" as const,\n    description: executeTool.description ?? \"\",\n    inputSchema: z.object({\n      code: z.string().meta({\n        description:\n          \"TypeScript async arrow function that uses the cdp connector\"\n      })\n    })\n  }).server(async ({ code }) => {\n    if (!executeTool.execute) {\n      throw new Error(\"browser_execute tool is not executable\");\n    }\n    const result = (await executeTool.execute(\n      { code },\n      { toolCallId: crypto.randomUUID(), messages: [] }\n    )) as ProxyToolOutput;\n    return result;\n  });\n\n  return [execute];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,mBACd,SACc;CACd,MAAM,EAAE,UAAU,qBAAqB,OAAO;CAC9C,MAAM,cAAc,MAAM;CAsB1B,OAAO,CApBS,eAAe;EAC7B,MAAM;EACN,aAAa,YAAY,eAAe;EACxC,aAAa,EAAE,OAAO,EACpB,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,EACpB,aACE,8DACJ,CAAC,EACH,CAAC;CACH,CAAC,CAAC,CAAC,OAAO,OAAO,EAAE,WAAW;EAC5B,IAAI,CAAC,YAAY,SACf,MAAM,IAAI,MAAM,wCAAwC;EAM1D,OAAO,MAJe,YAAY,QAChC,EAAE,KAAK,GACP;GAAE,YAAY,OAAO,WAAW;GAAG,UAAU,CAAC;EAAE,CAClD;CAEF,CAEc,CAAC;AACjB"}

package/dist/chat/index.d.ts

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