fix(chat): persist an action's edit before its turn, and label that turn

The edit an action makes is snapshotted before the turn chat.turn()
requests begins, so a turn that is cancelled or runs out of memory
continues from the edited history rather than from the snapshot the edit
replaced. The turn's run() payload carries trigger "action-turn", not
"action", so a handler that returns early on the action trigger still
answers. An action sent through useChat keeps the request's metadata.

Also moves the action-turn test onto this branch's own surface; it had
used the bound streamText and chat.agent({ system }) from #4884.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AxuSksX18bj1yhnLpkcQ6a

Author: ericallam

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

@@ -1602,7 +1602,7 @@ export type ChatTaskPayload<TClientData = unknown> = {
    *   to short-circuit the LLM call when an action doesn't need a response.
    * - `"close"`: The chat session is being closed (internal; `run()` is not called).
    */
-  trigger: "submit-message" | "regenerate-message" | "preload" | "action" | "close";
+  trigger: "submit-message" | "regenerate-message" | "preload" | "action" | "action-turn" | "close";
 
   /** The ID of the message to regenerate (only for `"regenerate-message"`) */
   messageId?: string;
@@ -8234,9 +8234,13 @@ function chatAgent<
                 // sees the same `turn` value — actions don't count.
                 if (isAction) {
                   if (isActionTurn(actionResult)) {
-                    // The edit is in the accumulators; the turn block below
-                    // runs on it and does its own persistence, hooks and
-                    // completion, so nothing more happens here.
+                    // Persist the edit before the turn starts, so a turn that is
+                    // cancelled or runs out of memory continues from the edited
+                    // history rather than from the snapshot the edit replaced.
+                    // The turn then does its own hooks, completion and snapshot.
+                    if (actionChangedHistory) {
+                      await writeSnapshotOutsideTurn("action");
+                    }
                     actionTurn = true;
                   } else if (actionResult !== undefined) {
                     throw new Error(
@@ -8439,6 +8443,9 @@ function chatAgent<
                       );
                       runResult = await userRun({
                         ...restWire,
+                        // A turn requested by chat.turn() is not the action itself:
+                        // a run() that short-circuits on "action" must still answer.
+                        ...(actionTurn ? { trigger: "action-turn" as const } : {}),
                         messages: preparedMessages,
                         clientData,
                         continuation,

packages/trigger-sdk/src/v3/chat.test.ts

@@ -1010,12 +1010,15 @@ describe("TriggerChatTransport", () => {
         messages: [{ id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] }],
         abortSignal: undefined,
         body: { action: { type: "regenerate" } },
+        metadata: { tenant: "t-1" },
       });
       await drainChunks(stream);
 
       expect(actionBody.payload.trigger).toBe("action");
       expect(actionBody.payload.action).toEqual({ type: "regenerate" });
       expect(actionBody.payload.message).toBeUndefined();
+      // The request's own metadata rides along, not only the transport defaults.
+      expect(actionBody.payload.metadata).toEqual({ tenant: "t-1" });
     });
 
     it("marks the session streaming and notifies before subscribing", async () => {

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

@@ -808,7 +808,7 @@ export class TriggerChatTransport implements ChatTransport<UIMessage> {
     // action that becomes a turn renders the way a message turn does.
     const actionInBody = (body as { action?: unknown } | undefined)?.action;
     if (actionInBody !== undefined) {
-      return this.sendAction(chatId, actionInBody, { abortSignal });
+      return this.sendAction(chatId, actionInBody, { abortSignal, metadata: mergedMetadata });
     }
 
     // First-turn handover routing — when `headStart` is set AND no
@@ -1269,7 +1269,7 @@ export class TriggerChatTransport implements ChatTransport<UIMessage> {
   sendAction = async (
     chatId: string,
     action: unknown,
-    options?: { abortSignal?: AbortSignal }
+    options?: { abortSignal?: AbortSignal; metadata?: Record<string, unknown> }
   ): Promise<ReadableStream<UIMessageChunk>> => {
     if (this.coordinator) {
       if (this.coordinator.isReadOnly(chatId)) {
@@ -1284,7 +1284,7 @@ export class TriggerChatTransport implements ChatTransport<UIMessage> {
       chatId,
       trigger: "action" as const,
       action,
-      metadata: this.defaultMetadata ?? undefined,
+      metadata: options?.metadata ?? this.defaultMetadata ?? undefined,
     };
 
     const body = this.serializeInputChunk({ kind: "message", payload: wirePayload });

packages/trigger-sdk/test/action-turn.test.ts

@@ -1,7 +1,7 @@
 import { mockChatAgent } from "../src/v3/test/index.js";
 
 import type { LanguageModelV3StreamPart } from "@ai-sdk/provider";
-import { simulateReadableStream } from "ai";
+import { simulateReadableStream, streamText } from "ai";
 import { MockLanguageModelV3 } from "ai/test";
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
@@ -44,6 +44,9 @@ async function waitFor(check: () => boolean, label = "condition", timeoutMs = 8_
 
 function agentWith(onAction: (action: { type: string }) => unknown) {
   const prompts: string[] = [];
+  const triggers: string[] = [];
+  /** The snapshot as it stood when each run() began. */
+  const snapshotsAtRun: string[][] = [];
   const starts: number[] = [];
   const completes: { turn: number; finishReason?: string }[] = [];
   let answers = 0;
@@ -60,7 +63,9 @@ function agentWith(onAction: (action: { type: string }) => unknown) {
   });
   const agent = chat.agent({
     id: "action-turn",
-    system: "AGENT-SYSTEM",
+    onChatStart: async () => {
+      chat.prompt.set("AGENT-SYSTEM");
+    },
     actionSchema: z.discriminatedUnion("type", [
       z.object({ type: z.literal("regenerate") }),
       z.object({ type: z.literal("undo") }),
@@ -73,22 +78,39 @@ function agentWith(onAction: (action: { type: string }) => unknown) {
       completes.push({ turn, finishReason });
     },
     onAction: async ({ action }) => onAction(action) as never,
-    run: async ({ messages, signal, streamText: bound }) =>
-      bound({ model, messages, abortSignal: signal }),
+    run: async ({ messages, signal, trigger }) => {
+      triggers.push(trigger);
+      snapshotsAtRun.push((snapshotReader?.()?.messages ?? []).map(textOf));
+      return streamText({ model, messages, abortSignal: signal, ...chat.toStreamTextOptions() });
+    },
   });
-  return { agent, prompts, starts, completes };
+  let snapshotReader: (() => { messages: { parts?: unknown[] }[] } | undefined) | undefined;
+  return {
+    agent,
+    prompts,
+    triggers,
+    snapshotsAtRun,
+    starts,
+    completes,
+    attach: (h: { getSnapshot: () => { messages: { parts?: unknown[] }[] } | undefined }) => {
+      snapshotReader = () => h.getSnapshot();
+    },
+  };
 }
 
 describe("an action that returns chat.turn()", () => {
   it("runs a turn on the edited history, with the turn's own machinery", async () => {
-    const { agent, prompts, starts, completes } = agentWith((action) => {
-      if (action.type === "regenerate") {
-        chat.history.slice(0, -1);
-        return chat.turn();
+    const { agent, prompts, triggers, snapshotsAtRun, starts, completes, attach } = agentWith(
+      (action) => {
+        if (action.type === "regenerate") {
+          chat.history.slice(0, -1);
+          return chat.turn();
+        }
+        return undefined;
       }
-      return undefined;
-    });
+    );
     const harness = mockChatAgent(agent, { chatId: "action-turn-regenerate" });
+    attach(harness);
     try {
       await harness.sendMessage(userMessage("ask", "u-1"));
       await waitFor(() => completes.length >= 1, "turn 0");
@@ -105,6 +127,12 @@ describe("an action that returns chat.turn()", () => {
       expect(p).not.toContain("answer-0");
       // Its answer replaced the old one in the conversation.
       expect(harness.getSnapshot()?.messages.map(textOf)).toEqual(["ask", "answer-1"]);
+      // run() saw it as a turn requested by an action, not as the action, so a
+      // handler that returns early on "action" still answers.
+      expect(triggers[1]).toBe("action-turn");
+      // And the edit was persisted before the turn began: a turn cut short
+      // continues from the edited history, not from the snapshot it replaced.
+      expect(snapshotsAtRun[1]).toEqual(["ask"]);
 
       // And the turn after it is numbered on from there.
       await harness.sendMessage(userMessage("more", "u-2"));