fix(sdk): fall back to the agent's tools in the managed streamText

An onAction handler has no tools in scope the way run() does, so a
regenerated answer built with the bound streamText could call nothing.
Omitting tools now falls back to chat.agent({ tools }); naming tools
still replaces the set for that call. onAction also receives tools.

Author: ericallam

docs/ai-chat/actions.mdx

@@ -58,7 +58,7 @@ export const myChat = chat.agent({
 
 The `messages` argument is captured before `onAction` runs, so a handler that mutates `chat.history` and then passes `messages` straight through sends the model the state it just changed. Rebuild from `chat.history.all()` after the mutation.
 
-Build the response with the `streamText` from `onAction`'s own argument, the same one `run()` receives. It carries the agent's system prompt, skill tools, resolved model and telemetry, so a regenerated answer is produced under the same configuration as every other turn. The `streamText` imported from `ai` carries none of that, and the reply still looks fine, which is what makes the difference easy to miss.
+Build the response with the `streamText` from `onAction`'s own argument, the same one `run()` receives. It carries the agent's system prompt, config tools, skill tools, resolved model and telemetry, so a regenerated answer is produced under the same configuration as every other turn. The `streamText` imported from `ai` carries none of that, and the reply still looks fine, which is what makes the difference easy to miss.
 
 ```ts
 onAction: async ({ action, streamText }) => {

docs/ai-chat/tools.mdx

@@ -46,7 +46,7 @@ There are three places a tool set shows up. Declare once, reuse:
 | Surface | What it's for |
 | --- | --- |
 | `chat.agent({ tools })` | Re-applies `toModelOutput` on prior-turn history; hands the set back typed on the `run()` payload. |
-| `streamText({ tools })` on the `run` argument's `streamText` | What the model actually calls. Detects which calls need [HITL approval](/ai-chat/patterns/human-in-the-loop) (`needsApproval`) and merges the auto-injected [skill](/ai-chat/patterns/skills) tools on top. |
+| `streamText({ tools })` on the `run` argument's `streamText` | What the model actually calls. Detects which calls need [HITL approval](/ai-chat/patterns/human-in-the-loop) (`needsApproval`) and merges the auto-injected [skill](/ai-chat/patterns/skills) tools on top. Naming `tools` replaces the config set for that call, so you can narrow it; omitting `tools` falls back to the config set. |
 | `chat.toStreamTextOptions({ tools })` | The same job by hand, for a [custom agent](#manual-turn-loops-chatcustomagent), which has no `run` argument. |
 
 The canonical pattern: declare `tools` on the config, read them back from the `run()` payload, and pass that set to the `streamText` the payload also carries.

packages/trigger-sdk/src/v3/ai.ts

@@ -4773,6 +4773,8 @@ type ManagedStreamTextConfig = {
   system?: ToStreamTextOptionsOptions["system"];
   cacheControl?: ToStreamTextOptionsOptions["cacheControl"];
   systemProviderOptions?: ToStreamTextOptionsOptions["systemProviderOptions"];
+  /** The agent's resolved tools, used when the call site names no `tools` of its own. */
+  tools?: ToolSet;
 };
 
 /**
@@ -4786,7 +4788,13 @@ function buildManagedStreamTextOptions(
   options: Record<string, unknown>,
   config: ManagedStreamTextConfig
 ): Record<string, unknown> {
-  const { registry, system: agentSystem, cacheControl, systemProviderOptions } = config;
+  const {
+    registry,
+    system: agentSystem,
+    cacheControl,
+    systemProviderOptions,
+    tools: agentTools,
+  } = config;
 
   /**
    * Only the three keys that collide are intercepted. Everything else, telemetry
@@ -4806,7 +4814,13 @@ function buildManagedStreamTextOptions(
     system: (callerSystem as ToStreamTextOptionsOptions["system"]) ?? agentSystem,
     cacheControl,
     systemProviderOptions,
-    tools: tools as Record<string, Tool> | undefined,
+    /**
+     * A call site that names `tools` replaces the agent's set rather than
+     * adding to it, so narrowing the tools for one call still works. Omitting
+     * `tools` falls back to the agent's, which is what an `onAction`
+     * regenerate needs: without it a regenerated answer can call nothing.
+     */
+    tools: (tools ?? agentTools) as Record<string, Tool> | undefined,
   });
 
   const promptSystem = locals.get(chatPromptKey)?.text;
@@ -4862,6 +4876,8 @@ function createBoundStreamText(
         system: agentSystem,
         cacheControl: agentCacheControl,
         systemProviderOptions: agentSystemProviderOptions,
+        /** Read per call, so per-turn tools resolved after binding are included. */
+        tools: locals.get(chatResolvedToolsKey),
       }) as any
     );
 
@@ -5562,6 +5578,8 @@ export type ActionEvent<
   uiMessages: TUIM[];
   /** The accumulated model messages (after hydration, if set). */
   messages: ModelMessage[];
+  /** The agent's resolved tools, the same set `run()` receives. */
+  tools: ToolSet;
   /**
    * `streamText` with the agent's managed options already applied, the same one
    * `run()` receives: the prompt from `chat.prompt.set()` or
@@ -8004,6 +8022,7 @@ function chatAgent<
                           clientData,
                           uiMessages: accumulatedUIMessages,
                           messages: accumulatedMessages,
+                          tools: locals.get(chatResolvedToolsKey) ?? {},
                           streamText: createBoundStreamText(
                             promptRegistry,
                             agentSystem,

packages/trigger-sdk/test/bound-streamtext.test.ts

@@ -503,6 +503,59 @@ describe("the streamText handed to onAction", () => {
       await harness.close();
     }
   });
+
+  it("carries the agent's tools into a regenerated answer", async () => {
+    /**
+     * A regenerate that can call nothing is not the same agent answering
+     * again. `onAction` has no `tools` in scope the way `run()` does, so
+     * omitting `tools` has to fall back to the agent's set rather than to
+     * none.
+     */
+    const turnModel = new MockLanguageModelV3({
+      doStream: async () => ({ stream: textStream("first answer") }),
+    });
+    const actionModel = new MockLanguageModelV3({
+      doStream: async () => ({ stream: textStream("regenerated answer") }),
+    });
+
+    const agentOnlyTool = tool({
+      description: "declared only on chat.agent({ tools })",
+      inputSchema: z.object({ a: z.string() }),
+      execute: async () => "a",
+    });
+
+    const agent = chat.agent({
+      id: "bound-streamtext-onaction-tools",
+      tools: { agentOnlyTool },
+      actionSchema: z.discriminatedUnion("type", [z.object({ type: z.literal("regenerate") })]),
+      onAction: async ({ action, streamText }) => {
+        if (action.type !== "regenerate") return;
+        chat.history.slice(0, -1);
+        return streamText({
+          model: actionModel,
+          messages: await convertToModelMessages(chat.history.all()),
+        });
+      },
+      run: async ({ messages, tools, signal, streamText }) =>
+        streamText({ model: turnModel, messages, tools, abortSignal: signal }),
+    });
+
+    const harness = mockChatAgent(agent, { chatId: "bound-streamtext-onaction-tools" });
+
+    try {
+      await harness.sendMessage({ id: "u1", role: "user", parts: [{ type: "text", text: "ask" }] });
+      await new Promise((r) => setTimeout(r, 40));
+
+      await harness.sendAction({ type: "regenerate" });
+      await new Promise((r) => setTimeout(r, 60));
+
+      expect(actionModel.doStreamCalls).toHaveLength(1);
+      const names = (actionModel.doStreamCalls[0]!.tools ?? []).map((t) => t.name);
+      expect(names).toEqual(["agentOnlyTool"]);
+    } finally {
+      await harness.close();
+    }
+  });
 });
 
 describe("a structured system message", () => {