veryfront 0.1.381 → 0.1.382

package/esm/src/provider/runtime-loader.js

@@ -1,15 +1,11 @@
-import { getAnthropicMessagesUrl } from "./runtime-loader/provider-endpoints.js";
 import { isNumberArray } from "./runtime-loader/provider-embedding-responses.js";
-import { normalizeAnthropicFinishReason } from "./runtime-loader/provider-finish-reasons.js";
-import { createAnthropicRequestInit } from "./runtime-loader/provider-request-init.js";
-import { parseSseChunk } from "./runtime-loader/provider-sse.js";
-import { extractAnthropicUsage, mergeUsage, } from "./runtime-loader/provider-usage.js";
+import { mergeUsage } from "./runtime-loader/provider-usage.js";
 import { buildProviderError, parseRetryAfterMs, requestJson, requestStream, } from "./runtime-loader/provider-http.js";
 import { readRecord } from "./runtime-loader/provider-records.js";
 import { TOOL_INPUT_PENDING_THRESHOLD_MS, withToolInputStatusTransitions, } from "./runtime-loader/tool-input-status.js";
 export { ProviderError, ProviderOverloadedError, ProviderQuotaError, ProviderRateLimitError, ProviderRequestError, } from "./runtime-loader/provider-http.js";
 export { TOOL_INPUT_PENDING_THRESHOLD_MS, withToolInputStatusTransitions };
