fix(dashboard-agent): detect legacy cache breakpoints without the discriminator

Conversations persisted before __cacheBreakpoint existed carry a bare
anthropic.cacheControl. Classify it by ttl and strip it on resume so
legacy breakpoints don't slip past the 4-breakpoint limit.

Author: kathiekiwi

internal-packages/dashboard-agent/src/model-provider.test.ts

@@ -96,4 +96,25 @@ describe("cache breakpoints", () => {
     expect(isLongLivedCacheBreakpoint(bedrockPrefix)).toBe(true);
     expect(withoutCacheBreakpoint(bedrockStep)).toEqual({});
   });
+
+  // Conversations persisted before the __cacheBreakpoint discriminator existed carry
+  // a bare anthropic.cacheControl. Detection must fall back to classifying its ttl.
+  it("classifies a legacy Anthropic cacheControl with no discriminator by its ttl", () => {
+    const legacyPrefix = { anthropic: { cacheControl: PROMPT_CACHE_CONTROL } };
+    const legacyStepWithTtl = { anthropic: { cacheControl: STEP_CACHE_CONTROL } };
+    const legacyStepNoTtl = { anthropic: { cacheControl: { type: "ephemeral" } } };
+
+    expect(isLongLivedCacheBreakpoint(legacyPrefix)).toBe(true);
+    expect(isStepCacheBreakpoint(legacyPrefix)).toBe(false);
+    expect(isStepCacheBreakpoint(legacyStepWithTtl)).toBe(true);
+    expect(isLongLivedCacheBreakpoint(legacyStepWithTtl)).toBe(false);
+    expect(isStepCacheBreakpoint(legacyStepNoTtl)).toBe(true);
+  });
+
+  it("strips a legacy Anthropic cacheControl even while Bedrock is active", () => {
+    useBedrock();
+    const legacyStep = { anthropic: { cacheControl: STEP_CACHE_CONTROL, keep: true } };
+
+    expect(withoutCacheBreakpoint(legacyStep)).toEqual({ anthropic: { keep: true } });
+  });
 });

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

@@ -69,7 +69,13 @@ type ProviderOptions = Record<string, any> | undefined;
 const CACHE_BREAKPOINT_KEY = "__cacheBreakpoint";
 
 function breakpointKind(providerOptions: ProviderOptions): CacheBreakpoint | undefined {
-  return providerOptions?.[CACHE_BREAKPOINT_KEY]?.kind;
+  const discriminated = providerOptions?.[CACHE_BREAKPOINT_KEY]?.kind;
+  if (discriminated) return discriminated;
+  // Conversations persisted before the discriminator existed carry a bare Anthropic
+  // cacheControl. Classify it by ttl: "1h" is the turn-wide prefix, anything else the step.
+  const legacyCacheControl = providerOptions?.anthropic?.cacheControl;
+  if (!legacyCacheControl) return undefined;
+  return legacyCacheControl.ttl === "1h" ? "prefix" : "step";
 }
 
 function cacheOptions(breakpoint: CacheBreakpoint): Record<string, any> {
@@ -131,7 +137,15 @@ export function cacheUsageFromProviderMetadata(providerMetadata: unknown): {
 
 /** The same options with the active provider's breakpoint and its discriminator removed. */
 export function withoutCacheBreakpoint(providerOptions: ProviderOptions): Record<string, any> {
-  const key = dashboardAgentProvider() === "anthropic" ? "anthropic" : "bedrock";
+  const hasDiscriminator = providerOptions?.[CACHE_BREAKPOINT_KEY] !== undefined;
+  // A legacy message keeps its native anthropic.cacheControl shape no matter which
+  // provider is active now, so strip that key rather than the current provider's.
+  const isLegacy = !hasDiscriminator && providerOptions?.anthropic?.cacheControl !== undefined;
+  const key = isLegacy
+    ? "anthropic"
+    : dashboardAgentProvider() === "anthropic"
+      ? "anthropic"
+      : "bedrock";
   const field = key === "anthropic" ? "cacheControl" : "cachePoint";
   const {
     [key]: provider,

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

@@ -131,6 +131,21 @@ describe("the step cache breakpoint", () => {
     const empty: Message[] = [];
     expect(markStepCacheBreakpoint(empty)).toBe(empty);
   });
+
+  // A conversation resumed after this branch shipped can still carry a step
+  // breakpoint in the pre-discriminator shape. It must be stripped like any other.
+  it("strips a legacy step breakpoint on resume", () => {
+    const legacyStep: Message = {
+      role: "tool",
+      content: "ok",
+      providerOptions: { anthropic: { cacheControl: STEP_CACHE_CONTROL, keep: true } },
+    };
+    const marked = markStepCacheBreakpoint([turnHistory(), legacyStep, toolResult(20)]);
+
+    expect(ttlOf(marked[1])).toBeUndefined();
+    expect(marked[1]!.providerOptions).toEqual({ anthropic: { keep: true } });
+    expect(ttlOf(marked[0])).toBe("1h");
+  });
 });
 
 describe("the step cache breakpoint on Bedrock", () => {