gsd-pi 2.37.1 → 2.38.0-dev.eeb3520

package/packages/pi-ai/dist/providers/anthropic.js

@@ -1,11 +1,9 @@
 import { getEnvApiKey } from "../env-api-keys.js";
-import { calculateCost } from "../models.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
-import { parseStreamingJson } from "../utils/json-parse.js";
-import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copilot-headers.js";
 import { adjustMaxTokensForThinking, buildBaseOptions } from "./simple-options.js";
-import { transformMessages } from "./transform-messages.js";
+import { extractRetryAfterMs, mapThinkingLevelToEffort, processAnthropicStream, supportsAdaptiveThinking, } from "./anthropic-shared.js";
+export { extractRetryAfterMs };
 let _AnthropicClass;
 async function getAnthropicClass() {
     if (!_AnthropicClass) {
@@ -14,102 +12,8 @@ async function getAnthropicClass() {
     }
     return _AnthropicClass;
 }
-/**
- * Resolve cache retention preference.
- * Defaults to "short" and uses PI_CACHE_RETENTION for backward compatibility.
- */
-function resolveCacheRetention(cacheRetention) {
-    if (cacheRetention) {
-        return cacheRetention;
-    }
-    if (typeof process !== "undefined" && process.env.PI_CACHE_RETENTION === "long") {
-        return "long";
-    }
-    return "short";
-}
-function getCacheControl(baseUrl, cacheRetention) {
-    const retention = resolveCacheRetention(cacheRetention);
-    if (retention === "none") {
-        return { retention };
-    }
-    const ttl = retention === "long" && baseUrl.includes("api.anthropic.com") ? "1h" : undefined;
-    return {
-        retention,
-        cacheControl: { type: "ephemeral", ...(ttl && { ttl }) },
-    };
-}
 // Stealth mode: Mimic Claude Code's tool naming exactly
 const claudeCodeVersion = "2.1.62";
-// 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 claudeCodeTools = [
-    "Read",
-    "Write",
-    "Edit",
-    "Bash",
-    "Grep",
-    "Glob",
-    "AskUserQuestion",
-    "EnterPlanMode",
-    "ExitPlanMode",
-    "KillShell",
-    "NotebookEdit",
-    "Skill",
-    "Task",
-    "TaskOutput",
-    "TodoWrite",
-    "WebFetch",
-    "WebSearch",
-];
-const ccToolLookup = new Map(claudeCodeTools.map((t) => [t.toLowerCase(), t]));
-// Convert tool name to CC canonical casing if it matches (case-insensitive)
-const toClaudeCodeName = (name) => ccToolLookup.get(name.toLowerCase()) ?? name;
-const fromClaudeCodeName = (name, tools) => {
-    if (tools && tools.length > 0) {
-        const lowerName = name.toLowerCase();
-        const matchedTool = tools.find((tool) => tool.name.toLowerCase() === lowerName);
-        if (matchedTool)
-            return matchedTool.name;
-    }
-    return name;
-};
-/**
- * Convert content blocks to Anthropic API format
- */
-function convertContentBlocks(content) {
-    // If only text blocks, return as concatenated string for simplicity
-    const hasImages = content.some((c) => c.type === "image");
-    if (!hasImages) {
-        return sanitizeSurrogates(content.map((c) => c.text).join("\n"));
-    }
-    // If we have images, convert to content block array
-    const blocks = content.map((block) => {
-        if (block.type === "text") {
-            return {
-                type: "text",
-                text: sanitizeSurrogates(block.text),
-            };
-        }
-        return {
-            type: "image",
-            source: {
-                type: "base64",
-                media_type: block.mimeType,
-                data: block.data,
-            },
-        };
-    });
-    // If only images (no text), add placeholder text block
-    const hasText = blocks.some((b) => b.type === "text");
-    if (!hasText) {
-        blocks.unshift({
-            type: "text",
-            text: "(see attached image)",
-        });
-    }
-    return blocks;
-}
 function mergeHeaders(...headerSources) {
     const merged = {};
     for (const headers of headerSources) {
@@ -119,383 +23,6 @@ function mergeHeaders(...headerSources) {
     }
     return merged;
 }
-/**
- * Detect transient network errors that are likely to succeed on retry.
- * Covers WebSocket disconnects (Tailscale, VPN), TCP resets, and DNS failures.
- */
-function isTransientNetworkError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const msg = error.message.toLowerCase();
-    const code = error.code;
-    return (code === 'ECONNRESET' ||
-        code === 'EPIPE' ||
-        code === 'ETIMEDOUT' ||
-        code === 'ENOTFOUND' ||
-        code === 'EAI_AGAIN' ||
-        msg.includes('connector_closed') ||
-        msg.includes('socket hang up') ||
-        msg.includes('network') ||
-        msg.includes('connection') && msg.includes('closed') ||
-        msg.includes('fetch failed'));
-}
-/**
- * Extract retry delay from Anthropic error response headers (in milliseconds).
- * Checks: retry-after (seconds or RFC date), x-ratelimit-reset-requests, x-ratelimit-reset-tokens.
- * Returns undefined if no valid delay is found or if the delay is in the past.
- */
-function extractRetryAfterMs(headers, errorText = "") {
-    const normalizeDelay = (ms) => (ms > 0 ? Math.ceil(ms + 1000) : undefined);
-    const retryAfter = headers.get("retry-after");
-    if (retryAfter) {
-        const seconds = Number(retryAfter);
-        if (Number.isFinite(seconds)) {
-            const delay = normalizeDelay(seconds * 1000);
-            if (delay !== undefined)
-                return delay;
-        }
-        const asDate = new Date(retryAfter).getTime();
-        if (!Number.isNaN(asDate)) {
-            const delay = normalizeDelay(asDate - Date.now());
-            if (delay !== undefined)
-                return delay;
-        }
-    }
-    // x-ratelimit-reset-requests / x-ratelimit-reset-tokens are Unix timestamps (seconds)
-    for (const header of ["x-ratelimit-reset-requests", "x-ratelimit-reset-tokens"]) {
-        const value = headers.get(header);
-        if (value) {
-            const resetSeconds = Number(value);
-            if (Number.isFinite(resetSeconds)) {
-                const delay = normalizeDelay(resetSeconds * 1000 - Date.now());
-                if (delay !== undefined)
-                    return delay;
-            }
-        }
-    }
-    return undefined;
-}
-export const streamAnthropic = (model, context, options) => {
-    const stream = new AssistantMessageEventStream();
-    (async () => {
-        const output = {
-            role: "assistant",
-            content: [],
-            api: model.api,
-            provider: model.provider,
-            model: model.id,
-            usage: {
-                input: 0,
-                output: 0,
-                cacheRead: 0,
-                cacheWrite: 0,
-                totalTokens: 0,
-                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-            },
-            stopReason: "stop",
-            timestamp: Date.now(),
-        };
-        try {
-            const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
-            let copilotDynamicHeaders;
-            if (model.provider === "github-copilot") {
-                const hasImages = hasCopilotVisionInput(context.messages);
-                copilotDynamicHeaders = buildCopilotDynamicHeaders({
-                    messages: context.messages,
-                    hasImages,
-                });
-            }
-            const { client, isOAuthToken } = await createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers, copilotDynamicHeaders);
-            let params = buildParams(model, context, isOAuthToken, options);
-            const nextParams = await options?.onPayload?.(params, model);
-            if (nextParams !== undefined) {
-                params = nextParams;
-            }
-            const anthropicStream = client.messages.stream({ ...params, stream: true }, { signal: options?.signal });
-            stream.push({ type: "start", partial: output });
-            const blocks = output.content;
-            for await (const event of anthropicStream) {
-                if (event.type === "message_start") {
-                    // 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;
-                    output.usage.output = event.message.usage.output_tokens || 0;
-                    output.usage.cacheRead = event.message.usage.cache_read_input_tokens || 0;
-                    output.usage.cacheWrite = event.message.usage.cache_creation_input_tokens || 0;
-                    // 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);
-                }
-                else if (event.type === "content_block_start") {
-                    if (event.content_block.type === "text") {
-                        const block = {
-                            type: "text",
-                            text: "",
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "text_start", contentIndex: output.content.length - 1, partial: output });
-                    }
-                    else if (event.content_block.type === "thinking") {
-                        const block = {
-                            type: "thinking",
-                            thinking: "",
-                            thinkingSignature: "",
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
-                    }
-                    else if (event.content_block.type === "redacted_thinking") {
-                        const block = {
-                            type: "thinking",
-                            thinking: "[Reasoning redacted]",
-                            thinkingSignature: event.content_block.data,
-                            redacted: true,
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "thinking_start", contentIndex: output.content.length - 1, partial: output });
-                    }
-                    else if (event.content_block.type === "tool_use") {
-                        const block = {
-                            type: "toolCall",
-                            id: event.content_block.id,
-                            name: isOAuthToken
-                                ? fromClaudeCodeName(event.content_block.name, context.tools)
-                                : event.content_block.name,
-                            arguments: event.content_block.input ?? {},
-                            partialJson: "",
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "toolcall_start", contentIndex: output.content.length - 1, partial: output });
-                    }
-                    else if (event.content_block.type === "server_tool_use") {
-                        const serverBlock = event.content_block;
-                        const block = {
-                            type: "serverToolUse",
-                            id: serverBlock.id,
-                            name: serverBlock.name,
-                            input: serverBlock.input,
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "server_tool_use", contentIndex: output.content.length - 1, partial: output });
-                    }
-                    else if (event.content_block.type === "web_search_tool_result") {
-                        const resultBlock = event.content_block;
-                        const block = {
-                            type: "webSearchResult",
-                            toolUseId: resultBlock.tool_use_id,
-                            content: resultBlock.content,
-                            index: event.index,
-                        };
-                        output.content.push(block);
-                        stream.push({ type: "web_search_result", contentIndex: output.content.length - 1, partial: output });
-                    }
-                }
-                else if (event.type === "content_block_delta") {
-                    if (event.delta.type === "text_delta") {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === "text") {
-                            block.text += event.delta.text;
-                            stream.push({
-                                type: "text_delta",
-                                contentIndex: index,
-                                delta: event.delta.text,
-                                partial: output,
-                            });
-                        }
-                    }
-                    else if (event.delta.type === "thinking_delta") {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === "thinking") {
-                            block.thinking += event.delta.thinking;
-                            stream.push({
-                                type: "thinking_delta",
-                                contentIndex: index,
-                                delta: event.delta.thinking,
-                                partial: output,
-                            });
-                        }
-                    }
-                    else if (event.delta.type === "input_json_delta") {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === "toolCall") {
-                            block.partialJson += event.delta.partial_json;
-                            block.arguments = parseStreamingJson(block.partialJson);
-                            stream.push({
-                                type: "toolcall_delta",
-                                contentIndex: index,
-                                delta: event.delta.partial_json,
-                                partial: output,
-                            });
-                        }
-                    }
-                    else if (event.delta.type === "signature_delta") {
-                        const index = blocks.findIndex((b) => b.index === event.index);
-                        const block = blocks[index];
-                        if (block && block.type === "thinking") {
-                            block.thinkingSignature = block.thinkingSignature || "";
-                            block.thinkingSignature += event.delta.signature;
-                        }
-                    }
-                }
-                else if (event.type === "content_block_stop") {
-                    const index = blocks.findIndex((b) => b.index === event.index);
-                    const block = blocks[index];
-                    if (block) {
-                        delete block.index;
-                        if (block.type === "text") {
-                            stream.push({
-                                type: "text_end",
-                                contentIndex: index,
-                                content: block.text,
-                                partial: output,
-                            });
-                        }
-                        else if (block.type === "thinking") {
-                            stream.push({
-                                type: "thinking_end",
-                                contentIndex: index,
-                                content: block.thinking,
-                                partial: output,
-                            });
-                        }
-                        else if (block.type === "toolCall") {
-                            block.arguments = parseStreamingJson(block.partialJson);
-                            delete block.partialJson;
-                            stream.push({
-                                type: "toolcall_end",
-                                contentIndex: index,
-                                toolCall: block,
-                                partial: output,
-                            });
-                        }
-                        // serverToolUse and webSearchResult blocks just need index cleanup (already emitted on start)
-                    }
-                }
-                else if (event.type === "message_delta") {
-                    if (event.delta.stop_reason) {
-                        output.stopReason = mapStopReason(event.delta.stop_reason);
-                    }
-                    // Only update usage fields if present (not null).
-                    // Preserves input_tokens from message_start when proxies omit it in message_delta.
-                    if (event.usage.input_tokens != null) {
-                        output.usage.input = event.usage.input_tokens;
-                    }
-                    if (event.usage.output_tokens != null) {
-                        output.usage.output = event.usage.output_tokens;
-                    }
-                    if (event.usage.cache_read_input_tokens != null) {
-                        output.usage.cacheRead = event.usage.cache_read_input_tokens;
-                    }
-                    if (event.usage.cache_creation_input_tokens != null) {
-                        output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
-                    }
-                    // 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);
-                }
-            }
-            if (options?.signal?.aborted) {
-                throw new Error("Request was aborted");
-            }
-            if (output.stopReason === "aborted" || output.stopReason === "error") {
-                throw new Error("An unknown error occurred");
-            }
-            stream.push({ type: "done", reason: output.stopReason, message: output });
-            stream.end();
-        }
-        catch (error) {
-            for (const block of output.content)
-                delete block.index;
-            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
-            if (model.provider === "alibaba-coding-plan") {
-                output.errorMessage = `[alibaba-coding-plan] ${output.errorMessage}`;
-            }
-            const AnthropicSdk = _AnthropicClass;
-            if (AnthropicSdk && error instanceof AnthropicSdk.APIError && error.headers) {
-                const retryAfterMs = extractRetryAfterMs(error.headers, error.message);
-                if (retryAfterMs !== undefined) {
-                    output.retryAfterMs = retryAfterMs;
-                }
-            }
-            // Mark transient network errors as retriable so auto-mode can
-            // detect them and retry instead of stopping (#833).
-            if (isTransientNetworkError(error)) {
-                output.retryAfterMs = output.retryAfterMs ?? 5000;
-            }
-            stream.push({ type: "error", reason: output.stopReason, error: output });
-            stream.end();
-        }
-    })();
-    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 4.6.
- */
-function mapThinkingLevelToEffort(level, modelId) {
-    switch (level) {
-        case "minimal":
-            return "low";
-        case "low":
-            return "low";
-        case "medium":
-            return "medium";
-        case "high":
-            return "high";
-        case "xhigh":
-            return modelId.includes("opus-4-6") || modelId.includes("opus-4.6") ? "max" : "high";
-        default:
-            return "high";
-    }
-}
-export const streamSimpleAnthropic = (model, context, options) => {
-    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
-    if (!apiKey) {
-        throw new Error(`No API key for provider: ${model.provider}`);
-    }
-    const base = buildBaseOptions(model, options, apiKey);
-    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);
-        return streamAnthropic(model, context, {
-            ...base,
-            thinkingEnabled: true,
-            effort,
-        });
-    }
-    const adjusted = adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options.thinkingBudgets);
-    return streamAnthropic(model, context, {
-        ...base,
-        maxTokens: adjusted.maxTokens,
-        thinkingEnabled: true,
-        thinkingBudgetTokens: adjusted.thinkingBudget,
-    });
-};
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
@@ -562,299 +89,55 @@ async function createClient(model, apiKey, interleavedThinking, optionsHeaders,
     });
     return { client, isOAuthToken: false };
 }
