@draht/ai 2026.5.12 → 2026.6.11

package/dist/providers/anthropic.js

@@ -1,9 +1,10 @@
 import Anthropic from "@anthropic-ai/sdk";
-import { getEnvApiKey } from "../env-api-keys.js";
-import { calculateCost, supportsMax } from "../models.js";
+import { calculateCost } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
-import { parseStreamingJson } from "../utils/json-parse.js";
+import { headersToRecord } from "../utils/headers.js";
+import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
+import { resolveCloudflareBaseUrl } from "./cloudflare.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { adjustMaxTokensForThinking, buildBaseOptions } from "./simple-options.js";
 import { transformMessages } from "./transform-messages.js";
@@ -20,58 +21,40 @@ function resolveCacheRetention(cacheRetention) {
     }
     return "short";
 }
-function getCacheControl(baseUrl, cacheRetention) {
+function getCacheControl(model, cacheRetention) {
     const retention = resolveCacheRetention(cacheRetention);
     if (retention === "none") {
         return { retention };
     }
-    const ttl = retention === "long" && baseUrl.includes("api.anthropic.com") ? "1h" : undefined;
+    const ttl = retention === "long" && getAnthropicCompat(model).supportsLongCacheRetention ? "1h" : undefined;
     return {
         retention,
         cacheControl: { type: "ephemeral", ...(ttl && { ttl }) },
     };
 }
-// Stealth mode: Mimic Claude Code's identity, headers, and tool naming.
-// Source: https://cchistory.mariozechner.at/data/prompts-2.1.100.md
+// Stealth mode: Mimic Claude Code's tool naming exactly
+const claudeCodeVersion = "2.1.75";
+// 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
-const claudeCodeVersion = "2.1.100";
-// Build hash suffix that Claude Code appends to the billing header's cc_version.
-// Each real release has its own hash (e.g. 2.1.100 -> "1af", 2.1.90 -> "232").
-// This value only needs to parse; it is not cryptographically verified server-side.
-const claudeCodeBuild = "1af";
-// First line of Claude Code's system prompt. Anthropic uses this to classify
-// traffic as first-party Claude Code (vs third-party SDK usage) for billing.
-const claudeCodeBillingHeader = `x-anthropic-billing-header: cc_version=${claudeCodeVersion}.${claudeCodeBuild}; cc_entrypoint=sdk-cli; cch=00000;`;
-// Identity statement that immediately follows the billing header in real Claude Code.
-const claudeCodeIdentity = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
-// Claude Code 2.1.100 tool names (canonical casing), both active and deferred
-// (deferred tools are loaded on-demand via ToolSearch but still use these names).
 const claudeCodeTools = [
-    "Agent",
-    "AskUserQuestion",
-    "Bash",
-    "CronCreate",
-    "CronDelete",
-    "CronList",
+    "Read",
+    "Write",
     "Edit",
+    "Bash",
+    "Grep",
+    "Glob",
+    "AskUserQuestion",
     "EnterPlanMode",
-    "EnterWorktree",
     "ExitPlanMode",
-    "ExitWorktree",
-    "Glob",
-    "Grep",
-    "Monitor",
+    "KillShell",
     "NotebookEdit",
-    "Read",
-    "RemoteTrigger",
     "Skill",
+    "Task",
     "TaskOutput",
-    "TaskStop",
     "TodoWrite",
-    "ToolSearch",
     "WebFetch",
     "WebSearch",
-    "Write",
 ];
 const ccToolLookup = new Map(claudeCodeTools.map((t) => [t.toLowerCase(), t]));
 // Convert tool name to CC canonical casing if it matches (case-insensitive)
@@ -121,6 +104,21 @@ function convertContentBlocks(content) {
     }
     return blocks;
 }
