fix(opencode): isolate Opus 5 recovery state

ualtinok · ualtinok · commit ddf530289660 · 2026-07-24T22:18:54.000+02:00
diff --git a/README.md b/README.md
@@ -32,8 +32,8 @@ This repo is a Bun workspace monorepo with two user-facing integrations and one
 - **Persistent Claude cache controls**: manage Anthropic 1-hour prompt caching from `/claude-cache` with explicit, automatic, or hybrid modes.
 - **Cache keepalive**: use `/claude-cachekeep always` or `/claude-cachekeep HH-HH` to pre-warm hybrid cache anchors for active sessions before the 1-hour TTL expires.
 - **Fast mode toggle**: use `/claude-fast on|off` to request Anthropic fast mode for supported Opus models.
-- **Fable/Mythos reasoning visibility**: request summarized adaptive thinking for Claude Fable 5 and Mythos 5 so agents can display reasoning summaries instead of blank signed-thinking blocks.
-- **Fable content-filter recovery (OpenCode)**: when Fable ends a session response with Anthropic's `refusal` content-filter reason, transparently retry with Opus 4.8 for 10 successful model responses. After each Opus response, a zero-output Fable prewarm advances the same prompt cache using the OAuth account that served the filtered Fable request. The latest Opus cache boundary is retained so a later refusal can bridge back to Opus even after more than 20 Fable content blocks; the selected OpenCode model remains Fable. The TUI sidebar shows the per-session recovery countdown and return to Fable, while OpenCode Desktop receives ignored `promptAsync` notices for both transitions.
+- **Adaptive reasoning visibility**: request summarized adaptive thinking for Claude Fable 5, Mythos 5, and Opus 5. OpenCode receives native `low`, `medium`, `high`, `xhigh`, and `max` Opus 5 effort variants rather than legacy manual-thinking budgets.
+- **Fable/Opus 5 content-filter recovery (OpenCode)**: when Fable or Opus 5 ends a session response with Anthropic's `refusal` content-filter reason, transparently retry that source-model family with Opus 4.8 for 10 successful model responses. Recovery state and pending cache warms remain independent when a session switches between Fable and Opus 5. After each downgraded response, a zero-output prewarm advances the source model's prompt cache using the OAuth account that served the filtered request. The latest Opus cache boundary is retained so a later refusal can bridge back even after more than 20 content blocks. The TUI sidebar and OpenCode Desktop report both transitions while preserving the selected model.
 - **Live quota visibility**: use `/claude-quota` to see main and fallback quota state, reset times, and refresh errors.
 - **Quota sidebar widget**: register the OpenCode TUI plugin in `tui.json` to render a live sidebar with per-account quota, routing, cache, and health state.
 - **Killswitch**: per-account hard-block thresholds that stop requests before hitting Anthropic's rate limits, with synthetic 429 retry-after when all accounts are exhausted.
diff --git a/packages/e2e-tests/tests/tool-prefix.test.ts b/packages/e2e-tests/tests/tool-prefix.test.ts
@@ -47,6 +47,35 @@ describe('OpenCode Anthropic auth e2e', () => {
     }
   }, 90_000)
 
