fix(sdk): don't overwrite a committed response when a post-response step throws

The chat.agent try block spans the whole turn, so a throw from a post-response
step (a customer onBeforeTurnComplete/onTurnComplete hook, a late conversion)
lands in the error handler after the response was already committed. Track a
per-turn responseCommitted flag and keep capturedPartialResponse pointed at the
enriched committed message, so the error path reports it without re-recovering a
raw partial and clobbering the committed message, its queued data parts, or a
prior turn's compaction. Also use truthy id checks to match the success path.

Author: matt-aitken

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

@@ -6396,6 +6396,7 @@ function chatAgent<
           // onFinish message if it fired; otherwise the buffered chunks are
           // reconstructed as the fallback (mirrors chat.pipeAndCapture).
           let capturedPartialResponse: TUIMessage | undefined;
+          let responseCommitted = false;
           const turnBufferedChunks: UIMessageChunk[] = [];
           try {
             // Extract turn-level context before entering the span. Slim
@@ -7404,6 +7405,11 @@ function chatAgent<
                     }
                   }
 
+                  if (capturedResponseMessage) {
+                    responseCommitted = true;
+                    capturedPartialResponse = capturedResponseMessage;
+                  }
+
                   if (runSignal.aborted) return "exit";
 
                   // Await deferred background work (e.g. DB writes from onTurnStart)
@@ -7625,6 +7631,7 @@ function chatAgent<
                         parts: [...(msg.parts ?? []), ...lateParts],
                       } as TUIMessage;
                       capturedResponseMessage = accumulatedUIMessages[idx] as TUIMessage;
+                      capturedPartialResponse = capturedResponseMessage;
                       turnCompleteEvent.responseMessage = capturedResponseMessage;
                       turnCompleteEvent.uiMessages = accumulatedUIMessages;
                     }
@@ -7935,10 +7942,9 @@ function chatAgent<
             // success path) instead of dropping it as a dup; otherwise append.
             // `erroredWireMessage` was already folded into `erroredUIMessages`
             // above when the pre-run merge hadn't happened.
-            const partialIdx =
-              partialResponse?.id != null
-                ? erroredUIMessages.findIndex((m) => m.id === partialResponse!.id)
-                : -1;
+            const partialIdx = partialResponse?.id
+              ? erroredUIMessages.findIndex((m) => m.id === partialResponse!.id)
+              : -1;
             const erroredUIMessagesWithPartial: TUIMessage[] = !partialResponse
               ? erroredUIMessages
               : partialIdx === -1
@@ -7950,7 +7956,7 @@ function chatAgent<
             const erroredNewUIMessages: TUIMessage[] = erroredWireMessage
               ? [erroredWireMessage]
               : [];
-            if (partialResponse) {
+            if (partialResponse && !responseCommitted) {
               erroredNewUIMessages.push(partialResponse);
             }
 
@@ -7964,7 +7970,7 @@ function chatAgent<
             // its model messages to preserve a prior turn's compaction (mirrors
             // the success path's append branch); otherwise reconvert from UI.
             // Guard the conversion so a secondary failure can't crash the run.
-            if (erroredUIMessagesWithPartial !== accumulatedUIMessages) {
+            if (!responseCommitted && erroredUIMessagesWithPartial !== accumulatedUIMessages) {
               const onlyAppendedPartial =
                 partialResponse != null &&
                 partialIdx === -1 &&

packages/trigger-sdk/test/chat-agent-source-stream-error.test.ts

@@ -160,6 +160,66 @@ describe("chat.agent managed loop — source-stream failure", () => {
       await harness.close();
     }
   });
+
+  it("does not overwrite an already-committed enriched response when a post-response hook throws", async () => {
+    const events: TurnCompleteEvent<unknown, UIMessage>[] = [];
+
+    const okModel = (text: string) =>
+      new MockLanguageModelV3({
+        doStream: async () => ({
+          stream: simulateReadableStream({
+            chunks: [
+              { type: "text-start", id: "t1" },
+              { type: "text-delta", id: "t1", delta: text },
+              { type: "text-end", id: "t1" },
+              {
+                type: "finish",
+                finishReason: { unified: "stop", raw: "stop" },
+                usage: {
+                  inputTokens: {
+                    total: 5,
+                    noCache: 5,
+                    cacheRead: undefined,
+                    cacheWrite: undefined,
+                  },
+                  outputTokens: { total: 5, text: 5, reasoning: undefined },
+                },
+              },
+            ] as LanguageModelV3StreamPart[],
+          }),
+        }),
+      });
+
+    const agent = chat.agent({
+      id: "chatAgent.post-commit-hook-throw",
+      run: async ({ messages }) => {
+        chat.response.write({ type: "data-marker", data: { kept: true } } as never);
+        return streamText({ model: okModel("full response"), messages });
+      },
+      onTurnComplete: async (event) => {
+        events.push(event);
+        if (event.error == null) {
+          throw new Error("hook boom after commit");
+        }
+      },
+    });
+
+    const harness = mockChatAgent(agent, { chatId: "cae-post-commit-throw" });
+    try {
+      await harness.sendMessage(userMessage("hi", "u-1"));
+      await waitFor(() => events.some((e) => e.error != null));
+
+      const errorEvent = events.find((e) => e.error != null)!;
+      const assistant = (errorEvent.uiMessages as UIMessage[]).find((m) => m.role === "assistant");
+      expect(assistant).toBeDefined();
+      expect(
+        (assistant!.parts as Array<{ type: string }>).some((p) => p.type === "data-marker")
+      ).toBe(true);
+      expect(extractText(assistant)).toBe("full response");
+    } finally {
+      await harness.close();
+    }
+  });
 });
 
 describe("chat.createSession turn.complete() — source-stream failure", () => {