@xiaozhiclaw/provider-core 0.1.0

package/dist/transports/anthropic-messages.js

@@ -0,0 +1,1004 @@
+/**
+ * Anthropic Messages TransportSSE streaming for Claude API.
+ *
+ * Aligned with CC (claude-code-haha) src/services/api/claude.ts:
+ *   - cache_control ephemeral injection on system prompt blocks
+ *   - ensureToolResultPairing() conversation repair before every request
+ *   - Retry with exponential backoff on transient errors (429/529/overloaded)
+ *   - Non-streaming fallback when stream errors out
+ *   - 90s idle watchdog timeout for silently dropped connections
+ *   - Adaptive/budget thinking with temperature omit
+ *   - Cache token extraction with >0 guard (CC updateUsage parity)
+ *   - signature_delta handling for thinking blocks
+ */
+import { MEDIA_MAX_UPLOAD_SIZE } from "../constants.js";
+import { isLocalUrl, resolveMediaUrlViaUpload } from "./media-resolve.js";
+import { DEFAULT_MAX_RETRIES, STREAM_IDLE_TIMEOUT_MS, TRANSIENT_STATUS_CODES, retryDelay, retrySleep, } from "../retry.js";
+// 鈹€鈹€ Constants 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+const DEFAULT_TIMEOUT_MS = 180_000;
+const NON_STREAMING_TIMEOUT_MS = 300_000;
+const MAX_NON_STREAMING_TOKENS = 64_000;
+// CC SYNTHETIC_TOOL_RESULT_PLACEHOLDER parity
+const SYNTHETIC_TOOL_RESULT_CONTENT = "[Tool execution failed; output not available during conversation recovery]";
+// 鈹€鈹€ Beta headers (CC parity for 3P callers) 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+// Only universally-applicable betas that any 3P API caller can use.
+// 1P-only betas (claude-code-20250219, afk-mode, cli-internal, redact-thinking) are omitted.
+const BETA_INTERLEAVED_THINKING = "interleaved-thinking-2025-05-14";
+const BETA_CONTEXT_1M = "context-1m-2025-08-07";
+const BETA_TOKEN_EFFICIENT_TOOLS = "token-efficient-tools-2026-03-28";
+const BETA_PROMPT_CACHING_SCOPE = "prompt-caching-scope-2026-01-05";
+const BETA_PDF_SUPPORT = "pdfs-2024-09-25";
+/**
+ * Check if a model supports Adaptive Thinking (鎼?).
+ * Only Opus 4.6/4.7 and Sonnet 4.6 support type: "adaptive".
+ * Haiku and older models must use type: "enabled" with budget_tokens.
+ */
+function supportsAdaptiveThinking(model) {
+    const ml = model.toLowerCase();
+    return ml.includes("opus-4-6") || ml.includes("opus-4-7")
+        || ml.includes("sonnet-4-6");
+}
+/**
+ * Build beta headers list based on model capabilities.
+ * CC parity: only send betas the model actually supports.
+ */
+function buildBetaHeaders(model, hasThinking, hasTools) {
+    const betas = [];
+    const ml = model.toLowerCase();
+    // Beta headers are Anthropic-specific features. Only send for actual Claude models.
+    // Non-Claude providers using anthropic-messages transport (DeepSeek, Qwen, MiniMax)
+    // don't support these and may return 400 errors.
+    const isClaude = ml.startsWith("claude");
+    if (!isClaude) {
+        // Still allow user-specified betas via env (advanced override)
+        const envBetas = process.env.ANTHROPIC_BETAS;
+        if (envBetas) {
+            for (const b of envBetas.split(",").map(s => s.trim()).filter(Boolean)) {
+                betas.push(b);
+            }
+        }
+        return betas;
+    }
+    // 1M context models: claude-opus-4-6/4-7, claude-sonnet-4-6
+    const is1mModel = ml.includes("opus-4-6") || ml.includes("opus-4-7")
+        || ml.includes("sonnet-4-6");
+    if (is1mModel) {
+        betas.push(BETA_CONTEXT_1M);
+    }
+    // PDF support: always send for models with vision
+    betas.push(BETA_PDF_SUPPORT);
+    // Interleaved thinking: supported by all thinking-capable Claude models (Opus 4+, Sonnet 3.7+)
+    if (hasThinking && !ml.includes("haiku")) {
+        betas.push(BETA_INTERLEAVED_THINKING);
+    }
+    // Token-efficient tools: reduces tool schema token overhead (~4.5% savings)
+    if (hasTools) {
+        betas.push(BETA_TOKEN_EFFICIENT_TOOLS);
+    }
+    // Prompt caching scope: always sendheader is a no-op without scope field
+    betas.push(BETA_PROMPT_CACHING_SCOPE);
+    // User-specified additional betas via env
+    const envBetas = process.env.ANTHROPIC_BETAS;
+    if (envBetas) {
+        for (const b of envBetas.split(",").map(s => s.trim()).filter(Boolean)) {
+            if (!betas.includes(b))
+                betas.push(b);
+        }
+    }
+    return betas;
+}
+// 鈹€鈹€ Transport class 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+export class AnthropicMessagesTransport {
+    baseUrl;
+    apiVersion;
+    timeoutMs;
+    streamIdleTimeoutMs;
+    enablePromptCaching;
+    maxRetries;
+    omitZeroTemperature;
+    quirks;
+    fileUploadAdapter;
+    constructor(config) {
+        if (!config.baseUrl) {
+            throw new Error("AnthropicMessagesTransport: baseUrl is required (got empty or undefined)");
+        }
+        this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+        this.apiVersion = config.apiVersion ?? "2023-06-01";
+        this.timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.streamIdleTimeoutMs = config.streamIdleTimeoutMs ?? STREAM_IDLE_TIMEOUT_MS;
+        this.enablePromptCaching = config.enablePromptCaching ?? true;
+        this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.omitZeroTemperature = config.omitZeroTemperature ?? false;
+        this.quirks = config.quirks ?? {};
+        this.fileUploadAdapter = config.fileUploadAdapter;
+    }
+    async *stream(request, apiKey, signal) {
+        // Note: DeepSeek prefix completion requires OpenAI Chat Completions
+        // format (base_url /beta), NOT Anthropic Messages format.
+        // The Anthropic API at /anthropic does not support prefix: true.
+        const url = `${this.baseUrl}/v1/messages`;
+        // CC parity: ensureToolResultPairing before converting messages
+        const repairedMessages = ensureToolResultPairing(request.messages);
+        // Pre-resolve local media URLs for Anthropic (localhost not reachable from API)
+        const resolvedMessages = await resolveMessagesMediaForAnthropic(repairedMessages, this.fileUploadAdapter, apiKey, signal);
+        // Convert OpenAI-style messages 閳?Anthropic format
+        const { system, messages } = convertMessages(resolvedMessages, this.quirks, request.model);
+        // CC parity: system prompt as block array with cache_control on last block
+        const systemParam = buildSystemParam(system, this.enablePromptCaching);
+        const hasThinking = !!request.reasoning;
+        const maxTokens = request.maxTokens ?? 8192;
+        const body = {
+            model: request.model,
+            messages,
+            // DeepSeek thinking models share max_tokens between thinking + text output.
+            // Enforce minimum 4096 when thinking is enabled to prevent thinking exhausting
+            // the entire budget and producing empty text responses.
+            max_tokens: hasThinking ? Math.max(maxTokens, 4096) : maxTokens,
+            stream: true,
+        };
+        if (systemParam)
+            body.system = systemParam;
+        if (request.tools && request.tools.length > 0) {
+            const tools = request.tools.map(convertToolDef);
+            // 鎼?2.6: Active cachingcache_control on last tool in the prefix layer
+            // Prefix order: tools 閳?system 閳?messages. Mark last tool for caching.
+            // Use session-scoped ephemeral (no global scope) to prevent cross-session cache leakage.
+            // CC separates static/dynamic prompt with SYSTEM_PROMPT_DYNAMIC_BOUNDARY for global scope;
+            // without that boundary, global scope can leak session context.
+            if (this.enablePromptCaching && tools.length > 0) {
+                tools[tools.length - 1].cache_control = { type: "ephemeral" };
+            }
+            body.tools = tools;
+            if (request.toolChoice) {
+                body.tool_choice =
+                    request.toolChoice === "auto"
+                        ? { type: "auto" }
+                        : request.toolChoice === "required"
+                            ? { type: "any" }
+                            : { type: "none" };
+            }
+        }
+        // CC parity: temperature must be undefined when thinking is enabled
+        if (!hasThinking && request.temperature !== undefined) {
+            // MiniMax rejects temperature=0; range is (0.0, 1.0]
+            if (!(this.omitZeroTemperature && request.temperature === 0)) {
+                body.temperature = request.temperature;
+            }
+        }
+        // Anthropic API: top_p (supported by Anthropic + MiniMax)
+        if (!hasThinking && request.topP !== undefined) {
+            body.top_p = request.topP;
+        }
+        // CC parity: adaptive vs budget thinking
+        if (hasThinking) {
+            if (this.quirks.useEffortInsteadOfBudget) {
+                // DeepSeek: budget_tokens is ignored, use output_config.effort instead.
+                // DeepSeek only supports "high" and "max"; lower levels map to "high".
+                body.thinking = { type: "enabled" };
+                const cap = this.quirks.maxReasoningEffort ?? "high";
+                const effortInput = request.reasoning?.effort ?? "high";
+                // Map: "low"/"medium"閳?high", "high"閳?high", anything above閳妽ap
+                const deepseekEffort = effortInput === "low" || effortInput === "medium"
+                    ? "high"
+                    : cap;
+                body.output_config = { effort: deepseekEffort };
+                // DeepSeek KV Cache: set user_id for session-level cache isolation.
+                // Server-side KV cache hit rate improves when same user_id sees repeated
+                // prefixes (system prompt, conversation history). Price: 1/50 of input.
+                // Use a hash of the system prompt as stable session identifier.
+                if (system) {
+                    let h = 0x811c9dc5; // FNV-1a seed
+                    for (let i = 0; i < system.length; i++) {
+                        h ^= system.charCodeAt(i);
+                        h = Math.imul(h, 0x01000193);
+                    }
+                    body.metadata = { user_id: `qa-${(h >>> 0).toString(36)}` };
+                }
+            }
+            else if (supportsAdaptiveThinking(request.model)) {
+                // Adaptive Thinking (anthropic-ProviderMax 鎼?):
+                // Opus 4.6/4.7 and Sonnet 4.6model self-adjusts thinking depth.
+                // Zero thinking for simple queries, deep thinking for complex ones.
+                // This is the CC (claude-code-haha) default mode.
+                body.thinking = { type: "adaptive" };
+            }
+            else {
+                // Extended Thinking (anthropic-ProviderMax 鎼?):
+                // Haiku 4.5 and older modelsexplicit budget control.
+                const budget = mapReasoningEffortToBudget(request.reasoning.effort, request.maxTokens);
+                body.thinking = {
+                    type: "enabled",
+                    budget_tokens: Math.min(maxTokens - 1, budget),
+                };
+            }
+        }
+        else if (this.quirks.supportsThinkingParam && this.quirks.disableThinkingByDefault) {
+            body.thinking = { type: "disabled" };
+        }
+        // CC parity: beta headers for model-specific capabilities
+        const betaHeaders = buildBetaHeaders(request.model, hasThinking, (request.tools?.length ?? 0) > 0);
+        const headers = {
+            "Content-Type": "application/json",
+            "x-api-key": apiKey,
+            "anthropic-version": this.apiVersion,
+        };
+        if (betaHeaders.length > 0) {
+            headers["anthropic-beta"] = betaHeaders.join(",");
+        }
+        // Retry loop with exponential backoff (CC withRetry parity)
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            if (signal?.aborted)
+                throw new Error("Request aborted");
+            if (attempt > 0 && lastError) {
+                await retrySleep(retryDelay(attempt), signal);
+            }
+            try {
+                yield* this.streamWithWatchdog(url, headers, body, signal);
+                return; // Success
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err : new Error(String(err));
+                // Parse HTTP status from error message for retry decision
+                const status = parseHttpStatus(lastError.message);
+                const isTransient = status !== null && TRANSIENT_STATUS_CODES.has(status);
+                const isIdleTimeout = lastError.message.includes("Stream idle timeout");
+                const isOverflow = lastError.message.includes("model_context_window_exceeded")
+                    || lastError.message.includes("context_length_exceeded");
+                if (isOverflow) {
+                    // CC parity: context window overflowunrecoverable, don't retry
+                    throw lastError;
+                }
+                if (!isTransient && !isIdleTimeout) {
+                    // Non-transient errordon't retry
+                    throw lastError;
+                }
+                if (attempt === this.maxRetries) {
+                    // Last attempttry non-streaming fallback (CC parity)
+                    // Skip fallback for stream-required models (QwQ, Omni) that reject non-streaming
+                    if ((isIdleTimeout || isTransient) && !request.streamRequired) {
+                        try {
+                            yield* this.nonStreamingFallback(url, headers, body, signal);
+                            return;
+                        }
+                        catch {
+                            throw lastError;
+                        }
+                    }
+                    throw lastError;
+                }
+                // Will retry
+            }
+        }
+        if (lastError)
+            throw lastError;
+    }
+    /**
+     * Stream with idle watchdog timer (CC parity: 90s default).
+     * Throws if no chunks received for streamIdleTimeoutMs.
+     */
+    async *streamWithWatchdog(url, headers, body, signal) {
+        const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
+        const combinedSignal = signal
+            ? AbortSignal.any([signal, timeoutSignal])
+            : timeoutSignal;
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: combinedSignal,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "");
+            const err = new Error(`Anthropic API error ${response.status}: ${errorBody.slice(0, 500)}`);
+            err.status = response.status;
+            throw err;
+        }
+        if (!response.body) {
+            throw new Error("Anthropic API returned no response body");
+        }
+        // CC parity: idle watchdogabort if no chunks for streamIdleTimeoutMs
+        let idleTimer = null;
+        let idleAborted = false;
+        const resetIdleTimer = () => {
+            if (idleTimer !== null)
+                clearTimeout(idleTimer);
+            idleTimer = setTimeout(() => {
+                idleAborted = true;
+            }, this.streamIdleTimeoutMs);
+        };
+        const clearIdleTimer = () => {
+            if (idleTimer !== null) {
+                clearTimeout(idleTimer);
+                idleTimer = null;
+            }
+        };
+        resetIdleTimer(); // Prime before stream starts
+        try {
+            yield* this.parseSSEStream(response.body, resetIdleTimer, () => idleAborted);
+        }
+        finally {
+            clearIdleTimer();
+        }
+        // CC parity: if watchdog fired and loop exited cleanly, throw
+        if (idleAborted) {
+            throw new Error("Stream idle timeout - no chunks received");
+        }
+    }
+    /**
+     * Non-streaming fallback (CC executeNonStreamingRequest parity).
+     * Used when streaming fails after all retries.
+     * Caps max_tokens at 64K and adjusts thinking budget accordingly.
+     */
+    async *nonStreamingFallback(url, headers, body, signal) {
+        const nonStreamBody = adjustParamsForNonStreaming({ ...body, stream: false });
+        const timeoutSignal = AbortSignal.timeout(NON_STREAMING_TIMEOUT_MS);
+        const combinedSignal = signal
+            ? AbortSignal.any([signal, timeoutSignal])
+            : timeoutSignal;
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(nonStreamBody),
+            signal: combinedSignal,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text().catch(() => "");
+            const err = new Error(`Anthropic API error ${response.status}: ${errorBody.slice(0, 500)}`);
+            err.status = response.status;
+            throw err;
+        }
+        const result = await response.json();
+        yield* this.mapNonStreamingResponse(result);
+    }
+    /**
+     * Convert a non-streaming API response to LLMChunk sequence.
+     */
+    *mapNonStreamingResponse(result) {
+        // Usage
+        const usage = result.usage;
+        if (usage) {
+            yield {
+                type: "usage",
+                promptTokens: usage.input_tokens ?? 0,
+                completionTokens: usage.output_tokens ?? 0,
+                cacheReadTokens: usage.cache_read_input_tokens > 0
+                    ? usage.cache_read_input_tokens
+                    : undefined,
+                cacheCreationTokens: usage.cache_creation_input_tokens > 0
+                    ? usage.cache_creation_input_tokens
+                    : undefined,
+                reasoningTokens: usage.reasoning_input_tokens > 0
+                    ? usage.reasoning_input_tokens
+                    : undefined,
+            };
+        }
+        // Content blocks
+        const content = result.content;
+        if (Array.isArray(content)) {
+            let toolIndex = 0;
+            for (const block of content) {
+                const blockType = block.type;
+                if (blockType === "text") {
+                    yield { type: "delta", text: block.text };
+                }
+                else if (blockType === "thinking") {
+                    yield { type: "reasoning_delta", text: block.thinking };
+                }
+                else if (blockType === "tool_use") {
+                    yield {
+                        type: "tool_call_delta",
+                        index: toolIndex++,
+                        id: block.id,
+                        name: block.name,
+                        arguments: JSON.stringify(block.input ?? {}),
+                    };
+                }
+            }
+        }
+        // Stop reason
+        const stopReason = result.stop_reason;
+        if (stopReason) {
+            yield { type: "done", finishReason: mapAnthropicStopReason(stopReason) };
+        }
+    }
+    async *parseSSEStream(body, resetIdleTimer, isIdleAborted) {
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let currentEvent = "";
+        // Track active content blocks for tool_use accumulation + signature
+        const blocks = new Map();
+        // CC parity: accumulated usage with >0 guard
+        const accUsage = {
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            reasoningTokens: 0,
+        };
+        for await (const raw of body) {
+            // CC parity: reset idle watchdog on every chunk
+            resetIdleTimer();
+            if (isIdleAborted())
+                break;
+            buffer += decoder.decode(raw, { stream: true });
+            let newlineIdx;
+            while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, newlineIdx).trim();
+                buffer = buffer.slice(newlineIdx + 1);
+                if (!line) {
+                    currentEvent = "";
+                    continue;
+                }
+                // SSE spec: field name is before colon, value after colon with optional leading space.
+                // Some providers (Qwen) omit the space: "event:message_start" vs "event: message_start"
+                if (line.startsWith("event:")) {
+                    currentEvent = line.slice(6).trimStart();
+                    continue;
+                }
+                if (!line.startsWith("data:"))
+                    continue;
+                const data = line.slice(5).trimStart();
+                let parsed;
+                try {
+                    parsed = JSON.parse(data);
+                }
+                catch {
+                    continue;
+                }
+                yield* this.mapEvent(currentEvent, parsed, blocks, accUsage);
+            }
+        }
+    }
+    *mapEvent(event, data, blocks, accUsage) {
+        switch (event) {
+            case "message_start": {
+                const msg = data.message;
+                const usage = msg?.usage;
+                if (usage) {
+                    // CC parity: update accumulated usage with >0 guard
+                    updateAccumulatedUsage(accUsage, usage);
+                    yield {
+                        type: "usage",
+                        promptTokens: accUsage.inputTokens,
+                        completionTokens: accUsage.outputTokens,
+                        cacheReadTokens: accUsage.cacheReadTokens > 0 ? accUsage.cacheReadTokens : undefined,
+                        cacheCreationTokens: accUsage.cacheCreationTokens > 0 ? accUsage.cacheCreationTokens : undefined,
+                        reasoningTokens: accUsage.reasoningTokens > 0 ? accUsage.reasoningTokens : undefined,
+                    };
+                }
+                break;
+            }
+            case "content_block_start": {
+                const index = data.index;
+                const block = data.content_block;
+                if (!block)
+                    break;
+                const blockType = block.type;
+                blocks.set(index, {
+                    type: blockType,
+                    id: block.id,
+                    name: block.name,
+                    // CC parity: initialize signature for thinking blocks
+                    signature: blockType === "thinking" ? "" : undefined,
+                });
+                if (blockType === "tool_use") {
+                    yield {
+                        type: "tool_call_delta",
+                        index,
+                        id: block.id,
+                        name: block.name,
+                        arguments: "",
+                    };
+                }
+                break;
+            }
+            case "content_block_delta": {
+                const index = data.index;
+                const delta = data.delta;
+                if (!delta)
+                    break;
+                const deltaType = delta.type;
+                if (deltaType === "text_delta") {
+                    yield { type: "delta", text: delta.text };
+                }
+                else if (deltaType === "input_json_delta") {
+                    yield {
+                        type: "tool_call_delta",
+                        index,
+                        arguments: delta.partial_json,
+                    };
+                }
+                else if (deltaType === "thinking_delta") {
+                    yield {
+                        type: "reasoning_delta",
+                        text: delta.thinking,
+                    };
+                }
+                else if (deltaType === "signature_delta") {
+                    // CC parity: store signature on thinking block
+                    const blockInfo = blocks.get(index);
+                    if (blockInfo && typeof delta.signature === "string") {
+                        blockInfo.signature = delta.signature;
+                    }
+                }
+                break;
+            }
+            case "content_block_stop": {
+                const index = data.index;
+                const stoppedBlock = blocks.get(index);
+                // Emit complete thinking block with signature for passback
+                if (stoppedBlock?.type === "thinking" && typeof stoppedBlock.signature === "string") {
+                    yield {
+                        type: "reasoning_block_complete",
+                        thinking: "", // text already streamed via reasoning_delta
+                        signature: stoppedBlock.signature,
+                    };
+                }
+                blocks.delete(index);
+                break;
+            }
+            case "message_delta": {
+                const delta = data.delta;
+                const usage = data.usage;
+                if (usage) {
+                    // CC parity: update with >0 guard (prevent delta zero overwrite)
+                    updateAccumulatedUsage(accUsage, usage);
+                    yield {
+                        type: "usage",
+                        promptTokens: accUsage.inputTokens,
+                        completionTokens: accUsage.outputTokens,
+                        cacheReadTokens: accUsage.cacheReadTokens > 0 ? accUsage.cacheReadTokens : undefined,
+                        cacheCreationTokens: accUsage.cacheCreationTokens > 0 ? accUsage.cacheCreationTokens : undefined,
+                        reasoningTokens: accUsage.reasoningTokens > 0 ? accUsage.reasoningTokens : undefined,
+                    };
+                }
+                if (delta?.stop_reason) {
+                    yield { type: "done", finishReason: mapAnthropicStopReason(delta.stop_reason) };
+                }
+                break;
+            }
+            case "message_stop":
+                break;
+            case "error": {
+                const error = data.error;
+                throw new Error(`Anthropic stream error: ${error?.message ?? JSON.stringify(data)}`);
+            }
+        }
+    }
+}
+/**
+ * CC updateUsage parity: only update a token count if the new value is > 0.
+ * Prevents message_delta events from overwriting real counts with explicit 0.
+ */
+function updateAccumulatedUsage(acc, usage) {
+    // CC parity: >0 guard on input-related tokens only.
+    // output_tokens uses ?? fallback because 0 at message_start is legitimate.
+    if (usage.input_tokens > 0)
+        acc.inputTokens = usage.input_tokens;
+    acc.outputTokens = usage.output_tokens ?? acc.outputTokens;
+    if (usage.cache_read_input_tokens > 0)
+        acc.cacheReadTokens = usage.cache_read_input_tokens;
+    if (usage.cache_creation_input_tokens > 0)
+        acc.cacheCreationTokens = usage.cache_creation_input_tokens;
+    // DeepSeek / Anthropic reasoning tokens (thinking budget consumption)
+    if (usage.reasoning_input_tokens > 0)
+        acc.reasoningTokens = usage.reasoning_input_tokens;
+}
+// 鈹€鈹€ Stop reason normalization (Anthropic 閳?OpenAI standard) 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+function mapAnthropicStopReason(reason) {
+    switch (reason) {
+        case "end_turn":
+        case "stop_sequence":
+            return "stop";
+        case "tool_use":
+            return "tool_calls";
+        case "max_tokens":
+            return "length";
+        default:
+            return reason;
+    }
+}
+// 鈹€鈹€ Reasoning effort 閳?thinking budget (CC paramsFromContext parity) 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+/**
+ * CC parity: Haiku models do not support tool_reference blocks in tool_result content.
+ * All other Anthropic-compatible models (including DeepSeek via /anthropic endpoint) support it.
+ */
+function modelSupportsToolReference(model) {
+    return !/haiku/i.test(model);
+}
+const THINKING_BUDGET = {
+    high: 16000,
+    medium: 8000,
+    low: 4000,
+};
+/**
+ * Map reasoning effort to thinking budget_tokens.
+ * CC parity: getMaxThinkingTokensForModel() = maxOutput - 1
+ * When maxTokens is available, scale dynamically; otherwise use static defaults.
+ */
+function mapReasoningEffortToBudget(effort, maxTokens) {
+    if (maxTokens && maxTokens > 16384) {
+        // Dynamic budget based on model's actual max output (CC parity)
+        switch (effort) {
+            case "high": return Math.min(maxTokens - 1, Math.max(16000, Math.floor(maxTokens * 0.5)));
+            case "medium": return Math.min(maxTokens - 1, Math.max(8000, Math.floor(maxTokens * 0.25)));
+            case "low": return Math.min(maxTokens - 1, 4000);
+            default: return THINKING_BUDGET.high;
+        }
+    }
+    return THINKING_BUDGET[effort] ?? THINKING_BUDGET.high;
+}
+// 鈹€鈹€ System prompt 閳?cache_control block array (CC buildSystemPromptBlocks) 鈹€鈹€鈹€
+/**
+ * Build system parameter with cache_control on the last block.
+ * CC parity: only ONE cache_control marker per request (at last block).
+ * Session-scoped ephemeral (no global scope) to prevent cross-session cache leakage.
+ */
+function buildSystemParam(system, enableCaching) {
+    if (!system)
+        return undefined;
+    if (!enableCaching)
+        return system;
+    // Return as block array with cache_control on last block
+    return [
+        {
+            type: "text",
+            text: system,
+            cache_control: { type: "ephemeral" },
+        },
+    ];
+}
+// 鈹€鈹€ ensureToolResultPairing (CC conversation repair, pre-request) 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+/**
+ * Repair tool_use/tool_result mismatches before sending to API.
+ * CC parity: fixes 3 classes of problems:
+ *   1. Orphaned tool_results (no matching tool_use) 閳?stripped
+ *   2. Missing tool_results (tool_use with no result) 閳?synthetic error inserted
+ *   3. Duplicate tool_use IDs 閳?cross-message dedup
+ */
+function ensureToolResultPairing(messages) {
+    const result = [];
+    const allSeenToolUseIds = new Set();
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
+            // Dedup tool_use IDs across messages (CC allSeenToolUseIds parity)
+            const dedupedCalls = msg.tool_calls.filter(tc => {
+                if (allSeenToolUseIds.has(tc.id))
+                    return false;
+                allSeenToolUseIds.add(tc.id);
+                return true;
+            });
+            const toolUseIds = new Set(dedupedCalls.map(tc => tc.id));
+            // Look ahead for matching tool_results
+            const existingResultIds = new Set();
+            const nextMessages = messages.slice(i + 1);
+            for (const nm of nextMessages) {
+                if (nm.role !== "tool")
+                    break;
+                if (nm.tool_call_id)
+                    existingResultIds.add(nm.tool_call_id);
+            }
+            // Push the assistant message (possibly with deduped tool calls)
+            if (dedupedCalls.length !== msg.tool_calls.length) {
+                result.push({ ...msg, tool_calls: dedupedCalls });
+            }
+            else {
+                result.push(msg);
+            }
+            // CC parity: inject synthetic error tool_results for missing ones
+            const missingIds = [...toolUseIds].filter(id => !existingResultIds.has(id));
+            for (const id of missingIds) {
+                const tc = dedupedCalls.find(c => c.id === id);
+                result.push({
+                    role: "tool",
+                    tool_call_id: id,
+                    name: tc?.function.name,
+                    content: "[Tool execution failed; output not available during conversation recovery]",
+                });
+            }
+        }
+        else if (msg.role === "tool") {
+            // Check if this tool_result has a matching tool_use
+            const hasMatch = allSeenToolUseIds.has(msg.tool_call_id ?? "");
+            if (hasMatch) {
+                result.push(msg);
+            }
+            // CC parity: strip orphaned tool_results silently
+        }
+        else {
+            result.push(msg);
+        }
+    }
+    return result;
+}
+// 鈹€鈹€ Local media resolution for Anthropic 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+/**
+ * Pre-resolve local media URLs for Anthropic.
+ * When Hub OSS adapter is available, uploads files 閳?public URL (no size limit).
+ * Otherwise falls back to base64 data URL (閳?0MB limit).
+ */
+async function resolveMessagesMediaForAnthropic(messages, uploadAdapter, apiKey, signal) {
+    const needsResolution = messages.some((m) => m.imageUrls?.some(isLocalUrl) || m.fileIds?.some((f) => isLocalUrl(f.id)));
+    if (!needsResolution)
+        return messages;
+    return Promise.all(messages.map(async (msg) => {
+        // Resolve imageUrls on both user messages and tool result messages
+        if (msg.role !== "user" && msg.role !== "tool")
+            return msg;
+        const patch = {};
+        if (msg.imageUrls?.some(isLocalUrl)) {
+            if (!uploadAdapter || !apiKey) {
+                throw new Error("FileUploadAdapter required for local image URLs. Configure OSS_ACCESS_KEY_ID/OSS_ACCESS_KEY_SECRET or QLOGICAGENT_HUB_URL.");
+            }
+            patch.imageUrls = await Promise.all(msg.imageUrls.map((url) => isLocalUrl(url)
+                ? resolveMediaUrlViaUpload(url, { uploadAdapter, apiKey, signal })
+                : Promise.resolve(url)));
+        }
+        if (msg.role === "user" && msg.fileIds?.some((f) => isLocalUrl(f.id))) {
+            if (!uploadAdapter || !apiKey) {
+                throw new Error("FileUploadAdapter required for local file URLs. Configure OSS_ACCESS_KEY_ID/OSS_ACCESS_KEY_SECRET or QLOGICAGENT_HUB_URL.");
+            }
+            patch.fileIds = await Promise.all(msg.fileIds.map(async (f) => {
+                if (!isLocalUrl(f.id))
+                    return f;
+                const resolved = await resolveMediaUrlViaUpload(f.id, { uploadAdapter, apiKey, signal });
+                return { ...f, id: resolved };
+            }));
+        }
+        return Object.keys(patch).length > 0 ? { ...msg, ...patch } : msg;
+    }));
+}
+// 鈹€鈹€ Message format conversion (OpenAI 閳?Anthropic) 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+function convertMessages(messages, quirks = {}, model) {
+    let system;
+    const out = [];
+    for (const msg of messages) {
+        if (msg.role === "system") {
+            system = system ? `${system}\n\n${msg.content ?? ""}` : (msg.content ?? "");
+            continue;
+        }
+        if (msg.role === "user") {
+            const hasImages = msg.imageUrls && msg.imageUrls.length > 0 && !quirks.filterImageBlocks;
+            const hasFiles = msg.fileIds && msg.fileIds.length > 0;
+            if (hasImages || hasFiles) {
+                // Vision + PDF + documents: build content block array
+                const content = [];
+                if (msg.content) {
+                    content.push({ type: "text", text: msg.content });
+                }
+                if (hasImages) {
+                    const multiImage = msg.imageUrls.length > 1;
+                    for (let imgIdx = 0; imgIdx < msg.imageUrls.length; imgIdx++) {
+                        const url = msg.imageUrls[imgIdx];
+                        // CC parity: inject [Image N] label before each image when multiple images present
+                        if (multiImage) {
+                            content.push({ type: "text", text: `[Image ${imgIdx + 1}]` });
+                        }
+                        if (url.startsWith("data:")) {
+                            // Base64 data URL 閳?extract media_type and data
+                            const match = /^data:([^;]+);base64,(.+)$/.exec(url);
+                            if (match) {
+                                const mimeType = match[1];
+                                // PDF documents use "document" block type (anthropic-ProviderMax 鎼?1)
+                                if (mimeType === "application/pdf") {
+                                    content.push({
+                                        type: "document",
+                                        source: { type: "base64", media_type: mimeType, data: match[2] },
+                                    });
+                                }
+                                else {
+                                    content.push({
+                                        type: "image",
+                                        source: { type: "base64", media_type: mimeType, data: match[2] },
+                                    });
+                                }
+                            }
+                        }
+                        else if (url.endsWith(".pdf") || url.includes(".pdf?")) {
+                            // PDF URL 閳?document block (anthropic-ProviderMax 鎼?1)
+                            content.push({
+                                type: "document",
+                                source: { type: "url", url },
+                            });
+                        }
+                        else {
+                            // HTTP(S) URL 閳?use source.type="url"
+                            content.push({
+                                type: "image",
+                                source: { type: "url", url },
+                            });
+                        }
+                    }
+                }
+                // fileIds: PDFs 閳?document blocks; other files 閳?text annotations
+                // Size-aware: files over 50MB always degrade to text annotation (agent uses tools)
+                if (hasFiles) {
+                    for (const f of msg.fileIds) {
+                        const mime = f.mimeType || "";
+                        const tooLarge = f.size != null && f.size > MEDIA_MAX_UPLOAD_SIZE;
+                        if (tooLarge) {
+                            const sizeLabel = `${(f.size / (1024 * 1024)).toFixed(1)}MB`;
+                            content.push({ type: "text", text: `[Attached: ${f.id} (${mime || "unknown"}, ${sizeLabel})file too large for direct vision, use tools to process]` });
+                        }
+                        else if (mime === "application/pdf" || f.id.endsWith(".pdf")) {
+                            if (f.id.startsWith("data:")) {
+                                const match = /^data:[^;]+;base64,(.+)$/.exec(f.id);
+                                if (match) {
+                                    content.push({
+                                        type: "document",
+                                        source: { type: "base64", media_type: "application/pdf", data: match[1] },
+                                    });
+                                }
+                            }
+                            else {
+                                content.push({
+                                    type: "document",
+                                    source: { type: "url", url: f.id },
+                                });
+                            }
+                        }
+                        else {
+                            // Non-PDF files: annotate as text so agent uses tools
+                            const label = mime ? `[Attached: ${f.id} (${mime})]` : `[Attached: ${f.id}]`;
+                            content.push({ type: "text", text: label });
+                        }
+                    }
+                }
+                out.push({ role: "user", content });
+            }
+            else {
+                out.push({ role: "user", content: msg.content ?? "" });
+            }
+        }
+        else if (msg.role === "assistant") {
+            // Provider-aware thinking block filtering (CC/altcode parity):
+            // Some providers (GLM) don't support thinking blocks in passback.
+            const effectiveThinkingBlocks = quirks.filterThinkingBlocks
+                ? undefined
+                : msg.thinkingBlocks;
+            if (msg.tool_calls && msg.tool_calls.length > 0) {
+                const content = [];
+                // Thinking blocks must appear first (DeepSeek/Claude passback requirement).
+                // CC parity (stripSignatureBlocks): skip blocks with empty/missing
+                // signaturesDeepSeek may not emit signature_delta, and sending
+                // an empty signature causes API 400.
+                if (effectiveThinkingBlocks) {
+                    for (const tb of effectiveThinkingBlocks) {
+                        if (!tb.signature)
+                            continue;
+                        content.push({ type: "thinking", thinking: tb.thinking, signature: tb.signature });
+                    }
+                }
+                if (msg.content) {
+                    content.push({ type: "text", text: msg.content });
+                }
+                for (const tc of msg.tool_calls) {
+                    let input;
+                    try {
+                        input = JSON.parse(tc.function.arguments);
+                    }
+                    catch {
+                        input = {};
+                    }
+                    content.push({
+                        type: "tool_use",
+                        id: tc.id,
+                        name: tc.function.name,
+                        input,
+                    });
+                }
+                out.push({ role: "assistant", content });
+            }
+            else if (effectiveThinkingBlocks && effectiveThinkingBlocks.length > 0) {
+                // Non-tool-call assistant message with thinking blocks:
+                // must use content block array format to include thinking.
+                // CC parity: skip blocks with empty/missing signatures.
+                const content = [];
+                for (const tb of effectiveThinkingBlocks) {
+                    if (!tb.signature)
+                        continue;
+                    content.push({ type: "thinking", thinking: tb.thinking, signature: tb.signature });
+                }
+                if (msg.content) {
+                    content.push({ type: "text", text: msg.content });
+                }
+                out.push({ role: "assistant", content });
+            }
+            else {
+                out.push({ role: "assistant", content: msg.content ?? "" });
+            }
+        }
+        else if (msg.role === "tool") {
+            // CC parity (normalizeMessagesForAPI): merge consecutive tool_result
+            // messages into the preceding user message's content array.
+            // Anthropic API requires all tool_results for one assistant turn
+            // in a single user message.
+            const content = msg.content ?? "";
+            // AP2: prefer explicit is_error field from buildToolResultMessage,
+            // fall back to content-prefix heuristic for backward compat.
+            const isError = msg.is_error === true
+                || content.startsWith("Error:") || content === SYNTHETIC_TOOL_RESULT_CONTENT;
+            // CC parity: tool_referencewhen the message carries toolReferences
+            // (from tool_search), use tool_reference blocks instead of plain text.
+            // This enables the Anthropic API to auto-expand the tool schemas
+            // so the model can see the activated tools' full definitions.
+            const toolRefs = msg.toolReferences;
+            const useToolReference = toolRefs && toolRefs.length > 0 && !isError
+                && (!model || modelSupportsToolReference(model));
+            // Image URLs from tool results (e.g. read tool reading an image file).
+            // Anthropic natively supports images in tool_result content blocks.
+            const imgUrls = msg.imageUrls;
+            let toolResultContent;
+            if (useToolReference) {
+                toolResultContent = toolRefs.map(name => ({ type: "tool_reference", tool_name: name }));
+            }
+            else if (imgUrls && imgUrls.length > 0 && !isError) {
+                // Include images as content blocks alongside text
+                const blocks = [];
+                if (content)
+                    blocks.push({ type: "text", text: content });
+                for (const url of imgUrls) {
+                    if (url.startsWith("data:")) {
+                        const match = /^data:([^;]+);base64,(.+)$/.exec(url);
+                        if (match) {
+                            blocks.push({ type: "image", source: { type: "base64", media_type: match[1], data: match[2] } });
+                        }
+                    }
+                    else {
+                        blocks.push({ type: "image", source: { type: "url", url } });
+                    }
+                }
+                toolResultContent = blocks;
+            }
+            else {
+                toolResultContent = content;
+            }
+            const block = {
+                type: "tool_result",
+                tool_use_id: msg.tool_call_id ?? "",
+                content: toolResultContent,
+                ...(isError && { is_error: true }),
+            };
+            const prev = out[out.length - 1];
+            if (prev && prev.role === "user" && Array.isArray(prev.content)) {
+                // Merge into existing user content block array
+                prev.content.push(block);
+            }
+            else {
+                out.push({ role: "user", content: [block] });
+            }
+        }
+    }
+    return { system, messages: out };
+}
+function convertToolDef(tool) {
+    return {
+        name: tool.function.name,
+        description: tool.function.description,
+        input_schema: tool.function.parameters ?? { type: "object", properties: {} },
+    };
+}
+// 鈹€鈹€ Helpers 鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€鈹€
+function parseHttpStatus(message) {
+    const match = /Anthropic API error (\d{3})/.exec(message);
+    return match ? parseInt(match[1], 10) : null;
+}
+/**
+ * CC adjustParamsForNonStreaming parity: cap max_tokens at 64K and
+ * re-constrain thinking budget_tokens < capped max_tokens.
+ */
+function adjustParamsForNonStreaming(params) {
+    const maxTokens = typeof params.max_tokens === "number" ? params.max_tokens : 8192;
+    const cappedMaxTokens = Math.min(maxTokens, MAX_NON_STREAMING_TOKENS);
+    const adjusted = { ...params, max_tokens: cappedMaxTokens };
+    const thinking = adjusted.thinking;
+    if (thinking?.type === "enabled" && thinking.budget_tokens) {
+        adjusted.thinking = {
+            ...thinking,
+            budget_tokens: Math.min(thinking.budget_tokens, cappedMaxTokens - 1),
+        };
+    }
+    return adjusted;
+}