@draht/ai 2026.7.30 → 2026.10.4-2

package/dist/api/anthropic-messages.js

@@ -1,25 +1,29 @@
-import Anthropic from "@anthropic-ai/sdk";
+import Anthropic, {} from "@anthropic-ai/sdk";
+import { ANTHROPIC_FEDERATION_RULE_ID_ENV, ANTHROPIC_IDENTITY_TOKEN_FILE_ENV, ANTHROPIC_ORGANIZATION_ID_ENV, ANTHROPIC_SERVICE_ACCOUNT_ID_ENV, ANTHROPIC_WORKSPACE_ID_ENV, } from "../env-api-keys.js";
 import { calculateCost } from "../models.js";
-import { splitDeferredTools } from "../utils/deferred-tools.js";
+import { appendAssistantMessageDiagnostic } from "../utils/diagnostics.js";
+import { getDrahtUserAgent } from "../utils/draht-user-agent.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { headersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
-import { resolveJsonSchemaStrictSampling } from "./constrained-sampling.js";
+import { getSystemMessageText, renderSystemMessageUpdate } from "../utils/text.js";
+import { getCurrentTools, getDeclaredTools, getInitialSystemMessage, hasToolRedefinitions, resolveTranscript, } from "../utils/transcript.js";
+import { getJsonSchemaToolParameters, resolveJsonSchemaStrictSampling, } from "./constrained-sampling.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { adjustMaxTokensForThinking, buildBaseOptions, clampMaxTokensToContext } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
 /**
  * Resolve cache retention preference.
- * Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
+ * Defaults to "short" and uses DRAHT_CACHE_RETENTION for backward compatibility.
  */
 function resolveCacheRetention(cacheRetention, env) {
     if (cacheRetention) {
         return cacheRetention;
     }
-    if (getProviderEnvValue("PI_CACHE_RETENTION", env) === "long") {
+    if (getProviderEnvValue("DRAHT_CACHE_RETENTION", env) === "long") {
         return "long";
     }
     return "short";
@@ -36,7 +40,7 @@ function getCacheControl(model, cacheRetention, env) {
     };
 }
 // Stealth mode: Mimic Claude Code's tool naming exactly
-const claudeCodeVersion = "2.1.75";
+const claudeCodeVersion = "2.1.280";
 // Claude Code 2.x tool names (canonical casing)
 // Source: https://cchistory.mariozechner.at/data/prompts-2.1.11.md
 // To update: https://github.com/badlogic/cchistory
@@ -109,33 +113,41 @@ function convertContentBlocks(content) {
 }
 const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+const SERVER_SIDE_FALLBACK_BETA = "server-side-fallback-2026-07-01";
+const MID_CONVERSATION_OUTPUT_CONFIG_BETA = "mid-conversation-output-config-2026-07-01";
+const THINKING_BINDING_CONTROLS_BETA = "thinking-binding-controls-2026-08-01";
+const MID_CONVERSATION_TOOL_CHANGES_BETA = "mid-conversation-tool-changes-2026-07-01";
+/**
+ * Stable deferred tool declared whenever native tool changes are in use. Anthropic adds
+ * hidden prompt scaffolding as soon as any tool has `defer_loading`; declaring this
+ * placeholder from the first request keeps that scaffolding in the cached prefix, so the
+ * first real late tool does not invalidate the cache (measured: full miss without it).
+ * It is never activated and the model cannot see it.
+ */
+const DEFERRED_TOOL_PLACEHOLDER = {
+    name: "__pi_deferred_placeholder__",
+    description: "Reserved placeholder. Never available. Never call this.",
+    input_schema: { type: "object", properties: {}, required: [] },
+    defer_loading: true,
+};
+function shouldUseServerSideFallbackBeta(model) {
+    return (model.compat?.allowedFallbackModels?.length ?? 0) > 0;
+}
 function getAnthropicCompat(model) {
+    const isOpenRouter = model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai");
     return {
         supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? true,
         supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
-        sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? false,
+        sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? isOpenRouter,
+        sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? (isOpenRouter ? "openrouter" : undefined),
         supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? true,
         supportsTemperature: model.compat?.supportsTemperature ?? true,
         allowEmptySignature: model.compat?.allowEmptySignature ?? false,
         supportsStrictTools: model.compat?.supportsStrictTools ?? false,
-        supportsToolReferences: model.compat?.supportsToolReferences ?? defaultSupportsToolReferences(model),
+        supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+        supportsMidConvoToolChanges: model.compat?.supportsMidConvoToolChanges ?? false,
     };
 }
-/**
- * Default for `supportsToolReferences`: first-party Anthropic models except
- * Haiku (rejects client-side tool_reference blocks) and models that predate
- * tool search (Claude 3.x, Opus/Sonnet 4.0, Opus 4.1).
- */
-function defaultSupportsToolReferences(model) {
-    if (model.provider !== "anthropic" || model.id.includes("haiku"))
-        return false;
-    const version = model.id.match(/^claude-(?:opus|sonnet|fable)-(\d+)(?:-(\d+))?(?:-|$)/);
-    if (!version)
-        return false;
-    const major = Number(version[1]);
-    const minor = version[2] && version[2].length < 8 ? Number(version[2]) : 0;
-    return major > 4 || (major === 4 && minor >= 5);
-}
 function mergeHeaders(...headerSources) {
     const merged = {};
     for (const headers of headerSources) {
@@ -145,6 +157,9 @@ function mergeHeaders(...headerSources) {
     }
     return merged;
 }
+function mergeClientHeaders(...headerSources) {
+    return mergeHeaders({ "User-Agent": getDrahtUserAgent() }, ...headerSources);
+}
 function hasHeader(headers, name) {
     if (!headers)
         return false;
@@ -155,16 +170,58 @@ function hasHeader(headers, name) {
     }
     return false;
 }
-function assertRequestAuth(provider, apiKey, headers) {
-    if (apiKey)
-        return;
-    if (hasHeader(headers, "authorization") ||
+function hasRequestAuth(apiKey, headers) {
+    return (!!apiKey ||
+        hasHeader(headers, "authorization") ||
         hasHeader(headers, "x-api-key") ||
-        hasHeader(headers, "cf-aig-authorization")) {
-        return;
+        hasHeader(headers, "cf-aig-authorization"));
+}
+function assertRequestAuth(provider, apiKey, headers) {
+    if (!hasRequestAuth(apiKey, headers))
+        throw new Error(`No API key for provider: ${provider}`);
+}
+/**
+ * Anthropic SDK client that never runs the SDK's own credential chain
+ * (ANTHROPIC_PROFILE config files, federation env vars). Without this, every
+ * client built with `apiKey: null, authToken: null` for header-owned auth would
+ * also resolve and exchange SDK credentials behind pi's auth resolver.
+ */
+class PiAnthropic extends Anthropic {
+    _shouldResolveDefaultCredentials() {
+        return false;
     }
-    throw new Error(`No API key for provider: ${provider}`);
 }
+/**
+ * Workload identity federation config from the ANTHROPIC_* variables the
+ * Anthropic SDK documents; the SDK performs the token exchange and refresh.
+ * Only for the anthropic provider, since the exchange is an Anthropic API
+ * endpoint, and only when no key or auth header was resolved.
+ */
+function getAnthropicFederation(model, apiKey, headers, env) {
+    if (model.provider !== "anthropic" || hasRequestAuth(apiKey, headers))
+        return undefined;
+    const federationRuleId = getProviderEnvValue(ANTHROPIC_FEDERATION_RULE_ID_ENV, env);
+    const organizationId = getProviderEnvValue(ANTHROPIC_ORGANIZATION_ID_ENV, env);
+    const identityTokenFile = getProviderEnvValue(ANTHROPIC_IDENTITY_TOKEN_FILE_ENV, env);
+    if (!federationRuleId || !organizationId || !identityTokenFile)
+        return undefined;
+    return {
+        organization_id: organizationId,
+        workspace_id: getProviderEnvValue(ANTHROPIC_WORKSPACE_ID_ENV, env),
+        authentication: {
+            type: "oidc_federation",
+            federation_rule_id: federationRuleId,
+            service_account_id: getProviderEnvValue(ANTHROPIC_SERVICE_ACCOUNT_ID_ENV, env),
+            identity_token: { source: "file", path: identityTokenFile },
+        },
+    };
+}
+/**
+ * The SDK caches the federated access token per client, but pi creates a client
+ * per request. Keep one client for the current federation config and fetch, and
+ * clone it per request with `withOptions()`, which shares the token cache.
+ */
+let federationClient;
 const ANTHROPIC_MESSAGE_EVENTS = new Set([
     "message_start",
     "message_delta",
@@ -318,13 +375,17 @@ async function* iterateAnthropicEvents(response, signal) {
 }
 export const stream = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
+    const normalizedContext = resolveTranscript(context, getAnthropicCompat(model).supportsMidConvoSystemMessages);
+    const currentTools = getCurrentTools(normalizedContext.messages);
     (async () => {
+        const providerThinkingLevel = model.compat?.supportsMidConvoEffort ? (options?.effort ?? "high") : undefined;
         const output = {
             role: "assistant",
             content: [],
             api: model.api,
             provider: model.provider,
             model: model.id,
+            ...(providerThinkingLevel === undefined ? {} : { providerThinkingLevel }),
             usage: {
                 input: 0,
                 output: 0,
@@ -339,38 +400,42 @@ export const stream = (model, context, options) => {
         try {
             let client;
             let isOAuth;
+            let usageModel = model;
+            let inputTransformations;
             if (options?.client) {
                 client = options.client;
                 isOAuth = false;
             }
             else {
                 const apiKey = options?.apiKey;
-                assertRequestAuth(model.provider, apiKey, options?.headers);
+                const federation = getAnthropicFederation(model, apiKey, options?.headers, options?.env);
+                if (!federation)
+                    assertRequestAuth(model.provider, apiKey, options?.headers);
                 let copilotDynamicHeaders;
                 if (model.provider === "github-copilot") {
-                    const hasImages = hasCopilotVisionInput(context.messages);
+                    const hasImages = hasCopilotVisionInput(normalizedContext.messages);
                     copilotDynamicHeaders = buildCopilotDynamicHeaders({
-                        messages: context.messages,
+                        messages: normalizedContext.messages,
                         hasImages,
                     });
                 }
                 const cacheRetention = resolveCacheRetention(options?.cacheRetention, options?.env);
                 const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
-                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, options?.fetch, copilotDynamicHeaders, cacheSessionId);
+                const created = createClient(model, apiKey, options?.headers, options?.fetch, copilotDynamicHeaders, cacheSessionId, federation);
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
-            let params = buildParams(model, context, isOAuth, options);
+            let params = buildParams(model, normalizedContext, isOAuth, options);
             const nextParams = await options?.onPayload?.(params, model);
             if (nextParams !== undefined) {
-                params = nextParams;
+                params = { ...nextParams, stream: true };
             }
             const requestOptions = {
                 ...(options?.signal ? { signal: options.signal } : {}),
                 ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
                 maxRetries: 0,
             };
-            const response = await retryProviderRequest(() => client.messages.create({ ...params, stream: true }, requestOptions).asResponse(), {
+            const response = await retryProviderRequest(() => client.beta.messages.create(params, requestOptions).asResponse(), {
                 maxRetries: options?.maxRetries,
                 maxRetryDelayMs: options?.maxRetryDelayMs,
                 signal: options?.signal,
@@ -379,8 +444,19 @@ export const stream = (model, context, options) => {
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
             for await (const event of iterateAnthropicEvents(response, options?.signal)) {
+                await options?.onProviderStreamEvent?.(event, model);
                 if (event.type === "message_start") {
                     output.responseId = event.message.id;
+                    const transformations = event.message.input_transformations;
+                    if (Array.isArray(transformations))
+                        inputTransformations = transformations;
+                    const responseModel = event.message.model;
+                    if (responseModel !== model.id)
+                        output.responseModel = responseModel;
+                    const fallbackCost = responseModel === model.id
+                        ? undefined
+                        : model.compat?.allowedFallbackModels?.find((fallback) => fallback.provider === model.provider && fallback.model === responseModel)?.cost;
+                    usageModel = fallbackCost ? { ...model, id: responseModel, cost: fallbackCost } : model;
                     // Capture initial token usage from message_start event
                     // This ensures we have input token counts even if the stream is aborted early
                     output.usage.input = event.message.usage.input_tokens || 0;
@@ -391,13 +467,19 @@ export const stream = (model, context, options) => {
                     // Anthropic doesn't provide total_tokens, compute from components
                     output.usage.totalTokens =
                         output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-                    calculateCost(model, output.usage);
+                    calculateCost(usageModel, output.usage);
                 }
                 else if (event.type === "content_block_start") {
+                    if (event.content_block.type === "fallback") {
+                        if (output.content.length > 0) {
+                            throw new Error("Anthropic performed an unsupported mid-output model fallback");
+                        }
+                        continue;
+                    }
                     if (event.content_block.type === "text") {
                         const block = {
                             type: "text",
-                            text: "",
+                            text: event.content_block.text ?? "",
                             index: event.index,
                         };
                         output.content.push(block);
@@ -406,8 +488,8 @@ export const stream = (model, context, options) => {
                     else if (event.content_block.type === "thinking") {
                         const block = {
                             type: "thinking",
-                            thinking: "",
-                            thinkingSignature: "",
+                            thinking: event.content_block.thinking ?? "",
+                            thinkingSignature: event.content_block.signature ?? "",
                             index: event.index,
                         };
                         output.content.push(block);
@@ -429,7 +511,7 @@ export const stream = (model, context, options) => {
                             type: "toolCall",
                             id: event.content_block.id,
                             name: isOAuth
-                                ? fromClaudeCodeName(event.content_block.name, context.tools)
+                                ? fromClaudeCodeName(event.content_block.name, currentTools)
                                 : event.content_block.name,
                             arguments: event.content_block.input ?? {},
                             partialJson: "",
@@ -525,6 +607,9 @@ export const stream = (model, context, options) => {
                     }
                 }
                 else if (event.type === "message_delta") {
+                    const transformations = event.input_transformations;
+                    if (Array.isArray(transformations))
+                        inputTransformations = transformations;
                     if (event.delta.stop_reason) {
                         output.rawStopReason = event.delta.stop_reason;
                         const stopReasonResult = mapStopReason(event.delta.stop_reason, event.delta.stop_details);
@@ -548,11 +633,13 @@ export const stream = (model, context, options) => {
                         if (event.usage.cache_creation_input_tokens != null) {
                             output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
                         }
-                        // Anthropic reports reasoning tokens in `output_tokens_details.thinking_tokens` on the
-                        // final message_delta usage (a subset of output_tokens). SDK 0.91.1 omits the field from
-                        // its Usage type, so read it through a narrow cast. Verified against the live API.
-                        const thinkingTokens = event.usage
-                            .output_tokens_details?.thinking_tokens;
+                        // Vercel AI Gateway includes the TTL breakdown in deltas, though the SDK only types it on message_start.
+                        const cacheCreation = event.usage.cache_creation;
+                        if (cacheCreation?.ephemeral_1h_input_tokens != null) {
+                            output.usage.cacheWrite1h = cacheCreation.ephemeral_1h_input_tokens;
+                        }
+                        // Anthropic reports reasoning tokens as a subset of output tokens.
+                        const thinkingTokens = event.usage.output_tokens_details?.thinking_tokens;
                         if (thinkingTokens != null) {
                             output.usage.reasoning = thinkingTokens;
                         }
@@ -560,7 +647,7 @@ export const stream = (model, context, options) => {
                     // Anthropic doesn't provide total_tokens, compute from components
                     output.usage.totalTokens =
                         output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
-                    calculateCost(model, output.usage);
+                    calculateCost(usageModel, output.usage);
                 }
             }
             if (options?.signal?.aborted) {
@@ -572,6 +659,19 @@ export const stream = (model, context, options) => {
             if (output.stopReason === "aborted" || output.stopReason === "error") {
                 throw new Error(output.errorMessage || "An unknown error occurred");
             }
+            if (inputTransformations && inputTransformations.length > 0) {
+                appendAssistantMessageDiagnostic(output, {
+                    type: "anthropic_input_transformations",
+                    timestamp: Date.now(),
+                    details: {
+                        transformations: inputTransformations.map((transformation) => ({
+                            type: transformation.type ?? undefined,
+                            path: transformation.path ?? undefined,
+                            reason: transformation.reason ?? undefined,
+                        })),
+                    },
+                });
+            }
             stream.push({ type: "done", reason: output.stopReason, message: output });
             stream.end();
         }
@@ -611,10 +711,18 @@ function mapThinkingLevelToEffort(model, level) {
     }
 }
 export const streamSimple = (model, context, options) => {
-    assertRequestAuth(model.provider, options?.apiKey, options?.headers);
-    const base = buildBaseOptions(model, context, options, options?.apiKey);
+    if (!getAnthropicFederation(model, options?.apiKey, options?.headers, options?.env)) {
+        assertRequestAuth(model.provider, options?.apiKey, options?.headers);
+    }
+    const base = {
+        ...buildBaseOptions(model, context, options, options?.apiKey),
+        toolChoice: options?.toolChoice,
+    };
     if (!options?.reasoning) {
-        return stream(model, context, { ...base, thinkingEnabled: false });
+        return stream(model, context, {
+            ...base,
+            thinkingEnabled: false,
+        });
     }
     // For models with adaptive thinking: use an effort level.
     // For older models: use budget-based thinking.
@@ -640,58 +748,66 @@ export const streamSimple = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, fetch, dynamicHeaders, sessionId) {
-    // Adaptive thinking models have interleaved thinking built in, so skip the beta header.
-    const needsInterleavedBeta = interleavedThinking && model.compat?.forceAdaptiveThinking !== true;
-    const betaFeatures = [];
-    if (useFineGrainedToolStreamingBeta) {
-        betaFeatures.push(FINE_GRAINED_TOOL_STREAMING_BETA);
-    }
-    if (needsInterleavedBeta) {
-        betaFeatures.push(INTERLEAVED_THINKING_BETA);
-    }
-    // Copilot: Bearer auth, selective betas.
+function createClient(model, apiKey, optionsHeaders, fetch, dynamicHeaders, sessionId, federation) {
+    // Copilot: Bearer auth.
     if (model.provider === "github-copilot") {
-        const client = new Anthropic({
+        const client = new PiAnthropic({
             apiKey: null,
             authToken: apiKey ?? null,
             baseURL: model.baseUrl,
             dangerouslyAllowBrowser: true,
             fetch,
-            defaultHeaders: mergeHeaders({
+            defaultHeaders: mergeClientHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
-                ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
             }, model.headers, dynamicHeaders, optionsHeaders),
         });
         return { client, isOAuthToken: false };
     }
     // OAuth: Bearer auth, Claude Code identity headers
     if (apiKey && isOAuthToken(apiKey)) {
-        const client = new Anthropic({
+        const client = new PiAnthropic({
             apiKey: null,
             authToken: apiKey,
             baseURL: model.baseUrl,
             dangerouslyAllowBrowser: true,
             fetch,
-            defaultHeaders: mergeHeaders({
+            defaultHeaders: mergeClientHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
-                "anthropic-beta": ["claude-code-20250219", "oauth-2025-04-20", ...betaFeatures].join(","),
                 "user-agent": `claude-cli/${claudeCodeVersion}`,
                 "x-app": "cli",
             }, model.headers, optionsHeaders),
         });
         return { client, isOAuthToken: true };
     }
-    // API key or header-owned auth.
-    const sessionAffinityHeaders = sessionId && getAnthropicCompat(model).sendSessionAffinityHeaders ? { "x-session-affinity": sessionId } : {};
-    const defaultHeaders = mergeHeaders({
+    // API key, header-owned auth, or workload identity federation.
+    const compat = getAnthropicCompat(model);
+    const sessionAffinityHeaders = {};
+    if (sessionId && compat.sendSessionAffinityHeaders) {
+        const header = compat.sessionAffinityFormat === "openrouter" ? "x-session-id" : "x-session-affinity";
+        sessionAffinityHeaders[header] = sessionId;
+    }
+    const defaultHeaders = mergeClientHeaders({
         accept: "application/json",
         "anthropic-dangerous-direct-browser-access": "true",
-        ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
     }, sessionAffinityHeaders, model.headers, optionsHeaders);
-    const client = new Anthropic({
+    if (federation) {
+        const key = JSON.stringify([model.baseUrl, federation]);
+        if (federationClient?.key !== key || federationClient.fetch !== fetch) {
+            const client = new PiAnthropic({
+                apiKey: null,
+                authToken: null,
+                config: federation,
+                baseURL: model.baseUrl,
+                dangerouslyAllowBrowser: true,
+                fetch,
+            });
+            federationClient = { key, fetch, client };
+        }
+        return { client: federationClient.client.withOptions({ defaultHeaders }), isOAuthToken: false };
+    }
+    const client = new PiAnthropic({
         apiKey: apiKey ?? null,
         authToken: null,
         baseURL: model.baseUrl,
@@ -701,24 +817,70 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
     });
     return { client, isOAuthToken: false };
 }
+function getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, options) {
+    let configuredFeatures;
+    for (const headers of [model.headers, options?.headers]) {
+        for (const [name, value] of Object.entries(headers ?? {})) {
+            if (name.toLowerCase() === "anthropic-beta")
+                configuredFeatures = value;
+        }
+    }
+    if (configuredFeatures === null)
+        return [];
+    if (configuredFeatures !== undefined) {
+        return [
+            ...new Set(configuredFeatures
+                .split(",")
+                .map((feature) => feature.trim())
+                .filter((feature) => feature.length > 0)),
+        ];
+    }
+    const features = [];
+    if (isOAuthToken)
+        features.push("claude-code-20250219", "oauth-2025-04-20");
+    if (shouldUseFineGrainedToolStreamingBeta(model, context))
+        features.push(FINE_GRAINED_TOOL_STREAMING_BETA);
+    if (model.reasoning &&
+        options?.thinkingEnabled === true &&
+        (options.interleavedThinking ?? true) &&
+        model.compat?.forceAdaptiveThinking !== true) {
+        features.push(INTERLEAVED_THINKING_BETA);
+    }
+    if (shouldUseServerSideFallbackBeta(model))
+        features.push(SERVER_SIDE_FALLBACK_BETA);
+    if (model.compat?.supportsMidConvoEffort === true) {
+        features.push(MID_CONVERSATION_OUTPUT_CONFIG_BETA, THINKING_BINDING_CONTROLS_BETA);
+    }
+    if (nativeToolChanges)
+        features.push(MID_CONVERSATION_TOOL_CHANGES_BETA);
+    return [...new Set(features)];
+}
 function buildParams(model, context, isOAuthToken, options) {
     const { cacheControl } = getCacheControl(model, options?.cacheRetention, options?.env);
     const compat = getAnthropicCompat(model);
+    const initialSystemMessage = getInitialSystemMessage(context.messages);
+    const initialSystemText = initialSystemMessage ? getSystemMessageText(initialSystemMessage) : "";
     const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
-    const normalizeToolName = isOAuthToken ? toClaudeCodeName : (name) => name;
-    const toolPlacement = splitDeferredTools({ ...context, messages: transformedMessages }, compat.supportsToolReferences, normalizeToolName);
-    let immediateTools = toolPlacement.immediate;
-    let deferredTools = [...toolPlacement.deferred.values()];
-    if (immediateTools.length === 0 && deferredTools.length > 0) {
-        immediateTools = deferredTools;
-        deferredTools = [];
-    }
-    const deferredToolNames = new Set(deferredTools.map((tool) => normalizeToolName(tool.name)));
+    const conversationMessages = initialSystemMessage ? transformedMessages.slice(1) : transformedMessages;
+    // Native tool changes reference tools by name, so a redefined name cannot be expressed,
+    // and Anthropic rejects a tool list where every tool is deferred, so there must be an
+    // initial active tool to anchor the deferred ones. Otherwise the current tool list is sent.
+    const initialTools = initialSystemMessage?.toolsAdded ?? [];
+    const nativeToolChanges = compat.supportsMidConvoSystemMessages &&
+        compat.supportsMidConvoToolChanges &&
+        initialTools.length > 0 &&
+        !hasToolRedefinitions(context.messages);
+    const converted = convertMessages(conversationMessages, isOAuthToken, cacheControl, compat.allowEmptySignature, model.compat?.supportsMidConvoEffort === true ? model.provider : undefined, nativeToolChanges);
+    const activeEffort = options?.effort ?? "high";
+    const betaFeatures = getBetaFeatures(model, context, isOAuthToken, nativeToolChanges, options);
     const params = {
         model: model.id,
-        messages: convertMessages(transformedMessages, isOAuthToken, cacheControl, compat.allowEmptySignature, deferredToolNames, normalizeToolName),
+        messages: model.compat?.supportsMidConvoEffort === true
+            ? insertThinkingLevelMessages(converted, activeEffort)
+            : converted.messages,
         max_tokens: options?.maxTokens ?? model.maxTokens,
         stream: true,
+        ...(betaFeatures.length > 0 ? { betas: betaFeatures } : {}),
     };
     // For OAuth tokens, we MUST include Claude Code identity
     if (isOAuthToken) {
@@ -729,36 +891,62 @@ function buildParams(model, context, isOAuthToken, options) {
                 ...(cacheControl ? { cache_control: cacheControl } : {}),
             },
         ];
-        if (context.systemPrompt) {
+        if (initialSystemText) {
             params.system.push({
                 type: "text",
-                text: sanitizeSurrogates(context.systemPrompt),
+                text: sanitizeSurrogates(initialSystemText),
                 ...(cacheControl ? { cache_control: cacheControl } : {}),
             });
         }
     }
-    else if (context.systemPrompt) {
+    else if (initialSystemText) {
         // Add cache control to system prompt for non-OAuth tokens
         params.system = [
             {
                 type: "text",
-                text: sanitizeSurrogates(context.systemPrompt),
+                text: sanitizeSurrogates(initialSystemText),
                 ...(cacheControl ? { cache_control: cacheControl } : {}),
             },
         ];
     }
     // Temperature is incompatible with extended thinking and unsupported on Claude Opus 4.7+.
-    if (options?.temperature !== undefined && !options?.thinkingEnabled && compat.supportsTemperature) {
+    if (options?.temperature !== undefined &&
+        !options?.thinkingEnabled &&
+        model.compat?.supportsMidConvoEffort !== true &&
+        compat.supportsTemperature) {
         params.temperature = options.temperature;
     }
-    if (immediateTools.length > 0 || deferredTools.length > 0) {
+    const toolCacheControl = compat.supportsCacheControlOnTools ? cacheControl : undefined;
+    if (nativeToolChanges) {
+        // Initial tools stay active with the cache breakpoint on the last one. Every later
+        // declaration is deferred and only surfaced by its `tool_addition` block; removed
+        // tools stay declared and are withdrawn by `tool_removal`. The request-level list
+        // therefore only grows, keeping the cached prefix intact across tool changes.
+        const initialNames = new Set(initialTools.map((tool) => tool.name));
+        const laterTools = getDeclaredTools(context.messages).filter((tool) => !initialNames.has(tool.name));
         params.tools = [
-            ...convertTools(immediateTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, compat.supportsCacheControlOnTools ? cacheControl : undefined),
-            ...convertTools(deferredTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, undefined, true),
+            ...convertTools(initialTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl),
+            DEFERRED_TOOL_PLACEHOLDER,
+            ...convertTools(laterTools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools).map((tool) => ({ ...tool, defer_loading: true })),
         ];
     }
-    // Configure thinking mode: adaptive, budget-based, or explicitly disabled.
-    if (model.reasoning) {
+    else {
+        const tools = getCurrentTools(context.messages);
+        if (tools.length > 0) {
+            params.tools = convertTools(tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsStrictTools, toolCacheControl);
+        }
+    }
+    // Managed effort models always use adaptive thinking so prefix mismatches can
+    // be dropped instead of surfacing as persistent 400 responses.
+    if (model.compat?.supportsMidConvoEffort === true) {
+        params.thinking = {
+            type: "adaptive",
+            display: options?.thinkingDisplay ?? "summarized",
+            block_binding: { prefix_mismatch_behavior: "drop_block" },
+        };
+        params.output_config = { effort: "high" };
+    }
+    else if (model.reasoning) {
         if (options?.thinkingEnabled) {
             // Default to "summarized" so Opus 4.7 and Mythos Preview behave like
             // older Claude 4 models (whose API default is also "summarized").
@@ -767,11 +955,7 @@ function buildParams(model, context, isOAuthToken, options) {
                 // Adaptive thinking: Claude decides when and how much to think.
                 params.thinking = { type: "adaptive", display };
                 if (options.effort) {
-                    // The Anthropic SDK types can lag newly supported effort values such as "xhigh".
-                    params.output_config =
-                        options.effort === "xhigh"
-                            ? { effort: options.effort }
-                            : { effort: options.effort };
+                    params.output_config = { effort: options.effort };
                 }
             }
             else {
@@ -801,46 +985,64 @@ function buildParams(model, context, isOAuthToken, options) {
             params.tool_choice = options.toolChoice;
         }
     }
+    const allowedFallbackModels = model.compat?.allowedFallbackModels;
+    if (allowedFallbackModels && allowedFallbackModels.length > 0) {
+        params.fallbacks = allowedFallbackModels.map((fallback) => ({ model: fallback.model }));
+    }
     return params;
 }
 // Normalize tool call IDs to match Anthropic's required pattern and length
 function normalizeToolCallId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-function convertToolResult(msg, isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName) {
-    const references = [];
-    for (const name of msg.addedToolNames ?? []) {
-        const normalizedName = normalizeToolName(name);
-        if (!deferredToolNames.has(normalizedName) || loadedToolNames.has(normalizedName))
-            continue;
-        loadedToolNames.add(normalizedName);
-        references.push({
-            type: "tool_reference",
-            tool_name: isOAuthToken ? toClaudeCodeName(name) : name,
-        });
-    }
-    const convertedContent = convertContentBlocks(msg.content);
-    // Anthropic rejects tool references mixed with ordinary tool-result content.
+function convertToolResult(msg) {
     return {
-        toolResult: {
-            type: "tool_result",
-            tool_use_id: msg.toolCallId,
-            content: references.length > 0 ? references : convertedContent,
-            is_error: msg.isError,
-        },
-        siblingContent: references.length === 0
-            ? []
-            : typeof convertedContent === "string"
-                ? [{ type: "text", text: convertedContent }]
-                : convertedContent,
+        type: "tool_result",
+        tool_use_id: msg.toolCallId,
+        content: convertContentBlocks(msg.content),
+        is_error: msg.isError,
     };
 }
-function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowEmptySignature = false, deferredToolNames = new Set(), normalizeToolName = (name) => name) {
+function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowEmptySignature = false, managedProvider, nativeToolChanges = false) {
     const params = [];
-    const loadedToolNames = new Set();
+    const assistantLevels = new Map();
+    // Later system messages are held back and emitted directly before the next assistant
+    // message (or at the end of the transcript). Anthropic requires `tool_result` blocks to
+    // immediately follow their `tool_use`, so a system message between them is rejected; this
+    // also mirrors where the managed-effort system messages are inserted. As a result an
+    // update placed before a user message in the transcript lands after it on the wire.
+    const pendingSystemMessages = [];
+    const flushPendingSystemMessages = () => {
+        params.push(...pendingSystemMessages);
+        pendingSystemMessages.length = 0;
+    };
     for (let i = 0; i < transformedMessages.length; i++) {
         const msg = transformedMessages[i];
-        if (msg.role === "user") {
+        if (msg.role === "system") {
+            // Later system messages only reach this point when the model accepts them natively;
+            // otherwise the transcript was collapsed into the leading message before conversion.
+            const text = renderSystemMessageUpdate(msg);
+            const blocks = [];
+            if (text.length > 0)
+                blocks.push({ type: "text", text: sanitizeSurrogates(text) });
+            if (nativeToolChanges) {
+                for (const tool of msg.toolsRemoved ?? []) {
+                    blocks.push({
+                        type: "tool_removal",
+                        tool: { type: "tool_reference", name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name },
+                    });
+                }
+                for (const tool of msg.toolsAdded ?? []) {
+                    blocks.push({
+                        type: "tool_addition",
+                        tool: { type: "tool_reference", name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name },
+                    });
+                }
+            }
+            if (blocks.length > 0)
+                pendingSystemMessages.push({ role: "system", content: blocks });
+        }
+        else if (msg.role === "user") {
             if (typeof msg.content === "string") {
                 if (msg.content.trim().length > 0) {
                     params.push({
@@ -883,6 +1085,7 @@ function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowE
             }
         }
         else if (msg.role === "assistant") {
+            flushPendingSystemMessages();
             const blocks = [];
             for (const block of msg.content) {
                 if (block.type === "text") {
@@ -940,39 +1143,47 @@ function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowE
             }
             if (blocks.length === 0)
                 continue;
+            const messageIndex = params.length;
             params.push({
                 role: "assistant",
                 content: blocks,
             });
+            if (managedProvider !== undefined &&
+                msg.api === "anthropic-messages" &&
+                msg.provider === managedProvider &&
+                isAnthropicEffort(msg.providerThinkingLevel)) {
+                assistantLevels.set(messageIndex, msg.providerThinkingLevel);
+            }
         }
         else if (msg.role === "toolResult") {
             // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint.
             const toolResults = [];
-            const siblingContent = [];
             let j = i;
             while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                const converted = convertToolResult(transformedMessages[j], isOAuthToken, deferredToolNames, loadedToolNames, normalizeToolName);
-                toolResults.push(converted.toolResult);
-                siblingContent.push(...converted.siblingContent);
+                toolResults.push(convertToolResult(transformedMessages[j]));
                 j++;
             }
             // Skip the messages we've already processed.
             i = j - 1;
-            // Displaced reference-bearing results must follow every tool_result block.
             params.push({
                 role: "user",
-                content: [...toolResults, ...siblingContent],
+                content: toolResults,
             });
         }
     }
-    // Add cache_control to the last user message to cache conversation history
+    flushPendingSystemMessages();
+    // Add cache_control to the last user or system message to cache conversation history
     if (cacheControl && params.length > 0) {
         const lastMessage = params[params.length - 1];
-        if (lastMessage.role === "user") {
+        if (lastMessage.role === "user" || lastMessage.role === "system") {
             if (Array.isArray(lastMessage.content)) {
                 const lastBlock = lastMessage.content[lastMessage.content.length - 1];
                 if (lastBlock &&
-                    (lastBlock.type === "text" || lastBlock.type === "image" || lastBlock.type === "tool_result")) {
+                    (lastBlock.type === "text" ||
+                        lastBlock.type === "image" ||
+                        lastBlock.type === "tool_result" ||
+                        lastBlock.type === "tool_addition" ||
+                        lastBlock.type === "tool_removal")) {
                     lastBlock.cache_control = cacheControl;
                 }
             }
@@ -987,17 +1198,69 @@ function convertMessages(transformedMessages, isOAuthToken, cacheControl, allowE
             }
         }
     }
-    return params;
+    return { messages: params, assistantLevels };
+}
+function isAnthropicEffort(value) {
+    return value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+}
+function insertThinkingLevelMessages(converted, activeEffort) {
+    const messages = [];
+    for (let index = 0; index < converted.messages.length; index++) {
+        const historicalEffort = converted.assistantLevels.get(index);
+        if (historicalEffort !== undefined) {
+            messages.push({ role: "system", content: [], output_config: { effort: historicalEffort } });
+        }
+        messages.push(converted.messages[index]);
+    }
+    messages.push({ role: "system", content: [], output_config: { effort: activeEffort } });
+    return messages;
 }
 function shouldUseFineGrainedToolStreamingBeta(model, context) {
-    return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
+    return getCurrentTools(context.messages).length > 0 && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
 }
-function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl, deferLoading = false) {
+// Keywords Anthropic strict tool use rejects with a 400 for the whole request.
+// https://platform.claude.com/docs/en/build-with-claude/structured-outputs#json-schema-limitations
+const ANTHROPIC_STRICT_UNSUPPORTED_KEYWORDS = new Set([
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "maxItems",
+    "uniqueItems",
+    "minContains",
+    "maxContains",
+    "minProperties",
+    "maxProperties",
+]);
+const ANTHROPIC_STRICT_STRING_FORMATS = new Set([
+    "date-time",
+    "time",
+    "date",
+    "duration",
+    "email",
+    "hostname",
+    "uri",
+    "ipv4",
+    "ipv6",
+    "uuid",
+]);
+const isAnthropicStrictUnsupportedKeyword = (key, value) => {
+    if (ANTHROPIC_STRICT_UNSUPPORTED_KEYWORDS.has(key))
+        return true;
+    if (key === "minItems")
+        return value !== 0 && value !== 1;
+    if (key === "format")
+        return typeof value !== "string" || !ANTHROPIC_STRICT_STRING_FORMATS.has(value);
+    return false;
+};
+function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supportsStrictTools, cacheControl) {
     if (!tools)
         return [];
     return tools.map((tool, index) => {
-        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictTools);
-        const schema = tool.parameters;
+        const strict = resolveJsonSchemaStrictSampling(tool, supportsStrictTools, isAnthropicStrictUnsupportedKeyword);
+        const parameters = getJsonSchemaToolParameters(tool, strict);
+        const schema = parameters;
         const legacyInputSchema = {
             type: "object",
             properties: schema.properties ?? {},
@@ -1005,7 +1268,7 @@ function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supp
         };
         const inputSchema = strict === true
             ? {
-                ...tool.parameters,
+                ...parameters,
                 ...legacyInputSchema,
             }
             : legacyInputSchema;
@@ -1015,7 +1278,6 @@ function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, supp
             ...(supportsEagerToolInputStreaming ? { eager_input_streaming: true } : {}),
             ...(strict === true ? { strict: true } : {}),
             input_schema: inputSchema,
-            ...(deferLoading ? { defer_loading: true } : {}),
             ...(cacheControl && index === tools.length - 1 ? { cache_control: cacheControl } : {}),
         };
     });