mixdog 0.9.147 → 0.9.149

package/src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs

@@ -24,7 +24,7 @@ import {
     resolveAnthropicModelAfter404,
     ensureLatestAnthropicModel,
 } from './anthropic-model-resolve.mjs';
-import { sanitizeToolPairs, sanitizeAnthropicContentPairs, foldUserTextIntoToolResultTail } from '../session/context-utils.mjs';
+import { sanitizeToolPairs } from '../session/context-utils.mjs';
 import {
     TOKEN_REFRESH_SKEW_MS,
     isAnthropicOAuthRefreshDisabled,
@@ -51,8 +51,9 @@ import {
     AnthropicFallbackTriggeredError,
     anthropicRequestTimeoutMs,
     classifyError,
+    markProviderRecoveryExhausted,
     anthropicMaxAttempts,
-    createStallRetryBudget,
+    resolveStallRetryBudget,
     midstreamBackoffFor,
     retryAfterMsFromError,
     STREAM_STALL_RETRY_BUDGET_MS,
@@ -66,6 +67,8 @@ import {
     stampAnthropicStreamOutcome,
 } from './anthropic-sse.mjs';
 import { buildAnthropicBetaHeaders, supportsAnthropicFastMode } from './anthropic-betas.mjs';
+import { applyAnthropicServerFallback } from './anthropic-server-fallback.mjs';
+import { fastModeAvailable, noteFastModeCapacityError } from './anthropic-fast-mode.mjs';
 import { gzipSync } from 'node:zlib';
 
 // Request-body gzip gate (see the fetch site below). Env kill-switch
@@ -84,7 +87,6 @@ import {
     shouldIncludeEffortBeta,
 } from './anthropic-effort.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
-import { normalizeContentForAnthropic } from './media-normalization.mjs';
 import { notifyCurrentAnthropicRateLimit } from './admission-scheduler.mjs';
 import {
     ANTHROPIC_CACHE_TTL_STABLE as CACHE_TTL_STABLE,
@@ -95,7 +97,9 @@ import {
     requestAnthropicTools as sharedRequestAnthropicTools,
     normalizeAnthropicNonStreamingResponse,
     resolveAnthropicCacheTtls as resolveCacheTtls,
+    resolveAnthropicMessageCacheSlots,
     sanitizeAnthropicInputSchema,
+    toAnthropicMessages,
     toAnthropicToolChoice,
 } from './lib/anthropic-request-utils.mjs';
 
@@ -258,92 +262,6 @@ function requestAnthropicTools(tools, messages, opts) {
     return sharedRequestAnthropicTools(tools, messages, opts, 'anthropic-oauth');
 }
 
-function toAnthropicMessages(messages) {
-    // Marker-free lowering. cache_control is applied AFTER sanitization by
-    // applyAnthropicCacheMarkers() so that block drops/inserts/reorders
-    // performed by sanitizeAnthropicContentPairs cannot move or delete a
-    // marked block (the root cause of the sporadic COLD-turn cache miss:
-    // pre-sanitize markers landed on blocks the sanitizer then rewrote, so
-    // the provider-visible breakpoint diverged from the cached one).
-    const result = [];
-    for (let idx = 0; idx < messages.length; idx++) {
-        const m = messages[idx];
-        if (m.role === 'system') continue;
-
-        if (m.role === 'assistant' && (m.toolCalls?.length || m.assistantBlocks?.length || m.thinkingBlocks?.length)) {
-            let content;
-            if (m.assistantBlocks?.length) {
-                content = m.assistantBlocks.slice();
-            } else {
-                content = [];
-                // Adaptive-thinking round-trip: prior-turn thinking blocks are
-                // REQUIRED back, unmodified (signature intact; empty thinking
-                // field allowed), and MUST precede tool_use blocks. Emit them
-                // first, verbatim as received from the SSE parser.
-                if (Array.isArray(m.thinkingBlocks)) {
-                    for (const tb of m.thinkingBlocks) {
-                        if (tb && typeof tb === 'object') content.push(tb);
-                    }
-                }
-                if (m.content) content.push({ type: 'text', text: m.content });
-                for (const tc of m.toolCalls || []) {
-                    content.push({
-                        type: 'tool_use',
-                        id: tc.id,
-                        name: tc.name,
-                        input: tc.arguments,
-                    });
-                }
-            }
-            result.push({ role: 'assistant', content });
-            continue;
-        }
-
-        if (m.role === 'tool') {
-            const last = result[result.length - 1];
-            const native = m.nativeToolSearch;
-            const nativeProvider = String(native?.provider || '').toLowerCase();
-            const anthropicNative = new Set(['anthropic', 'anthropic-oauth']);
-            const references = (!nativeProvider || anthropicNative.has(nativeProvider))
-                && Array.isArray(native?.toolReferences)
-                ? native.toolReferences.map((name) => String(name || '').trim()).filter(Boolean)
-                : [];
-            const block = {
-                type: 'tool_result',
-                tool_use_id: m.toolCallId || '',
-                content: references.length
-                    ? references.map((tool_name) => ({ type: 'tool_reference', tool_name }))
-                    : normalizeContentForAnthropic(m.content),
-                ...((m.toolKind === 'error' || m.isError === true) ? { is_error: true } : {}),
-            };
-            if (last?.role === 'user' && Array.isArray(last.content)) {
-                last.content.push(block);
-            } else {
-                result.push({ role: 'user', content: [block] });
-            }
-            continue;
-        }
-
-        // First-party client parity: fold a user text turn that directly follows a
-        // tool_result turn into that tool_result's content. A sibling text
-        // turn after tool_result renders as `</function_results>\n\nHuman:`
-        // on the wire and trains the model toward 3-token empty end_turn
-        // completions (see foldUserTextIntoToolResultTail).
-        //   EXCEPTION: steering-origin user messages (human/TUI interjections)
-        //   must keep their own user turn so their provenance survives — folding
-        //   them into the preceding tool_result would disguise user input as
-        //   tool output. Anthropic accepts a user text message after a
-        //   tool_result message, so the distinct turn stays request-valid.
-        const isSteering = m.role === 'user' && m.meta?.source === 'steering';
-        if (m.role === 'user' && !isSteering
-            && foldUserTextIntoToolResultTail(result, normalizeContentForAnthropic(m.content))) {
-            continue;
-        }
-        result.push({ role: m.role, content: normalizeContentForAnthropic(m.content) });
-    }
-    return sanitizeAnthropicContentPairs(result);
-}
-
 // Applies cache_control markers to the FINAL, already-sanitized Anthropic
 // message array — by INVARIANT, never by pre-sanitize index. Because
 // sanitizeAnthropicContentPairs has already run (and must NOT run again
@@ -375,32 +293,16 @@ function buildRequestBody(messages, model, tools, sendOpts) {
     // sessionMarker (cacheTier:'tier3') at ttls.tier3.
     const systemBlocks = buildSystemBlocks(systemMsgs, model, ttls?.system, ttls?.tier3);
 
-    // 4-BP budget layout. tools BP is dropped — system BP covers the
-    // tools prefix via Anthropic's prompt cache prefix semantics
-    // (order: tools → system → messages). That frees slots for the
-    // messages-tail. The system blocks now hold BP1/BP2/BP3 (tier3), so the
-    // tier3 breakpoint is accounted for inside systemBpUsed.
-    const systemBpUsed = systemBlocks.filter(b => b.cache_control).length;
-    const toolsBpUsed = 0;
-    const usedSlots = toolsBpUsed + systemBpUsed;
-    // Env override for BP strategy. ANTHROPIC_MSG_SLOTS=0 disables message
-    // caching entirely. Any value >=1 first marks the previous user text turn
-    // so consecutive requests share a breakpoint; a second free slot marks the
-    // tail for the newest delta.
-    const msgSlotsCap = Number.parseInt(process.env.ANTHROPIC_MSG_SLOTS, 10);
-    const defaultMsgSlots = Math.max(0, 4 - usedSlots);
-    const msgSlots = ttls.messages
-        ? (Number.isFinite(msgSlotsCap) && msgSlotsCap >= 0 ? Math.min(msgSlotsCap, defaultMsgSlots) : defaultMsgSlots)
-        : 0;
+    // Message-tail cache budget (4-BP layout + ANTHROPIC_MSG_SLOTS) is shared
+    // with anthropic.mjs — see resolveAnthropicMessageCacheSlots.
+    const messageCacheSlots = resolveAnthropicMessageCacheSlots(systemBlocks, ttls);
     // Build → sanitize (once, inside toAnthropicMessages) → mark. Markers are
     // applied to the FINAL sanitized array by invariant, so block drops /
     // inserts / reorders performed by the sanitizer can never move or delete a
     // marked block. NEVER sanitize again after this (see send path).
-    // msgSlots === 0 (ANTHROPIC_MSG_SLOTS=0, or no free slot) → tail disabled.
-    const tailTtl = msgSlots > 0 ? ttls.messages : null;
     const anthropicMessages = applyAnthropicCacheMarkers(
         toAnthropicMessages(chatMsgs),
-        { messageTtl: tailTtl, messageSlots: msgSlots },
+        messageCacheSlots,
     );
 
     const body = {
@@ -409,6 +311,9 @@ function buildRequestBody(messages, model, tools, sendOpts) {
         messages: anthropicMessages,
         stream: true,
     };
+    applyAnthropicServerFallback(body, model, {
+        enabled: opts.serverFallback !== false,
+    });
 
     if (systemBlocks.length) body.system = systemBlocks;
 
@@ -436,7 +341,9 @@ function buildRequestBody(messages, model, tools, sendOpts) {
         logTag: 'anthropic-oauth',
     });
 
-    if (opts.fast === true && supportsAnthropicFastMode(model)) {
+    // Skipped while the fast capacity pool is in cooldown (or permanently
+    // unavailable) so a drained pool is not re-probed every turn.
+    if (opts.fast === true && supportsAnthropicFastMode(model) && fastModeAvailable()) {
         body.speed = 'fast';
     }
 
@@ -691,6 +598,7 @@ export class AnthropicOAuthProvider {
                             fastMode: this.fastModeBetaHeaderLatched,
                             toolSearch: hasDeferredTools,
                             effort: shouldIncludeEffortBeta(useModel, opts),
+                            serverFallback: body.fallbacks === 'default',
                         }),
                         'anthropic-dangerous-direct-browser-access': 'true',
                         'user-agent': `claude-cli/${resolveCliVersion()} (external, sdk-cli)`,
@@ -761,6 +669,12 @@ export class AnthropicOAuthProvider {
                     try { result.controller?.abort?.(); } catch {}
                     // Initial-response failure: nothing was sampled, so the
                     // typed retry rules upstream own the decision.
+                    // Subscription 429s never retry in-loop, so the cooldown is
+                    // what keeps the NEXT turn off the drained fast pool.
+                    noteFastModeCapacityError(
+                        { httpStatus: status, headers: result?.response?.headers },
+                        { fast: requestBody?.speed === 'fast' },
+                    );
                     throw Object.assign(
                         anthropicQuotaError(status, result?.response?.headers, this.scrubTokens(quotaText)),
                         { initialResponseError: true },
@@ -800,6 +714,12 @@ export class AnthropicOAuthProvider {
             onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
                 const status = Number(lastErr?.httpStatus || lastErr?.status || lastErr?.response?.status || 0) || null;
                 if (status === 429) notifyCurrentAnthropicRateLimit(lastErr);
+                // Fast capacity exhausted: drop `speed` so the replay runs at
+                // standard speed instead of re-hitting the drained pool.
+                if (requestBody?.speed === 'fast'
+                    && noteFastModeCapacityError(lastErr, { fast: true }) !== 'retry-fast') {
+                    delete requestBody.speed;
+                }
                 const reason = status || lastErr?.code || lastErr?.message || 'network error';
                 const suffix = delayReason ? ` (${delayReason})` : '';
                 try {
@@ -814,9 +734,21 @@ export class AnthropicOAuthProvider {
         const MAX_MIDSTREAM_RETRIES = ANTHROPIC_MAX_MIDSTREAM_RETRIES;
         let firstAttemptError = null;
         let firstAttemptClassifier = null;
-        // Send-scoped stall window: in-place stall retries share one wall
-        // clock starting at the first stall (see createStallRetryBudget).
-        const stallRetryBudget = createStallRetryBudget();
+        // Shared logical-send window: provider fallback and loop replay consume
+        // the same recovery budget.
+        const stallRetryBudget = resolveStallRetryBudget(opts);
+        const requireTransportRecoveryBudget = (error, controller) => {
+            if (stallRetryBudget.allowStallRetry()) return;
+            try {
+                process.stderr.write(
+                    `[anthropic-oauth] transport recovery budget exhausted (${STREAM_STALL_RETRY_BUDGET_MS}ms since first failure)\n`,
+                );
+            } catch {}
+            try { controller?.abort?.(error); } catch {}
+            throw markProviderRecoveryExhausted(error, {
+                owner: 'anthropic-oauth-transport-budget',
+            });
+        };
 
         // Core non-streaming re-issue: abort the dead stream and repeat the
         // SAME request with stream:false. Shared by the exposed-text recovery
@@ -882,10 +814,13 @@ export class AnthropicOAuthProvider {
                 const message = await fallback.response.json();
                 return normalizeAnthropicNonStreamingResponse(message, useModel);
             } catch (err) {
-                if (lifetime.signal.aborted && lifetime.signal.reason instanceof Error) {
-                    throw lifetime.signal.reason;
-                }
-                throw err;
+                const failure = lifetime.signal.aborted && lifetime.signal.reason instanceof Error
+                    ? lifetime.signal.reason
+                    : err;
+                if (failure instanceof AnthropicFallbackTriggeredError || totalSignal?.aborted) throw failure;
+                throw markProviderRecoveryExhausted(failure, {
+                    owner: 'anthropic-oauth-nonstreaming-fallback',
+                });
             } finally {
                 releaseFallback('Anthropic non-streaming fallback complete');
                 lifetime.cleanup();
@@ -910,6 +845,7 @@ export class AnthropicOAuthProvider {
                 try { streamingError.liveTextEmitted = true; streamingError.unsafeToRetry = true; } catch {}
                 throw streamingError;
             }
+            requireTransportRecoveryBudget(streamingError, controller);
             return issueNonStreamingFallback(controller, streamingError);
         };
 
@@ -1162,13 +1098,12 @@ export class AnthropicOAuthProvider {
                     && !midState.emittedToolCall
                     && !midState.partialToolCall
                     && !midState.emittedThinking) {
+                    requireTransportRecoveryBudget(err, controller);
                     try { process.stderr.write('[anthropic-oauth] stream stalled with no exposure — retrying non-streaming\n'); } catch {}
                     return await issueNonStreamingFallback(controller, err);
                 }
-                if (classifier === 'stream_stalled' && !stallRetryBudget.allowStallRetry()) {
-                    try { process.stderr.write(`[anthropic-oauth] stall retry budget exhausted (${STREAM_STALL_RETRY_BUDGET_MS}ms since first stall) — surfacing for fresh-request retry\n`); } catch {}
-                    try { controller?.abort?.(err); } catch { /* best-effort teardown */ }
-                    throw err;
+                if (classifier === 'stream_stalled') {
+                    requireTransportRecoveryBudget(err, controller);
                 }
                 if (classifier && attemptIndex < MAX_MIDSTREAM_RETRIES) {
                     firstAttemptError = err;
@@ -1195,6 +1130,12 @@ export class AnthropicOAuthProvider {
                     );
                     continue;
                 }
+                if (classifier && attemptIndex >= MAX_MIDSTREAM_RETRIES) {
+                    markProviderRecoveryExhausted(err, {
+                        owner: 'anthropic-oauth-midstream',
+                        attempts: attemptIndex + 1,
+                    });
+                }
                 if (attemptIndex > 0 && firstAttemptError) {
                     try { err.midstreamRetries = attemptIndex; } catch {}
                     try { err.midstreamClassifier = firstAttemptClassifier; } catch {}

package/src/runtime/agent/orchestrator/providers/anthropic-server-fallback.mjs

@@ -0,0 +1,48 @@
+function normalizedModelId(value) {
+    const raw = typeof value === 'string'
+        ? value
+        : value && typeof value === 'object'
+            ? value.model
+            : '';
+    return typeof raw === 'string' ? raw.trim() : '';
+}
+
+export function supportsAnthropicServerFallback(model) {
+    const id = normalizedModelId(model).toLowerCase().replace(/\./g, '-');
+    return /^claude-(?:opus|fable)-5(?:$|[-@])/.test(id);
+}
+
+export function applyAnthropicServerFallback(body, model, { enabled = true } = {}) {
+    if (!body || typeof body !== 'object' || !enabled || !supportsAnthropicServerFallback(model)) {
+        return false;
+    }
+    body.fallbacks = 'default';
+    return true;
+}
+
+export function parseAnthropicFallbackBlock(block) {
+    if (!block || typeof block !== 'object' || block.type !== 'fallback') return null;
+    const originalModel = normalizedModelId(block.from);
+    const fallbackModel = normalizedModelId(block.to);
+    if (!originalModel || !fallbackModel) return null;
+    const trigger = block.trigger && typeof block.trigger === 'object'
+        ? block.trigger
+        : null;
+    const triggerType = typeof trigger?.type === 'string' && trigger.type.trim()
+        ? trigger.type.trim()
+        : 'refusal';
+    const category = typeof trigger?.category === 'string' && trigger.category.trim()
+        ? trigger.category.trim()
+        : null;
+    return {
+        trigger: triggerType,
+        originalModel,
+        fallbackModel,
+        ...(category ? { category } : {}),
+    };
+}
+
+export function anthropicFallbackProviderMetadata(events) {
+    const fallbacks = Array.isArray(events) ? events.filter(Boolean) : [];
+    return fallbacks.length ? { anthropicFallbacks: fallbacks } : undefined;
+}

package/src/runtime/agent/orchestrator/providers/anthropic-server-fallback.test.mjs

@@ -0,0 +1,215 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+    SERVER_SIDE_FALLBACK_BETA_HEADER,
+    buildAnthropicBetaHeaders,
+} from './anthropic-betas.mjs';
+import { _buildRequestBodyForCacheSmoke } from './anthropic-oauth.mjs';
+import {
+    applyAnthropicServerFallback,
+    parseAnthropicFallbackBlock,
+    supportsAnthropicServerFallback,
+} from './anthropic-server-fallback.mjs';
+import { parseSSEStream } from './anthropic-sse.mjs';
+import { normalizeAnthropicNonStreamingResponse } from './lib/anthropic-request-utils.mjs';
+import { agentLoop } from '../session/agent-loop.mjs';
+
+const fallbackBlock = {
+    type: 'fallback',
+    from: { model: 'claude-opus-5' },
+    to: { model: 'claude-opus-4-8' },
+    trigger: { type: 'refusal', category: 'cyber' },
+};
+
+test('server fallback defaults only eligible Anthropic model families', () => {
+    assert.equal(supportsAnthropicServerFallback('claude-opus-5'), true);
+    assert.equal(supportsAnthropicServerFallback('claude-fable-5-20260801'), true);
+    assert.equal(supportsAnthropicServerFallback('claude-opus-4-8'), false);
+
+    const body = {};
+    assert.equal(applyAnthropicServerFallback(body, 'claude-opus-5'), true);
+    assert.equal(body.fallbacks, 'default');
+
+    const disabled = {};
+    assert.equal(
+        applyAnthropicServerFallback(disabled, 'claude-opus-5', { enabled: false }),
+        false,
+    );
+    assert.equal('fallbacks' in disabled, false);
+});
+
+test('server fallback beta header is request-gated and deduplicated', () => {
+    assert.equal(
+        buildAnthropicBetaHeaders({ base: '', serverFallback: false }).includes(SERVER_SIDE_FALLBACK_BETA_HEADER),
+        false,
+    );
+    const headers = buildAnthropicBetaHeaders({
+        base: SERVER_SIDE_FALLBACK_BETA_HEADER,
+        serverFallback: true,
+    }).split(',');
+    assert.equal(headers.filter((item) => item === SERVER_SIDE_FALLBACK_BETA_HEADER).length, 1);
+});
+
+test('OAuth request body opts eligible models into Anthropic default fallback', () => {
+    const opus5 = _buildRequestBodyForCacheSmoke([], 'claude-opus-5');
+    assert.equal(opus5.fallbacks, 'default');
+
+    const opus48 = _buildRequestBodyForCacheSmoke([], 'claude-opus-4-8');
+    assert.equal('fallbacks' in opus48, false);
+
+    const disabled = _buildRequestBodyForCacheSmoke(
+        [],
+        'claude-opus-5',
+        [],
+        { serverFallback: false },
+    );
+    assert.equal('fallbacks' in disabled, false);
+});
+
+test('fallback block parser uses structured model and refusal category fields', () => {
+    assert.deepEqual(parseAnthropicFallbackBlock(fallbackBlock), {
+        trigger: 'refusal',
+        originalModel: 'claude-opus-5',
+        fallbackModel: 'claude-opus-4-8',
+        category: 'cyber',
+    });
+    assert.equal(parseAnthropicFallbackBlock({ type: 'text', text: 'fallback' }), null);
+});
+
+const encoder = new TextEncoder();
+function sseResponse(events) {
+    const chunks = events.map((event) => (
+        encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`)
+    ));
+    let index = 0;
+    return {
+        body: {
+            getReader() {
+                return {
+                    read() {
+                        if (index < chunks.length) {
+                            return Promise.resolve({ done: false, value: chunks[index++] });
+                        }
+                        return Promise.resolve({ done: true, value: undefined });
+                    },
+                    cancel() { return Promise.resolve(); },
+                    releaseLock() {},
+                };
+            },
+        },
+    };
+}
+
+test('SSE parser records server fallback and attributes the turn to the serving model', async () => {
+    const state = {
+        attemptIndex: 0,
+        sawMessageStart: false,
+        sawCompleted: false,
+        emittedToolCall: false,
+        partialToolCall: false,
+        emittedThinking: false,
+        emittedText: false,
+    };
+    const result = await parseSSEStream(
+        sseResponse([
+            {
+                type: 'message_start',
+                message: {
+                    model: 'claude-opus-5',
+                    usage: { input_tokens: 10 },
+                },
+            },
+            { type: 'content_block_start', index: 0, content_block: fallbackBlock },
+            { type: 'content_block_stop', index: 0 },
+            { type: 'content_block_start', index: 1, content_block: { type: 'text', text: '' } },
+            { type: 'content_block_delta', index: 1, delta: { type: 'text_delta', text: 'done' } },
+            { type: 'content_block_stop', index: 1 },
+            {
+                type: 'message_delta',
+                delta: { stop_reason: 'end_turn' },
+                usage: { output_tokens: 2 },
+            },
+            { type: 'message_stop' },
+        ]),
+        null,
+        () => {},
+        () => {},
+        () => {},
+        state,
+        () => {},
+    );
+
+    assert.equal(result.content, 'done');
+    assert.equal(result.model, 'claude-opus-4-8');
+    assert.equal(result.stopReason, 'end_turn');
+    assert.equal(result.contentBlockTypes.includes('fallback'), true);
+    assert.deepEqual(result.providerMetadata, {
+        anthropicFallbacks: [{
+            trigger: 'refusal',
+            originalModel: 'claude-opus-5',
+            fallbackModel: 'claude-opus-4-8',
+            category: 'cyber',
+        }],
+    });
+});
+
+test('agent loop reports the actual serving model in per-request usage deltas', async () => {
+    const deltas = [];
+    const provider = {
+        name: 'anthropic-oauth',
+        async send() {
+            return {
+                content: 'done',
+                model: 'claude-opus-4-8',
+                stopReason: 'end_turn',
+                usage: {
+                    inputTokens: 1,
+                    outputTokens: 2,
+                    cachedTokens: 3,
+                    cacheWriteTokens: 4,
+                    promptTokens: 8,
+                },
+            };
+        },
+    };
+
+    const result = await agentLoop(
+        provider,
+        [{ role: 'user', content: 'test' }],
+        'claude-opus-5',
+        [],
+        async () => {},
+        process.cwd(),
+        {
+            sessionId: 'server-fallback-usage-test',
+            onUsageDelta: (delta) => deltas.push(delta),
+        },
+    );
+
+    assert.equal(result.model, 'claude-opus-4-8');
+    assert.equal(deltas.length, 1);
+    assert.equal(deltas[0].requestedModel, 'claude-opus-5');
+    assert.equal(deltas[0].model, 'claude-opus-4-8');
+});
+
+test('non-streaming normalizer excludes fallback blocks and preserves metadata', () => {
+    const result = normalizeAnthropicNonStreamingResponse({
+        model: 'claude-opus-5',
+        content: [
+            fallbackBlock,
+            { type: 'text', text: 'done' },
+        ],
+        stop_reason: 'end_turn',
+        usage: { input_tokens: 10, output_tokens: 2 },
+    });
+
+    assert.equal(result.content, 'done');
+    assert.equal(result.model, 'claude-opus-4-8');
+    assert.deepEqual(result.providerMetadata?.anthropicFallbacks, [{
+        trigger: 'refusal',
+        originalModel: 'claude-opus-5',
+        fallbackModel: 'claude-opus-4-8',
+        category: 'cyber',
+    }]);
+});