fix(chat): rebuild the model messages after a steering injection

The UI and model accumulators are maintained separately, and a drained
message was appended to the UI one only. The model saw it through the
prepareStep return value, which is per-step, so the model lane never
learned it existed and every later turn of the run answered without it
while the browser, the snapshot and chat.history.* all still showed it.

The drain now marks the model lane stale and it is rebuilt from the UI
lane at the end of the turn. Flips the it.fails repro in
steering-injection.test.ts to a passing test.

Author: ericallam

.changeset/steering-messages-accumulator.md

@@ -2,6 +2,6 @@
 "@trigger.dev/sdk": patch
 ---
 
-Steering messages injected mid-answer are now part of the conversation your hooks see. Previously they reached the model and the browser but not `onTurnComplete`, so an app storing its own transcript lost the instruction the answer was shaped by. It vanished from the conversation on reload, and later turns had no record of it.
+Steering messages injected mid-answer are now part of the conversation, both for your hooks and for the model on later turns. Previously they reached the model for the answer they steered and reached the browser, but nothing else: `onTurnComplete` never saw them, so an app storing its own transcript lost the instruction the answer was shaped by, and it vanished from the conversation on reload. The model also forgot the instruction from the next turn onwards, answering as though the message had never been sent, while the chat UI still showed it.
 
 If you worked around this by saving steering messages as they arrive, in `pendingMessages.onReceived` for example, that write now duplicates the one you get from `newUIMessages`. Drop it, or skip messages you have already stored.

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

@@ -3561,6 +3561,19 @@ const chatSteeringQueueKey = locals.create<SteeringQueueEntry[]>("chat.steeringQ
  * `onTurnComplete` never learns it existed.
  */
 const chatTurnNewUIMessagesKey = locals.create<UIMessage[]>("chat.turnNewUIMessages");
+
+/**
+ * Set when a steering drain appended to the UI accumulator, so the model
+ * accumulator gets rebuilt from it at the end of the turn.
+ *
+ * The two accumulators are maintained separately, and the model one is
+ * normally advanced by appending each turn's delta. A drained message is
+ * appended to the UI one but reaches the model only through the `prepareStep`
+ * return value, which is per-step: without a rebuild the model lane never
+ * learns the message exists and every later turn of the run answers without
+ * it, while the browser, the snapshot and `chat.history.*` all still show it.
+ */
+const chatModelLaneStaleKey = locals.create<boolean>("chat.modelLaneStale");
 /** @internal — IDs of messages that were successfully injected via prepareStep */
 const chatInjectedMessageIdsKey = locals.create<Set<string>>("chat.injectedMessageIds");
 /** @internal — non-transient data parts queued via chat.response or writer.write() for accumulation into the response message */
@@ -4286,6 +4299,9 @@ async function drainSteeringQueue(
           turnNew.push(m);
         }
       }
+      if (claimedUIMessages.length > 0) {
+        locals.set(chatModelLaneStaleKey, true);
+      }
 
       // Write injection confirmation chunk to the stream so the frontend
       // knows which messages were injected and where in the response.
@@ -8600,6 +8616,23 @@ function chatAgent<
                     turnBufferedChunks.length = 0;
                   }
 
+                  // Bring the model accumulator back in line with the UI one
+                  // after a steering drain. Placed after response accumulation
+                  // and before compaction reads `accumulatedMessages`, and
+                  // outside the `capturedResponseMessage` branches so a turn
+                  // that captured no response is covered too.
+                  if (locals.get(chatModelLaneStaleKey)) {
+                    locals.set(chatModelLaneStaleKey, false);
+                    try {
+                      accumulatedMessages = await toModelMessages(accumulatedUIMessages);
+                    } catch (error) {
+                      logger.warn(
+                        "chat.agent: toModelMessages failed rebuilding after an injection; the injected message will be missing from the next turn",
+                        { error: error instanceof Error ? error.message : String(error) }
+                      );
+                    }
+                  }
+
                   if (runSignal.aborted) return "exit";
 
                   // Await deferred background work (e.g. DB writes from onTurnStart)

packages/trigger-sdk/test/steering-injection.test.ts

@@ -355,18 +355,14 @@ describe("chat.agent injection claims only its own batch", () => {
 /**
  * Whether an injected message survives into the next turn's model context.
  *
- * Recorded here because the deployed QA lane finds the two surfaces disagree:
- * a `chat.createSession()` recap in the same run recalls a mid-turn steer,
- * while the managed `chat.agent` loop denies it. That difference is
- * pre-existing and is the surface-specific half of the accumulator gap.
- *
- * `it.fails` because the managed path does not carry it: turn 2's prompt comes
- * back as the original and the following message only, with the injected one
- * absent. Held here so the day that changes is noticed, and so the gap has a
- * repro that does not need a deployed environment.
+ * The UI accumulator and the model accumulator are maintained separately, and
+ * a drained message used to reach only the first: the browser, the snapshot
+ * and `chat.history.*` all showed it while every later turn of the run
+ * answered without it. The model lane is now rebuilt from the UI lane at the
+ * end of a turn that drained, and this is the repro for it.
  */
 describe("chat.agent injected message in the next turn's context", () => {
-  it.fails(
+  it(
     "carries an injected message into the following turn's prompt",
     { timeout: 30_000 },
     async () => {