-export { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, parseSseChunk, readRecord, requestJson, requestStream, };
+export { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, readRecord, requestJson, requestStream, };
 export function createWarningCollector() {
     const list = [];
     return {
@@ -118,715 +114,6 @@ export function readProviderOptions(providerOptions, ...providerNames) {
     }
     return merged;
 }
-function normalizeAnthropicToolChoice(toolChoice) {
-    if (typeof toolChoice === "string") {
-        return { type: toolChoice };
-    }
-    return toolChoice;
-}
-function toSnakeCaseRecord(record) {
-    return Object.fromEntries(Object.entries(record).map(([key, value]) => [
-        key.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`),
-        value,
-    ]));
-}
-/**
- * Recursive snake_case key converter for nested config objects (used for
- * Anthropic mcp_servers, where authorizationToken / toolConfiguration /
- * allowedTools all need conversion).
- */
-function deepSnakeCase(value) {
-    if (Array.isArray(value)) {
-        return value.map(deepSnakeCase);
-    }
-    if (value !== null && typeof value === "object") {
-        return Object.fromEntries(Object.entries(value).map(([key, v]) => [
-            key.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`),
-            deepSnakeCase(v),
-        ]));
-    }
-    return value;
-}
-function pushAnthropicUserContent(messages, content) {
-    if (content.length === 0) {
-        return;
-    }
-    const lastMessage = messages.at(-1);
-    if (lastMessage?.role === "user") {
-        lastMessage.content.push(...content);
-        return;
-    }
-    messages.push({
-        role: "user",
-        content,
-    });
-}
-/**
- * Resolves a {@link ProviderCacheTtl} into Anthropic's `cache_control` shape.
- *
- * Returns `undefined` when caching is not requested (`false` / `undefined`),
- * `{ type: "ephemeral" }` for the 5-minute default (`true` / `"5m"`), or
- * `{ type: "ephemeral", ttl: "1h" }` for the extended 1-hour cache.
- */
-function resolveAnthropicCacheControlBlock(ttl) {
-    if (ttl === undefined || ttl === false) {
-        return undefined;
-    }
-    if (ttl === "1h") {
-        return { type: "ephemeral", ttl: "1h" };
-    }
-    return { type: "ephemeral" };
-}
-function toAnthropicMessages(prompt, systemCacheControl) {
-    const systemParts = [];
-    const messages = [];
-    for (const message of prompt) {
-        switch (message.role) {
-            case "system":
-                if (message.content.length > 0) {
-                    systemParts.push(message.content);
-                }
-                break;
-            case "user":
-                pushAnthropicUserContent(messages, [{
-                        type: "text",
-                        text: readTextParts(message.content),
-                    }]);
-                break;
-            case "assistant":
-                messages.push({
-                    role: "assistant",
-                    content: message.content.map((part) => {
-                        if (part.type === "text") {
-                            return { type: "text", text: part.text };
-                        }
-                        if (part.type === "reasoning") {
-                            // Redacted thinking blocks roundtrip as the encrypted blob
-                            // form Anthropic gave us. Plain thinking blocks need the
-                            // signature to verify on the server.
-                            if (typeof part.redactedData === "string") {
-                                return {
-                                    type: "redacted_thinking",
-                                    data: part.redactedData,
-                                };
-                            }
-                            return {
-                                type: "thinking",
-                                thinking: part.text ?? "",
-                                ...(typeof part.signature === "string" ? { signature: part.signature } : {}),
-                            };
-                        }
-                        return {
-                            type: "tool_use",
-                            id: part.toolCallId,
-                            name: part.toolName,
-                            input: part.input,
-                        };
-                    }),
-                });
-                break;
-            case "tool":
-                pushAnthropicUserContent(messages, message.content.map((part) => ({
-                    type: "tool_result",
-                    tool_use_id: part.toolCallId,
-                    content: stringifyJsonValue(part.output.value),
-                })));
-                break;
-        }
-    }
-    if (systemParts.length === 0) {
-        return { messages };
-    }
-    const joined = systemParts.join("\n\n");
-    // Cache-controlled system prompts must use the array-of-blocks form so the
-    // breakpoint lands on an individual content block. Callers that don't opt
-    // in keep the legacy raw-string form for backward compatibility.
-    if (systemCacheControl) {
-        return {
-            system: [{
-                    type: "text",
-                    text: joined,
-                    cache_control: systemCacheControl,
-                }],
-            messages,
-        };
-    }
-    return { system: joined, messages };
-}
-/**
- * Short-name → latest-versioned-type alias map for Anthropic provider tools.
- *
- * Anthropic tool types are date-stamped (e.g. `code_execution_20260120`) so
- * callers either pin a version or get the latest. We accept both: a caller
- * can pass `anthropic.code_execution` and we map to the latest known version,
- * or pass `anthropic.code_execution_20250522` and we forward verbatim.
- *
- * Versions chosen here are the latest documented releases as of 2026-04-15
- * — see https://docs.claude.com/en/docs/agents-and-tools/tool-use/overview.
- * When Anthropic ships newer versions, update this map.
- */
-const ANTHROPIC_TOOL_VERSION_ALIASES = {
-    code_execution: "code_execution_20260120",
-    computer_use: "computer_20250124",
-    computer: "computer_20250124",
-    text_editor: "text_editor_20250728",
-    bash: "bash_20250124",
-    memory: "memory_20250818",
-    web_search: "web_search_20250305",
-    web_fetch: "web_fetch_20250910",
-};
-function resolveAnthropicProviderType(rawType) {
-    // Already-versioned types (contain a date stamp suffix) pass through verbatim.
-    if (/_\d{8}$/.test(rawType)) {
-        return rawType;
-    }
-    return ANTHROPIC_TOOL_VERSION_ALIASES[rawType] ?? rawType;
-}
-function toAnthropicTools(tools, toolsCacheControl) {
-    if (!tools) {
-        return undefined;
-    }
-    const normalized = [];
-    for (const tool of tools) {
-        if (tool.type === "function") {
-            normalized.push({
-                name: tool.name,
-                ...(typeof tool.description === "string" ? { description: tool.description } : {}),
-                input_schema: unwrapToolInputSchema(tool.inputSchema),
-            });
-            continue;
-        }
-        if (!tool.id.startsWith("anthropic.")) {
-            continue;
-        }
-        const rawType = tool.id.slice("anthropic.".length);
-        if (rawType.length === 0) {
-            continue;
-        }
-        normalized.push({
-            type: resolveAnthropicProviderType(rawType),
-            name: tool.name,
-            ...toSnakeCaseRecord(tool.args),
-        });
-    }
-    if (normalized.length === 0) {
-        return undefined;
-    }
-    // Attach the cache breakpoint to the final tool entry so Anthropic caches
-    // the entire tools block up to and including that definition. Earlier tool
-    // entries are implicitly covered by the same breakpoint per Anthropic's
-    // walk-backward cache lookup behaviour.
-    if (toolsCacheControl) {
-        const lastIndex = normalized.length - 1;
-        normalized[lastIndex] = {
-            ...normalized[lastIndex],
-            cache_control: toolsCacheControl,
-        };
-    }
-    return normalized;
-}
-/**
- * Anthropic's Messages API requires `max_tokens` on every call, so the
- * outbound request builder must always supply a number. Picking the right
- * one means knowing the model: different Claude families have wildly
- * different maximum output budgets, and a flat default either truncates
- * modern models mid-response or gets rejected with "too many tokens" on
- * older ones. Return the model's advertised maximum as the default, and
- * clamp caller-provided values at that same ceiling for known models so a
- * bad input becomes a clipped response rather than an API error. Unknown
- * model ids get a conservative 4096 fallback and pass caller values
- * through unchanged, since we have no intel to clamp against.
- */
-function getAnthropicModelCapabilities(modelId) {
-    if (modelId.includes("claude-sonnet-4-6") || modelId.includes("claude-opus-4-6")) {
-        return { maxOutputTokens: 128_000, isKnownModel: true };
-    }
-    if (modelId.includes("claude-sonnet-4-5") ||
-        modelId.includes("claude-opus-4-5") ||
-        modelId.includes("claude-haiku-4-5")) {
-        return { maxOutputTokens: 64_000, isKnownModel: true };
-    }
-    if (modelId.includes("claude-opus-4-1")) {
-        return { maxOutputTokens: 32_000, isKnownModel: true };
-    }
-    if (modelId.includes("claude-sonnet-4-")) {
-        return { maxOutputTokens: 64_000, isKnownModel: true };
-    }
-    if (modelId.includes("claude-opus-4-")) {
-        return { maxOutputTokens: 32_000, isKnownModel: true };
-    }
-    if (modelId.includes("claude-3-haiku")) {
-        return { maxOutputTokens: 4096, isKnownModel: true };
-    }
-    return { maxOutputTokens: 4096, isKnownModel: false };
-}
-function resolveAnthropicMaxTokens(modelId, callerMaxOutputTokens) {
-    const { maxOutputTokens: modelMax, isKnownModel } = getAnthropicModelCapabilities(modelId);
-    const requested = callerMaxOutputTokens ?? modelMax;
-    if (isKnownModel && requested > modelMax) {
-        return modelMax;
-    }
-    return requested;
-}
-/**
- * Map a unified reasoning effort level to an Anthropic `thinking.budget_tokens`
- * value. Anthropic's minimum accepted budget is 1024; higher tiers give Claude
- * more headroom to explore. `max` maps to the upper bound documented for
- * Claude 4.x family (32k tokens of thinking — caller can override via
- * `budgetTokens` if they need more).
- */
-function resolveAnthropicThinkingBudget(option) {
-    if (!option || option.enabled !== true) {
-        return undefined;
-    }
-    if (typeof option.budgetTokens === "number" && option.budgetTokens >= 1024) {
-        return option.budgetTokens;
-    }
-    switch (option.effort) {
-        case "low":
-            return 1024;
-        case "high":
-            return 16_384;
-        case "max":
-            return 32_768;
-        case "medium":
-        default:
-            return 4096;
-    }
-}
-function buildAnthropicMessagesRequest(modelId, providerName, options, stream, warnings) {
-    const systemCacheControl = resolveAnthropicCacheControlBlock(options.cacheControl?.system);
-    const toolsCacheControl = resolveAnthropicCacheControlBlock(options.cacheControl?.tools);
-    const { system, messages } = toAnthropicMessages(options.prompt, systemCacheControl);
-    const anthropicTools = toAnthropicTools(options.tools, toolsCacheControl);
-    const thinkingBudget = resolveAnthropicThinkingBudget(options.reasoning);
-    const thinkingEnabled = thinkingBudget !== undefined;
-    // Anthropic doesn't support these unified options at all — emit warnings
-    // so callers don't quietly pass values that have zero effect.
-    if (options.presencePenalty !== undefined) {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "anthropic",
-            setting: "presencePenalty",
-            details: "Anthropic Messages API has no equivalent and the value was dropped.",
-        });
-    }
-    if (options.frequencyPenalty !== undefined) {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "anthropic",
-            setting: "frequencyPenalty",
-            details: "Anthropic Messages API has no equivalent and the value was dropped.",
-        });
-    }
-    if (options.seed !== undefined) {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "anthropic",
-            setting: "seed",
-            details: "Anthropic Messages API does not support deterministic seeding.",
-        });
-    }
-    if (options.topK !== undefined) {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "anthropic",
-            setting: "topK",
-            details: "Anthropic Messages API does not expose top_k on this surface.",
-        });
-    }
-    if (options.stopSequences && options.stopSequences.length > 4) {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "anthropic",
-            setting: "stopSequences",
-            details: `Anthropic accepts at most 4 stop sequences; ${options.stopSequences.length} were provided and the extras were truncated.`,
-        });
-    }
-    if (thinkingEnabled && options.temperature !== undefined) {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "anthropic",
-            setting: "temperature",
-            details: "Dropped because Anthropic rejects sampling params when extended thinking is enabled.",
-        });
-    }
-    if (thinkingEnabled && options.topP !== undefined) {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "anthropic",
-            setting: "topP",
-            details: "Dropped because Anthropic rejects sampling params when extended thinking is enabled.",
-        });
-    }
-    if (options.responseFormat && options.responseFormat.type !== "text") {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "anthropic",
-            setting: "responseFormat",
-            details: "Anthropic Messages API does not have a structured-output response_format equivalent. Use a tool with the schema as input_schema instead.",
-        });
-    }
-    // Anthropic requires max_tokens > budget_tokens when thinking is enabled.
-    // Growing max_tokens by the thinking budget preserves the caller's intended
-    // output budget, and we clamp the sum at the model's advertised maximum so
-    // the request never exceeds the API's hard cap.
-    const baseMaxTokens = resolveAnthropicMaxTokens(modelId, options.maxOutputTokens);
-    const maxTokens = thinkingEnabled
-        ? Math.min(baseMaxTokens + (thinkingBudget ?? 0), getAnthropicModelCapabilities(modelId).maxOutputTokens)
-        : baseMaxTokens;
-    const body = {
-        model: modelId,
-        messages,
-        max_tokens: maxTokens,
-        ...(stream ? { stream: true } : {}),
-        ...(system ? { system } : {}),
-        // Sampling params are mutually exclusive with thinking on Anthropic — the
-        // API rejects the combo outright. Drop them silently when thinking is on
-        // (callers see thinking's output instead of what they'd have gotten from
-        // custom sampling, which is the documented tradeoff).
-        ...(!thinkingEnabled && options.temperature !== undefined
-            ? { temperature: options.temperature }
-            : {}),
-        ...(!thinkingEnabled && options.topP !== undefined ? { top_p: options.topP } : {}),
-        ...(options.stopSequences && options.stopSequences.length > 0
-            ? { stop_sequences: options.stopSequences.slice(0, 4) }
-            : {}),
-        ...(anthropicTools ? { tools: anthropicTools } : {}),
-        ...(options.toolChoice !== undefined
-            ? { tool_choice: normalizeAnthropicToolChoice(options.toolChoice) }
-            : {}),
-        ...(thinkingEnabled ? { thinking: { type: "enabled", budget_tokens: thinkingBudget } } : {}),
-        ...(typeof options.userId === "string" && options.userId.length > 0
-            ? { metadata: { user_id: options.userId } }
-            : {}),
-        ...(options.mcpServers && options.mcpServers.length > 0
-            ? { mcp_servers: deepSnakeCase(options.mcpServers) }
-            : {}),
-        ...(options.anthropicContainer !== undefined ? { container: options.anthropicContainer } : {}),
-    };
-    Object.assign(body, readProviderOptions(options.providerOptions, "anthropic", providerName));
-    return body;
-}
-/**
- * Best-effort camelCase normalization of a single Anthropic citation
- * record. Handles the union of fields across web_search_result_location,
- * web_fetch_result_location, char_location, page_location, and
- * content_block_location citation kinds — see
- * https://docs.claude.com/en/docs/build-with-claude/citations
- */
-function normalizeAnthropicCitation(raw) {
-    const r = readRecord(raw);
-    if (!r)
-        return undefined;
-    const typeStr = typeof r.type === "string" ? r.type : undefined;
-    if (!typeStr)
-        return undefined;
-    const out = { type: typeStr };
-    if (typeof r.cited_text === "string")
-        out.citedText = r.cited_text;
-    if (typeof r.url === "string")
-        out.url = r.url;
-    if (typeof r.title === "string")
-        out.title = r.title;
-    if (typeof r.start_char_index === "number")
-        out.startCharIndex = r.start_char_index;
-    if (typeof r.end_char_index === "number")
-        out.endCharIndex = r.end_char_index;
-    if (typeof r.start_block_index === "number")
-        out.startBlockIndex = r.start_block_index;
-    if (typeof r.end_block_index === "number")
-        out.endBlockIndex = r.end_block_index;
-    if (typeof r.start_page_number === "number")
-        out.startPageNumber = r.start_page_number;
-    if (typeof r.end_page_number === "number")
-        out.endPageNumber = r.end_page_number;
-    if (typeof r.document_index === "number")
-        out.documentIndex = r.document_index;
-    if (typeof r.document_title === "string")
-        out.documentTitle = r.document_title;
-    return out;
-}
-function buildAnthropicGenerateResult(payload) {
-    const record = readRecord(payload);
-    const content = Array.isArray(record?.content) ? record.content : [];
-    const normalized = [];
-    for (const blockValue of content) {
-        const block = readRecord(blockValue);
-        const blockType = typeof block?.type === "string" ? block.type : undefined;
-        if (blockType === "text" && typeof block?.text === "string" && block.text.length > 0) {
-            const citationsRaw = Array.isArray(block.citations) ? block.citations : undefined;
-            const citations = citationsRaw
-                ?.flatMap((c) => {
-                const normalizedCitation = normalizeAnthropicCitation(c);
-                return normalizedCitation ? [normalizedCitation] : [];
-            });
-            normalized.push({
-                type: "text",
-                text: block.text,
-                ...(citations && citations.length > 0 ? { citations } : {}),
-            });
-            continue;
-        }
-        // Thinking blocks carry the cleartext trace plus a signature that
-        // Anthropic uses to verify on subsequent turns. Surfacing both lets
-        // callers persist them as `reasoning` content parts and replay on
-        // the next turn so Claude can continue from the same thinking.
-        if (blockType === "thinking") {
-            normalized.push({
-                type: "reasoning",
-                ...(typeof block?.thinking === "string" ? { text: block.thinking } : {}),
-                ...(typeof block?.signature === "string" ? { signature: block.signature } : {}),
-            });
-            continue;
-        }
-        // Redacted thinking blocks arrive when Claude's safety classifier
-        // hides the trace. Pass the encrypted blob through opaquely so the
-        // caller can replay it on the next turn (Anthropic still needs the
-        // blob to verify continuity even though it can't read it).
-        if (blockType === "redacted_thinking" && typeof block?.data === "string") {
-            normalized.push({
-                type: "reasoning",
-                redactedData: block.data,
-            });
-            continue;
-        }
-        if ((blockType === "tool_use" || blockType === "server_tool_use") &&
-            typeof block?.id === "string" &&
-            typeof block?.name === "string") {
-            normalized.push({
-                type: "tool-call",
-                toolCallId: block.id,
-                toolName: block.name,
-                input: stringifyJsonValue(block.input ?? {}),
-            });
-            continue;
-        }
-        if (blockType === "web_search_tool_result" &&
-            typeof block?.tool_use_id === "string" &&
-            Array.isArray(block?.content)) {
-            normalized.push({
-                type: "tool-result",
-                toolCallId: block.tool_use_id,
-                toolName: "web_search",
-                result: block.content,
-            });
-        }
-        if (blockType === "web_fetch_tool_result" &&
-            typeof block?.tool_use_id === "string" &&
-            readRecord(block?.content)) {
-            normalized.push({
-                type: "tool-result",
-                toolCallId: block.tool_use_id,
-                toolName: "web_fetch",
-                result: block.content,
-            });
-        }
-    }
-    return {
-        content: normalized,
-        finishReason: normalizeAnthropicFinishReason(record?.stop_reason),
-        usage: extractAnthropicUsage(payload),
-    };
-}
-async function* streamAnthropicCompatibleParts(stream) {
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const toolCalls = new Map();
-    const reasoningBlocks = new Map();
-    let finishReason = null;
-    let usage;
-    for await (const chunk of stream) {
-        buffer += decoder.decode(chunk, { stream: true });
-        const parsed = parseSseChunk(buffer);
-        buffer = parsed.remainder;
-        for (const event of parsed.events) {
-            if (event === "[DONE]") {
-                continue;
-            }
-            const record = readRecord(event);
-            const eventType = typeof record?.type === "string" ? record.type : undefined;
-            usage = mergeUsage(usage, extractAnthropicUsage(record));
-            if (eventType === "message_start") {
-                usage = mergeUsage(usage, extractAnthropicUsage(record?.message));
-                continue;
-            }
-            if (eventType === "content_block_start") {
-                const index = typeof record?.index === "number" ? record.index : 0;
-                const contentBlock = readRecord(record?.content_block);
-                const blockType = typeof contentBlock?.type === "string" ? contentBlock.type : undefined;
-                if (blockType === "text" && typeof contentBlock?.text === "string" &&
-                    contentBlock.text.length > 0) {
-                    yield { type: "text-delta", delta: contentBlock.text };
-                    continue;
-                }
-                if (blockType === "thinking") {
-                    const reasoningId = `thinking-${index}`;
-                    reasoningBlocks.set(index, { id: reasoningId });
-                    yield {
-                        type: "reasoning-start",
-                        id: reasoningId,
-                    };
-                    if (typeof contentBlock?.thinking === "string" && contentBlock.thinking.length > 0) {
-                        yield {
-                            type: "reasoning-delta",
-                            id: reasoningId,
-                            delta: contentBlock.thinking,
-                        };
-                    }
-                    continue;
-                }
-                // Redacted thinking blocks arrive as opaque encrypted payloads when
-                // Claude's safety classifier flags the reasoning trace. Surface them
-                // as a zero-length reasoning block so callers know thinking happened
-                // without leaking the (legitimately hidden) contents.
-                if (blockType === "redacted_thinking") {
-                    const reasoningId = `thinking-${index}`;
-                    reasoningBlocks.set(index, { id: reasoningId });
-                    yield {
-                        type: "reasoning-start",
-                        id: reasoningId,
-                    };
-                    continue;
-                }
-                if ((blockType === "tool_use" || blockType === "server_tool_use") &&
-                    typeof contentBlock?.id === "string" &&
-                    typeof contentBlock?.name === "string") {
-                    const providerExecuted = blockType === "server_tool_use" ? true : undefined;
-                    const current = {
-                        id: contentBlock.id,
-                        name: contentBlock.name,
-                        input: "",
-                        ...(providerExecuted ? { providerExecuted } : {}),
-                    };
-                    toolCalls.set(index, current);
-                    yield {
-                        type: "tool-input-start",
-                        id: current.id,
-                        toolName: current.name,
-                        ...(providerExecuted ? { providerExecuted } : {}),
-                    };
-                    const initialInput = contentBlock.input;
-                    if (initialInput !== undefined) {
-                        const serializedInput = stringifyJsonValue(initialInput);
-                        current.input += serializedInput;
-                        yield {
-                            type: "tool-input-delta",
-                            id: current.id,
-                            delta: serializedInput,
-                        };
-                    }
-                    continue;
-                }
-                if (blockType === "web_search_tool_result" &&
-                    typeof contentBlock?.tool_use_id === "string" &&
-                    Array.isArray(contentBlock?.content)) {
-                    yield {
-                        type: "tool-result",
-                        toolCallId: contentBlock.tool_use_id,
-                        toolName: "web_search",
-                        result: contentBlock.content,
-                        providerExecuted: true,
-                    };
-                }
-                if (blockType === "web_fetch_tool_result" &&
-                    typeof contentBlock?.tool_use_id === "string" &&
-                    readRecord(contentBlock?.content)) {
-                    yield {
-                        type: "tool-result",
-                        toolCallId: contentBlock.tool_use_id,
-                        toolName: "web_fetch",
-                        result: contentBlock.content,
-                        providerExecuted: true,
-                    };
-                }
-                continue;
-            }
-            if (eventType === "content_block_delta") {
-                const index = typeof record?.index === "number" ? record.index : 0;
-                const delta = readRecord(record?.delta);
-                const deltaType = typeof delta?.type === "string" ? delta.type : undefined;
-                if (deltaType === "text_delta" && typeof delta?.text === "string" && delta.text.length > 0) {
-                    yield { type: "text-delta", delta: delta.text };
-                    continue;
-                }
-                if (deltaType === "thinking_delta" && typeof delta?.thinking === "string" &&
-                    delta.thinking.length > 0) {
-                    const current = reasoningBlocks.get(index);
-                    if (!current) {
-                        continue;
-                    }
-                    yield {
-                        type: "reasoning-delta",
-                        id: current.id,
-                        delta: delta.thinking,
-                    };
-                    continue;
-                }
-                if (deltaType === "input_json_delta" && typeof delta?.partial_json === "string") {
-                    const current = toolCalls.get(index);
-                    if (!current) {
-                        continue;
-                    }
-                    current.input += delta.partial_json;
-                    yield {
-                        type: "tool-input-delta",
-                        id: current.id,
-                        delta: delta.partial_json,
-                    };
-                }
-                continue;
-            }
-            if (eventType === "content_block_stop") {
-                const index = typeof record?.index === "number" ? record.index : 0;
-                const reasoning = reasoningBlocks.get(index);
-                if (reasoning) {
-                    yield {
-                        type: "reasoning-end",
-                        id: reasoning.id,
-                    };
-                    reasoningBlocks.delete(index);
-                    continue;
-                }
-                const current = toolCalls.get(index);
-                if (!current) {
-                    continue;
-                }
-                yield {
-                    type: "tool-call",
-                    toolCallId: current.id,
-                    toolName: current.name,
-                    input: current.input.length > 0 ? current.input : "{}",
-                    ...(current.providerExecuted ? { providerExecuted: true } : {}),
-                };
-                toolCalls.delete(index);
-                continue;
-            }
-            if (eventType === "message_delta") {
-                const delta = readRecord(record?.delta);
-                const normalizedFinishReason = normalizeAnthropicFinishReason(delta?.stop_reason);
-                if (normalizedFinishReason) {
-                    finishReason = normalizedFinishReason;
-                }
-            }
-        }
-    }
-    if (buffer.trim().length > 0) {
-        const parsed = parseSseChunk(`${buffer}\n\n`);
-        for (const event of parsed.events) {
-            if (event === "[DONE]") {
-                continue;
-            }
-            const record = readRecord(event);
-            usage = mergeUsage(usage, extractAnthropicUsage(record));
-        }
-    }
-    yield {
-        type: "finish",
-        finishReason,
-        ...(usage ? { usage } : {}),
-    };
-}
 export function unwrapToolInputSchema(inputSchema) {
     if (typeof inputSchema !== "object" || inputSchema === null || Array.isArray(inputSchema)) {
         return inputSchema;
@@ -834,63 +121,3 @@ export function unwrapToolInputSchema(inputSchema) {
     const candidate = Reflect.get(inputSchema, "jsonSchema");
     return candidate ?? inputSchema;
 }
-export function createAnthropicModelRuntime(config, modelId) {
-    const fetchImpl = config.fetch ?? globalThis.fetch;
-    return {
-        provider: config.name ?? "anthropic",
-        modelId,
-        specificationVersion: "v3",
-        supportedUrls: {},
-        doGenerate(optionsForRuntime) {
-            const options = optionsForRuntime;
-            const url = getAnthropicMessagesUrl(config.baseURL);
-            const warnings = createWarningCollector();
-            const body = buildAnthropicMessagesRequest(modelId, config.name ?? "anthropic", options, false, warnings);
-            return requestJson({
-                url,
-                fetchImpl,
-                providerLabel: config.name ?? "anthropic",
-                providerKind: "anthropic",
-                init: createAnthropicRequestInit({
-                    apiKey: config.apiKey,
-                    authToken: config.authToken,
-                    extraHeaders: options.headers,
-                    body: JSON.stringify(body),
-                    signal: options.abortSignal,
-                }),
-            }).then((payload) => {
-                const drained = warnings.drain();
-                return {
-                    ...buildAnthropicGenerateResult(payload),
-                    ...(drained.length > 0 ? { warnings: drained } : {}),
-                };
-            });
-        },
-        doStream(optionsForRuntime) {
-            const options = optionsForRuntime;
-            const url = getAnthropicMessagesUrl(config.baseURL);
-            const warnings = createWarningCollector();
-            const body = buildAnthropicMessagesRequest(modelId, config.name ?? "anthropic", options, true, warnings);
-            return requestStream({
-                url,
-                fetchImpl,
-                providerLabel: config.name ?? "anthropic",
-                providerKind: "anthropic",
-                init: createAnthropicRequestInit({
-                    apiKey: config.apiKey,
-                    authToken: config.authToken,
-                    extraHeaders: options.headers,
-                    enableFineGrainedToolStreaming: true,
-                    body: JSON.stringify(body),
-                    signal: options.abortSignal,
-                }),
-            }).then((responseStream) => {
-                const drained = warnings.drain();
-                return {
-                    stream: ReadableStream.from(withToolInputStatusTransitions(streamAnthropicCompatibleParts(responseStream))),
-                    ...(drained.length > 0 ? { warnings: drained } : {}),
-                };
-            });
-        },
-    };
-}