fix(webapp): merge the turn's cache breakpoint into the last message's Anthropic options

Both places that roll the per-turn cache breakpoint onto the last message wrote
`anthropic: { cacheControl }` wholesale, replacing the namespace and silently
dropping every other Anthropic option that message carried.

`withCacheBreakpointOnLast()` now spreads the existing options and overwrites only
`cacheControl`. The agent's `prepareMessages` hook had the same write inlined, so
it goes through that one function instead, as `prepareTurnMessages()` — which also
gives the hook's behaviour a name a test can reach.

The system block's breakpoint in `chat.prompt.set` is left alone: it builds a fresh
options object, so there is nothing to merge into.

Author: kathiekiwi

internal-packages/dashboard-agent/src/agent-runtime.ts

@@ -349,7 +349,9 @@ export function withCacheBreakpointOnLast(messages: ModelMessage[]): ModelMessag
       ...last,
       providerOptions: {
         ...last.providerOptions,
-        anthropic: { cacheControl: PROMPT_CACHE_CONTROL },
+        // Merged, not replaced: the breakpoint is one Anthropic option among any
+        // others the message already carries.
+        anthropic: { ...last.providerOptions?.anthropic, cacheControl: PROMPT_CACHE_CONTROL },
       },
     },
   ];

internal-packages/dashboard-agent/src/cache-breakpoint.test.ts

@@ -0,0 +1,75 @@
+// `@trigger.dev/sdk/ai/test` MUST be imported before the agent module so the
+// resource catalog is installed before `chat.agent({ id })` / `prompts.define`
+// register at module load.
+import "@trigger.dev/sdk/ai/test";
+
+import type { ModelMessage } from "ai";
+import { describe, expect, it } from "vitest";
+
+import { withCacheBreakpointOnLast } from "./agent-runtime";
+import { prepareTurnMessages } from "./dashboard-agent";
+import { PROMPT_CACHE_CONTROL } from "./prompt-prefix";
+
+/**
+ * Rolling the turn's cache breakpoint onto the last message must not take the rest of
+ * that message's Anthropic options with it: writing the namespace wholesale silently
+ * dropped every other option the message carried.
+ */
+
+function lastMessageWithAnthropicOptions(): ModelMessage[] {
+  return [
+    { role: "user", content: "first" },
+    {
+      role: "user",
+      content: "second",
+      providerOptions: {
+        anthropic: { cacheControl: { type: "ephemeral", ttl: "5m" }, thinking: { budget: 1024 } },
+        openai: { store: false },
+      },
+    },
+  ];
+}
+
+describe("withCacheBreakpointOnLast", () => {
+  it("keeps the last message's other Anthropic options alongside the breakpoint", () => {
+    const prepared = withCacheBreakpointOnLast(lastMessageWithAnthropicOptions());
+
+    expect(prepared[1]!.providerOptions).toEqual({
+      anthropic: { cacheControl: PROMPT_CACHE_CONTROL, thinking: { budget: 1024 } },
+      openai: { store: false },
+    });
+  });
+
+  it("leaves earlier messages untouched", () => {
+    const messages = lastMessageWithAnthropicOptions();
+    expect(withCacheBreakpointOnLast(messages)[0]).toEqual(messages[0]);
+  });
+});
+
+describe("prepareTurnMessages", () => {
+  it("keeps the last message's other Anthropic options alongside the breakpoint", () => {
+    const prepared = prepareTurnMessages({
+      messages: lastMessageWithAnthropicOptions(),
+      reason: "run",
+    });
+
+    expect(prepared[1]!.providerOptions).toEqual({
+      anthropic: { cacheControl: PROMPT_CACHE_CONTROL, thinking: { budget: 1024 } },
+      openai: { store: false },
+    });
+  });
+
+  it("still coerces a replayed tool input the API would reject", () => {
+    const prepared = prepareTurnMessages({
+      messages: [
+        {
+          role: "assistant",
+          content: [{ type: "tool-call", toolCallId: "call_1", toolName: "noop", input: "" }],
+        },
+      ],
+      reason: "run",
+    });
+
+    expect((prepared[0]!.content as { input: unknown }[])[0]!.input).toEqual({});
+  });
+});

internal-packages/dashboard-agent/src/dashboard-agent.ts

@@ -20,6 +20,7 @@ import {
   settlementCardMessages,
   clearOpenInvestigations,
   pendingInvestigationSettlements,
+  withCacheBreakpointOnLast,
   type DashboardAgentStore,
 } from "./agent-runtime";
 import { titlePrompt } from "./prompts";
@@ -314,6 +315,27 @@ export type {
   AgentPageSignal,
 } from "@internal/dashboard-agent-contracts";
 
+/**
+ * What the turn's model actually sees: replayed tool inputs the API would reject
+ * coerced back, the durable state pinned back on, and a cache breakpoint on the last
+ * message so the growing conversation prefix is read back cheaply.
+ *
+ * The between-steps compaction path rebuilds history as the summary alone and never
+ * reaches `compactModelMessages`, so the live investigation and watch state is pinned
+ * back here instead.
+ */
+export function prepareTurnMessages(args: {
+  messages: ModelMessage[];
+  reason: string;
+}): ModelMessage[] {
+  if (args.messages.length === 0) return args.messages;
+  return withCacheBreakpointOnLast(
+    sanitizeReplayedToolInputs(
+      args.reason === "run" ? args.messages : withDurableState(args.messages, chat.history.all())
+    )
+  );
+}
+
 export const dashboardAgent = chat.agent({
   id: "dashboard-agent",
   clientDataSchema,
@@ -525,27 +547,7 @@ export const dashboardAgent = chat.agent({
   // conversation prefix is cached and read back cheaply. Composes with the
   // system-block breakpoint above. chat.agent keeps the Head Start handover's
   // tool-approval tail intact across this hook, so it is safe on a resume turn.
-  prepareMessages: ({ messages, reason }) => {
-    if (messages.length === 0) return messages;
-    // The between-steps compaction path rebuilds history as the summary alone and
-    // never reaches `compactModelMessages`, so the live investigation and watch state
-    // is pinned back here instead.
-    const sanitized = sanitizeReplayedToolInputs(
-      reason === "run" ? messages : withDurableState(messages, chat.history.all())
-    );
-
-    const last = sanitized[sanitized.length - 1];
-    return [
-      ...sanitized.slice(0, -1),
-      {
-        ...last,
-        providerOptions: {
-          ...last.providerOptions,
-          anthropic: { cacheControl: PROMPT_CACHE_CONTROL },
-        },
-      },
-    ];
-  },
+  prepareMessages: ({ messages, reason }) => prepareTurnMessages({ messages, reason }),
 
   // System prompt and model come from the managed prompt set in onTurnStart, so
   // they are dashboard-editable. toStreamTextOptions() supplies the system text