-function buildParams(model, context, isOAuthToken, options) {
-    const { cacheControl } = getCacheControl(model.baseUrl, options?.cacheRetention);
-    // Strip variant suffixes like [1m] from model ID before sending to the API.
-    // The API only accepts the base model ID (e.g. "claude-opus-4-6"),
-    // not internal variant identifiers (e.g. "claude-opus-4-6[1m]").
-    // This applies to all auth methods — API keys, OAuth, and Copilot alike.
-    const apiModelId = model.id.replace(/\[.*\]$/, "");
-    const params = {
-        model: apiModelId,
-        messages: convertMessages(context.messages, model, isOAuthToken, cacheControl),
-        max_tokens: options?.maxTokens || (model.maxTokens / 3) | 0,
-        stream: true,
-    };
-    // For OAuth tokens, we MUST include Claude Code identity
-    if (isOAuthToken) {
-        params.system = [
-            {
-                type: "text",
-                text: "You are Claude Code, Anthropic's official CLI for Claude.",
-                ...(cacheControl ? { cache_control: cacheControl } : {}),
-            },
-        ];
-        if (context.systemPrompt) {
-            params.system.push({
-                type: "text",
-                text: sanitizeSurrogates(context.systemPrompt),
-                ...(cacheControl ? { cache_control: cacheControl } : {}),
+export const streamAnthropic = (model, context, options) => {
+    const stream = new AssistantMessageEventStream();
+    (async () => {
+        const apiKey = options?.apiKey ?? getEnvApiKey(model.provider) ?? "";
+        let copilotDynamicHeaders;
+        if (model.provider === "github-copilot") {
+            const hasImages = hasCopilotVisionInput(context.messages);
+            copilotDynamicHeaders = buildCopilotDynamicHeaders({
+                messages: context.messages,
+                hasImages,
             });
         }
+        const { client, isOAuthToken: isOAuth } = await createClient(model, apiKey, options?.interleavedThinking ?? true, options?.headers, copilotDynamicHeaders);
+        processAnthropicStream(stream, {
+            client,
+            model,
+            context,
+            isOAuthToken: isOAuth,
+            options,
+            AnthropicSdkClass: _AnthropicClass,
+        });
+    })();
+    return stream;
+};
+export const streamSimpleAnthropic = (model, context, options) => {
+    const apiKey = options?.apiKey || getEnvApiKey(model.provider);
+    if (!apiKey) {
+        throw new Error(`No API key for provider: ${model.provider}`);
     }
-    else if (context.systemPrompt) {
-        // Add cache control to system prompt for non-OAuth tokens
-        params.system = [
-            {
-                type: "text",
-                text: sanitizeSurrogates(context.systemPrompt),
-                ...(cacheControl ? { cache_control: cacheControl } : {}),
-            },
-        ];
-    }
-    // Temperature is incompatible with extended thinking (adaptive or budget-based).
-    if (options?.temperature !== undefined && !options?.thinkingEnabled) {
-        params.temperature = options.temperature;
-    }
-    if (context.tools) {
-        params.tools = convertTools(context.tools, isOAuthToken);
-    }
-    // Configure thinking mode: adaptive (Opus 4.6 and Sonnet 4.6) or budget-based (older models)
-    if (options?.thinkingEnabled && model.reasoning) {
-        if (supportsAdaptiveThinking(model.id)) {
-            // Adaptive thinking: Claude decides when and how much to think
-            params.thinking = { type: "adaptive" };
-            if (options.effort) {
-                params.output_config = { effort: options.effort };
-            }
-        }
-        else {
-            // Budget-based thinking for older models
-            params.thinking = {
-                type: "enabled",
-                budget_tokens: options.thinkingBudgetTokens || 1024,
-            };
-        }
-    }
-    if (options?.metadata) {
-        const userId = options.metadata.user_id;
-        if (typeof userId === "string") {
-            params.metadata = { user_id: userId };
-        }
-    }
-    if (options?.toolChoice) {
-        if (typeof options.toolChoice === "string") {
-            params.tool_choice = { type: options.toolChoice };
-        }
-        else {
-            params.tool_choice = options.toolChoice;
-        }
-    }
-    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 convertMessages(messages, model, isOAuthToken, cacheControl) {
-    const params = [];
-    // Transform messages for cross-provider compatibility
-    const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
-    for (let i = 0; i < transformedMessages.length; i++) {
-        const msg = transformedMessages[i];
-        if (msg.role === "user") {
-            if (typeof msg.content === "string") {
-                if (msg.content.trim().length > 0) {
-                    params.push({
-                        role: "user",
-                        content: sanitizeSurrogates(msg.content),
-                    });
-                }
-            }
-            else {
-                const blocks = msg.content.map((item) => {
-                    if (item.type === "text") {
-                        return {
-                            type: "text",
-                            text: sanitizeSurrogates(item.text),
-                        };
-                    }
-                    else {
-                        return {
-                            type: "image",
-                            source: {
-                                type: "base64",
-                                media_type: item.mimeType,
-                                data: item.data,
-                            },
-                        };
-                    }
-                });
-                let filteredBlocks = !model?.input.includes("image") ? blocks.filter((b) => b.type !== "image") : blocks;
-                filteredBlocks = filteredBlocks.filter((b) => {
-                    if (b.type === "text") {
-                        return b.text.trim().length > 0;
-                    }
-                    return true;
-                });
-                if (filteredBlocks.length === 0)
-                    continue;
-                params.push({
-                    role: "user",
-                    content: filteredBlocks,
-                });
-            }
-        }
-        else if (msg.role === "assistant") {
-            const blocks = [];
-            for (const block of msg.content) {
-                if (block.type === "text") {
-                    if (block.text.trim().length === 0)
-                        continue;
-                    blocks.push({
-                        type: "text",
-                        text: sanitizeSurrogates(block.text),
-                    });
-                }
-                else if (block.type === "thinking") {
-                    // Redacted thinking: pass the opaque payload back as redacted_thinking
-                    if (block.redacted) {
-                        blocks.push({
-                            type: "redacted_thinking",
-                            data: block.thinkingSignature,
-                        });
-                        continue;
-                    }
-                    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
-                    if (!block.thinkingSignature || block.thinkingSignature.trim().length === 0) {
-                        blocks.push({
-                            type: "text",
-                            text: sanitizeSurrogates(block.thinking),
-                        });
-                    }
-                    else {
-                        blocks.push({
-                            type: "thinking",
-                            thinking: sanitizeSurrogates(block.thinking),
-                            signature: block.thinkingSignature,
-                        });
-                    }
-                }
-                else if (block.type === "toolCall") {
-                    blocks.push({
-                        type: "tool_use",
-                        id: block.id,
-                        name: isOAuthToken ? toClaudeCodeName(block.name) : block.name,
-                        input: block.arguments ?? {},
-                    });
-                }
-                else if (block.type === "serverToolUse") {
-                    blocks.push({
-                        type: "server_tool_use",
-                        id: block.id,
-                        name: block.name,
-                        input: block.input ?? {},
-                    });
-                }
-                else if (block.type === "webSearchResult") {
-                    blocks.push({
-                        type: "web_search_tool_result",
-                        tool_use_id: block.toolUseId,
-                        content: block.content,
-                    });
-                }
-            }
-            if (blocks.length === 0)
-                continue;
-            params.push({
-                role: "assistant",
-                content: blocks,
-            });
-        }
-        else if (msg.role === "toolResult") {
-            // Collect all consecutive toolResult messages, needed for z.ai Anthropic endpoint
-            const toolResults = [];
-            // Add the current tool result
-            toolResults.push({
-                type: "tool_result",
-                tool_use_id: msg.toolCallId,
-                content: convertContentBlocks(msg.content),
-                is_error: msg.isError,
-            });
-            // Look ahead for consecutive toolResult messages
-            let j = i + 1;
-            while (j < transformedMessages.length && transformedMessages[j].role === "toolResult") {
-                const nextMsg = transformedMessages[j]; // We know it's a toolResult
-                toolResults.push({
-                    type: "tool_result",
-                    tool_use_id: nextMsg.toolCallId,
-                    content: convertContentBlocks(nextMsg.content),
-                    is_error: nextMsg.isError,
-                });
-                j++;
-            }
-            // Skip the messages we've already processed
-            i = j - 1;
-            // Add a single user message with all tool results
-            params.push({
-                role: "user",
-                content: toolResults,
-            });
-        }
+    const base = buildBaseOptions(model, options, apiKey);
+    if (!options?.reasoning) {
+        return streamAnthropic(model, context, { ...base, thinkingEnabled: false });
     }
-    // Add cache_control to the last user message to cache conversation history
-    if (cacheControl && params.length > 0) {
-        const lastMessage = params[params.length - 1];
-        if (lastMessage.role === "user") {
-            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.cache_control = cacheControl;
-                }
-            }
-            else if (typeof lastMessage.content === "string") {
-                lastMessage.content = [
-                    {
-                        type: "text",
-                        text: lastMessage.content,
-                        cache_control: cacheControl,
-                    },
-                ];
-            }
-        }
+    // 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);
+        return streamAnthropic(model, context, {
+            ...base,
+            thinkingEnabled: true,
+            effort,
+        });
     }
-    return params;
-}
-function convertTools(tools, isOAuthToken) {
-    if (!tools)
-        return [];
-    return tools.map((tool) => {
-        const jsonSchema = tool.parameters; // TypeBox already generates JSON Schema
-        return {
-            name: isOAuthToken ? toClaudeCodeName(tool.name) : tool.name,
-            description: tool.description,
-            input_schema: {
-                type: "object",
-                properties: jsonSchema.properties || {},
-                required: jsonSchema.required || [],
-            },
-        };
+    const adjusted = adjustMaxTokensForThinking(base.maxTokens || 0, model.maxTokens, options.reasoning, options.thinkingBudgets);
+    return streamAnthropic(model, context, {
+        ...base,
+        maxTokens: adjusted.maxTokens,
+        thinkingEnabled: true,
+        thinkingBudgetTokens: adjusted.thinkingBudget,
     });
-}
-function mapStopReason(reason) {
-    switch (reason) {
-        case "end_turn":
-            return "stop";
-        case "max_tokens":
-            return "length";
-        case "tool_use":
-            return "toolUse";
-        case "refusal":
-            return "error";
-        case "pause_turn": // Stop is good enough -> resubmit
-            return "stop";
-        case "stop_sequence":
-            return "stop"; // We don't supply stop sequences, so this should never happen
-        case "sensitive": // Content flagged by safety filters (not yet in SDK types)
-            return "error";
-        default:
-            // Handle unknown stop reasons gracefully (API may add new values)
-            throw new Error(`Unhandled stop reason: ${reason}`);
-    }
-}
+};
 //# sourceMappingURL=anthropic.js.map