+const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+function getAnthropicCompat(model) {
+    // Auto-detect session affinity and cache control support from provider
+    const isFireworks = model.provider === "fireworks";
+    const isCloudflareAiGatewayAnthropic = model.provider === "cloudflare-ai-gateway" && model.baseUrl.includes("anthropic");
+    return {
+        supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? !isFireworks,
+        supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? !isFireworks,
+        sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? !!(isFireworks || isCloudflareAiGatewayAnthropic),
+        supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? !isFireworks,
+        supportsTemperature: model.compat?.supportsTemperature ?? true,
+        allowEmptySignature: model.compat?.allowEmptySignature ?? false,
+    };
+}
 function mergeHeaders(...headerSources) {
     const merged = {};
     for (const headers of headerSources) {
@@ -130,6 +128,157 @@ function mergeHeaders(...headerSources) {
     }
     return merged;
 }
+const ANTHROPIC_MESSAGE_EVENTS = new Set([
+    "message_start",
+    "message_delta",
+    "message_stop",
+    "content_block_start",
+    "content_block_delta",
+    "content_block_stop",
+]);
+function flushSseEvent(state) {
+    if (!state.event && state.data.length === 0) {
+        return null;
+    }
+    const event = {
+        event: state.event,
+        data: state.data.join("\n"),
+        raw: [...state.raw],
+    };
+    state.event = null;
+    state.data = [];
+    state.raw = [];
+    return event;
+}
+function decodeSseLine(line, state) {
+    if (line === "") {
+        return flushSseEvent(state);
+    }
+    state.raw.push(line);
+    if (line.startsWith(":")) {
+        return null;
+    }
+    const delimiterIndex = line.indexOf(":");
+    const fieldName = delimiterIndex === -1 ? line : line.slice(0, delimiterIndex);
+    let value = delimiterIndex === -1 ? "" : line.slice(delimiterIndex + 1);
+    if (value.startsWith(" ")) {
+        value = value.slice(1);
+    }
+    if (fieldName === "event") {
+        state.event = value;
+    }
+    else if (fieldName === "data") {
+        state.data.push(value);
+    }
+    return null;
+}
+function nextLineBreakIndex(text) {
+    const carriageReturnIndex = text.indexOf("\r");
+    const newlineIndex = text.indexOf("\n");
+    if (carriageReturnIndex === -1) {
+        return newlineIndex;
+    }
+    if (newlineIndex === -1) {
+        return carriageReturnIndex;
+    }
+    return Math.min(carriageReturnIndex, newlineIndex);
+}
+function consumeLine(text) {
+    const lineBreakIndex = nextLineBreakIndex(text);
+    if (lineBreakIndex === -1) {
+        return null;
+    }
+    let nextIndex = lineBreakIndex + 1;
+    if (text[lineBreakIndex] === "\r" && text[nextIndex] === "\n") {
+        nextIndex += 1;
+    }
+    return {
+        line: text.slice(0, lineBreakIndex),
+        rest: text.slice(nextIndex),
+    };
+}
+async function* iterateSseMessages(body, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const state = { event: null, data: [], raw: [] };
+    let buffer = "";
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
+            const { value, done } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            let consumed = consumeLine(buffer);
+            while (consumed) {
+                buffer = consumed.rest;
+                const event = decodeSseLine(consumed.line, state);
+                if (event) {
+                    yield event;
+                }
+                consumed = consumeLine(buffer);
+            }
+        }
+        buffer += decoder.decode();
+        let consumed = consumeLine(buffer);
+        while (consumed) {
+            buffer = consumed.rest;
+            const event = decodeSseLine(consumed.line, state);
+            if (event) {
+                yield event;
+            }
+            consumed = consumeLine(buffer);
+        }
+        if (buffer.length > 0) {
+            const event = decodeSseLine(buffer, state);
+            if (event) {
+                yield event;
+            }
+        }
+        const trailingEvent = flushSseEvent(state);
+        if (trailingEvent) {
+            yield trailingEvent;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+async function* iterateAnthropicEvents(response, signal) {
+    if (!response.body) {
+        throw new Error("Attempted to iterate over an Anthropic response with no body");
+    }
+    let sawMessageStart = false;
+    let sawMessageEnd = false;
+    for await (const sse of iterateSseMessages(response.body, signal)) {
+        if (sse.event === "error") {
+            throw new Error(sse.data);
+        }
+        if (!ANTHROPIC_MESSAGE_EVENTS.has(sse.event ?? "")) {
+            continue;
+        }
+        try {
+            const event = parseJsonWithRepair(sse.data);
+            if (event.type === "message_start") {
+                sawMessageStart = true;
+            }
+            else if (event.type === "message_stop") {
+                sawMessageEnd = true;
+            }
+            yield event;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Could not parse Anthropic SSE event ${sse.event}: ${message}; data=${sse.data}; raw=${sse.raw.join("\\n")}`);
+        }
+    }
+    if (sawMessageStart && !sawMessageEnd) {
+        throw new Error("Anthropic stream ended before message_stop");
+    }
+}
 export const streamAnthropic = (model, context, options) => {
     const stream = new AssistantMessageEventStream();
     (async () => {
@@ -158,7 +307,10 @@ export const streamAnthropic = (model, context, options) => {
                 isOAuth = false;
             }
             else {
-                const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
+                const apiKey = options?.apiKey;
+                if (!apiKey) {
+                    throw new Error(`No API key for provider: ${model.provider}`);
+                }
                 let copilotDynamicHeaders;
                 if (model.provider === "github-copilot") {
                     const hasImages = hasCopilotVisionInput(context.messages);
@@ -167,7 +319,9 @@ export const streamAnthropic = (model, context, options) => {
                         hasImages,
                     });
                 }
-                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers, copilotDynamicHeaders);
+                const cacheRetention = options?.cacheRetention ?? resolveCacheRetention();
+                const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
+                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, copilotDynamicHeaders, cacheSessionId);
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
@@ -176,10 +330,16 @@ export const streamAnthropic = (model, context, options) => {
             if (nextParams !== undefined) {
                 params = nextParams;
             }
-            const anthropicStream = client.messages.stream({ ...params, stream: true }, { signal: options?.signal });
+            const requestOptions = {
+                ...(options?.signal ? { signal: options.signal } : {}),
+                ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+                maxRetries: options?.maxRetries ?? 0,
+            };
+            const response = await client.messages.create({ ...params, stream: true }, requestOptions).asResponse();
+            await options?.onResponse?.({ status: response.status, headers: headersToRecord(response.headers) }, model);
             stream.push({ type: "start", partial: output });
             const blocks = output.content;
-            for await (const event of anthropicStream) {
+            for await (const event of iterateAnthropicEvents(response, options?.signal)) {
                 if (event.type === "message_start") {
                     output.responseId = event.message.id;
                     // Capture initial token usage from message_start event
@@ -312,6 +472,8 @@ export const streamAnthropic = (model, context, options) => {
                         }
                         else if (block.type === "toolCall") {
                             block.arguments = parseStreamingJson(block.partialJson);
+                            // Finalize in-place and strip the scratch buffer so replay only
+                            // carries parsed arguments.
                             delete block.partialJson;
                             stream.push({
                                 type: "toolcall_end",
@@ -356,8 +518,11 @@ export const streamAnthropic = (model, context, options) => {
             stream.end();
         }
         catch (error) {
-            for (const block of output.content)
+            for (const block of output.content) {
                 delete block.index;
+                // partialJson is only a streaming scratch buffer; never persist it.
+                delete block.partialJson;
+            }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
             output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
             stream.push({ type: "error", reason: output.stopReason, error: output });
@@ -366,41 +531,28 @@ export const streamAnthropic = (model, context, options) => {
     })();
     return stream;
 };
-/**
- * Check if a model supports adaptive thinking (Opus 4.6 and Sonnet 4.6)
- */
-function supportsAdaptiveThinking(modelId) {
-    // Opus 4.6 and Sonnet 4.6 model IDs (with or without date suffix)
-    return (modelId.includes("opus-4-6") ||
-        modelId.includes("opus-4.6") ||
-        modelId.includes("sonnet-4-6") ||
-        modelId.includes("sonnet-4.6"));
-}
 /**
  * Map ThinkingLevel to Anthropic effort levels for adaptive thinking.
- * Note: effort "max" is only valid on Opus models that pass `supportsMax`.
+ * Note: effort "max" is only valid on Opus 4.6, while Opus 4.7+ and Fable 5 support "xhigh".
  */
-function mapThinkingLevelToEffort(level, modelId) {
-    const supportsMaxEffort = supportsMax({ id: modelId });
+function mapThinkingLevelToEffort(model, level) {
+    const mapped = level ? model.thinkingLevelMap?.[level] : undefined;
+    if (typeof mapped === "string")
+        return mapped;
     switch (level) {
         case "minimal":
-            return "low";
         case "low":
             return "low";
         case "medium":
             return "medium";
         case "high":
             return "high";
-        case "xhigh":
-            return supportsMaxEffort ? "max" : "high";
-        case "max":
-            return supportsMaxEffort ? "max" : "high";
         default:
             return "high";
     }
 }
 export const streamSimpleAnthropic = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+    const apiKey = options?.apiKey;
     if (!apiKey) {
         throw new Error(`No API key for provider: ${model.provider}`);
     }
@@ -408,17 +560,19 @@ export const streamSimpleAnthropic = (model, context, options) => {
     if (!options?.reasoning) {
         return streamAnthropic(model, context, { ...base, thinkingEnabled: false });
     }
-    // For Opus 4.6 and Sonnet 4.6: use adaptive thinking with effort level
-    // For older models: use budget-based thinking
-    if (supportsAdaptiveThinking(model.id)) {
-        const effort = mapThinkingLevelToEffort(options.reasoning, model.id);
+    // For models with adaptive thinking: use an effort level.
+    // For older models: use budget-based thinking.
+    if (model.compat?.forceAdaptiveThinking === true) {
+        const effort = mapThinkingLevelToEffort(model, options.reasoning);
         return streamAnthropic(model, context, {
             ...base,
             thinkingEnabled: true,
             effort,
         });
     }
-    const adjusted = adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options.thinkingBudgets);
+    // Undefined means the caller did not request an output cap; let the helper use the model cap.
+    // Do not coerce to 0 here, or the thinking budget would become the entire max_tokens value.
+    const adjusted = adjustMaxTokensForThinking(base.maxTokens, model.maxTokens, options.reasoning, options.thinkingBudgets);
     return streamAnthropic(model, context, {
         ...base,
         maxTokens: adjusted.maxTokens,
@@ -429,16 +583,35 @@ export const streamSimpleAnthropic = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynamicHeaders) {
-    // Adaptive thinking models (Opus 4.6, Sonnet 4.6) have interleaved thinking built-in.
-    // The beta header is deprecated on Opus 4.6 and redundant on Sonnet 4.6, so skip it.
-    const needsInterleavedBeta = interleavedThinking && !supportsAdaptiveThinking(model.id);
-    // Copilot: Bearer auth, selective betas (no fine-grained-tool-streaming)
+function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, 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);
+    }
+    if (model.provider === "cloudflare-ai-gateway") {
+        const client = new Anthropic({
+            apiKey: null,
+            authToken: null,
+            baseURL: resolveCloudflareBaseUrl(model),
+            dangerouslyAllowBrowser: true,
+            defaultHeaders: mergeHeaders({
+                accept: "application/json",
+                "anthropic-dangerous-direct-browser-access": "true",
+                "cf-aig-authorization": `Bearer ${apiKey}`,
+                "x-api-key": null,
+                Authorization: null,
+                ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
+            }, model.headers, optionsHeaders),
+        });
+        return { client, isOAuthToken: false };
+    }
+    // Copilot: Bearer auth, selective betas.
     if (model.provider === "github-copilot") {
-        const betaFeatures = [];
-        if (needsInterleavedBeta) {
-            betaFeatures.push("interleaved-thinking-2025-05-14");
-        }
         const client = new Anthropic({
             apiKey: null,
             authToken: apiKey,
@@ -452,10 +625,6 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
         });
         return { client, isOAuthToken: false };
     }
-    const betaFeatures = ["fine-grained-tool-streaming-2025-05-14"];
-    if (needsInterleavedBeta) {
-        betaFeatures.push("interleaved-thinking-2025-05-14");
-    }
     // OAuth: Bearer auth, Claude Code identity headers
     if (isOAuthToken(apiKey)) {
         const client = new Anthropic({
@@ -466,7 +635,7 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
             defaultHeaders: mergeHeaders({
                 accept: "application/json",
                 "anthropic-dangerous-direct-browser-access": "true",
-                "anthropic-beta": `claude-code-20250219,oauth-2025-04-20,${betaFeatures.join(",")}`,
+                "anthropic-beta": ["claude-code-20250219", "oauth-2025-04-20", ...betaFeatures].join(","),
                 "user-agent": `claude-cli/${claudeCodeVersion}`,
                 "x-app": "cli",
             }, model.headers, optionsHeaders),
@@ -474,36 +643,35 @@ function createClient(model, apiKey, interleavedThinking, optionsHeaders, dynami
         return { client, isOAuthToken: true };
     }
     // API key auth
+    const sessionAffinityHeaders = sessionId && getAnthropicCompat(model).sendSessionAffinityHeaders ? { "x-session-affinity": sessionId } : {};
     const client = new Anthropic({
         apiKey,
+        authToken: null,
         baseURL: model.baseUrl,
         dangerouslyAllowBrowser: true,
         defaultHeaders: mergeHeaders({
             accept: "application/json",
             "anthropic-dangerous-direct-browser-access": "true",
-            "anthropic-beta": betaFeatures.join(","),
-        }, model.headers, optionsHeaders),
+            ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
+        }, sessionAffinityHeaders, model.headers, optionsHeaders),
     });
     return { client, isOAuthToken: false };
 }
 function buildParams(model, context, isOAuthToken, options) {
-    const { cacheControl } = getCacheControl(model.baseUrl, options?.cacheRetention);
+    const { cacheControl } = getCacheControl(model, options?.cacheRetention);
+    const compat = getAnthropicCompat(model);
     const params = {
         model: model.id,
-        messages: convertMessages(context.messages, model, isOAuthToken, cacheControl),
-        max_tokens: options?.maxTokens || (model.maxTokens / 3) | 0,
+        messages: convertMessages(context.messages, model, isOAuthToken, cacheControl, compat.allowEmptySignature),
+        max_tokens: options?.maxTokens ?? model.maxTokens,
         stream: true,
     };
-    // For OAuth tokens, we MUST prepend the Claude Code billing header and identity.
-    // Anthropic inspects the first system block to classify traffic as first-party
-    // Claude Code (billed against the Claude subscription) vs third-party SDK usage
-    // (billed as extra usage per token). Without these exact strings, Pro/Max/Team
-    // subscriptions are metered as third-party.
+    // For OAuth tokens, we MUST include Claude Code identity
     if (isOAuthToken) {
         params.system = [
             {
                 type: "text",
-                text: `${claudeCodeBillingHeader}\n${claudeCodeIdentity}`,
+                text: "You are Claude Code, Anthropic's official CLI for Claude.",
                 ...(cacheControl ? { cache_control: cacheControl } : {}),
             },
         ];
@@ -525,22 +693,29 @@ function buildParams(model, context, isOAuthToken, options) {
             },
         ];
     }
-    // Temperature is incompatible with extended thinking (adaptive or budget-based).
-    if (options?.temperature !== undefined && !options?.thinkingEnabled) {
+    // Temperature is incompatible with extended thinking and unsupported on Claude Opus 4.7+.
+    if (options?.temperature !== undefined && !options?.thinkingEnabled && compat.supportsTemperature) {
         params.temperature = options.temperature;
     }
-    if (context.tools) {
-        params.tools = convertTools(context.tools, isOAuthToken);
+    if (context.tools && context.tools.length > 0) {
+        const compat = getAnthropicCompat(model);
+        params.tools = convertTools(context.tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined);
     }
-    // Configure thinking mode: adaptive (Opus 4.6 and Sonnet 4.6),
-    // budget-based (older models), or explicitly disabled.
+    // Configure thinking mode: adaptive, budget-based, or explicitly disabled.
     if (model.reasoning) {
         if (options?.thinkingEnabled) {
-            if (supportsAdaptiveThinking(model.id)) {
-                // Adaptive thinking: Claude decides when and how much to think
-                params.thinking = { type: "adaptive" };
+            // Default to "summarized" so Opus 4.7 and Mythos Preview behave like
+            // older Claude 4 models (whose API default is also "summarized").
+            const display = options.thinkingDisplay ?? "summarized";
+            if (model.compat?.forceAdaptiveThinking === true) {
+                // Adaptive thinking: Claude decides when and how much to think.
+                params.thinking = { type: "adaptive", display };
                 if (options.effort) {
-                    params.output_config = { effort: 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 };
                 }
             }
             else {
@@ -548,10 +723,11 @@ function buildParams(model, context, isOAuthToken, options) {
                 params.thinking = {
                     type: "enabled",
                     budget_tokens: options.thinkingBudgetTokens || 1024,
+                    display,
                 };
             }
         }
-        else if (options?.thinkingEnabled === false) {
+        else if (options?.thinkingEnabled === false && model.thinkingLevelMap?.off !== null) {
             params.thinking = { type: "disabled" };
         }
     }
@@ -575,7 +751,7 @@ function buildParams(model, context, isOAuthToken, options) {
 function normalizeToolCallId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
 }
-function convertMessages(messages, model, isOAuthToken, cacheControl) {
+function convertMessages(messages, model, isOAuthToken, cacheControl, allowEmptySignature = false) {
     const params = [];
     // Transform messages for cross-provider compatibility
     const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
@@ -609,8 +785,7 @@ function convertMessages(messages, model, isOAuthToken, cacheControl) {
                         };
                     }
                 });
-                let filteredBlocks = !model?.input.includes("image") ? blocks.filter((b) => b.type !== "image") : blocks;
-                filteredBlocks = filteredBlocks.filter((b) => {
+                const filteredBlocks = blocks.filter((b) => {
                     if (b.type === "text") {
                         return b.text.trim().length > 0;
                     }
@@ -647,13 +822,19 @@ function convertMessages(messages, model, isOAuthToken, cacheControl) {
                     if (block.thinking.trim().length === 0)
                         continue;
                     // If thinking signature is missing/empty (e.g., from aborted stream),
-                    // convert to plain text block without <thinking> tags to avoid API rejection
-                    // and prevent Claude from mimicking the tags in responses
+                    // convert to plain text for Anthropic. Some compatible providers emit
+                    // and accept empty signatures, so let marked models preserve the block.
                     if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
-                        blocks.push({
-                            type: "text",
-                            text: sanitizeSurrogates(block.thinking),
-                        });
+                        blocks.push(allowEmptySignature
+                            ? {
+                                type: "thinking",
+                                thinking: sanitizeSurrogates(block.thinking),
+                                signature: "",
+                            }
+                            : {
+                                type: "text",
+                                text: sanitizeSurrogates(block.thinking),
+                            });
                     }
                     else {
                         blocks.push({
@@ -734,19 +915,24 @@ function convertMessages(messages, model, isOAuthToken, cacheControl) {
     }
     return params;
 }
-function convertTools(tools, isOAuthToken) {
+function shouldUseFineGrainedToolStreamingBeta(model, context) {
+    return !!context.tools?.length && !getAnthropicCompat(model).supportsEagerToolInputStreaming;
+}
+function convertTools(tools, isOAuthToken, supportsEagerToolInputStreaming, cacheControl) {
     if (!tools)
         return [];
-    return tools.map((tool) => {
-        const jsonSchema = tool.parameters; // TypeBox already generates JSON Schema
+    return tools.map((tool, index) => {
+        const schema = tool.parameters;
         return {
             name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
             description: tool.description,
+            ...(supportsEagerToolInputStreaming ? { eager_input_streaming: true } : {}),
             input_schema: {
                 type: "object",
-                properties: jsonSchema.properties || {},
-                required: jsonSchema.required || [],
+                properties: schema.properties ?? {},
+                required: schema.required ?? [],
             },
+            ...(cacheControl && index === tools.length - 1 ? { cache_control: cacheControl } : {}),
         };
     });
 }