thaddeus 1.0.18 → 1.0.27

package/src/services/api/claude.js

@@ -0,0 +1,2466 @@
+import { randomUUID } from 'crypto';
+import { getAPIProvider, isFirstPartyAnthropicBaseUrl, } from 'src/utils/model/providers.js';
+import { getAttributionHeader, getCLISyspromptPrefix, } from '../../constants/system.js';
+import { getEmptyToolPermissionContext, toolMatchesName, } from '../../Tool.js';
+import { isConnectorTextBlock, } from '../../types/connectorText.js';
+import { logAPIPrefix, splitSysPromptPrefix, toolToAPISchema, } from '../../utils/api.js';
+import { getOauthAccountInfo } from '../../utils/auth.js';
+import { getBedrockExtraBodyParamsBetas, getMergedBetas, getModelBetas, } from '../../utils/betas.js';
+import { getOrCreateUserID } from '../../utils/config.js';
+import { CAPPED_DEFAULT_MAX_TOKENS, getModelMaxOutputTokens, getSonnet1mExpTreatmentEnabled, } from '../../utils/context.js';
+import { resolveAppliedEffort } from '../../utils/effort.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+import { errorMessage } from '../../utils/errors.js';
+import { computeFingerprintFromMessages } from '../../utils/fingerprint.js';
+import { captureAPIRequest, logError } from '../../utils/log.js';
+import { createAssistantAPIErrorMessage, createUserMessage, ensureToolResultPairing, normalizeContentFromAPI, normalizeMessagesForAPI, stripAdvisorBlocks, stripCallerFieldFromAssistantMessage, stripToolReferenceBlocksFromUserMessage, } from '../../utils/messages.js';
+import { getDefaultOpusModel, getDefaultSonnetModel, getSmallFastModel, isNonCustomOpusModel, } from '../../utils/model/model.js';
+import { asSystemPrompt, } from '../../utils/systemPromptType.js';
+import { tokenCountFromLastAPIResponse } from '../../utils/tokens.js';
+import { getDynamicConfig_BLOCKS_ON_INIT } from '../analytics/growthbook.js';
+import { currentLimits, extractQuotaStatusFromError, extractQuotaStatusFromHeaders, } from '../claudeAiLimits.js';
+import { getAPIContextManagement } from '../compact/apiMicrocompact.js';
+/* eslint-disable @typescript-eslint/no-require-imports */
+const autoModeStateModule = feature('TRANSCRIPT_CLASSIFIER')
+    ? require('../../utils/permissions/autoModeState.js')
+    : null;
+import { feature } from 'bun:bundle';
+import { APIConnectionTimeoutError, APIError, APIUserAbortError, } from '@anthropic-ai/sdk/error';
+import { getAfkModeHeaderLatched, getCacheEditingHeaderLatched, getFastModeHeaderLatched, getLastApiCompletionTimestamp, getPromptCache1hAllowlist, getPromptCache1hEligible, getSessionId, getThinkingClearLatched, setAfkModeHeaderLatched, setCacheEditingHeaderLatched, setFastModeHeaderLatched, setLastMainRequestId, setPromptCache1hAllowlist, setPromptCache1hEligible, setThinkingClearLatched, } from 'src/bootstrap/state.js';
+import { AFK_MODE_BETA_HEADER, CONTEXT_1M_BETA_HEADER, CONTEXT_MANAGEMENT_BETA_HEADER, EFFORT_BETA_HEADER, FAST_MODE_BETA_HEADER, PROMPT_CACHING_SCOPE_BETA_HEADER, REDACT_THINKING_BETA_HEADER, STRUCTURED_OUTPUTS_BETA_HEADER, TASK_BUDGETS_BETA_HEADER, } from 'src/constants/betas.js';
+import { addToTotalSessionCost } from 'src/cost-tracker.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js';
+import { ADVISOR_TOOL_INSTRUCTIONS, getExperimentAdvisorModels, isAdvisorEnabled, isValidAdvisorModel, modelSupportsAdvisor, } from 'src/utils/advisor.js';
+import { getAgentContext } from 'src/utils/agentContext.js';
+import { isClaudeAISubscriber } from 'src/utils/auth.js';
+import { getToolSearchBetaHeader, modelSupportsStructuredOutputs, shouldIncludeFirstPartyOnlyBetas, shouldUseGlobalCacheScope, } from 'src/utils/betas.js';
+import { CLAUDE_IN_CHROME_MCP_SERVER_NAME } from 'src/utils/claudeInChrome/common.js';
+import { CHROME_TOOL_SEARCH_INSTRUCTIONS } from 'src/utils/claudeInChrome/prompt.js';
+import { getMaxThinkingTokensForModel } from 'src/utils/context.js';
+import { logForDebugging } from 'src/utils/debug.js';
+import { logForDiagnosticsNoPII } from 'src/utils/diagLogs.js';
+import { modelSupportsEffort } from 'src/utils/effort.js';
+import { isFastModeAvailable, isFastModeCooldown, isFastModeEnabled, isFastModeSupportedByModel, } from 'src/utils/fastMode.js';
+import { returnValue } from 'src/utils/generators.js';
+import { headlessProfilerCheckpoint } from 'src/utils/headlessProfiler.js';
+import { isMcpInstructionsDeltaEnabled } from 'src/utils/mcpInstructionsDelta.js';
+import { calculateUSDCost } from 'src/utils/modelCost.js';
+import { endQueryProfile, queryCheckpoint } from 'src/utils/queryProfiler.js';
+import { modelSupportsAdaptiveThinking, modelSupportsThinking, } from 'src/utils/thinking.js';
+import { extractDiscoveredToolNames, isDeferredToolsDeltaEnabled, isToolSearchEnabled, } from 'src/utils/toolSearch.js';
+import { API_MAX_MEDIA_PER_REQUEST } from '../../constants/apiLimits.js';
+import { ADVISOR_BETA_HEADER } from '../../constants/betas.js';
+import { formatDeferredToolLine, isDeferredTool, TOOL_SEARCH_TOOL_NAME, } from '../../tools/ToolSearchTool/prompt.js';
+import { count } from '../../utils/array.js';
+import { insertBlockAfterToolResults } from '../../utils/contentArray.js';
+import { validateBoundedIntEnvVar } from '../../utils/envValidation.js';
+import { safeParseJSON } from '../../utils/json.js';
+import { getInferenceProfileBackingModel } from '../../utils/model/bedrock.js';
+import { normalizeModelStringForAPI, parseUserSpecifiedModel, } from '../../utils/model/model.js';
+import { startSessionActivity, stopSessionActivity, } from '../../utils/sessionActivity.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+import { isBetaTracingEnabled, startLLMRequestSpan, } from '../../utils/telemetry/sessionTracing.js';
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { logEvent, } from '../analytics/index.js';
+import { consumePendingCacheEdits, getPinnedCacheEdits, markToolsSentToAPIState, pinCacheEdits, } from '../compact/microCompact.js';
+import { getInitializationStatus } from '../lsp/manager.js';
+import { isToolFromMcpServer } from '../mcp/utils.js';
+import { withStreamingVCR, withVCR } from '../vcr.js';
+import { CLIENT_REQUEST_ID_HEADER, getAnthropicClient } from './client.js';
+import { API_ERROR_MESSAGE_PREFIX, CUSTOM_OFF_SWITCH_MESSAGE, getAssistantMessageFromError, getErrorMessageIfRefusal, } from './errors.js';
+import { EMPTY_USAGE, logAPIError, logAPIQuery, logAPISuccessAndDuration, } from './logging.js';
+import { CACHE_TTL_1HOUR_MS, checkResponseForCacheBreak, recordPromptState, } from './promptCacheBreakDetection.js';
+import { CannotRetryError, FallbackTriggeredError, is529Error, withRetry, } from './withRetry.js';
+/**
+ * Assemble the extra body parameters for the API request, based on the
+ * THADDEUS_EXTRA_BODY environment variable if present and on any beta
+ * headers (primarily for Bedrock requests).
+ *
+ * @param betaHeaders - An array of beta headers to include in the request.
+ * @returns A JSON object representing the extra body parameters.
+ */
+export function getExtraBodyParams(betaHeaders) {
+    // Parse user's extra body parameters first
+    const extraBodyStr = process.env.THADDEUS_EXTRA_BODY;
+    let result = {};
+    if (extraBodyStr) {
+        try {
+            // Parse as JSON, which can be null, boolean, number, string, array or object
+            const parsed = safeParseJSON(extraBodyStr);
+            // We expect an object with key-value pairs to spread into API parameters
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                // Shallow clone — safeParseJSON is LRU-cached and returns the same
+                // object reference for the same string. Mutating `result` below
+                // would poison the cache, causing stale values to persist.
+                result = { ...parsed };
+            }
+            else {
+                logForDebugging(`THADDEUS_EXTRA_BODY env var must be a JSON object, but was given ${extraBodyStr}`, { level: 'error' });
+            }
+        }
+        catch (error) {
+            logForDebugging(`Error parsing THADDEUS_EXTRA_BODY: ${errorMessage(error)}`, { level: 'error' });
+        }
+    }
+    // Anti-distillation: send fake_tools opt-in for 1P CLI only
+    if (feature('ANTI_DISTILLATION_CC')
+        ? process.env.THADDEUS_ENTRYPOINT === 'cli' &&
+            shouldIncludeFirstPartyOnlyBetas() &&
+            getFeatureValue_CACHED_MAY_BE_STALE('thaddeus_anti_distill_fake_tool_injection', false)
+        : false) {
+        result.anti_distillation = ['fake_tools'];
+    }
+    // Handle beta headers if provided
+    if (betaHeaders && betaHeaders.length > 0) {
+        if (result.anthropic_beta && Array.isArray(result.anthropic_beta)) {
+            // Add to existing array, avoiding duplicates
+            const existingHeaders = result.anthropic_beta;
+            const newHeaders = betaHeaders.filter(header => !existingHeaders.includes(header));
+            result.anthropic_beta = [...existingHeaders, ...newHeaders];
+        }
+        else {
+            // Create new array with the beta headers
+            result.anthropic_beta = betaHeaders;
+        }
+    }
+    return result;
+}
+export function getPromptCachingEnabled(model) {
+    // Global disable takes precedence
+    if (isEnvTruthy(process.env.DISABLE_PROMPT_CACHING))
+        return false;
+    // Check if we should disable for small/fast model
+    if (isEnvTruthy(process.env.DISABLE_PROMPT_CACHING_HAIKU)) {
+        const smallFastModel = getSmallFastModel();
+        if (model === smallFastModel)
+            return false;
+    }
+    // Check if we should disable for default Sonnet
+    if (isEnvTruthy(process.env.DISABLE_PROMPT_CACHING_SONNET)) {
+        const defaultSonnet = getDefaultSonnetModel();
+        if (model === defaultSonnet)
+            return false;
+    }
+    // Check if we should disable for default Opus
+    if (isEnvTruthy(process.env.DISABLE_PROMPT_CACHING_OPUS)) {
+        const defaultOpus = getDefaultOpusModel();
+        if (model === defaultOpus)
+            return false;
+    }
+    return true;
+}
+export function getCacheControl({ scope, querySource, } = {}) {
+    return {
+        type: 'ephemeral',
+        ...(should1hCacheTTL(querySource) && { ttl: '1h' }),
+        ...(scope === 'global' && { scope }),
+    };
+}
+/**
+ * Determines if 1h TTL should be used for prompt caching.
+ *
+ * Only applied when:
+ * 1. User is eligible (ant or subscriber within rate limits)
+ * 2. The query source matches a pattern in the GrowthBook allowlist
+ *
+ * GrowthBook config shape: { allowlist: string[] }
+ * Patterns support trailing '*' for prefix matching.
+ * Examples:
+ * - { allowlist: ["repl_main_thread*", "sdk"] } — main thread + SDK only
+ * - { allowlist: ["repl_main_thread*", "sdk", "agent:*"] } — also subagents
+ * - { allowlist: ["*"] } — all sources
+ *
+ * The allowlist is cached in STATE for session stability — prevents mixed
+ * TTLs when GrowthBook's disk cache updates mid-request.
+ */
+function should1hCacheTTL(querySource) {
+    // 3P Bedrock users get 1h TTL when opted in via env var — they manage their own billing
+    // No GrowthBook gating needed since 3P users don't have GrowthBook configured
+    if (getAPIProvider() === 'bedrock' &&
+        isEnvTruthy(process.env.ENABLE_PROMPT_CACHING_1H_BEDROCK)) {
+        return true;
+    }
+    // Latch eligibility in bootstrap state for session stability — prevents
+    // mid-session overage flips from changing the cache_control TTL, which
+    // would bust the server-side prompt cache (~20K tokens per flip).
+    let userEligible = getPromptCache1hEligible();
+    if (userEligible === null) {
+        userEligible =
+            process.env.USER_TYPE === 'ant' ||
+                (isClaudeAISubscriber() && !currentLimits.isUsingOverage);
+        setPromptCache1hEligible(userEligible);
+    }
+    if (!userEligible)
+        return false;
+    // Cache allowlist in bootstrap state for session stability — prevents mixed
+    // TTLs when GrowthBook's disk cache updates mid-request
+    let allowlist = getPromptCache1hAllowlist();
+    if (allowlist === null) {
+        const config = getFeatureValue_CACHED_MAY_BE_STALE('thaddeus_prompt_cache_1h_config', {});
+        allowlist = config.allowlist ?? [];
+        setPromptCache1hAllowlist(allowlist);
+    }
+    return (querySource !== undefined &&
+        allowlist.some(pattern => pattern.endsWith('*')
+            ? querySource.startsWith(pattern.slice(0, -1))
+            : querySource === pattern));
+}
+/**
+ * Configure effort parameters for API request.
+ *
+ */
+function configureEffortParams(effortValue, outputConfig, extraBodyParams, betas, model) {
+    if (!modelSupportsEffort(model) || 'effort' in outputConfig) {
+        return;
+    }
+    if (effortValue === undefined) {
+        betas.push(EFFORT_BETA_HEADER);
+    }
+    else if (typeof effortValue === 'string') {
+        // Send string effort level as is
+        outputConfig.effort = effortValue;
+        betas.push(EFFORT_BETA_HEADER);
+    }
+    else if (process.env.USER_TYPE === 'ant') {
+        // Numeric effort override - ant-only (uses anthropic_internal)
+        const existingInternal = extraBodyParams.anthropic_internal || {};
+        extraBodyParams.anthropic_internal = {
+            ...existingInternal,
+            effort_override: effortValue,
+        };
+    }
+}
+export function configureTaskBudgetParams(taskBudget, outputConfig, betas) {
+    if (!taskBudget ||
+        'task_budget' in outputConfig ||
+        !shouldIncludeFirstPartyOnlyBetas()) {
+        return;
+    }
+    outputConfig.task_budget = {
+        type: 'tokens',
+        total: taskBudget.total,
+        ...(taskBudget.remaining !== undefined && {
+            remaining: taskBudget.remaining,
+        }),
+    };
+    if (!betas.includes(TASK_BUDGETS_BETA_HEADER)) {
+        betas.push(TASK_BUDGETS_BETA_HEADER);
+    }
+}
+export function getAPIMetadata() {
+    // https://docs.google.com/document/d/1dURO9ycXXQCBS0V4Vhl4poDBRgkelFc5t2BNPoEgH5Q/edit?tab=t.0#heading=h.5g7nec5b09w5
+    let extra = {};
+    const extraStr = process.env.THADDEUS_EXTRA_METADATA;
+    if (extraStr) {
+        const parsed = safeParseJSON(extraStr, false);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            extra = parsed;
+        }
+        else {
+            logForDebugging(`THADDEUS_EXTRA_METADATA env var must be a JSON object, but was given ${extraStr}`, { level: 'error' });
+        }
+    }
+    return {
+        user_id: jsonStringify({
+            ...extra,
+            device_id: getOrCreateUserID(),
+            // Only include OAuth account UUID when actively using OAuth authentication
+            account_uuid: getOauthAccountInfo()?.accountUuid ?? '',
+            session_id: getSessionId(),
+        }),
+    };
+}
+export async function verifyApiKey(apiKey, isNonInteractiveSession) {
+    // Skip API verification if running in print mode (isNonInteractiveSession)
+    if (isNonInteractiveSession) {
+        return true;
+    }
+    try {
+        // WARNING: if you change this to use a non-Haiku model, this request will fail in 1P unless it uses getCLISyspromptPrefix.
+        const model = getSmallFastModel();
+        const betas = getModelBetas(model);
+        return await returnValue(withRetry(() => getAnthropicClient({
+            apiKey,
+            maxRetries: 3,
+            model,
+            source: 'verify_api_key',
+        }), async (anthropic) => {
+            const messages = [{ role: 'user', content: 'test' }];
+            // biome-ignore lint/plugin: API key verification is intentionally a minimal direct call
+            await anthropic.beta.messages.create({
+                model,
+                max_tokens: 1,
+                messages,
+                temperature: 1,
+                ...(betas.length > 0 && { betas }),
+                metadata: getAPIMetadata(),
+                ...getExtraBodyParams(),
+            });
+            return true;
+        }, { maxRetries: 2, model, thinkingConfig: { type: 'disabled' } }));
+    }
+    catch (errorFromRetry) {
+        let error = errorFromRetry;
+        if (errorFromRetry instanceof CannotRetryError) {
+            error = errorFromRetry.originalError;
+        }
+        logError(error);
+        // Check for authentication error
+        if (error instanceof Error &&
+            error.message.includes('{"type":"error","error":{"type":"authentication_error","message":"invalid x-api-key"}}')) {
+            return false;
+        }
+        throw error;
+    }
+}
+export function userMessageToMessageParam(message, addCache = false, enablePromptCaching, querySource) {
+    if (addCache) {
+        if (typeof message.message.content === 'string') {
+            return {
+                role: 'user',
+                content: [
+                    {
+                        type: 'text',
+                        text: message.message.content,
+                        ...(enablePromptCaching && {
+                            cache_control: getCacheControl({ querySource }),
+                        }),
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                role: 'user',
+                content: message.message.content.map((_, i) => ({
+                    ..._,
+                    ...(i === message.message.content.length - 1
+                        ? enablePromptCaching
+                            ? { cache_control: getCacheControl({ querySource }) }
+                            : {}
+                        : {}),
+                })),
+            };
+        }
+    }
+    // Clone array content to prevent in-place mutations (e.g., insertCacheEditsBlock's
+    // splice) from contaminating the original message. Without cloning, multiple calls
+    // to addCacheBreakpoints share the same array and each splices in duplicate cache_edits.
+    return {
+        role: 'user',
+        content: Array.isArray(message.message.content)
+            ? [...message.message.content]
+            : message.message.content,
+    };
+}
+export function assistantMessageToMessageParam(message, addCache = false, enablePromptCaching, querySource) {
+    if (addCache) {
+        if (typeof message.message.content === 'string') {
+            return {
+                role: 'assistant',
+                content: [
+                    {
+                        type: 'text',
+                        text: message.message.content,
+                        ...(enablePromptCaching && {
+                            cache_control: getCacheControl({ querySource }),
+                        }),
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                role: 'assistant',
+                content: message.message.content.map((_, i) => ({
+                    ..._,
+                    ...(i === message.message.content.length - 1 &&
+                        _.type !== 'thinking' &&
+                        _.type !== 'redacted_thinking' &&
+                        (feature('CONNECTOR_TEXT') ? !isConnectorTextBlock(_) : true)
+                        ? enablePromptCaching
+                            ? { cache_control: getCacheControl({ querySource }) }
+                            : {}
+                        : {}),
+                })),
+            };
+        }
+    }
+    return {
+        role: 'assistant',
+        content: message.message.content,
+    };
+}
+export async function queryModelWithoutStreaming({ messages, systemPrompt, thinkingConfig, tools, signal, options, }) {
+    // Store the assistant message but continue consuming the generator to ensure
+    // logAPISuccessAndDuration gets called (which happens after all yields)
+    let assistantMessage;
+    for await (const message of withStreamingVCR(messages, async function* () {
+        yield* queryModel(messages, systemPrompt, thinkingConfig, tools, signal, options);
+    })) {
+        if (message.type === 'assistant') {
+            assistantMessage = message;
+        }
+    }
+    if (!assistantMessage) {
+        // If the signal was aborted, throw APIUserAbortError instead of a generic error
+        // This allows callers to handle abort scenarios gracefully
+        if (signal.aborted) {
+            throw new APIUserAbortError();
+        }
+        throw new Error('No assistant message found');
+    }
+    return assistantMessage;
+}
+export async function* queryModelWithStreaming({ messages, systemPrompt, thinkingConfig, tools, signal, options, }) {
+    return yield* withStreamingVCR(messages, async function* () {
+        yield* queryModel(messages, systemPrompt, thinkingConfig, tools, signal, options);
+    });
+}
+/**
+ * Determines if an LSP tool should be deferred (tool appears with defer_loading: true)
+ * because LSP initialization is not yet complete.
+ */
+function shouldDeferLspTool(tool) {
+    if (!('isLsp' in tool) || !tool.isLsp) {
+        return false;
+    }
+    const status = getInitializationStatus();
+    // Defer when pending or not started
+    return status.status === 'pending' || status.status === 'not-started';
+}
+/**
+ * Per-attempt timeout for non-streaming fallback requests, in milliseconds.
+ * Reads API_TIMEOUT_MS when set so slow backends and the streaming path
+ * share the same ceiling.
+ *
+ * Remote sessions default to 120s to stay under CCR's container idle-kill
+ * (~5min) so a hung fallback to a wedged backend surfaces a clean
+ * APIConnectionTimeoutError instead of stalling past SIGKILL.
+ *
+ * Otherwise defaults to 300s — long enough for slow backends without
+ * approaching the API's 10-minute non-streaming boundary.
+ */
+function getNonstreamingFallbackTimeoutMs() {
+    const override = parseInt(process.env.API_TIMEOUT_MS || '', 10);
+    if (override)
+        return override;
+    return isEnvTruthy(process.env.THADDEUS_REMOTE) ? 120_000 : 300_000;
+}
+/**
+ * Helper generator for non-streaming API requests.
+ * Encapsulates the common pattern of creating a withRetry generator,
+ * iterating to yield system messages, and returning the final BetaMessage.
+ */
+export async function* executeNonStreamingRequest(clientOptions, retryOptions, paramsFromContext, onAttempt, captureRequest, 
+/**
+ * Request ID of the failed streaming attempt this fallback is recovering
+ * from. Emitted in thaddeus_nonstreaming_fallback_error for funnel correlation.
+ */
+originatingRequestId) {
+    const fallbackTimeoutMs = getNonstreamingFallbackTimeoutMs();
+    const generator = withRetry(() => getAnthropicClient({
+        maxRetries: 0,
+        model: clientOptions.model,
+        fetchOverride: clientOptions.fetchOverride,
+        source: clientOptions.source,
+    }), async (anthropic, attempt, context) => {
+        const start = Date.now();
+        const retryParams = paramsFromContext(context);
+        captureRequest(retryParams);
+        onAttempt(attempt, start, retryParams.max_tokens);
+        const adjustedParams = adjustParamsForNonStreaming(retryParams, MAX_NON_STREAMING_TOKENS);
+        try {
+            // biome-ignore lint/plugin: non-streaming API call
+            return await anthropic.beta.messages.create({
+                ...adjustedParams,
+                model: normalizeModelStringForAPI(adjustedParams.model),
+            }, {
+                signal: retryOptions.signal,
+                timeout: fallbackTimeoutMs,
+            });
+        }
+        catch (err) {
+            // User aborts are not errors — re-throw immediately without logging
+            if (err instanceof APIUserAbortError)
+                throw err;
+            // Instrumentation: record when the non-streaming request errors (including
+            // timeouts). Lets us distinguish "fallback hung past container kill"
+            // (no event) from "fallback hit the bounded timeout" (this event).
+            logForDiagnosticsNoPII('error', 'cli_nonstreaming_fallback_error');
+            logEvent('thaddeus_nonstreaming_fallback_error', {
+                model: clientOptions.model,
+                error: err instanceof Error
+                    ? err.name
+                    : 'unknown',
+                attempt,
+                timeout_ms: fallbackTimeoutMs,
+                request_id: (originatingRequestId ??
+                    'unknown'),
+            });
+            throw err;
+        }
+    }, {
+        model: retryOptions.model,
+        fallbackModel: retryOptions.fallbackModel,
+        thinkingConfig: retryOptions.thinkingConfig,
+        ...(isFastModeEnabled() && { fastMode: retryOptions.fastMode }),
+        signal: retryOptions.signal,
+        initialConsecutive529Errors: retryOptions.initialConsecutive529Errors,
+        querySource: retryOptions.querySource,
+    });
+    let e;
+    do {
+        e = await generator.next();
+        if (!e.done && e.value.type === 'system') {
+            yield e.value;
+        }
+    } while (!e.done);
+    return e.value;
+}
+/**
+ * Extracts the request ID from the most recent assistant message in the
+ * conversation. Used to link consecutive API requests in analytics so we can
+ * join them for cache-hit-rate analysis and incremental token tracking.
+ *
+ * Deriving this from the message array (rather than global state) ensures each
+ * query chain (main thread, subagent, teammate) tracks its own request chain
+ * independently, and rollback/undo naturally updates the value.
+ */
+function getPreviousRequestIdFromMessages(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.type === 'assistant' && msg.requestId) {
+            return msg.requestId;
+        }
+    }
+    return undefined;
+}
+function isMedia(block) {
+    return block.type === 'image' || block.type === 'document';
+}
+function isToolResult(block) {
+    return block.type === 'tool_result';
+}
+/**
+ * Ensures messages contain at most `limit` media items (images + documents).
+ * Strips oldest media first to preserve the most recent.
+ */
+export function stripExcessMediaItems(messages, limit) {
+    let toRemove = 0;
+    for (const msg of messages) {
+        if (!Array.isArray(msg.message.content))
+            continue;
+        for (const block of msg.message.content) {
+            if (isMedia(block))
+                toRemove++;
+            if (isToolResult(block) && Array.isArray(block.content)) {
+                for (const nested of block.content) {
+                    if (isMedia(nested))
+                        toRemove++;
+                }
+            }
+        }
+    }
+    toRemove -= limit;
+    if (toRemove <= 0)
+        return messages;
+    return messages.map(msg => {
+        if (toRemove <= 0)
+            return msg;
+        const content = msg.message.content;
+        if (!Array.isArray(content))
+            return msg;
+        const before = toRemove;
+        const stripped = content
+            .map(block => {
+            if (toRemove <= 0 ||
+                !isToolResult(block) ||
+                !Array.isArray(block.content))
+                return block;
+            const filtered = block.content.filter(n => {
+                if (toRemove > 0 && isMedia(n)) {
+                    toRemove--;
+                    return false;
+                }
+                return true;
+            });
+            return filtered.length === block.content.length
+                ? block
+                : { ...block, content: filtered };
+        })
+            .filter(block => {
+            if (toRemove > 0 && isMedia(block)) {
+                toRemove--;
+                return false;
+            }
+            return true;
+        });
+        return before === toRemove
+            ? msg
+            : {
+                ...msg,
+                message: { ...msg.message, content: stripped },
+            };
+    });
+}
+async function* queryModel(messages, systemPrompt, thinkingConfig, tools, signal, options) {
+    // Check cheap conditions first — the off-switch await blocks on GrowthBook
+    // init (~10ms). For non-Opus models (haiku, sonnet) this skips the await
+    // entirely. Subscribers don't hit this path at all.
+    if (!isClaudeAISubscriber() &&
+        isNonCustomOpusModel(options.model) &&
+        (await getDynamicConfig_BLOCKS_ON_INIT('thaddeus-off-switch', {
+            activated: false,
+        })).activated) {
+        logEvent('thaddeus_off_switch_query', {});
+        yield getAssistantMessageFromError(new Error(CUSTOM_OFF_SWITCH_MESSAGE), options.model);
+        return;
+    }
+    // Derive previous request ID from the last assistant message in this query chain.
+    // This is scoped per message array (main thread, subagent, teammate each have their own),
+    // so concurrent agents don't clobber each other's request chain tracking.
+    // Also naturally handles rollback/undo since removed messages won't be in the array.
+    const previousRequestId = getPreviousRequestIdFromMessages(messages);
+    const resolvedModel = getAPIProvider() === 'bedrock' &&
+        options.model.includes('application-inference-profile')
+        ? ((await getInferenceProfileBackingModel(options.model)) ??
+            options.model)
+        : options.model;
+    queryCheckpoint('query_tool_schema_build_start');
+    const isAgenticQuery = options.querySource.startsWith('repl_main_thread') ||
+        options.querySource.startsWith('agent:') ||
+        options.querySource === 'sdk' ||
+        options.querySource === 'hook_agent' ||
+        options.querySource === 'verification_agent';
+    const betas = getMergedBetas(options.model, { isAgenticQuery });
+    // Always send the advisor beta header when advisor is enabled, so
+    // non-agentic queries (compact, side_question, extract_memories, etc.)
+    // can parse advisor server_tool_use blocks already in the conversation history.
+    if (isAdvisorEnabled()) {
+        betas.push(ADVISOR_BETA_HEADER);
+    }
+    let advisorModel;
+    if (isAgenticQuery && isAdvisorEnabled()) {
+        let advisorOption = options.advisorModel;
+        const advisorExperiment = getExperimentAdvisorModels();
+        if (advisorExperiment !== undefined) {
+            if (normalizeModelStringForAPI(advisorExperiment.baseModel) ===
+                normalizeModelStringForAPI(options.model)) {
+                // Override the advisor model if the base model matches. We
+                // should only have experiment models if the user cannot
+                // configure it themselves.
+                advisorOption = advisorExperiment.advisorModel;
+            }
+        }
+        if (advisorOption) {
+            const normalizedAdvisorModel = normalizeModelStringForAPI(parseUserSpecifiedModel(advisorOption));
+            if (!modelSupportsAdvisor(options.model)) {
+                logForDebugging(`[AdvisorTool] Skipping advisor - base model ${options.model} does not support advisor`);
+            }
+            else if (!isValidAdvisorModel(normalizedAdvisorModel)) {
+                logForDebugging(`[AdvisorTool] Skipping advisor - ${normalizedAdvisorModel} is not a valid advisor model`);
+            }
+            else {
+                advisorModel = normalizedAdvisorModel;
+                logForDebugging(`[AdvisorTool] Server-side tool enabled with ${advisorModel} as the advisor model`);
+            }
+        }
+    }
+    // Check if tool search is enabled (checks mode, model support, and threshold for auto mode)
+    // This is async because it may need to calculate MCP tool description sizes for TstAuto mode
+    let useToolSearch = await isToolSearchEnabled(options.model, tools, options.getToolPermissionContext, options.agents, 'query');
+    // Precompute once — isDeferredTool does 2 GrowthBook lookups per call
+    const deferredToolNames = new Set();
+    if (useToolSearch) {
+        for (const t of tools) {
+            if (isDeferredTool(t))
+                deferredToolNames.add(t.name);
+        }
+    }
+    // Even if tool search mode is enabled, skip if there are no deferred tools
+    // AND no MCP servers are still connecting. When servers are pending, keep
+    // ToolSearch available so the model can discover tools after they connect.
+    if (useToolSearch &&
+        deferredToolNames.size === 0 &&
+        !options.hasPendingMcpServers) {
+        logForDebugging('Tool search disabled: no deferred tools available to search');
+        useToolSearch = false;
+    }
+    // Filter out ToolSearchTool if tool search is not enabled for this model
+    // ToolSearchTool returns tool_reference blocks which unsupported models can't handle
+    let filteredTools;
+    if (useToolSearch) {
+        // Dynamic tool loading: Only include deferred tools that have been discovered
+        // via tool_reference blocks in the message history. This eliminates the need
+        // to predeclare all deferred tools upfront and removes limits on tool quantity.
+        const discoveredToolNames = extractDiscoveredToolNames(messages);
+        filteredTools = tools.filter(tool => {
+            // Always include non-deferred tools
+            if (!deferredToolNames.has(tool.name))
+                return true;
+            // Always include ToolSearchTool (so it can discover more tools)
+            if (toolMatchesName(tool, TOOL_SEARCH_TOOL_NAME))
+                return true;
+            // Only include deferred tools that have been discovered
+            return discoveredToolNames.has(tool.name);
+        });
+    }
+    else {
+        filteredTools = tools.filter(t => !toolMatchesName(t, TOOL_SEARCH_TOOL_NAME));
+    }
+    // Add tool search beta header if enabled - required for defer_loading to be accepted
+    // Header differs by provider: 1P/Foundry use advanced-tool-use, Vertex/Bedrock use tool-search-tool
+    // For Bedrock, this header must go in extraBodyParams, not the betas array
+    const toolSearchHeader = useToolSearch ? getToolSearchBetaHeader() : null;
+    if (toolSearchHeader && getAPIProvider() !== 'bedrock') {
+        if (!betas.includes(toolSearchHeader)) {
+            betas.push(toolSearchHeader);
+        }
+    }
+    // Determine if cached microcompact is enabled for this model.
+    // Computed once here (in async context) and captured by paramsFromContext.
+    // The beta header is also captured here to avoid a top-level import of the
+    // ant-only CACHE_EDITING_BETA_HEADER constant.
+    let cachedMCEnabled = false;
+    let cacheEditingBetaHeader = '';
+    if (feature('CACHED_MICROCOMPACT')) {
+        const { isCachedMicrocompactEnabled, isModelSupportedForCacheEditing, getCachedMCConfig, } = await import('../compact/cachedMicrocompact.js');
+        const betas = await import('src/constants/betas.js');
+        cacheEditingBetaHeader = betas.CACHE_EDITING_BETA_HEADER;
+        const featureEnabled = isCachedMicrocompactEnabled();
+        const modelSupported = isModelSupportedForCacheEditing(options.model);
+        cachedMCEnabled = featureEnabled && modelSupported;
+        const config = getCachedMCConfig();
+        logForDebugging(`Cached MC gate: enabled=${featureEnabled} modelSupported=${modelSupported} model=${options.model} supportedModels=${jsonStringify(config.supportedModels)}`);
+    }
+    const useGlobalCacheFeature = shouldUseGlobalCacheScope();
+    const willDefer = (t) => useToolSearch && (deferredToolNames.has(t.name) || shouldDeferLspTool(t));
+    // MCP tools are per-user → dynamic tool section → can't globally cache.
+    // Only gate when an MCP tool will actually render (not defer_loading).
+    const needsToolBasedCacheMarker = useGlobalCacheFeature &&
+        filteredTools.some(t => t.isMcp === true && !willDefer(t));
+    // Ensure prompt_caching_scope beta header is present when global cache is enabled.
+    if (useGlobalCacheFeature &&
+        !betas.includes(PROMPT_CACHING_SCOPE_BETA_HEADER)) {
+        betas.push(PROMPT_CACHING_SCOPE_BETA_HEADER);
+    }
+    // Determine global cache strategy for logging
+    const globalCacheStrategy = useGlobalCacheFeature
+        ? needsToolBasedCacheMarker
+            ? 'none'
+            : 'system_prompt'
+        : 'none';
+    // Build tool schemas, adding defer_loading for MCP tools when tool search is enabled
+    // Note: We pass the full `tools` list (not filteredTools) to toolToAPISchema so that
+    // ToolSearchTool's prompt can list ALL available MCP tools. The filtering only affects
+    // which tools are actually sent to the API, not what the model sees in tool descriptions.
+    const toolSchemas = await Promise.all(filteredTools.map(tool => toolToAPISchema(tool, {
+        getToolPermissionContext: options.getToolPermissionContext,
+        tools,
+        agents: options.agents,
+        allowedAgentTypes: options.allowedAgentTypes,
+        model: options.model,
+        deferLoading: willDefer(tool),
+    })));
+    if (useToolSearch) {
+        const includedDeferredTools = count(filteredTools, t => deferredToolNames.has(t.name));
+        logForDebugging(`Dynamic tool loading: ${includedDeferredTools}/${deferredToolNames.size} deferred tools included`);
+    }
+    queryCheckpoint('query_tool_schema_build_end');
+    // Normalize messages before building system prompt (needed for fingerprinting)
+    // Instrumentation: Track message count before normalization
+    logEvent('thaddeus_api_before_normalize', {
+        preNormalizedMessageCount: messages.length,
+    });
+    queryCheckpoint('query_message_normalization_start');
+    let messagesForAPI = normalizeMessagesForAPI(messages, filteredTools);
+    queryCheckpoint('query_message_normalization_end');
+    // Model-specific post-processing: strip tool-search-specific fields if the
+    // selected model doesn't support tool search.
+    //
+    // Why is this needed in addition to normalizeMessagesForAPI?
+    // - normalizeMessagesForAPI uses isToolSearchEnabledNoModelCheck() because it's
+    //   called from ~20 places (analytics, feedback, sharing, etc.), many of which
+    //   don't have model context. Adding model to its signature would be a large refactor.
+    // - This post-processing uses the model-aware isToolSearchEnabled() check
+    // - This handles mid-conversation model switching (e.g., Sonnet → Haiku) where
+    //   stale tool-search fields from the previous model would cause 400 errors
+    //
+    // Note: For assistant messages, normalizeMessagesForAPI already normalized the
+    // tool inputs, so stripCallerFieldFromAssistantMessage only needs to remove the
+    // 'caller' field (not re-normalize inputs).
+    if (!useToolSearch) {
+        messagesForAPI = messagesForAPI.map(msg => {
+            switch (msg.type) {
+                case 'user':
+                    // Strip tool_reference blocks from tool_result content
+                    return stripToolReferenceBlocksFromUserMessage(msg);
+                case 'assistant':
+                    // Strip 'caller' field from tool_use blocks
+                    return stripCallerFieldFromAssistantMessage(msg);
+                default:
+                    return msg;
+            }
+        });
+    }
+    // Repair tool_use/tool_result pairing mismatches that can occur when resuming
+    // remote/teleport sessions. Inserts synthetic error tool_results for orphaned
+    // tool_uses and strips orphaned tool_results referencing non-existent tool_uses.
+    messagesForAPI = ensureToolResultPairing(messagesForAPI);
+    // Strip advisor blocks — the API rejects them without the beta header.
+    if (!betas.includes(ADVISOR_BETA_HEADER)) {
+        messagesForAPI = stripAdvisorBlocks(messagesForAPI);
+    }
+    // Strip excess media items before making the API call.
+    // The API rejects requests with >100 media items but returns a confusing error.
+    // Rather than erroring (which is hard to recover from in Cowork/CCD), we
+    // silently drop the oldest media items to stay within the limit.
+    messagesForAPI = stripExcessMediaItems(messagesForAPI, API_MAX_MEDIA_PER_REQUEST);
+    // Instrumentation: Track message count after normalization
+    logEvent('thaddeus_api_after_normalize', {
+        postNormalizedMessageCount: messagesForAPI.length,
+    });
+    // Compute fingerprint from first user message for attribution.
+    // Must run BEFORE injecting synthetic messages (e.g. deferred tool names)
+    // so the fingerprint reflects the actual user input.
+    const fingerprint = computeFingerprintFromMessages(messagesForAPI);
+    // When the delta attachment is enabled, deferred tools are announced
+    // via persisted deferred_tools_delta attachments instead of this
+    // ephemeral prepend (which busts cache whenever the pool changes).
+    if (useToolSearch && !isDeferredToolsDeltaEnabled()) {
+        const deferredToolList = tools
+            .filter(t => deferredToolNames.has(t.name))
+            .map(formatDeferredToolLine)
+            .sort()
+            .join('\n');
+        if (deferredToolList) {
+            messagesForAPI = [
+                createUserMessage({
+                    content: `<available-deferred-tools>\n${deferredToolList}\n</available-deferred-tools>`,
+                    isMeta: true,
+                }),
+                ...messagesForAPI,
+            ];
+        }
+    }
+    // Chrome tool-search instructions: when the delta attachment is enabled,
+    // these are carried as a client-side block in mcp_instructions_delta
+    // (attachments.ts) instead of here. This per-request sys-prompt append
+    // busts the prompt cache when chrome connects late.
+    const hasChromeTools = filteredTools.some(t => isToolFromMcpServer(t.name, CLAUDE_IN_CHROME_MCP_SERVER_NAME));
+    const injectChromeHere = useToolSearch && hasChromeTools && !isMcpInstructionsDeltaEnabled();
+    // filter(Boolean) works by converting each element to a boolean - empty strings become false and are filtered out.
+    systemPrompt = asSystemPrompt([
+        getAttributionHeader(fingerprint),
+        getCLISyspromptPrefix({
+            isNonInteractive: options.isNonInteractiveSession,
+            hasAppendSystemPrompt: options.hasAppendSystemPrompt,
+        }),
+        ...systemPrompt,
+        ...(advisorModel ? [ADVISOR_TOOL_INSTRUCTIONS] : []),
+        ...(injectChromeHere ? [CHROME_TOOL_SEARCH_INSTRUCTIONS] : []),
+    ].filter(Boolean));
+    // Prepend system prompt block for easy API identification
+    logAPIPrefix(systemPrompt);
+    const enablePromptCaching = options.enablePromptCaching ?? getPromptCachingEnabled(options.model);
+    const system = buildSystemPromptBlocks(systemPrompt, enablePromptCaching, {
+        skipGlobalCacheForSystemPrompt: needsToolBasedCacheMarker,
+        querySource: options.querySource,
+    });
+    const useBetas = betas.length > 0;
+    // Build minimal context for detailed tracing (when beta tracing is enabled)
+    // Note: The actual new_context message extraction is done in sessionTracing.ts using
+    // hash-based tracking per querySource (agent) from the messagesForAPI array
+    const extraToolSchemas = [...(options.extraToolSchemas ?? [])];
+    if (advisorModel) {
+        // Server tools must be in the tools array by API contract. Appended after
+        // toolSchemas (which carries the cache_control marker) so toggling /advisor
+        // only churns the small suffix, not the cached prefix.
+        extraToolSchemas.push({
+            type: 'advisor_20260301',
+            name: 'advisor',
+            model: advisorModel,
+        });
+    }
+    const allTools = [...toolSchemas, ...extraToolSchemas];
+    const isFastMode = isFastModeEnabled() &&
+        isFastModeAvailable() &&
+        !isFastModeCooldown() &&
+        isFastModeSupportedByModel(options.model) &&
+        !!options.fastMode;
+    // Sticky-on latches for dynamic beta headers. Each header, once first
+    // sent, keeps being sent for the rest of the session so mid-session
+    // toggles don't change the server-side cache key and bust ~50-70K tokens.
+    // Latches are cleared on /clear and /compact via clearBetaHeaderLatches().
+    // Per-call gates (isAgenticQuery, querySource===repl_main_thread) stay
+    // per-call so non-agentic queries keep their own stable header set.
+    let afkHeaderLatched = getAfkModeHeaderLatched() === true;
+    if (feature('TRANSCRIPT_CLASSIFIER')) {
+        if (!afkHeaderLatched &&
+            isAgenticQuery &&
+            shouldIncludeFirstPartyOnlyBetas() &&
+            (autoModeStateModule?.isAutoModeActive() ?? false)) {
+            afkHeaderLatched = true;
+            setAfkModeHeaderLatched(true);
+        }
+    }
+    let fastModeHeaderLatched = getFastModeHeaderLatched() === true;
+    if (!fastModeHeaderLatched && isFastMode) {
+        fastModeHeaderLatched = true;
+        setFastModeHeaderLatched(true);
+    }
+    let cacheEditingHeaderLatched = getCacheEditingHeaderLatched() === true;
+    if (feature('CACHED_MICROCOMPACT')) {
+        if (!cacheEditingHeaderLatched &&
+            cachedMCEnabled &&
+            getAPIProvider() === 'firstParty' &&
+            options.querySource === 'repl_main_thread') {
+            cacheEditingHeaderLatched = true;
+            setCacheEditingHeaderLatched(true);
+        }
+    }
+    // Only latch from agentic queries so a classifier call doesn't flip the
+    // main thread's context_management mid-turn.
+    let thinkingClearLatched = getThinkingClearLatched() === true;
+    if (!thinkingClearLatched && isAgenticQuery) {
+        const lastCompletion = getLastApiCompletionTimestamp();
+        if (lastCompletion !== null &&
+            Date.now() - lastCompletion > CACHE_TTL_1HOUR_MS) {
+            thinkingClearLatched = true;
+            setThinkingClearLatched(true);
+        }
+    }
+    const effort = resolveAppliedEffort(options.model, options.effortValue);
+    if (feature('PROMPT_CACHE_BREAK_DETECTION')) {
+        // Exclude defer_loading tools from the hash -- the API strips them from the
+        // prompt, so they never affect the actual cache key. Including them creates
+        // false-positive "tool schemas changed" breaks when tools are discovered or
+        // MCP servers reconnect.
+        const toolsForCacheDetection = allTools.filter(t => !('defer_loading' in t && t.defer_loading));
+        // Capture everything that could affect the server-side cache key.
+        // Pass latched header values (not live state) so break detection
+        // reflects what we actually send, not what the user toggled.
+        recordPromptState({
+            system,
+            toolSchemas: toolsForCacheDetection,
+            querySource: options.querySource,
+            model: options.model,
+            agentId: options.agentId,
+            fastMode: fastModeHeaderLatched,
+            globalCacheStrategy,
+            betas,
+            autoModeActive: afkHeaderLatched,
+            isUsingOverage: currentLimits.isUsingOverage ?? false,
+            cachedMCEnabled: cacheEditingHeaderLatched,
+            effortValue: effort,
+            extraBodyParams: getExtraBodyParams(),
+        });
+    }
+    const newContext = isBetaTracingEnabled()
+        ? {
+            systemPrompt: systemPrompt.join('\n\n'),
+            querySource: options.querySource,
+            tools: jsonStringify(allTools),
+        }
+        : undefined;
+    // Capture the span so we can pass it to endLLMRequestSpan later
+    // This ensures responses are matched to the correct request when multiple requests run in parallel
+    const llmSpan = startLLMRequestSpan(options.model, newContext, messagesForAPI, isFastMode);
+    const startIncludingRetries = Date.now();
+    let start = Date.now();
+    let attemptNumber = 0;
+    const attemptStartTimes = [];
+    let stream = undefined;
+    let streamRequestId = undefined;
+    let clientRequestId = undefined;
+    // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins -- Response is available in Node 18+ and is used by the SDK
+    let streamResponse = undefined;
+    // Release all stream resources to prevent native memory leaks.
+    // The Response object holds native TLS/socket buffers that live outside the
+    // V8 heap (observed on the Node.js/npm path; see GH #32920), so we must
+    // explicitly cancel and release it regardless of how the generator exits.
+    function releaseStreamResources() {
+        cleanupStream(stream);
+        stream = undefined;
+        if (streamResponse) {
+            streamResponse.body?.cancel().catch(() => { });
+            streamResponse = undefined;
+        }
+    }
+    // Consume pending cache edits ONCE before paramsFromContext is defined.
+    // paramsFromContext is called multiple times (logging, retries), so consuming
+    // inside it would cause the first call to steal edits from subsequent calls.
+    const consumedCacheEdits = cachedMCEnabled ? consumePendingCacheEdits() : null;
+    const consumedPinnedEdits = cachedMCEnabled ? getPinnedCacheEdits() : [];
+    // Capture the betas sent in the last API request, including the ones that
+    // were dynamically added, so we can log and send it to telemetry.
+    let lastRequestBetas;
+    const paramsFromContext = (retryContext) => {
+        const betasParams = [...betas];
+        // Append 1M beta dynamically for the Sonnet 1M experiment.
+        if (!betasParams.includes(CONTEXT_1M_BETA_HEADER) &&
+            getSonnet1mExpTreatmentEnabled(retryContext.model)) {
+            betasParams.push(CONTEXT_1M_BETA_HEADER);
+        }
+        // For Bedrock, include both model-based betas and dynamically-added tool search header
+        const bedrockBetas = getAPIProvider() === 'bedrock'
+            ? [
+                ...getBedrockExtraBodyParamsBetas(retryContext.model),
+                ...(toolSearchHeader ? [toolSearchHeader] : []),
+            ]
+            : [];
+        const extraBodyParams = getExtraBodyParams(bedrockBetas);
+        const outputConfig = {
+            ...(extraBodyParams.output_config ?? {}),
+        };
+        configureEffortParams(effort, outputConfig, extraBodyParams, betasParams, options.model);
+        configureTaskBudgetParams(options.taskBudget, outputConfig, betasParams);
+        // Merge outputFormat into extraBodyParams.output_config alongside effort
+        // Requires structured-outputs beta header per SDK (see parse() in messages.mjs)
+        if (options.outputFormat && !('format' in outputConfig)) {
+            outputConfig.format = options.outputFormat;
+            // Add beta header if not already present and provider supports it
+            if (modelSupportsStructuredOutputs(options.model) &&
+                !betasParams.includes(STRUCTURED_OUTPUTS_BETA_HEADER)) {
+                betasParams.push(STRUCTURED_OUTPUTS_BETA_HEADER);
+            }
+        }
+        // Retry context gets preference because it tries to course correct if we exceed the context window limit
+        const maxOutputTokens = retryContext?.maxTokensOverride ||
+            options.maxOutputTokensOverride ||
+            getMaxOutputTokensForModel(options.model);
+        const hasThinking = thinkingConfig.type !== 'disabled' &&
+            !isEnvTruthy(process.env.THADDEUS_DISABLE_THINKING);
+        let thinking = undefined;
+        // IMPORTANT: Do not change the adaptive-vs-budget thinking selection below
+        // without notifying the model launch DRI and research. This is a sensitive
+        // setting that can greatly affect model quality and bashing.
+        if (hasThinking && modelSupportsThinking(options.model)) {
+            if (!isEnvTruthy(process.env.THADDEUS_DISABLE_ADAPTIVE_THINKING) &&
+                modelSupportsAdaptiveThinking(options.model)) {
+                // For models that support adaptive thinking, always use adaptive
+                // thinking without a budget.
+                thinking = {
+                    type: 'adaptive',
+                };
+            }
+            else {
+                // For models that do not support adaptive thinking, use the default
+                // thinking budget unless explicitly specified.
+                let thinkingBudget = getMaxThinkingTokensForModel(options.model);
+                if (thinkingConfig.type === 'enabled' &&
+                    thinkingConfig.budgetTokens !== undefined) {
+                    thinkingBudget = thinkingConfig.budgetTokens;
+                }
+                thinkingBudget = Math.min(maxOutputTokens - 1, thinkingBudget);
+                thinking = {
+                    budget_tokens: thinkingBudget,
+                    type: 'enabled',
+                };
+            }
+        }
+        // Get API context management strategies if enabled
+        const contextManagement = getAPIContextManagement({
+            hasThinking,
+            isRedactThinkingActive: betasParams.includes(REDACT_THINKING_BETA_HEADER),
+            clearAllThinking: thinkingClearLatched,
+        });
+        const enablePromptCaching = options.enablePromptCaching ?? getPromptCachingEnabled(retryContext.model);
+        // Fast mode: header is latched session-stable (cache-safe), but
+        // `speed='fast'` stays dynamic so cooldown still suppresses the actual
+        // fast-mode request without changing the cache key.
+        let speed;
+        const isFastModeForRetry = isFastModeEnabled() &&
+            isFastModeAvailable() &&
+            !isFastModeCooldown() &&
+            isFastModeSupportedByModel(options.model) &&
+            !!retryContext.fastMode;
+        if (isFastModeForRetry) {
+            speed = 'fast';
+        }
+        if (fastModeHeaderLatched && !betasParams.includes(FAST_MODE_BETA_HEADER)) {
+            betasParams.push(FAST_MODE_BETA_HEADER);
+        }
+        // AFK mode beta: latched once auto mode is first activated. Still gated
+        // by isAgenticQuery per-call so classifiers/compaction don't get it.
+        if (feature('TRANSCRIPT_CLASSIFIER')) {
+            if (afkHeaderLatched &&
+                shouldIncludeFirstPartyOnlyBetas() &&
+                isAgenticQuery &&
+                !betasParams.includes(AFK_MODE_BETA_HEADER)) {
+                betasParams.push(AFK_MODE_BETA_HEADER);
+            }
+        }
+        // Cache editing beta: header is latched session-stable; useCachedMC
+        // (controls cache_edits body behavior) stays live so edits stop when
+        // the feature disables but the header doesn't flip.
+        const useCachedMC = cachedMCEnabled &&
+            getAPIProvider() === 'firstParty' &&
+            options.querySource === 'repl_main_thread';
+        if (cacheEditingHeaderLatched &&
+            getAPIProvider() === 'firstParty' &&
+            options.querySource === 'repl_main_thread' &&
+            !betasParams.includes(cacheEditingBetaHeader)) {
+            betasParams.push(cacheEditingBetaHeader);
+            logForDebugging('Cache editing beta header enabled for cached microcompact');
+        }
+        // Only send temperature when thinking is disabled — the API requires
+        // temperature: 1 when thinking is enabled, which is already the default.
+        const temperature = !hasThinking
+            ? (options.temperatureOverride ?? 1)
+            : undefined;
+        lastRequestBetas = betasParams;
+        return {
+            model: normalizeModelStringForAPI(options.model),
+            messages: addCacheBreakpoints(messagesForAPI, enablePromptCaching, options.querySource, useCachedMC, consumedCacheEdits, consumedPinnedEdits, options.skipCacheWrite),
+            system,
+            tools: allTools,
+            tool_choice: options.toolChoice,
+            ...(useBetas && { betas: betasParams }),
+            metadata: getAPIMetadata(),
+            max_tokens: maxOutputTokens,
+            thinking,
+            ...(temperature !== undefined && { temperature }),
+            ...(contextManagement &&
+                useBetas &&
+                betasParams.includes(CONTEXT_MANAGEMENT_BETA_HEADER) && {
+                context_management: contextManagement,
+            }),
+            ...extraBodyParams,
+            ...(Object.keys(outputConfig).length > 0 && {
+                output_config: outputConfig,
+            }),
+            ...(speed !== undefined && { speed }),
+        };
+    };
+    // Compute log scalars synchronously so the fire-and-forget .then() closure
+    // captures only primitives instead of paramsFromContext's full closure scope
+    // (messagesForAPI, system, allTools, betas — the entire request-building
+    // context), which would otherwise be pinned until the promise resolves.
+    {
+        const queryParams = paramsFromContext({
+            model: options.model,
+            thinkingConfig,
+        });
+        const logMessagesLength = queryParams.messages.length;
+        const logBetas = useBetas ? (queryParams.betas ?? []) : [];
+        const logThinkingType = queryParams.thinking?.type ?? 'disabled';
+        const logEffortValue = queryParams.output_config?.effort;
+        void options.getToolPermissionContext().then(permissionContext => {
+            logAPIQuery({
+                model: options.model,
+                messagesLength: logMessagesLength,
+                temperature: options.temperatureOverride ?? 1,
+                betas: logBetas,
+                permissionMode: permissionContext.mode,
+                querySource: options.querySource,
+                queryTracking: options.queryTracking,
+                thinkingType: logThinkingType,
+                effortValue: logEffortValue,
+                fastMode: isFastMode,
+                previousRequestId,
+            });
+        });
+    }
+    const newMessages = [];
+    let ttftMs = 0;
+    let partialMessage = undefined;
+    const contentBlocks = [];
+    let usage = EMPTY_USAGE;
+    let costUSD = 0;
+    let stopReason = null;
+    let didFallBackToNonStreaming = false;
+    let fallbackMessage;
+    let maxOutputTokens = 0;
+    let responseHeaders = undefined;
+    let research = undefined;
+    let isFastModeRequest = isFastMode; // Keep separate state as it may change if falling back
+    let isAdvisorInProgress = false;
+    try {
+        queryCheckpoint('query_client_creation_start');
+        const generator = withRetry(() => getAnthropicClient({
+            maxRetries: 0, // Disabled auto-retry in favor of manual implementation
+            model: options.model,
+            fetchOverride: options.fetchOverride,
+            source: options.querySource,
+        }), async (anthropic, attempt, context) => {
+            attemptNumber = attempt;
+            isFastModeRequest = context.fastMode ?? false;
+            start = Date.now();
+            attemptStartTimes.push(start);
+            // Client has been created by withRetry's getClient() call. This fires
+            // once per attempt; on retries the client is usually cached (withRetry
+            // only calls getClient() again after auth errors), so the delta from
+            // client_creation_start is meaningful on attempt 1.
+            queryCheckpoint('query_client_creation_end');
+            const params = paramsFromContext(context);
+            captureAPIRequest(params, options.querySource); // Capture for bug reports
+            maxOutputTokens = params.max_tokens;
+            // Fire immediately before the fetch is dispatched. .withResponse() below
+            // awaits until response headers arrive, so this MUST be before the await
+            // or the "Network TTFB" phase measurement is wrong.
+            queryCheckpoint('query_api_request_sent');
+            if (!options.agentId) {
+                headlessProfilerCheckpoint('api_request_sent');
+            }
+            // Generate and track client request ID so timeouts (which return no
+            // server request ID) can still be correlated with server logs.
+            // First-party only — 3P providers don't log it (inc-4029 class).
+            clientRequestId =
+                getAPIProvider() === 'firstParty' && isFirstPartyAnthropicBaseUrl()
+                    ? randomUUID()
+                    : undefined;
+            // Use raw stream instead of BetaMessageStream to avoid O(n²) partial JSON parsing
+            // BetaMessageStream calls partialParse() on every input_json_delta, which we don't need
+            // since we handle tool input accumulation ourselves
+            // biome-ignore lint/plugin: main conversation loop handles attribution separately
+            const result = await anthropic.beta.messages
+                .create({ ...params, stream: true }, {
+                signal,
+                ...(clientRequestId && {
+                    headers: { [CLIENT_REQUEST_ID_HEADER]: clientRequestId },
+                }),
+            })
+                .withResponse();
+            queryCheckpoint('query_response_headers_received');
+            streamRequestId = result.request_id;
+            streamResponse = result.response;
+            return result.data;
+        }, {
+            model: options.model,
+            fallbackModel: options.fallbackModel,
+            thinkingConfig,
+            ...(isFastModeEnabled() ? { fastMode: isFastMode } : false),
+            signal,
+            querySource: options.querySource,
+        });
+        let e;
+        do {
+            e = await generator.next();
+            // yield API error messages (the stream has a 'controller' property, error messages don't)
+            if (!('controller' in e.value)) {
+                yield e.value;
+            }
+        } while (!e.done);
+        stream = e.value;
+        // reset state
+        newMessages.length = 0;
+        ttftMs = 0;
+        partialMessage = undefined;
+        contentBlocks.length = 0;
+        usage = EMPTY_USAGE;
+        stopReason = null;
+        isAdvisorInProgress = false;
+        // Streaming idle timeout watchdog: abort the stream if no chunks arrive
+        // for STREAM_IDLE_TIMEOUT_MS. Unlike the stall detection below (which only
+        // fires when the *next* chunk arrives), this uses setTimeout to actively
+        // kill hung streams. Without this, a silently dropped connection can hang
+        // the session indefinitely since the SDK's request timeout only covers the
+        // initial fetch(), not the streaming body.
+        const streamWatchdogEnabled = isEnvTruthy(process.env.CLAUDE_ENABLE_STREAM_WATCHDOG);
+        const STREAM_IDLE_TIMEOUT_MS = parseInt(process.env.CLAUDE_STREAM_IDLE_TIMEOUT_MS || '', 10) || 90_000;
+        const STREAM_IDLE_WARNING_MS = STREAM_IDLE_TIMEOUT_MS / 2;
+        let streamIdleAborted = false;
+        // performance.now() snapshot when watchdog fires, for measuring abort propagation delay
+        let streamWatchdogFiredAt = null;
+        let streamIdleWarningTimer = null;
+        let streamIdleTimer = null;
+        function clearStreamIdleTimers() {
+            if (streamIdleWarningTimer !== null) {
+                clearTimeout(streamIdleWarningTimer);
+                streamIdleWarningTimer = null;
+            }
+            if (streamIdleTimer !== null) {
+                clearTimeout(streamIdleTimer);
+                streamIdleTimer = null;
+            }
+        }
+        function resetStreamIdleTimer() {
+            clearStreamIdleTimers();
+            if (!streamWatchdogEnabled) {
+                return;
+            }
+            streamIdleWarningTimer = setTimeout(warnMs => {
+                logForDebugging(`Streaming idle warning: no chunks received for ${warnMs / 1000}s`, { level: 'warn' });
+                logForDiagnosticsNoPII('warn', 'cli_streaming_idle_warning');
+            }, STREAM_IDLE_WARNING_MS, STREAM_IDLE_WARNING_MS);
+            streamIdleTimer = setTimeout(() => {
+                streamIdleAborted = true;
+                streamWatchdogFiredAt = performance.now();
+                logForDebugging(`Streaming idle timeout: no chunks received for ${STREAM_IDLE_TIMEOUT_MS / 1000}s, aborting stream`, { level: 'error' });
+                logForDiagnosticsNoPII('error', 'cli_streaming_idle_timeout');
+                logEvent('thaddeus_streaming_idle_timeout', {
+                    model: options.model,
+                    request_id: (streamRequestId ??
+                        'unknown'),
+                    timeout_ms: STREAM_IDLE_TIMEOUT_MS,
+                });
+                releaseStreamResources();
+            }, STREAM_IDLE_TIMEOUT_MS);
+        }
+        resetStreamIdleTimer();
+        startSessionActivity('api_call');
+        try {
+            // stream in and accumulate state
+            let isFirstChunk = true;
+            let lastEventTime = null; // Set after first chunk to avoid measuring TTFB as a stall
+            const STALL_THRESHOLD_MS = 30_000; // 30 seconds
+            let totalStallTime = 0;
+            let stallCount = 0;
+            for await (const part of stream) {
+                resetStreamIdleTimer();
+                const now = Date.now();
+                // Detect and log streaming stalls (only after first event to avoid counting TTFB)
+                if (lastEventTime !== null) {
+                    const timeSinceLastEvent = now - lastEventTime;
+                    if (timeSinceLastEvent > STALL_THRESHOLD_MS) {
+                        stallCount++;
+                        totalStallTime += timeSinceLastEvent;
+                        logForDebugging(`Streaming stall detected: ${(timeSinceLastEvent / 1000).toFixed(1)}s gap between events (stall #${stallCount})`, { level: 'warn' });
+                        logEvent('thaddeus_streaming_stall', {
+                            stall_duration_ms: timeSinceLastEvent,
+                            stall_count: stallCount,
+                            total_stall_time_ms: totalStallTime,
+                            event_type: part.type,
+                            model: options.model,
+                            request_id: (streamRequestId ??
+                                'unknown'),
+                        });
+                    }
+                }
+                lastEventTime = now;
+                if (isFirstChunk) {
+                    logForDebugging('Stream started - received first chunk');
+                    queryCheckpoint('query_first_chunk_received');
+                    if (!options.agentId) {
+                        headlessProfilerCheckpoint('first_chunk');
+                    }
+                    endQueryProfile();
+                    isFirstChunk = false;
+                }
+                switch (part.type) {
+                    case 'message_start': {
+                        partialMessage = part.message;
+                        ttftMs = Date.now() - start;
+                        usage = updateUsage(usage, part.message?.usage);
+                        // Capture research from message_start if available (internal only).
+                        // Always overwrite with the latest value.
+                        if (process.env.USER_TYPE === 'ant' &&
+                            'research' in part.message) {
+                            research = part.message
+                                .research;
+                        }
+                        break;
+                    }
+                    case 'content_block_start':
+                        switch (part.content_block.type) {
+                            case 'tool_use':
+                                contentBlocks[part.index] = {
+                                    ...part.content_block,
+                                    input: '',
+                                };
+                                break;
+                            case 'server_tool_use':
+                                contentBlocks[part.index] = {
+                                    ...part.content_block,
+                                    input: '',
+                                };
+                                if (part.content_block.name === 'advisor') {
+                                    isAdvisorInProgress = true;
+                                    logForDebugging(`[AdvisorTool] Advisor tool called`);
+                                    logEvent('thaddeus_advisor_tool_call', {
+                                        model: options.model,
+                                        advisor_model: (advisorModel ??
+                                            'unknown'),
+                                    });
+                                }
+                                break;
+                            case 'text':
+                                contentBlocks[part.index] = {
+                                    ...part.content_block,
+                                    // awkwardly, the sdk sometimes returns text as part of a
+                                    // content_block_start message, then returns the same text
+                                    // again in a content_block_delta message. we ignore it here
+                                    // since there doesn't seem to be a way to detect when a
+                                    // content_block_delta message duplicates the text.
+                                    text: '',
+                                };
+                                break;
+                            case 'thinking':
+                                contentBlocks[part.index] = {
+                                    ...part.content_block,
+                                    // also awkward
+                                    thinking: '',
+                                    // initialize signature to ensure field exists even if signature_delta never arrives
+                                    signature: '',
+                                };
+                                break;
+                            default:
+                                // even more awkwardly, the sdk mutates the contents of text blocks
+                                // as it works. we want the blocks to be immutable, so that we can
+                                // accumulate state ourselves.
+                                contentBlocks[part.index] = { ...part.content_block };
+                                if (part.content_block.type === 'advisor_tool_result') {
+                                    isAdvisorInProgress = false;
+                                    logForDebugging(`[AdvisorTool] Advisor tool result received`);
+                                }
+                                break;
+                        }
+                        break;
+                    case 'content_block_delta': {
+                        const contentBlock = contentBlocks[part.index];
+                        const delta = part.delta;
+                        if (!contentBlock) {
+                            logEvent('thaddeus_streaming_error', {
+                                error_type: 'content_block_not_found_delta',
+                                part_type: part.type,
+                                part_index: part.index,
+                            });
+                            throw new RangeError('Content block not found');
+                        }
+                        if (feature('CONNECTOR_TEXT') &&
+                            delta.type === 'connector_text_delta') {
+                            if (contentBlock.type !== 'connector_text') {
+                                logEvent('thaddeus_streaming_error', {
+                                    error_type: 'content_block_type_mismatch_connector_text',
+                                    expected_type: 'connector_text',
+                                    actual_type: contentBlock.type,
+                                });
+                                throw new Error('Content block is not a connector_text block');
+                            }
+                            contentBlock.connector_text += delta.connector_text;
+                        }
+                        else {
+                            switch (delta.type) {
+                                case 'citations_delta':
+                                    // TODO: handle citations
+                                    break;
+                                case 'input_json_delta':
+                                    if (contentBlock.type !== 'tool_use' &&
+                                        contentBlock.type !== 'server_tool_use') {
+                                        logEvent('thaddeus_streaming_error', {
+                                            error_type: 'content_block_type_mismatch_input_json',
+                                            expected_type: 'tool_use',
+                                            actual_type: contentBlock.type,
+                                        });
+                                        throw new Error('Content block is not a input_json block');
+                                    }
+                                    if (typeof contentBlock.input !== 'string') {
+                                        logEvent('thaddeus_streaming_error', {
+                                            error_type: 'content_block_input_not_string',
+                                            input_type: typeof contentBlock.input,
+                                        });
+                                        throw new Error('Content block input is not a string');
+                                    }
+                                    contentBlock.input += delta.partial_json;
+                                    break;
+                                case 'text_delta':
+                                    if (contentBlock.type !== 'text') {
+                                        logEvent('thaddeus_streaming_error', {
+                                            error_type: 'content_block_type_mismatch_text',
+                                            expected_type: 'text',
+                                            actual_type: contentBlock.type,
+                                        });
+                                        throw new Error('Content block is not a text block');
+                                    }
+                                    // Decode HTML entities from xAI/Grok responses (&#39; → ', &amp; → &, etc.)
+                                    contentBlock.text += delta.text.includes('&')
+                                        ? delta.text
+                                            .replace(/&amp;/g, '&')
+                                            .replace(/&lt;/g, '<')
+                                            .replace(/&gt;/g, '>')
+                                            .replace(/&quot;/g, '"')
+                                            .replace(/&apos;/g, "'")
+                                            .replace(/&nbsp;/g, ' ')
+                                            .replace(/&#(\d+);/g, (_m, code) => String.fromCharCode(parseInt(code, 10)))
+                                            .replace(/&#x([0-9a-fA-F]+);/g, (_m, hex) => String.fromCharCode(parseInt(hex, 16)))
+                                        : delta.text;
+                                    break;
+                                case 'signature_delta':
+                                    if (feature('CONNECTOR_TEXT') &&
+                                        contentBlock.type === 'connector_text') {
+                                        contentBlock.signature = delta.signature;
+                                        break;
+                                    }
+                                    if (contentBlock.type !== 'thinking') {
+                                        logEvent('thaddeus_streaming_error', {
+                                            error_type: 'content_block_type_mismatch_thinking_signature',
+                                            expected_type: 'thinking',
+                                            actual_type: contentBlock.type,
+                                        });
+                                        throw new Error('Content block is not a thinking block');
+                                    }
+                                    contentBlock.signature = delta.signature;
+                                    break;
+                                case 'thinking_delta':
+                                    if (contentBlock.type !== 'thinking') {
+                                        logEvent('thaddeus_streaming_error', {
+                                            error_type: 'content_block_type_mismatch_thinking_delta',
+                                            expected_type: 'thinking',
+                                            actual_type: contentBlock.type,
+                                        });
+                                        throw new Error('Content block is not a thinking block');
+                                    }
+                                    contentBlock.thinking += delta.thinking;
+                                    break;
+                            }
+                        }
+                        // Capture research from content_block_delta if available (internal only).
+                        // Always overwrite with the latest value.
+                        if (process.env.USER_TYPE === 'ant' && 'research' in part) {
+                            research = part.research;
+                        }
+                        break;
+                    }
+                    case 'content_block_stop': {
+                        const contentBlock = contentBlocks[part.index];
+                        if (!contentBlock) {
+                            logEvent('thaddeus_streaming_error', {
+                                error_type: 'content_block_not_found_stop',
+                                part_type: part.type,
+                                part_index: part.index,
+                            });
+                            throw new RangeError('Content block not found');
+                        }
+                        if (!partialMessage) {
+                            logEvent('thaddeus_streaming_error', {
+                                error_type: 'partial_message_not_found',
+                                part_type: part.type,
+                            });
+                            throw new Error('Message not found');
+                        }
+                        const m = {
+                            message: {
+                                ...partialMessage,
+                                content: normalizeContentFromAPI([contentBlock], tools, options.agentId),
+                            },
+                            requestId: streamRequestId ?? undefined,
+                            type: 'assistant',
+                            uuid: randomUUID(),
+                            timestamp: new Date().toISOString(),
+                            ...(process.env.USER_TYPE === 'ant' &&
+                                research !== undefined && { research }),
+                            ...(advisorModel && { advisorModel }),
+                        };
+                        newMessages.push(m);
+                        yield m;
+                        break;
+                    }
+                    case 'message_delta': {
+                        usage = updateUsage(usage, part.usage);
+                        // Capture research from message_delta if available (internal only).
+                        // Always overwrite with the latest value. Also write back to
+                        // already-yielded messages since message_delta arrives after
+                        // content_block_stop.
+                        if (process.env.USER_TYPE === 'ant' &&
+                            'research' in part) {
+                            research = part.research;
+                            for (const msg of newMessages) {
+                                msg.research = research;
+                            }
+                        }
+                        // Write final usage and stop_reason back to the last yielded
+                        // message. Messages are created at content_block_stop from
+                        // partialMessage, which was set at message_start before any tokens
+                        // were generated (output_tokens: 0, stop_reason: null).
+                        // message_delta arrives after content_block_stop with the real
+                        // values.
+                        //
+                        // IMPORTANT: Use direct property mutation, not object replacement.
+                        // The transcript write queue holds a reference to message.message
+                        // and serializes it lazily (100ms flush interval). Object
+                        // replacement ({ ...lastMsg.message, usage }) would disconnect
+                        // the queued reference; direct mutation ensures the transcript
+                        // captures the final values.
+                        stopReason = part.delta.stop_reason;
+                        const lastMsg = newMessages.at(-1);
+                        if (lastMsg) {
+                            lastMsg.message.usage = usage;
+                            lastMsg.message.stop_reason = stopReason;
+                        }
+                        // Update cost
+                        const costUSDForPart = calculateUSDCost(resolvedModel, usage);
+                        costUSD += addToTotalSessionCost(costUSDForPart, usage, options.model);
+                        const refusalMessage = getErrorMessageIfRefusal(part.delta.stop_reason, options.model);
+                        if (refusalMessage) {
+                            yield refusalMessage;
+                        }
+                        if (stopReason === 'max_tokens') {
+                            logEvent('thaddeus_max_tokens_reached', {
+                                max_tokens: maxOutputTokens,
+                            });
+                            yield createAssistantAPIErrorMessage({
+                                content: `${API_ERROR_MESSAGE_PREFIX}: The response exceeded the ${maxOutputTokens} output token maximum. To configure this behavior, set the THADDEUS_MAX_OUTPUT_TOKENS environment variable.`,
+                                apiError: 'max_output_tokens',
+                                error: 'max_output_tokens',
+                            });
+                        }
+                        if (stopReason === 'model_context_window_exceeded') {
+                            logEvent('thaddeus_context_window_exceeded', {
+                                max_tokens: maxOutputTokens,
+                                output_tokens: usage.output_tokens,
+                            });
+                            // Reuse the max_output_tokens recovery path — from the model's
+                            // perspective, both mean "response was cut off, continue from
+                            // where you left off."
+                            yield createAssistantAPIErrorMessage({
+                                content: `${API_ERROR_MESSAGE_PREFIX}: The model has reached its context window limit.`,
+                                apiError: 'max_output_tokens',
+                                error: 'max_output_tokens',
+                            });
+                        }
+                        break;
+                    }
+                    case 'message_stop':
+                        break;
+                }
+                yield {
+                    type: 'stream_event',
+                    event: part,
+                    ...(part.type === 'message_start' ? { ttftMs } : undefined),
+                };
+            }
+            // Clear the idle timeout watchdog now that the stream loop has exited
+            clearStreamIdleTimers();
+            // If the stream was aborted by our idle timeout watchdog, fall back to
+            // non-streaming retry rather than treating it as a completed stream.
+            if (streamIdleAborted) {
+                // Instrumentation: proves the for-await exited after the watchdog fired
+                // (vs. hung forever). exit_delay_ms measures abort propagation latency:
+                // 0-10ms = abort worked; >>1000ms = something else woke the loop.
+                const exitDelayMs = streamWatchdogFiredAt !== null
+                    ? Math.round(performance.now() - streamWatchdogFiredAt)
+                    : -1;
+                logForDiagnosticsNoPII('info', 'cli_stream_loop_exited_after_watchdog_clean');
+                logEvent('thaddeus_stream_loop_exited_after_watchdog', {
+                    request_id: (streamRequestId ??
+                        'unknown'),
+                    exit_delay_ms: exitDelayMs,
+                    exit_path: 'clean',
+                    model: options.model,
+                });
+                // Prevent double-emit: this throw lands in the catch block below,
+                // whose exit_path='error' probe guards on streamWatchdogFiredAt.
+                streamWatchdogFiredAt = null;
+                throw new Error('Stream idle timeout - no chunks received');
+            }
+            // Detect when the stream completed without producing any assistant messages.
+            // This covers two proxy failure modes:
+            // 1. No events at all (!partialMessage): proxy returned 200 with non-SSE body
+            // 2. Partial events (partialMessage set but no content blocks completed AND
+            //    no stop_reason received): proxy returned message_start but stream ended
+            //    before content_block_stop and before message_delta with stop_reason
+            // BetaMessageStream had the first check in _endRequest() but the raw Stream
+            // does not - without it the generator silently returns no assistant messages,
+            // causing "Execution error" in -p mode.
+            // Note: We must check stopReason to avoid false positives. For example, with
+            // structured output (--json-schema), the model calls a StructuredOutput tool
+            // on turn 1, then on turn 2 responds with end_turn and no content blocks.
+            // That's a legitimate empty response, not an incomplete stream.
+            if (!partialMessage || (newMessages.length === 0 && !stopReason)) {
+                logForDebugging(!partialMessage
+                    ? 'Stream completed without receiving message_start event - triggering non-streaming fallback'
+                    : 'Stream completed with message_start but no content blocks completed - triggering non-streaming fallback', { level: 'error' });
+                logEvent('thaddeus_stream_no_events', {
+                    model: options.model,
+                    request_id: (streamRequestId ??
+                        'unknown'),
+                });
+                throw new Error('Stream ended without receiving any events');
+            }
+            // Log summary if any stalls occurred during streaming
+            if (stallCount > 0) {
+                logForDebugging(`Streaming completed with ${stallCount} stall(s), total stall time: ${(totalStallTime / 1000).toFixed(1)}s`, { level: 'warn' });
+                logEvent('thaddeus_streaming_stall_summary', {
+                    stall_count: stallCount,
+                    total_stall_time_ms: totalStallTime,
+                    model: options.model,
+                    request_id: (streamRequestId ??
+                        'unknown'),
+                });
+            }
+            // Check if the cache actually broke based on response tokens
+            if (feature('PROMPT_CACHE_BREAK_DETECTION')) {
+                void checkResponseForCacheBreak(options.querySource, usage.cache_read_input_tokens, usage.cache_creation_input_tokens, messages, options.agentId, streamRequestId);
+            }
+            // Process fallback percentage header and quota status if available
+            // streamResponse is set when the stream is created in the withRetry callback above
+            // TypeScript's control flow analysis can't track that streamResponse is set in the callback
+            // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
+            const resp = streamResponse;
+            if (resp) {
+                extractQuotaStatusFromHeaders(resp.headers);
+                // Store headers for gateway detection
+                responseHeaders = resp.headers;
+            }
+        }
+        catch (streamingError) {
+            // Clear the idle timeout watchdog on error path too
+            clearStreamIdleTimers();
+            // Instrumentation: if the watchdog had already fired and the for-await
+            // threw (rather than exiting cleanly), record that the loop DID exit and
+            // how long after the watchdog. Distinguishes true hangs from error exits.
+            if (streamIdleAborted && streamWatchdogFiredAt !== null) {
+                const exitDelayMs = Math.round(performance.now() - streamWatchdogFiredAt);
+                logForDiagnosticsNoPII('info', 'cli_stream_loop_exited_after_watchdog_error');
+                logEvent('thaddeus_stream_loop_exited_after_watchdog', {
+                    request_id: (streamRequestId ??
+                        'unknown'),
+                    exit_delay_ms: exitDelayMs,
+                    exit_path: 'error',
+                    error_name: streamingError instanceof Error
+                        ? streamingError.name
+                        : 'unknown',
+                    model: options.model,
+                });
+            }
+            if (streamingError instanceof APIUserAbortError) {
+                // Check if the abort signal was triggered by the user (ESC key)
+                // If the signal is aborted, it's a user-initiated abort
+                // If not, it's likely a timeout from the SDK
+                if (signal.aborted) {
+                    // This is a real user abort (ESC key was pressed)
+                    logForDebugging(`Streaming aborted by user: ${errorMessage(streamingError)}`);
+                    if (isAdvisorInProgress) {
+                        logEvent('thaddeus_advisor_tool_interrupted', {
+                            model: options.model,
+                            advisor_model: (advisorModel ??
+                                'unknown'),
+                        });
+                    }
+                    throw streamingError;
+                }
+                else {
+                    // The SDK threw APIUserAbortError but our signal wasn't aborted
+                    // This means it's a timeout from the SDK's internal timeout
+                    logForDebugging(`Streaming timeout (SDK abort): ${streamingError.message}`, { level: 'error' });
+                    // Throw a more specific error for timeout
+                    throw new APIConnectionTimeoutError({ message: 'Request timed out' });
+                }
+            }
+            // When the flag is enabled, skip the non-streaming fallback and let the
+            // error propagate to withRetry. The mid-stream fallback causes double tool
+            // execution when streaming tool execution is active: the partial stream
+            // starts a tool, then the non-streaming retry produces the same tool_use
+            // and runs it again. See inc-4258.
+            const disableFallback = isEnvTruthy(process.env.THADDEUS_DISABLE_NONSTREAMING_FALLBACK) ||
+                getFeatureValue_CACHED_MAY_BE_STALE('thaddeus_disable_streaming_to_non_streaming_fallback', false);
+            if (disableFallback) {
+                logForDebugging(`Error streaming (non-streaming fallback disabled): ${errorMessage(streamingError)}`, { level: 'error' });
+                logEvent('thaddeus_streaming_fallback_to_non_streaming', {
+                    model: options.model,
+                    error: streamingError instanceof Error
+                        ? streamingError.name
+                        : String(streamingError),
+                    attemptNumber,
+                    maxOutputTokens,
+                    thinkingType: thinkingConfig.type,
+                    fallback_disabled: true,
+                    request_id: (streamRequestId ??
+                        'unknown'),
+                    fallback_cause: (streamIdleAborted
+                        ? 'watchdog'
+                        : 'other'),
+                });
+                throw streamingError;
+            }
+            logForDebugging(`Error streaming, falling back to non-streaming mode: ${errorMessage(streamingError)}`, { level: 'error' });
+            didFallBackToNonStreaming = true;
+            if (options.onStreamingFallback) {
+                options.onStreamingFallback();
+            }
+            logEvent('thaddeus_streaming_fallback_to_non_streaming', {
+                model: options.model,
+                error: streamingError instanceof Error
+                    ? streamingError.name
+                    : String(streamingError),
+                attemptNumber,
+                maxOutputTokens,
+                thinkingType: thinkingConfig.type,
+                fallback_disabled: false,
+                request_id: (streamRequestId ??
+                    'unknown'),
+                fallback_cause: (streamIdleAborted
+                    ? 'watchdog'
+                    : 'other'),
+            });
+            // Fall back to non-streaming mode with retries.
+            // If the streaming failure was itself a 529, count it toward the
+            // consecutive-529 budget so total 529s-before-model-fallback is the
+            // same whether the overload was hit in streaming or non-streaming mode.
+            // This is a speculative fix for https://github.com/anthropics/claude-code/issues/1513
+            // Instrumentation: proves executeNonStreamingRequest was entered (vs. the
+            // fallback event firing but the call itself hanging at dispatch).
+            logForDiagnosticsNoPII('info', 'cli_nonstreaming_fallback_started');
+            logEvent('thaddeus_nonstreaming_fallback_started', {
+                request_id: (streamRequestId ??
+                    'unknown'),
+                model: options.model,
+                fallback_cause: (streamIdleAborted
+                    ? 'watchdog'
+                    : 'other'),
+            });
+            const result = yield* executeNonStreamingRequest({ model: options.model, source: options.querySource }, {
+                model: options.model,
+                fallbackModel: options.fallbackModel,
+                thinkingConfig,
+                ...(isFastModeEnabled() && { fastMode: isFastMode }),
+                signal,
+                initialConsecutive529Errors: is529Error(streamingError) ? 1 : 0,
+                querySource: options.querySource,
+            }, paramsFromContext, (attempt, _startTime, tokens) => {
+                attemptNumber = attempt;
+                maxOutputTokens = tokens;
+            }, params => captureAPIRequest(params, options.querySource), streamRequestId);
+            const m = {
+                message: {
+                    ...result,
+                    content: normalizeContentFromAPI(result.content, tools, options.agentId),
+                },
+                requestId: streamRequestId ?? undefined,
+                type: 'assistant',
+                uuid: randomUUID(),
+                timestamp: new Date().toISOString(),
+                ...(process.env.USER_TYPE === 'ant' &&
+                    research !== undefined && {
+                    research,
+                }),
+                ...(advisorModel && {
+                    advisorModel,
+                }),
+            };
+            newMessages.push(m);
+            fallbackMessage = m;
+            yield m;
+        }
+        finally {
+            clearStreamIdleTimers();
+        }
+    }
+    catch (errorFromRetry) {
+        // FallbackTriggeredError must propagate to query.ts, which performs the
+        // actual model switch. Swallowing it here would turn the fallback into a
+        // no-op — the user would just see "Model fallback triggered: X -> Y" as
+        // an error message with no actual retry on the fallback model.
+        if (errorFromRetry instanceof FallbackTriggeredError) {
+            throw errorFromRetry;
+        }
+        // Check if this is a 404 error during stream creation that should trigger
+        // non-streaming fallback. This handles gateways that return 404 for streaming
+        // endpoints but work fine with non-streaming. Before v2.1.8, BetaMessageStream
+        // threw 404s during iteration (caught by inner catch with fallback), but now
+        // with raw streams, 404s are thrown during creation (caught here).
+        const is404StreamCreationError = !didFallBackToNonStreaming &&
+            errorFromRetry instanceof CannotRetryError &&
+            errorFromRetry.originalError instanceof APIError &&
+            errorFromRetry.originalError.status === 404;
+        if (is404StreamCreationError) {
+            // 404 is thrown at .withResponse() before streamRequestId is assigned,
+            // and CannotRetryError means every retry failed — so grab the failed
+            // request's ID from the error header instead.
+            const failedRequestId = errorFromRetry.originalError.requestID ?? 'unknown';
+            logForDebugging('Streaming endpoint returned 404, falling back to non-streaming mode', { level: 'warn' });
+            didFallBackToNonStreaming = true;
+            if (options.onStreamingFallback) {
+                options.onStreamingFallback();
+            }
+            logEvent('thaddeus_streaming_fallback_to_non_streaming', {
+                model: options.model,
+                error: '404_stream_creation',
+                attemptNumber,
+                maxOutputTokens,
+                thinkingType: thinkingConfig.type,
+                request_id: failedRequestId,
+                fallback_cause: '404_stream_creation',
+            });
+            try {
+                // Fall back to non-streaming mode
+                const result = yield* executeNonStreamingRequest({ model: options.model, source: options.querySource }, {
+                    model: options.model,
+                    fallbackModel: options.fallbackModel,
+                    thinkingConfig,
+                    ...(isFastModeEnabled() && { fastMode: isFastMode }),
+                    signal,
+                }, paramsFromContext, (attempt, _startTime, tokens) => {
+                    attemptNumber = attempt;
+                    maxOutputTokens = tokens;
+                }, params => captureAPIRequest(params, options.querySource), failedRequestId);
+                const m = {
+                    message: {
+                        ...result,
+                        content: normalizeContentFromAPI(result.content, tools, options.agentId),
+                    },
+                    requestId: streamRequestId ?? undefined,
+                    type: 'assistant',
+                    uuid: randomUUID(),
+                    timestamp: new Date().toISOString(),
+                    ...(process.env.USER_TYPE === 'ant' &&
+                        research !== undefined && { research }),
+                    ...(advisorModel && { advisorModel }),
+                };
+                newMessages.push(m);
+                fallbackMessage = m;
+                yield m;
+                // Continue to success logging below
+            }
+            catch (fallbackError) {
+                // Propagate model-fallback signal to query.ts (see comment above).
+                if (fallbackError instanceof FallbackTriggeredError) {
+                    throw fallbackError;
+                }
+                // Fallback also failed, handle as normal error
+                logForDebugging(`Non-streaming fallback also failed: ${errorMessage(fallbackError)}`, { level: 'error' });
+                let error = fallbackError;
+                let errorModel = options.model;
+                if (fallbackError instanceof CannotRetryError) {
+                    error = fallbackError.originalError;
+                    errorModel = fallbackError.retryContext.model;
+                }
+                if (error instanceof APIError) {
+                    extractQuotaStatusFromError(error);
+                }
+                const requestId = streamRequestId ||
+                    (error instanceof APIError ? error.requestID : undefined) ||
+                    (error instanceof APIError
+                        ? error.error?.request_id
+                        : undefined);
+                logAPIError({
+                    error,
+                    model: errorModel,
+                    messageCount: messagesForAPI.length,
+                    messageTokens: tokenCountFromLastAPIResponse(messagesForAPI),
+                    durationMs: Date.now() - start,
+                    durationMsIncludingRetries: Date.now() - startIncludingRetries,
+                    attempt: attemptNumber,
+                    requestId,
+                    clientRequestId,
+                    didFallBackToNonStreaming,
+                    queryTracking: options.queryTracking,
+                    querySource: options.querySource,
+                    llmSpan,
+                    fastMode: isFastModeRequest,
+                    previousRequestId,
+                });
+                if (error instanceof APIUserAbortError) {
+                    releaseStreamResources();
+                    return;
+                }
+                yield getAssistantMessageFromError(error, errorModel, {
+                    messages,
+                    messagesForAPI,
+                });
+                releaseStreamResources();
+                return;
+            }
+        }
+        else {
+            // Original error handling for non-404 errors
+            logForDebugging(`Error in API request: ${errorMessage(errorFromRetry)}`, {
+                level: 'error',
+            });
+            let error = errorFromRetry;
+            let errorModel = options.model;
+            if (errorFromRetry instanceof CannotRetryError) {
+                error = errorFromRetry.originalError;
+                errorModel = errorFromRetry.retryContext.model;
+            }
+            // Extract quota status from error headers if it's a rate limit error
+            if (error instanceof APIError) {
+                extractQuotaStatusFromError(error);
+            }
+            // Extract requestId from stream, error header, or error body
+            const requestId = streamRequestId ||
+                (error instanceof APIError ? error.requestID : undefined) ||
+                (error instanceof APIError
+                    ? error.error?.request_id
+                    : undefined);
+            logAPIError({
+                error,
+                model: errorModel,
+                messageCount: messagesForAPI.length,
+                messageTokens: tokenCountFromLastAPIResponse(messagesForAPI),
+                durationMs: Date.now() - start,
+                durationMsIncludingRetries: Date.now() - startIncludingRetries,
+                attempt: attemptNumber,
+                requestId,
+                clientRequestId,
+                didFallBackToNonStreaming,
+                queryTracking: options.queryTracking,
+                querySource: options.querySource,
+                llmSpan,
+                fastMode: isFastModeRequest,
+                previousRequestId,
+            });
+            // Don't yield an assistant error message for user aborts
+            // The interruption message is handled in query.ts
+            if (error instanceof APIUserAbortError) {
+                releaseStreamResources();
+                return;
+            }
+            yield getAssistantMessageFromError(error, errorModel, {
+                messages,
+                messagesForAPI,
+            });
+            releaseStreamResources();
+            return;
+        }
+    }
+    finally {
+        stopSessionActivity('api_call');
+        // Must be in the finally block: if the generator is terminated early
+        // via .return() (e.g. consumer breaks out of for-await-of, or query.ts
+        // encounters an abort), code after the try/finally never executes.
+        // Without this, the Response object's native TLS/socket buffers leak
+        // until the generator itself is GC'd (see GH #32920).
+        releaseStreamResources();
+        // Non-streaming fallback cost: the streaming path tracks cost in the
+        // message_delta handler before any yield. Fallback pushes to newMessages
+        // then yields, so tracking must be here to survive .return() at the yield.
+        if (fallbackMessage) {
+            const fallbackUsage = fallbackMessage.message.usage;
+            usage = updateUsage(EMPTY_USAGE, fallbackUsage);
+            stopReason = fallbackMessage.message.stop_reason;
+            const fallbackCost = calculateUSDCost(resolvedModel, fallbackUsage);
+            costUSD += addToTotalSessionCost(fallbackCost, fallbackUsage, options.model);
+        }
+    }
+    // Mark all registered tools as sent to API so they become eligible for deletion
+    if (feature('CACHED_MICROCOMPACT') && cachedMCEnabled) {
+        markToolsSentToAPIState();
+    }
+    // Track the last requestId for the main conversation chain so shutdown
+    // can send a cache eviction hint to inference. Exclude backgrounded
+    // sessions (Ctrl+B) which share the repl_main_thread querySource but
+    // run inside an agent context — they are independent conversation chains
+    // whose cache should not be evicted when the foreground session clears.
+    if (streamRequestId &&
+        !getAgentContext() &&
+        (options.querySource.startsWith('repl_main_thread') ||
+            options.querySource === 'sdk')) {
+        setLastMainRequestId(streamRequestId);
+    }
+    // Precompute scalars so the fire-and-forget .then() closure doesn't pin the
+    // full messagesForAPI array (the entire conversation up to the context window
+    // limit) until getToolPermissionContext() resolves.
+    const logMessageCount = messagesForAPI.length;
+    const logMessageTokens = tokenCountFromLastAPIResponse(messagesForAPI);
+    void options.getToolPermissionContext().then(permissionContext => {
+        logAPISuccessAndDuration({
+            model: newMessages[0]?.message.model ?? partialMessage?.model ?? options.model,
+            preNormalizedModel: options.model,
+            usage,
+            start,
+            startIncludingRetries,
+            attempt: attemptNumber,
+            messageCount: logMessageCount,
+            messageTokens: logMessageTokens,
+            requestId: streamRequestId ?? null,
+            stopReason,
+            ttftMs,
+            didFallBackToNonStreaming,
+            querySource: options.querySource,
+            headers: responseHeaders,
+            costUSD,
+            queryTracking: options.queryTracking,
+            permissionMode: permissionContext.mode,
+            // Pass newMessages for beta tracing - extraction happens in logging.ts
+            // only when beta tracing is enabled
+            newMessages,
+            llmSpan,
+            globalCacheStrategy,
+            requestSetupMs: start - startIncludingRetries,
+            attemptStartTimes,
+            fastMode: isFastModeRequest,
+            previousRequestId,
+            betas: lastRequestBetas,
+        });
+    });
+    // Defensive: also release on normal completion (no-op if finally already ran).
+    releaseStreamResources();
+}
+/**
+ * Cleans up stream resources to prevent memory leaks.
+ * @internal Exported for testing
+ */
+export function cleanupStream(stream) {
+    if (!stream) {
+        return;
+    }
+    try {
+        // Abort the stream via its controller if not already aborted
+        if (!stream.controller.signal.aborted) {
+            stream.controller.abort();
+        }
+    }
+    catch {
+        // Ignore - stream may already be closed
+    }
+}
+/**
+ * Updates usage statistics with new values from streaming API events.
+ * Note: The streaming API provides cumulative usage totals, not incremental deltas.
+ * Each event contains the complete usage up to that point in the stream.
+ *
+ * Input-related tokens (input_tokens, cache_creation_input_tokens, cache_read_input_tokens)
+ * are typically set in message_start and remain constant. message_delta events may send
+ * explicit 0 values for these fields, which should not overwrite the values from message_start.
+ * We only update these fields if they have a non-null, non-zero value.
+ */
+export function updateUsage(usage, partUsage) {
+    if (!partUsage) {
+        return { ...usage };
+    }
+    return {
+        input_tokens: partUsage.input_tokens !== null && partUsage.input_tokens > 0
+            ? partUsage.input_tokens
+            : usage.input_tokens,
+        cache_creation_input_tokens: partUsage.cache_creation_input_tokens !== null &&
+            partUsage.cache_creation_input_tokens > 0
+            ? partUsage.cache_creation_input_tokens
+            : usage.cache_creation_input_tokens,
+        cache_read_input_tokens: partUsage.cache_read_input_tokens !== null &&
+            partUsage.cache_read_input_tokens > 0
+            ? partUsage.cache_read_input_tokens
+            : usage.cache_read_input_tokens,
+        output_tokens: partUsage.output_tokens ?? usage.output_tokens,
+        server_tool_use: {
+            web_search_requests: partUsage.server_tool_use?.web_search_requests ??
+                usage.server_tool_use.web_search_requests,
+            web_fetch_requests: partUsage.server_tool_use?.web_fetch_requests ??
+                usage.server_tool_use.web_fetch_requests,
+        },
+        service_tier: usage.service_tier,
+        cache_creation: {
+            // SDK type BetaMessageDeltaUsage is missing cache_creation, but it's real!
+            ephemeral_1h_input_tokens: partUsage.cache_creation?.ephemeral_1h_input_tokens ??
+                usage.cache_creation.ephemeral_1h_input_tokens,
+            ephemeral_5m_input_tokens: partUsage.cache_creation?.ephemeral_5m_input_tokens ??
+                usage.cache_creation.ephemeral_5m_input_tokens,
+        },
+        // cache_deleted_input_tokens: returned by the API when cache editing
+        // deletes KV cache content, but not in SDK types. Kept off NonNullableUsage
+        // so the string is eliminated from external builds by dead code elimination.
+        // Uses the same > 0 guard as other token fields to prevent message_delta
+        // from overwriting the real value with 0.
+        ...(feature('CACHED_MICROCOMPACT')
+            ? {
+                cache_deleted_input_tokens: partUsage
+                    .cache_deleted_input_tokens != null &&
+                    partUsage
+                        .cache_deleted_input_tokens > 0
+                    ? partUsage
+                        .cache_deleted_input_tokens
+                    : (usage
+                        .cache_deleted_input_tokens ?? 0),
+            }
+            : {}),
+        inference_geo: usage.inference_geo,
+        iterations: partUsage.iterations ?? usage.iterations,
+        speed: partUsage.speed ?? usage.speed,
+    };
+}
+/**
+ * Accumulates usage from one message into a total usage object.
+ * Used to track cumulative usage across multiple assistant turns.
+ */
+export function accumulateUsage(totalUsage, messageUsage) {
+    return {
+        input_tokens: totalUsage.input_tokens + messageUsage.input_tokens,
+        cache_creation_input_tokens: totalUsage.cache_creation_input_tokens +
+            messageUsage.cache_creation_input_tokens,
+        cache_read_input_tokens: totalUsage.cache_read_input_tokens + messageUsage.cache_read_input_tokens,
+        output_tokens: totalUsage.output_tokens + messageUsage.output_tokens,
+        server_tool_use: {
+            web_search_requests: totalUsage.server_tool_use.web_search_requests +
+                messageUsage.server_tool_use.web_search_requests,
+            web_fetch_requests: totalUsage.server_tool_use.web_fetch_requests +
+                messageUsage.server_tool_use.web_fetch_requests,
+        },
+        service_tier: messageUsage.service_tier, // Use the most recent service tier
+        cache_creation: {
+            ephemeral_1h_input_tokens: totalUsage.cache_creation.ephemeral_1h_input_tokens +
+                messageUsage.cache_creation.ephemeral_1h_input_tokens,
+            ephemeral_5m_input_tokens: totalUsage.cache_creation.ephemeral_5m_input_tokens +
+                messageUsage.cache_creation.ephemeral_5m_input_tokens,
+        },
+        // See comment in updateUsage — field is not on NonNullableUsage to keep
+        // the string out of external builds.
+        ...(feature('CACHED_MICROCOMPACT')
+            ? {
+                cache_deleted_input_tokens: (totalUsage
+                    .cache_deleted_input_tokens ?? 0) +
+                    (messageUsage.cache_deleted_input_tokens ?? 0),
+            }
+            : {}),
+        inference_geo: messageUsage.inference_geo, // Use the most recent
+        iterations: messageUsage.iterations, // Use the most recent
+        speed: messageUsage.speed, // Use the most recent
+    };
+}
+function isToolResultBlock(block) {
+    return (block !== null &&
+        typeof block === 'object' &&
+        'type' in block &&
+        block.type === 'tool_result' &&
+        'tool_use_id' in block);
+}
+// Exported for testing cache_reference placement constraints
+export function addCacheBreakpoints(messages, enablePromptCaching, querySource, useCachedMC = false, newCacheEdits, pinnedEdits, skipCacheWrite = false) {
+    logEvent('thaddeus_api_cache_breakpoints', {
+        totalMessageCount: messages.length,
+        cachingEnabled: enablePromptCaching,
+        skipCacheWrite,
+    });
+    // Exactly one message-level cache_control marker per request. Mycro's
+    // turn-to-turn eviction (page_manager/index.rs: Index::insert) frees
+    // local-attention KV pages at any cached prefix position NOT in
+    // cache_store_int_token_boundaries. With two markers the second-to-last
+    // position is protected and its locals survive an extra turn even though
+    // nothing will ever resume from there — with one marker they're freed
+    // immediately. For fire-and-forget forks (skipCacheWrite) we shift the
+    // marker to the second-to-last message: that's the last shared-prefix
+    // point, so the write is a no-op merge on mycro (entry already exists)
+    // and the fork doesn't leave its own tail in the KVCC. Dense pages are
+    // refcounted and survive via the new hash either way.
+    const markerIndex = skipCacheWrite ? messages.length - 2 : messages.length - 1;
+    const result = messages.map((msg, index) => {
+        const addCache = index === markerIndex;
+        if (msg.type === 'user') {
+            return userMessageToMessageParam(msg, addCache, enablePromptCaching, querySource);
+        }
+        return assistantMessageToMessageParam(msg, addCache, enablePromptCaching, querySource);
+    });
+    if (!useCachedMC) {
+        return result;
+    }
+    // Track all cache_references being deleted to prevent duplicates across blocks.
+    const seenDeleteRefs = new Set();
+    // Helper to deduplicate a cache_edits block against already-seen deletions
+    const deduplicateEdits = (block) => {
+        const uniqueEdits = block.edits.filter(edit => {
+            if (seenDeleteRefs.has(edit.cache_reference)) {
+                return false;
+            }
+            seenDeleteRefs.add(edit.cache_reference);
+            return true;
+        });
+        return { ...block, edits: uniqueEdits };
+    };
+    // Re-insert all previously-pinned cache_edits at their original positions
+    for (const pinned of pinnedEdits ?? []) {
+        const msg = result[pinned.userMessageIndex];
+        if (msg && msg.role === 'user') {
+            if (!Array.isArray(msg.content)) {
+                msg.content = [{ type: 'text', text: msg.content }];
+            }
+            const dedupedBlock = deduplicateEdits(pinned.block);
+            if (dedupedBlock.edits.length > 0) {
+                insertBlockAfterToolResults(msg.content, dedupedBlock);
+            }
+        }
+    }
+    // Insert new cache_edits into the last user message and pin them
+    if (newCacheEdits && result.length > 0) {
+        const dedupedNewEdits = deduplicateEdits(newCacheEdits);
+        if (dedupedNewEdits.edits.length > 0) {
+            for (let i = result.length - 1; i >= 0; i--) {
+                const msg = result[i];
+                if (msg && msg.role === 'user') {
+                    if (!Array.isArray(msg.content)) {
+                        msg.content = [{ type: 'text', text: msg.content }];
+                    }
+                    insertBlockAfterToolResults(msg.content, dedupedNewEdits);
+                    // Pin so this block is re-sent at the same position in future calls
+                    pinCacheEdits(i, newCacheEdits);
+                    logForDebugging(`Added cache_edits block with ${dedupedNewEdits.edits.length} deletion(s) to message[${i}]: ${dedupedNewEdits.edits.map(e => e.cache_reference).join(', ')}`);
+                    break;
+                }
+            }
+        }
+    }
+    // Add cache_reference to tool_result blocks that are within the cached prefix.
+    // Must be done AFTER cache_edits insertion since that modifies content arrays.
+    if (enablePromptCaching) {
+        // Find the last message containing a cache_control marker
+        let lastCCMsg = -1;
+        for (let i = 0; i < result.length; i++) {
+            const msg = result[i];
+            if (Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block && typeof block === 'object' && 'cache_control' in block) {
+                        lastCCMsg = i;
+                    }
+                }
+            }
+        }
+        // Add cache_reference to tool_result blocks that are strictly before
+        // the last cache_control marker. The API requires cache_reference to
+        // appear "before or on" the last cache_control — we use strict "before"
+        // to avoid edge cases where cache_edits splicing shifts block indices.
+        //
+        // Create new objects instead of mutating in-place to avoid contaminating
+        // blocks reused by secondary queries that use models without cache_editing support.
+        if (lastCCMsg >= 0) {
+            for (let i = 0; i < lastCCMsg; i++) {
+                const msg = result[i];
+                if (msg.role !== 'user' || !Array.isArray(msg.content)) {
+                    continue;
+                }
+                let cloned = false;
+                for (let j = 0; j < msg.content.length; j++) {
+                    const block = msg.content[j];
+                    if (block && isToolResultBlock(block)) {
+                        if (!cloned) {
+                            msg.content = [...msg.content];
+                            cloned = true;
+                        }
+                        msg.content[j] = Object.assign({}, block, {
+                            cache_reference: block.tool_use_id,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+export function buildSystemPromptBlocks(systemPrompt, enablePromptCaching, options) {
+    // IMPORTANT: Do not add any more blocks for caching or you will get a 400
+    return splitSysPromptPrefix(systemPrompt, {
+        skipGlobalCacheForSystemPrompt: options?.skipGlobalCacheForSystemPrompt,
+    }).map(block => {
+        return {
+            type: 'text',
+            text: block.text,
+            ...(enablePromptCaching &&
+                block.cacheScope !== null && {
+                cache_control: getCacheControl({
+                    scope: block.cacheScope,
+                    querySource: options?.querySource,
+                }),
+            }),
+        };
+    });
+}
+export async function queryHaiku({ systemPrompt = asSystemPrompt([]), userPrompt, outputFormat, signal, options, }) {
+    const result = await withVCR([
+        createUserMessage({
+            content: systemPrompt.map(text => ({ type: 'text', text })),
+        }),
+        createUserMessage({
+            content: userPrompt,
+        }),
+    ], async () => {
+        const messages = [
+            createUserMessage({
+                content: userPrompt,
+            }),
+        ];
+        const result = await queryModelWithoutStreaming({
+            messages,
+            systemPrompt,
+            thinkingConfig: { type: 'disabled' },
+            tools: [],
+            signal,
+            options: {
+                ...options,
+                model: getSmallFastModel(),
+                enablePromptCaching: options.enablePromptCaching ?? false,
+                outputFormat,
+                async getToolPermissionContext() {
+                    return getEmptyToolPermissionContext();
+                },
+            },
+        });
+        return [result];
+    });
+    // We don't use streaming for Haiku so this is safe
+    return result[0];
+}
+/**
+ * Query a specific model through the Thaddeus infrastructure.
+ * This goes through the full query pipeline including proper authentication,
+ * betas, and headers - unlike direct API calls.
+ */
+export async function queryWithModel({ systemPrompt = asSystemPrompt([]), userPrompt, outputFormat, signal, options, }) {
+    const result = await withVCR([
+        createUserMessage({
+            content: systemPrompt.map(text => ({ type: 'text', text })),
+        }),
+        createUserMessage({
+            content: userPrompt,
+        }),
+    ], async () => {
+        const messages = [
+            createUserMessage({
+                content: userPrompt,
+            }),
+        ];
+        const result = await queryModelWithoutStreaming({
+            messages,
+            systemPrompt,
+            thinkingConfig: { type: 'disabled' },
+            tools: [],
+            signal,
+            options: {
+                ...options,
+                enablePromptCaching: options.enablePromptCaching ?? false,
+                outputFormat,
+                async getToolPermissionContext() {
+                    return getEmptyToolPermissionContext();
+                },
+            },
+        });
+        return [result];
+    });
+    return result[0];
+}
+// Non-streaming requests have a 10min max per the docs:
+// https://platform.claude.com/docs/en/api/errors#long-requests
+// The SDK's 21333-token cap is derived from 10min × 128k tokens/hour, but we
+// bypass it by setting a client-level timeout, so we can cap higher.
+export const MAX_NON_STREAMING_TOKENS = 64_000;
+/**
+ * Adjusts thinking budget when max_tokens is capped for non-streaming fallback.
+ * Ensures the API constraint: max_tokens > thinking.budget_tokens
+ *
+ * @param params - The parameters that will be sent to the API
+ * @param maxTokensCap - The maximum allowed tokens (MAX_NON_STREAMING_TOKENS)
+ * @returns Adjusted parameters with thinking budget capped if needed
+ */
+export function adjustParamsForNonStreaming(params, maxTokensCap) {
+    const cappedMaxTokens = Math.min(params.max_tokens, maxTokensCap);
+    // Adjust thinking budget if it would exceed capped max_tokens
+    // to maintain the constraint: max_tokens > thinking.budget_tokens
+    const adjustedParams = { ...params };
+    if (adjustedParams.thinking?.type === 'enabled' &&
+        adjustedParams.thinking.budget_tokens) {
+        adjustedParams.thinking = {
+            ...adjustedParams.thinking,
+            budget_tokens: Math.min(adjustedParams.thinking.budget_tokens, cappedMaxTokens - 1),
+        };
+    }
+    return {
+        ...adjustedParams,
+        max_tokens: cappedMaxTokens,
+    };
+}
+function isMaxTokensCapEnabled() {
+    // 3P default: false (not validated on Bedrock/Vertex)
+    return getFeatureValue_CACHED_MAY_BE_STALE('thaddeus_otk_slot_v1', false);
+}
+export function getMaxOutputTokensForModel(model) {
+    const maxOutputTokens = getModelMaxOutputTokens(model);
+    // Slot-reservation cap: drop default to 8k for all models. BQ p99 output
+    // = 4,911 tokens; 32k/64k defaults over-reserve 8-16× slot capacity.
+    // Requests hitting the cap get one clean retry at 64k (query.ts
+    // max_output_tokens_escalate). Math.min keeps models with lower native
+    // defaults (e.g. claude-3-opus at 4k) at their native value. Applied
+    // before the env-var override so THADDEUS_MAX_OUTPUT_TOKENS still wins.
+    const defaultTokens = isMaxTokensCapEnabled()
+        ? Math.min(maxOutputTokens.default, CAPPED_DEFAULT_MAX_TOKENS)
+        : maxOutputTokens.default;
+    const result = validateBoundedIntEnvVar('THADDEUS_MAX_OUTPUT_TOKENS', process.env.THADDEUS_MAX_OUTPUT_TOKENS, defaultTokens, maxOutputTokens.upperLimit);
+    return result.effective;
+}