fix(ui): scope tool outcomes to run boundaries

harjothkhara · harjothkhara · commit 4f8ab4412654 · 2026-06-29T09:01:36.000-07:00
diff --git a/ui/src/ui/chat/build-chat-items.test.ts b/ui/src/ui/chat/build-chat-items.test.ts
@@ -1140,13 +1140,14 @@ function createAssistantCanvasBlock(params: { suffix: string }) {
 }
 
 describe("tool turn outcome annotation (#89683)", () => {
-  function failedTool(timestamp: number) {
+  function failedTool(timestamp: number, runId?: string) {
     return {
       role: "toolResult",
       toolName: "shell",
       content: JSON.stringify({ status: "failed", exitCode: 1 }),
       isError: true,
       timestamp,
+      ...(runId ? { runId } : {}),
     };
   }
   function userMsg(text: string, timestamp: number) {
@@ -1155,6 +1156,9 @@ describe("tool turn outcome annotation (#89683)", () => {
   function assistantReply(text: string, timestamp: number) {
     return { role: "assistant", content: [{ type: "text", text }], timestamp };
   }
+  function assistantRunReply(text: string, timestamp: number, runId: string) {
+    return { ...assistantReply(text, timestamp), runId };
+  }
   function toolGroups(messages: unknown[]): MessageGroup[] {
     return messageGroups({ messages }).filter((group) => group.role === "tool");
   }
@@ -1194,4 +1198,14 @@ describe("tool turn outcome annotation (#89683)", () => {
     ]);
     expect(tools.map((group) => group.turnSucceeded)).toEqual([true, false]);
   });
+
+  it("does not carry an agent-initiated reply across run boundaries", () => {
+    const tools = toolGroups([
+      failedTool(1, "run-terminal-failure"),
+      failedTool(2, "run-later-success"),
+      assistantRunReply("Recovered on the later turn.", 3, "run-later-success"),
+    ]);
+    expect(tools).toHaveLength(2);
+    expect(tools.map((group) => group.turnSucceeded)).toEqual([false, true]);
+  });
 });
diff --git a/ui/src/ui/chat/build-chat-items.ts b/ui/src/ui/chat/build-chat-items.ts
@@ -89,6 +89,34 @@ function safeNormalizeMessage(message: unknown): NormalizedMessage | null {
   }
 }
 
+function messageTurnKey(message: unknown): string | null {
+  const record = asRecord(message);
+  if (!record) {
+    return null;
+  }
+  const metadata = asRecord(record.__openclaw);
+  const key = [
+    record.runId,
+    record.agentRunId,
+    record.turnId,
+    metadata?.runId,
+    metadata?.agentRunId,
+    metadata?.turnId,
+  ].find((value): value is string => typeof value === "string" && value.trim().length > 0);
+  return key?.trim() ?? null;
+}
+
+function groupTurnKey(group: MessageGroup): string | null {
+  const keys = new Set<string>();
+  for (const entry of group.messages) {
+    const key = messageTurnKey(entry.message);
+    if (key) {
+      keys.add(key);
+    }
+  }
+  return keys.size === 1 ? (keys.values().next().value ?? null) : null;
+}
+
 function extractChatMessagePreview(toolMessage: unknown): {
   preview: Extract<NonNullable<ToolCard["preview"]>, { kind: "canvas" }>;
   text: string | null;
@@ -193,17 +221,23 @@ function groupMessages(items: ChatItem[]): Array<ChatItem | MessageGroup> {
 
     const normalized = normalizeMessage(item.message);
     const role = normalizeRoleForGrouping(normalized.role);
+    const roleKey = role.toLowerCase();
     const senderLabel =
-      role.toLowerCase() === "user" || role.toLowerCase() === "assistant"
-        ? (normalized.senderLabel ?? null)
-        : null;
+      roleKey === "user" || roleKey === "assistant" ? (normalized.senderLabel ?? null) : null;
+    const itemTurnKey = messageTurnKey(item.message);
     const timestamp = normalized.timestamp || Date.now();
-    const shouldSplitBySender = role.toLowerCase() === "user" || role.toLowerCase() === "assistant";
+    const shouldSplitBySender = roleKey === "user" || roleKey === "assistant";
+    const currentTurnKey = currentGroup ? groupTurnKey(currentGroup) : null;
+    const shouldSplitByTurn =
+      (roleKey === "assistant" || roleKey === "tool") &&
+      currentGroup?.role === role &&
+      Boolean(itemTurnKey && currentTurnKey && itemTurnKey !== currentTurnKey);
 
     if (
       !currentGroup ||
       currentGroup.role !== role ||
-      (shouldSplitBySender && currentGroup.senderLabel !== senderLabel)
+      (shouldSplitBySender && currentGroup.senderLabel !== senderLabel) ||
+      shouldSplitByTurn
     ) {
       if (currentGroup) {
         result.push(currentGroup);
@@ -348,12 +382,14 @@ function assistantGroupHasReplyText(group: MessageGroup): boolean {
 // failure (e.g. a no-match search) must not render as a primary error banner
 // once a clean reply exists. Backward pass: a user group ends the turn
 // downstream; an assistant reply marks success for earlier tool groups in the
-// same turn. turnSucceeded stays undefined for terminal or in-progress failures,
-// preserving the existing error banner.
+// same turn. Explicit run/turn metadata scopes agent-initiated turns that have
+// no user boundary; legacy transcripts without that metadata still use the user
+// boundary fallback. Terminal or in-progress failures keep the error banner.
 function annotateToolTurnOutcome(
   items: Array<ChatItem | MessageGroup>,
 ): Array<ChatItem | MessageGroup> {
   let sawAssistantReply = false;
+  const successfulTurnKeys = new Set<string>();
   for (let i = items.length - 1; i >= 0; i -= 1) {
     const item = items[i];
     if (item.kind !== "group") {
@@ -362,12 +398,19 @@ function annotateToolTurnOutcome(
     const role = item.role.toLowerCase();
     if (role === "user") {
       sawAssistantReply = false;
+      successfulTurnKeys.clear();
     } else if (role === "assistant") {
       if (assistantGroupHasReplyText(item)) {
-        sawAssistantReply = true;
+        const turnKey = groupTurnKey(item);
+        if (turnKey) {
+          successfulTurnKeys.add(turnKey);
+        } else {
+          sawAssistantReply = true;
+        }
       }
     } else if (role === "tool") {
-      item.turnSucceeded = sawAssistantReply;
+      const turnKey = groupTurnKey(item);
+      item.turnSucceeded = turnKey ? successfulTurnKeys.has(turnKey) : sawAssistantReply;
     }
   }
   return items;
