fix(chat): keep a prepared steer through a history edit and a failed turn

A chat.history edit rebuilt the model lane from the UI lane, which put
the steer's raw form back, and when a compaction override replaced that
lane in the same turn the steer was left with no form at all, since the
id-set skip then withheld the prepared one. The rebuild now leaves
consumed steers out and reconciliation appends the prepared form once;
a steer the edit removed stays removed. The id-set skip is gone.

The failed-turn delta is built from the recorded forms rather than by
converting the UI list, so newMessages reports the form the lane holds.

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

@@ -6710,20 +6710,15 @@ function chatAgent<
       const reconcilePendingSteer = (options?: {
         /** This turn's model delta, as `onTurnComplete.newMessages` reports it. */
         turnNew?: ModelMessage[];
-        /**
-         * UI message ids already in the lane because a `chat.history` edit
-         * rebuilt it from the UI lane this turn. Their model form is not
-         * appended again, or later turns would get the steer twice.
-         */
-        alreadyInLane?: Set<string>;
-      }) => {
+      }): PendingSteer[] => {
         const pending = locals.get(chatPendingSteerKey);
-        if (!pending || pending.length === 0) return;
+        if (!pending || pending.length === 0) return [];
         locals.set(chatPendingSteerKey, []);
         for (const entry of pending) {
-          if (!options?.alreadyInLane?.has(entry.ui.id)) accumulatedMessages.push(...entry.model);
+          accumulatedMessages.push(...entry.model);
           options?.turnNew?.push(...entry.model);
         }
+        return pending;
       };
 
       // Accumulated UI messages for persistence. Mirrors the model accumulator
@@ -8567,13 +8562,27 @@ function chatAgent<
                   // during this turn. The updated messages become the new base, and the
                   // response gets appended on top.
                   const runOverride = locals.get(chatOverrideMessagesKey);
-                  let rebuiltFromUiIds: Set<string> | undefined;
                   if (runOverride) {
                     locals.set(chatOverrideMessagesKey, undefined);
                     accumulatedUIMessages = [...runOverride] as TUIMessage[];
-                    accumulatedMessages = await toModelMessages(runOverride);
+                    /**
+                     * Steers the drain consumed are left out of the rebuild and
+                     * appended by the reconciliation below instead, so the lane
+                     * gets the form the model actually received rather than a
+                     * reconversion of the UI message, and gets it once. A steer
+                     * the edit removed is dropped from the pending list too, so
+                     * the edit is honoured.
+                     */
+                    const overrideIds = new Set(runOverride.map((m) => m.id));
+                    const pending = (locals.get(chatPendingSteerKey) ?? []).filter((e) =>
+                      overrideIds.has(e.ui.id)
+                    );
+                    locals.set(chatPendingSteerKey, pending);
+                    const pendingIds = new Set(pending.map((e) => e.ui.id));
+                    accumulatedMessages = await toModelMessages(
+                      runOverride.filter((m) => !pendingIds.has(m.id))
+                    );
                     locals.set(chatCurrentUIMessagesKey, accumulatedUIMessages);
-                    rebuiltFromUiIds = new Set(runOverride.map((m) => m.id));
                   }
 
                   // Check if compaction set a model-only override (preserves UI messages).
@@ -8616,10 +8625,7 @@ function chatAgent<
                   // before the response is appended so the order stays
                   // steer-then-answer. Outside the `capturedResponseMessage`
                   // branches below, so a turn that captured no response is covered.
-                  reconcilePendingSteer({
-                    turnNew: turnNewModelMessages,
-                    alreadyInLane: rebuiltFromUiIds,
-                  });
+                  reconcilePendingSteer({ turnNew: turnNewModelMessages });
 
                   // Append the assistant's response (partial or complete) to the accumulator.
                   // The onFinish callback fires even on abort/stop, so partial responses
@@ -9281,14 +9287,28 @@ function chatAgent<
 
             let erroredNewModelMessages: ModelMessage[] = [];
 
