perf(webapp): restore the stripped-message cache the UI rewrite dropped

The transcript perf fix had two halves. The winners half kept its identity because a test
pinned it; the strip cache had none, so rewriting the component into chat primitives quietly
brought back the rebuild-every-render version, and every tool-calling turn re-rendered on each
streamed token again. Restore the cache and pin it the same way.

orderTranscript is not implicated: it returns a fresh array but the same message objects, which
is what the turns memoize on.

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/DashboardAgentMessages.tsx

@@ -38,10 +38,17 @@ export type DashboardAgentMessagesProps = {
   pagePaths?: Record<string, string>;
 };
 
-// Returns the same reference when there are no `step-start` parts, so memoization holds.
-function stripStepParts(message: UIMessage): UIMessage {
+// Cached so a stripped message keeps its identity across renders and memoization holds:
+// rebuilding it re-renders every tool-calling turn on each streamed token.
+const strippedMessages = new WeakMap<UIMessage, UIMessage>();
+
+export function stripStepParts(message: UIMessage): UIMessage {
   if (!message.parts?.some((p) => p.type === "step-start")) return message;
-  return { ...message, parts: message.parts.filter((p) => p.type !== "step-start") };
+  const cached = strippedMessages.get(message);
+  if (cached) return cached;
+  const stripped = { ...message, parts: message.parts.filter((p) => p.type !== "step-start") };
+  strippedMessages.set(message, stripped);
+  return stripped;
 }
 
 function viewSpecFor(part: UIMessage["parts"][number]): { blocks: unknown[] } | null {

apps/webapp/app/components/dashboard-agent/investigation-winners.test.ts

@@ -1,7 +1,11 @@
 import { readFileSync } from "node:fs";
 import type { UIMessage } from "@ai-sdk/react";
 import { describe, expect, it } from "vitest";
-import { blocksFor, winningInvestigationOccurrences } from "./DashboardAgentMessages";
+import {
+  blocksFor,
+  stripStepParts,
+  winningInvestigationOccurrences,
+} from "./DashboardAgentMessages";
 import { reuseWinners, sameOccurrences } from "./investigation-winners";
 
 const source = readFileSync(new URL("./DashboardAgentMessages.tsx", import.meta.url), "utf8");
@@ -50,6 +54,46 @@ describe("investigation winners identity", () => {
   });
 });
 
+/**
+ * The turns are memoized on the message object, so a stripped message rebuilt on every
+ * render defeats the memo for every tool-calling turn at once.
+ */
+describe("stripped message identity", () => {
+  function withStepStart(): UIMessage {
+    return {
+      id: "m1",
+      role: "assistant",
+      parts: [{ type: "step-start" }, { type: "text", text: "hello" }],
+    } as unknown as UIMessage;
+  }
+
+  it("returns the very same reference when there is nothing to strip", () => {
+    const plain = { id: "m1", role: "assistant", parts: [{ type: "text", text: "hi" }] };
+    const message = plain as unknown as UIMessage;
+
+    expect(stripStepParts(message)).toBe(message);
+  });
+
+  it("returns the same stripped reference on every later call", () => {
+    const message = withStepStart();
+    const first = stripStepParts(message);
+
+    expect(first).not.toBe(message);
+    expect(first.parts).toHaveLength(1);
+    for (let token = 0; token < 20; token++) {
+      expect(stripStepParts(message)).toBe(first);
+    }
+  });
+
+  it("strips a different message to its own reference", () => {
+    const a = withStepStart();
+    const b = withStepStart();
+
+    expect(stripStepParts(a)).not.toBe(stripStepParts(b));
+    expect(stripStepParts(a)).toBe(stripStepParts(a));
+  });
+});
+
 /**
  * The winner pass runs once per streamed token over the whole transcript, so it must
  * not touch report payloads. `output` is a counting getter because a report parse is