+  it('publishes adaptive Opus 5 effort variants to OpenCode', async () => {
+    harness = await E2EHarness.create()
+    const response = await fetch(`${harness.opencode.url}/provider`)
+    expect(response.status).toBe(200)
+    const providers = (await response.json()) as {
+      all: Array<{
+        id: string
+        models: Record<
+          string,
+          { variants?: Record<string, Record<string, unknown>> }
+        >
+      }>
+    }
+    const opus5 = providers.all.find((provider) => provider.id === 'anthropic')
+      ?.models['claude-opus-5']
+
+    expect(Object.keys(opus5?.variants ?? {})).toEqual([
+      'low',
+      'medium',
+      'high',
+      'xhigh',
+      'max',
+    ])
+    expect(opus5?.variants?.max).toEqual({
+      thinking: { type: 'adaptive', display: 'summarized' },
+      effort: 'max',
+    })
+  }, 90_000)
+
   it('strips mcp_ tool names even when Anthropic SSE chunks split the name field', async () => {
     harness = await E2EHarness.create()
     harness.script([
diff --git a/packages/opencode/README.md b/packages/opencode/README.md
@@ -31,8 +31,8 @@ This repo is a Bun workspace monorepo with two user-facing integrations and one
 - **Persistent Claude cache controls**: manage Anthropic 1-hour prompt caching from `/claude-cache` with explicit, automatic, or hybrid modes.
 - **Cache keepalive**: use `/claude-cachekeep always` or `/claude-cachekeep HH-HH` to pre-warm hybrid cache anchors for active sessions before the 1-hour TTL expires.
 - **Fast mode toggle**: use `/claude-fast on|off` to request Anthropic fast mode for supported Opus models.
-- **Fable/Mythos reasoning visibility**: request summarized adaptive thinking for Claude Fable 5 and Mythos 5 so agents can display reasoning summaries instead of blank signed-thinking blocks.
-- **Fable content-filter recovery**: when Fable ends a session response with Anthropic's `refusal` content-filter reason, transparently retry with Opus 4.8 for 10 successful model responses. After each Opus response, a zero-output Fable prewarm advances the same prompt cache using the OAuth account that served the filtered Fable request. The latest Opus cache boundary is retained so a later refusal can bridge back to Opus even after more than 20 Fable content blocks; the selected OpenCode model remains Fable. The TUI sidebar shows the per-session recovery countdown and return to Fable, while OpenCode Desktop receives ignored `promptAsync` notices for both transitions.
+- **Adaptive reasoning visibility**: request summarized adaptive thinking for Claude Fable 5, Mythos 5, and Opus 5. OpenCode receives native `low`, `medium`, `high`, `xhigh`, and `max` Opus 5 effort variants rather than legacy manual-thinking budgets.
+- **Fable/Opus 5 content-filter recovery**: when Fable or Opus 5 ends a session response with Anthropic's `refusal` content-filter reason, transparently retry that source-model family with Opus 4.8 for 10 successful model responses. Recovery state and pending cache warms remain independent when a session switches between Fable and Opus 5. After each downgraded response, a zero-output prewarm advances the source model's prompt cache using the OAuth account that served the filtered request. The latest Opus cache boundary is retained so a later refusal can bridge back even after more than 20 content blocks. The TUI sidebar and OpenCode Desktop report both transitions while preserving the selected model.
 - **Live quota visibility**: use `/claude-quota` to see main and fallback quota state, reset times, and refresh errors.
 - **Killswitch**: per-account hard-block thresholds that stop requests before hitting Anthropic's rate limits, with synthetic 429 retry-after when all accounts are exhausted.
 - **User-owned Cloudflare relay**: optionally provision your own Worker relay to reduce repeated client upload bytes for large OpenCode or Pi requests.
diff --git a/packages/opencode/src/fable-fallback.ts b/packages/opencode/src/fable-fallback.ts
@@ -13,11 +13,12 @@ export type FableStandbyCacheAnchor = {
   oauthAccountId: string
 }
 
-const MAX_TRACKED_SESSIONS = 128
-const SESSION_TTL_MS = 24 * 60 * 60_000
+const MAX_TRACKED_RECOVERIES = 128
+const RECOVERY_TTL_MS = 24 * 60 * 60_000
 
 export type FableFallbackPlan = {
   sessionId: string
+  recoveryKey: string
   requestedModel: string
   effectiveModel: string
   bodyText: string
@@ -49,13 +50,29 @@ type FableFallbackState = {
  * gate. The single shared fallback id matches Anthropic's default for both
  * source models, so the recovery period is uniform.
  */
-function isRecoverableRefusalModel(model: unknown): model is string {
-  if (typeof model !== 'string') return false
-  if (isClaudeOpus5Model(model)) return true
-  return (
+type RecoverableRefusalFamily = 'fable-5' | 'opus-5'
+
+function recoverableRefusalFamily(
+  model: unknown,
+): RecoverableRefusalFamily | null {
+  if (typeof model !== 'string') return null
+  if (isClaudeOpus5Model(model)) return 'opus-5'
+  if (
     model === CLAUDE_FABLE_5_MODEL_ID ||
     model.startsWith(`${CLAUDE_FABLE_5_MODEL_ID}-`)
-  )
+  ) {
+    return 'fable-5'
+  }
+  return null
+}
+
+function isRecoverableRefusalModel(model: unknown): model is string {
+  return recoverableRefusalFamily(model) !== null
+}
+
+function fallbackRecoveryKey(sessionId: string, model: string) {
+  const family = recoverableRefusalFamily(model)
+  return family ? `${sessionId}\0${family}` : null
 }
 
 function parseBody(bodyText: string) {
@@ -68,21 +85,22 @@ function parseBody(bodyText: string) {
 }
 
 export class FableFallbackManager {
-  private readonly sessions = new Map<string, FableFallbackState>()
+  private readonly recoveries = new Map<string, FableFallbackState>()
   private nextCycle = 1
 
   constructor(private readonly now: () => number = Date.now) {}
 
   private prune() {
     const now = this.now()
-    for (const [sessionId, state] of this.sessions) {
-      if (now - state.updatedAt >= SESSION_TTL_MS)
-        this.sessions.delete(sessionId)
+    for (const [recoveryKey, state] of this.recoveries) {
+      if (now - state.updatedAt >= RECOVERY_TTL_MS) {
+        this.recoveries.delete(recoveryKey)
+      }
     }
-    while (this.sessions.size > MAX_TRACKED_SESSIONS) {
-      const oldest = this.sessions.keys().next().value
+    while (this.recoveries.size > MAX_TRACKED_RECOVERIES) {
+      const oldest = this.recoveries.keys().next().value
       if (typeof oldest !== 'string') break
-      this.sessions.delete(oldest)
+      this.recoveries.delete(oldest)
     }
   }
 
@@ -93,12 +111,15 @@ export class FableFallbackManager {
     if (!sessionId || typeof bodyText !== 'string') return null
     const parsed = parseBody(bodyText)
     if (!parsed || !isRecoverableRefusalModel(parsed.model)) return null
+    const recoveryKey = fallbackRecoveryKey(sessionId, parsed.model)
+    if (!recoveryKey) return null
 
     this.prune()
-    const state = this.sessions.get(sessionId)
+    const state = this.recoveries.get(recoveryKey)
     if (!state || state.remaining <= 0) {
       return {
         sessionId,
+        recoveryKey,
         requestedModel: parsed.model,
         effectiveModel: parsed.model,
         bodyText,
@@ -109,11 +130,12 @@ export class FableFallbackManager {
 
     state.updatedAt = this.now()
     state.nextRequestSequence++
-    this.sessions.delete(sessionId)
-    this.sessions.set(sessionId, state)
+    this.recoveries.delete(recoveryKey)
+    this.recoveries.set(recoveryKey, state)
     parsed.body.model = FABLE_FALLBACK_MODEL_ID
     return {
       sessionId,
+      recoveryKey,
       requestedModel: state.model,
       effectiveModel: FABLE_FALLBACK_MODEL_ID,
       bodyText: JSON.stringify(parsed.body),
@@ -127,15 +149,15 @@ export class FableFallbackManager {
 
   recoveryAccount(plan: FableFallbackPlan) {
     if (plan.cycle === undefined) return plan.cacheAccountId
-    const state = this.sessions.get(plan.sessionId)
+    const state = this.recoveries.get(plan.recoveryKey)
     return state?.cycle === plan.cycle
       ? state.cacheAccountId
       : plan.cacheAccountId
   }
 
   bindRecoveryAccount(plan: FableFallbackPlan, oauthAccountId: string) {
     if (!plan.downgraded || plan.cycle === undefined) return false
-    const state = this.sessions.get(plan.sessionId)
+    const state = this.recoveries.get(plan.recoveryKey)
     if (!state || state.cycle !== plan.cycle) return false
     if (state.cacheAccountId === oauthAccountId) return false
     state.cacheAccountId = oauthAccountId
@@ -149,7 +171,7 @@ export class FableFallbackManager {
 
   activate(plan: FableFallbackPlan, cacheAccountId?: string): number {
     if (plan.downgraded || !isRecoverableRefusalModel(plan.requestedModel)) {
-      return this.remaining(plan.sessionId)
+      return this.remaining(plan)
     }
     const state: FableFallbackState = {
       model: plan.requestedModel,
@@ -161,8 +183,8 @@ export class FableFallbackManager {
       standbyAnchorSequence: 0,
       updatedAt: this.now(),
     }
-    this.sessions.delete(plan.sessionId)
-    this.sessions.set(plan.sessionId, state)
+    this.recoveries.delete(plan.recoveryKey)
+    this.recoveries.set(plan.recoveryKey, state)
     this.prune()
     return state.remaining
   }
@@ -172,10 +194,10 @@ export class FableFallbackManager {
     standbyCacheAnchor?: FableStandbyCacheAnchor,
   ): { counted: boolean; remaining: number } {
     if (!plan.downgraded || plan.cycle == null || plan.completed) {
-      return { counted: false, remaining: this.remaining(plan.sessionId) }
+      return { counted: false, remaining: this.remaining(plan) }
     }
     plan.completed = true
-    const state = this.sessions.get(plan.sessionId)
+    const state = this.recoveries.get(plan.recoveryKey)
     if (!state || state.cycle !== plan.cycle || state.remaining <= 0) {
       return { counted: false, remaining: state?.remaining ?? 0 }
     }
@@ -195,13 +217,13 @@ export class FableFallbackManager {
     // Retain the zero-remaining state so a later refusal can bridge back
     // to this model-specific Opus cache boundary without continuously warming
     // Opus while the original model is healthy.
-    this.sessions.delete(plan.sessionId)
-    this.sessions.set(plan.sessionId, state)
+    this.recoveries.delete(plan.recoveryKey)
+    this.recoveries.set(plan.recoveryKey, state)
     return { counted: true, remaining: state.remaining }
   }
 
-  remaining(sessionId: string): number {
+  remaining(plan: FableFallbackPlan): number {
     this.prune()
-    return this.sessions.get(sessionId)?.remaining ?? 0
+    return this.recoveries.get(plan.recoveryKey)?.remaining ?? 0
   }
 }
diff --git a/packages/opencode/src/index.ts b/packages/opencode/src/index.ts
@@ -708,6 +708,36 @@ function addFableMythos5Models<
   } as T
 }
 
+const CLAUDE_OPUS_5_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'] as const
+
+function createClaudeOpus5Variants() {
+  return Object.fromEntries(
+    CLAUDE_OPUS_5_EFFORTS.map((effort) => [
+      effort,
+      {
+        thinking: { type: 'adaptive', display: 'summarized' },
+        effort,
+      },
+    ]),
+  )
+}
+
+function applyClaudeOpus5Variants<
+  T extends Record<string, AnthropicProviderModel>,
+>(models: T) {
+  return Object.fromEntries(
+    Object.entries(models).map(([id, model]) => {
+      const modelId = model.api?.id ?? model.id ?? id
+      return [
+        id,
+        isClaudeOpus5Model(modelId)
+          ? { ...model, variants: createClaudeOpus5Variants() }
+          : model,
+      ]
+    }),
+  ) as T
+}
+
 function zeroModelCosts<T extends Record<string, AnthropicProviderModel>>(
   models: T,
 ) {
@@ -1165,9 +1195,9 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
     },
   })
 
-  const fableWarmChains = new Map<string, Promise<void>>()
+  const recoveryWarmChains = new Map<string, Promise<void>>()
 
-  function warmFableAfterOpus(context: FableRequestContext) {
+  function warmRecoverySourceAfterOpus(context: FableRequestContext) {
     const sessionId = context.plan.sessionId
     const modelLabel = isClaudeOpus5Model(context.plan.requestedModel)
       ? 'Opus 5'
@@ -1206,7 +1236,7 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
         if (result.ok) {
           logger.debug('fable-fallback', `${modelLabel} cache warmed`, {
             session: sessionId,
-            remaining: fableFallbackManager.remaining(sessionId),
+            remaining: fableFallbackManager.remaining(context.plan),
             ...(result.usage && { usage: result.usage }),
           })
           return
@@ -1224,12 +1254,13 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
       }
     }
 
-    const previous = fableWarmChains.get(sessionId) ?? Promise.resolve()
+    const { recoveryKey } = context.plan
+    const previous = recoveryWarmChains.get(recoveryKey) ?? Promise.resolve()
     const current = previous.then(run, run)
-    fableWarmChains.set(sessionId, current)
+    recoveryWarmChains.set(recoveryKey, current)
     void current.finally(() => {
-      if (fableWarmChains.get(sessionId) === current) {
-        fableWarmChains.delete(sessionId)
+      if (recoveryWarmChains.get(recoveryKey) === current) {
+        recoveryWarmChains.delete(recoveryKey)
       }
     })
     return current
@@ -2401,7 +2432,9 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
         provider: { models: Record<string, AnthropicProviderModel> },
         context: { auth?: { type?: string } },
       ) {
-        const models = addFableMythos5Models(provider.models)
+        const models = applyClaudeOpus5Variants(
+          addFableMythos5Models(provider.models),
+        )
         // Zero OAuth model costs by default (quota-based, not per-token billed).
         // Opt out via persisted config costZeroing.enabled=false to show real costs.
         // initialStorage is nullable (no config file yet) → default to enabled.
@@ -3899,7 +3932,7 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
                 incomingHeaders.get('x-opencode-session')
               let fablePlan = fableFallbackManager.plan(sessionId, init?.body)
               if (fablePlan && !fablePlan.downgraded) {
-                const finalWarm = fableWarmChains.get(fablePlan.sessionId)
+                const finalWarm = recoveryWarmChains.get(fablePlan.recoveryKey)
                 if (finalWarm) {
                   await finalWarm
                   fablePlan = fableFallbackManager.plan(sessionId, init?.body)
@@ -3989,13 +4022,11 @@ export const AnthropicAuthPlugin: Plugin = async (ctx) => {
                             storage,
                             auth,
                           )
-                          const warm = warmFableAfterOpus(fableRequest)
+                          const warm = warmRecoverySourceAfterOpus(fableRequest)
                           if (completed.remaining === 0) {
                             const notifyRestored = () => {
                               if (
-                                fableFallbackManager.remaining(
-                                  fablePlan.sessionId,
-                                ) !== 0
+                                fableFallbackManager.remaining(fablePlan) !== 0
                               )
                                 return
                               publishFableRecoveryNotice(
diff --git a/packages/opencode/src/tests/fable-fallback.test.ts b/packages/opencode/src/tests/fable-fallback.test.ts
@@ -136,7 +136,7 @@ describe('FableFallbackManager', () => {
     manager.activate(manager.plan('session-a', body())!)
     const failed = manager.plan('session-a', body())!
 
-    expect(manager.remaining('session-a')).toBe(10)
+    expect(manager.remaining(failed)).toBe(10)
     expect(manager.complete(failed)).toEqual({ counted: true, remaining: 9 })
     expect(manager.complete(failed)).toEqual({ counted: false, remaining: 9 })
   })
@@ -151,6 +151,38 @@ describe('FableFallbackManager', () => {
     expect(manager.plan(undefined, body())).toBeNull()
   })
 
+  test('tracks Fable and Opus 5 recovery independently in the same session', () => {
+    const manager = new FableFallbackManager()
+    const fable = manager.plan('session-a', body('claude-fable-5'))!
+    manager.activate(fable, 'fable-account')
+
+    const healthyOpus = manager.plan('session-a', body('claude-opus-5'))!
+    expect(healthyOpus).toMatchObject({
+      requestedModel: 'claude-opus-5',
+      effectiveModel: 'claude-opus-5',
+      downgraded: false,
+    })
+    expect(JSON.parse(healthyOpus.bodyText).model).toBe('claude-opus-5')
+
+    manager.activate(healthyOpus, 'opus-account')
+    const downgradedFable = manager.plan('session-a', body('claude-fable-5'))!
+    const downgradedOpus = manager.plan('session-a', body('claude-opus-5'))!
+
+    expect(downgradedFable).toMatchObject({
+      requestedModel: 'claude-fable-5',
+      effectiveModel: FABLE_FALLBACK_MODEL_ID,
+      cacheAccountId: 'fable-account',
+      downgraded: true,
+    })
+    expect(downgradedOpus).toMatchObject({
+      requestedModel: 'claude-opus-5',
+      effectiveModel: FABLE_FALLBACK_MODEL_ID,
+      cacheAccountId: 'opus-account',
+      downgraded: true,
+    })
+    expect(downgradedFable.cycle).not.toBe(downgradedOpus.cycle)
+  })
+
   test('a new filter cycle does not let an older Opus response decrement it', () => {
     const manager = new FableFallbackManager()
     const initial = manager.plan('session-a', body())!
diff --git a/packages/opencode/src/tests/index.test.ts b/packages/opencode/src/tests/index.test.ts