-            reconcilePendingSteer();
+            const reconciledSteer = reconcilePendingSteer();
 
             if (!responseCommitted) {
               try {
                 if (erroredNewUIMessages.length > 0) {
-                  erroredNewModelMessages = await toModelMessages(
-                    erroredNewUIMessages.map((m) => stripProviderMetadata(m))
+                  /**
+                   * Built in order from the recorded forms rather than by
+                   * converting the UI list, so a steer appears in the delta as
+                   * the model received it (what `prepare` produced), matching the
+                   * lane. The wire message and partial are converted as before.
+                   */
+                  const steerModelById = new Map(
+                    reconciledSteer.map((e) => [e.ui.id, e.model] as const)
                   );
+                  for (const m of erroredNewUIMessages) {
+                    const recorded = steerModelById.get(m.id);
+                    if (recorded) erroredNewModelMessages.push(...recorded);
+                    else
+                      erroredNewModelMessages.push(
+                        ...(await toModelMessages([stripProviderMetadata(m)]))
+                      );
+                  }
                 }
                 if (erroredUIMessagesWithPartial !== accumulatedUIMessages) {
                   if (partialIdx === -1) {

packages/trigger-sdk/test/steering-error-path.test.ts

@@ -92,7 +92,12 @@ describe("chat.agent steering on a turn that fails", () => {
     const chatId = "steer-error-path";
     const toolGate = deferred();
     let toolEntered = false;
-    const events: { newUIMessages: UIMessage[]; messages: unknown[]; finishReason?: string }[] = [];
+    const events: {
+      newUIMessages: UIMessage[];
+      messages: unknown[];
+      newMessages: unknown[];
+      finishReason?: string;
+    }[] = [];
     const promptsSawSteer: boolean[] = [];
 
     const gateTool = tool({
@@ -132,11 +137,22 @@ describe("chat.agent steering on a turn that fails", () => {
 
     const agent = chat.agent({
       id: "steer-error-path",
-      pendingMessages: { shouldInject: () => true },
-      onTurnComplete: async ({ newUIMessages, messages, finishReason }) => {
+      pendingMessages: {
+        shouldInject: () => true,
+        prepare: async ({ messages }) => [
+          {
+            role: "system",
+            content: `[OPERATOR-NOTE] ${messages
+              .map((m) => (m.parts as { text?: string }[]).map((p) => p.text ?? "").join(""))
+              .join(" ")}`,
+          },
+        ],
+      },
+      onTurnComplete: async ({ newUIMessages, messages, newMessages, finishReason }) => {
         events.push({
           newUIMessages: [...(newUIMessages ?? [])],
           messages: [...messages],
+          newMessages: [...(newMessages ?? [])],
           finishReason,
         });
       },
@@ -176,7 +192,11 @@ describe("chat.agent steering on a turn that fails", () => {
       // does the prompt the next turn actually sends. Reconciling only on the
       // success path leaves it pending, so the next turn misses it and it
       // lands a slot late at the end of that turn.
-      expect(JSON.stringify(events[0]!.messages)).toContain("steer-me");
+      expect(JSON.stringify(events[0]!.messages)).toContain("[OPERATOR-NOTE] steer-me");
+      // The per-turn delta carries the same form, not a reconversion of the UI
+      // message: append-only model persistence from `newMessages` would
+      // otherwise store a different instruction from the one the model acted on.
+      expect(JSON.stringify(events[0]!.newMessages)).toContain("[OPERATOR-NOTE] steer-me");
       const promptsBefore = promptsSawSteer.length;
       await harness.sendMessage(userMessage("m3", "u-3"));
       await waitFor(() => promptsSawSteer.length > promptsBefore, "turn 2 prompt built");

packages/trigger-sdk/test/steering-history-edit-once.test.ts

@@ -65,77 +65,136 @@ async function sendAndLand(
 }
 const countOf = (hay: string, needle: string) => hay.split(needle).length - 1;
 
-describe("a history edit after a steer was drained", () => {
-  it("sends the steer to later turns exactly once", { timeout: 30_000 }, async () => {
-    const chatId = "steer-history-edit-once";
-    const toolGate = deferred();
-    let toolEntered = false;
-    const prompts: string[] = [];
+type Variant = { prepare?: boolean; compact?: boolean; deleteSteer?: boolean };
 
-    const gateTool = tool({
-      description: "blocks until the test opens it",
-      inputSchema: z.object({ q: z.string() }),
-      execute: async () => {
-        toolEntered = true;
-        await toolGate.promise;
-        return "ok";
-      },
-    });
+/** One steered turn with a history edit from onInjected, then a follow-up turn. Returns turn 2's prompt. */
+async function runVariant(chatId: string, v: Variant): Promise<string> {
+  const toolGate = deferred();
+  let toolEntered = false;
+  const prompts: string[] = [];
+  let compacted = 0;
 
-    let step = 0;
-    const model = new MockLanguageModelV3({
-      doStream: async ({ prompt }) => {
-        prompts.push(JSON.stringify(prompt));
-        const isToolStep = step++ % 2 === 0;
-        return {
-          stream: simulateReadableStream({
-            chunks: isToolStep ? toolCallChunks(`tc-${step}`) : textChunks("done"),
-            initialDelayInMs: 10,
-            chunkDelayInMs: 2,
-          }),
-        };
-      },
-    });
+  const gateTool = tool({
+    description: "blocks until the test opens it",
+    inputSchema: z.object({ q: z.string() }),
+    execute: async () => {
+      toolEntered = true;
+      await toolGate.promise;
+      return "ok";
+    },
+  });
 
-    const agent = chat.agent({
-      id: "steer-history-edit-once",
-      pendingMessages: {
-        shouldInject: () => true,
-        // An identity rewrite is enough: any chat.history write sets the
-        // override that is applied by rebuilding from the UI lane.
-        onInjected: () => {
-          chat.history.set(chat.history.all());
-        },
-      },
-      run: async ({ messages, signal }) =>
-        streamText({
-          model,
-          messages,
-          abortSignal: signal,
-          ...chat.toStreamTextOptions(),
-          tools: { gate: gateTool },
-          stopWhen: stepCountIs(5),
+  let step = 0;
+  const model = new MockLanguageModelV3({
+    doStream: async ({ prompt }) => {
+      prompts.push(JSON.stringify(prompt));
+      const isToolStep = step++ % 2 === 0;
+      return {
+        stream: simulateReadableStream({
+          chunks: isToolStep ? toolCallChunks(`tc-${step}`) : textChunks("done"),
+          initialDelayInMs: 10,
+          chunkDelayInMs: 2,
         }),
-    });
+      };
+    },
+  });
+
+  const agent = chat.agent({
+    id: chatId,
+    pendingMessages: {
+      shouldInject: () => true,
+      ...(v.prepare
+        ? {
+            prepare: async ({ messages }) => [
+              {
+                role: "system" as const,
+                content: `[OPERATOR-NOTE] ${messages.map((m) => (m.parts as { text?: string }[]).map((p) => p.text ?? "").join("")).join(" ")}`,
+              },
+            ],
+          }
+        : {}),
+      onInjected: () => {
+        chat.history.set(chat.history.all().filter((m) => !(v.deleteSteer && m.id === "u-2")));
+      },
+    },
+    ...(v.compact
+      ? {
+          compaction: {
+            shouldCompact: () => compacted === 0,
+            summarize: async () => {
+              compacted++;
+              return "SUMMARY-OF-EVERYTHING";
+            },
+          },
+        }
+      : {}),
+    run: async ({ messages, signal }) =>
+      streamText({
+        model,
+        messages,
+        abortSignal: signal,
+        ...chat.toStreamTextOptions(),
+        tools: { gate: gateTool },
+        stopWhen: stepCountIs(5),
+      }),
+  });
+
+  const harness = mockChatAgent(agent, { chatId });
+  try {
+    const first = harness.sendMessage(userMessage("m1", "u-1"));
+    await waitFor(() => toolEntered, "tool entered");
+    await sendAndLand(harness, chatId, "steer-me", "u-2");
+    toolGate.resolve();
+    await first;
+    await waitFor(() => prompts.length >= 2, "turn 1 done");
+    if (v.compact) await waitFor(() => compacted > 0, "compaction ran");
+    const promptsAfterTurn1 = prompts.length;
+    await harness.sendMessage(userMessage("m3", "u-3"));
+    await waitFor(() => prompts.length > promptsAfterTurn1, "turn 2 prompt built");
+    return prompts[promptsAfterTurn1]!;
+  } finally {
+    toolGate.resolve();
+    await harness.close();
+  }
+}
+
+describe("a history edit after a steer was drained", () => {
+  it("sends the steer to later turns exactly once", { timeout: 30_000 }, async () => {
+    const turn2 = await runVariant("steer-history-edit-once", {});
+    expect(countOf(turn2, '"steer-me"')).toBe(1);
+  });
 
-    const harness = mockChatAgent(agent, { chatId });
-    try {
-      const first = harness.sendMessage(userMessage("m1", "u-1"));
-      await waitFor(() => toolEntered, "tool entered");
-      await sendAndLand(harness, chatId, "steer-me", "u-2");
-      toolGate.resolve();
-      await first;
-      await waitFor(() => prompts.length >= 2, "turn 1 done");
-      const promptsAfterTurn1 = prompts.length;
+  it("keeps the prepared form, once", { timeout: 30_000 }, async () => {
+    /**
+     * The rebuild converts the UI message, which is the raw form. If the raw
+     * form is what stays, the model's memory of the instruction differs from
+     * the one it acted on. If both stay, it is there twice.
+     */
+    const turn2 = await runVariant("steer-history-edit-prepared", { prepare: true });
+    expect(countOf(turn2, "[OPERATOR-NOTE] steer-me")).toBe(1);
+    expect(countOf(turn2, '"steer-me"')).toBe(0);
+  });
 
-      await harness.sendMessage(userMessage("m3", "u-3"));
-      await waitFor(() => prompts.length > promptsAfterTurn1, "turn 2 prompt built");
+  it("keeps the steer when compaction also replaces the lane", { timeout: 30_000 }, async () => {
+    /**
+     * A model-only compaction replaces the rebuilt lane, raw steer included.
+     * If reconciliation then withholds the prepared form because the rebuild
+     * "already had it", the steer is gone from the model lane altogether.
+     */
+    const turn2 = await runVariant("steer-history-edit-compacted", {
+      prepare: true,
+      compact: true,
+    });
+    expect(turn2).toContain("SUMMARY-OF-EVERYTHING");
+    expect(countOf(turn2, "[OPERATOR-NOTE] steer-me")).toBe(1);
+  });
 
-      const turn2 = prompts[promptsAfterTurn1]!;
-      expect(countOf(turn2, '"steer-me"')).toBe(1);
-    } finally {
-      toolGate.resolve();
-      await harness.close();
-    }
+  it("does not bring back a steer the edit removed", { timeout: 30_000 }, async () => {
+    /** The edit is the app's decision. Reconciliation must not undo it. */
+    const turn2 = await runVariant("steer-history-edit-deleted", {
+      prepare: true,
+      deleteSteer: true,
+    });
+    expect(turn2).not.toContain("steer-me");
   });
 });