veryfront 0.1.283 → 0.1.285

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

@@ -1,15 +1,16 @@
-import { getAnthropicMessagesUrl, getGoogleEmbeddingUrl, getGoogleGenerateContentUrl, getGoogleStreamGenerateContentUrl, getOpenAIChatCompletionsUrl, getOpenAIEmbeddingUrl, getOpenAIResponsesUrl, } from "./runtime-loader/provider-endpoints.js";
-import { extractGoogleEmbedding, extractGoogleUsageTokens, extractOpenAIEmbeddings, extractOpenAIUsageTokens, } from "./runtime-loader/provider-embedding-responses.js";
-import { normalizeAnthropicFinishReason, normalizeGoogleFinishReason, normalizeOpenAIFinishReason, normalizeOpenAIResponsesFinishReason, } from "./runtime-loader/provider-finish-reasons.js";
-import { createAnthropicRequestInit, createGoogleRequestInit, createOpenAIRequestInit, } from "./runtime-loader/provider-request-init.js";
+import { getAnthropicMessagesUrl, getGoogleEmbeddingUrl, getGoogleGenerateContentUrl, getGoogleStreamGenerateContentUrl, } from "./runtime-loader/provider-endpoints.js";
+import { extractGoogleEmbedding, extractGoogleUsageTokens, isNumberArray, } from "./runtime-loader/provider-embedding-responses.js";
+import { normalizeAnthropicFinishReason, normalizeGoogleFinishReason, } from "./runtime-loader/provider-finish-reasons.js";
+import { createAnthropicRequestInit, createGoogleRequestInit, } from "./runtime-loader/provider-request-init.js";
 import { parseSseChunk } from "./runtime-loader/provider-sse.js";
-import { extractAnthropicUsage, extractGoogleUsage, extractOpenAIResponsesUsage, extractOpenAIUsage, mergeUsage, } from "./runtime-loader/provider-usage.js";
-import { requestJson, requestStream } from "./runtime-loader/provider-http.js";
+import { extractAnthropicUsage, extractGoogleUsage, 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 };
-function createWarningCollector() {
+export { buildProviderError, isNumberArray, mergeUsage, parseRetryAfterMs, readRecord, requestJson, requestStream, };
+export function createWarningCollector() {
     const list = [];
     return {
         push(warning) {
@@ -20,13 +21,13 @@ function createWarningCollector() {
         },
     };
 }
-function stringifyJsonValue(value) {
+export function stringifyJsonValue(value) {
     if (typeof value === "string") {
         return value;
     }
     return JSON.stringify(value);
 }
-function readTextParts(parts) {
+export function readTextParts(parts) {
     let text = "";
     for (const part of parts) {
         if (part.type === "text" && typeof part.text === "string") {
@@ -35,7 +36,7 @@ function readTextParts(parts) {
     }
     return text;
 }
-function toOpenAICompatibleMessages(prompt) {
+export function toOpenAICompatibleMessages(prompt) {
     const messages = [];
     for (const message of prompt) {
         switch (message.role) {
@@ -87,7 +88,7 @@ function toOpenAICompatibleMessages(prompt) {
     }
     return messages;
 }
-function toOpenAICompatibleTools(tools) {
+export function toOpenAICompatibleTools(tools) {
     if (!tools) {
         return undefined;
     }
@@ -103,7 +104,7 @@ function toOpenAICompatibleTools(tools) {
         : []);
     return functions.length > 0 ? functions : undefined;
 }
-function readProviderOptions(providerOptions, ...providerNames) {
+export function readProviderOptions(providerOptions, ...providerNames) {
     if (!providerOptions) {
         return {};
     }
@@ -826,198 +827,6 @@ async function* streamAnthropicCompatibleParts(stream) {
         ...(usage ? { usage } : {}),
     };
 }
-function extractOpenAIContentText(content) {
-    if (typeof content === "string") {
-        return content;
-    }
-    if (!Array.isArray(content)) {
-        return "";
-    }
-    let text = "";
-    for (const part of content) {
-        const record = readRecord(part);
-        const type = record?.type;
-        if (type === "text" && typeof record?.text === "string") {
-            text += record.text;
-        }
-    }
-    return text;
-}
-function extractOpenAIToolCalls(message) {
-    const toolCalls = message.tool_calls;
-    if (!Array.isArray(toolCalls)) {
-        return [];
-    }
-    const normalized = [];
-    for (const entry of toolCalls) {
-        const record = readRecord(entry);
-        const id = typeof record?.id === "string" ? record.id : undefined;
-        const fn = readRecord(record?.function);
-        const name = typeof fn?.name === "string" ? fn.name : undefined;
-        const argumentsText = typeof fn?.arguments === "string" ? fn.arguments : undefined;
-        if (!id || !name || argumentsText === undefined) {
-            continue;
-        }
-        normalized.push({
-            toolCallId: id,
-            toolName: name,
-            input: argumentsText,
-        });
-    }
-    return normalized;
-}
-/**
- * OpenAI reasoning models (o1 / o3 / o4 family) use the completion path but
- * have different constraints than chat models: sampling params are rejected,
- * and they accept a `reasoning_effort` field. We detect them by model id
- * prefix so callers don't have to configure it per runtime.
- */
-function isOpenAIReasoningModel(modelId) {
-    return /^o[134](-|$)/.test(modelId);
-}
-/**
- * Detect native OpenAI models (gpt-*, o-series, chatgpt-*) vs third-party
- * OpenAI-compatible providers (Kimi, etc.). Native OpenAI models require
- * `max_completion_tokens` (the old `max_tokens` is rejected by newer models
- * like gpt-5.2), while third-party providers still expect `max_tokens`.
- */
-function isNativeOpenAIModel(modelId) {
-    return /^(gpt-|o[134](-|$)|chatgpt-)/.test(modelId);
-}
-/**
- * Kimi K2.5 fixes sampling parameters (temperature, top_p, presence_penalty,
- * frequency_penalty) to predetermined values and rejects any other values.
- * See https://platform.moonshot.cn/docs/guide/kimi-k2-5-quickstart
- */
-function isFixedSamplingModel(modelId) {
-    return /^kimi-k2\.5/.test(modelId);
-}
-/**
- * Map the unified reasoning effort to OpenAI's `reasoning_effort` enum.
- * OpenAI doesn't accept "max" — we collapse it to "high".
- */
-function resolveOpenAIReasoningEffort(option) {
-    if (!option || option.enabled !== true) {
-        return undefined;
-    }
-    switch (option.effort) {
-        case "low":
-            return "low";
-        case "high":
-        case "max":
-            return "high";
-        case "medium":
-        default:
-            return "medium";
-    }
-}
-function buildOpenAIChatRequest(modelId, providerName, options, stream, warnings) {
-    const isReasoningModel = isOpenAIReasoningModel(modelId);
-    const reasoningEffort = resolveOpenAIReasoningEffort(options.reasoning);
-    const reasoningEnabled = isReasoningModel || reasoningEffort !== undefined;
-    const fixedSampling = isFixedSamplingModel(modelId);
-    const dropSamplingParams = reasoningEnabled || fixedSampling;
-    // OpenAI Chat Completions has no top_k surface (it's exposed only on the
-    // Responses API for some reasoning models). Quietly accepting it would
-    // mislead callers into thinking it took effect.
-    if (options.topK !== undefined) {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "openai",
-            setting: "topK",
-            details: "OpenAI Chat Completions does not expose top_k; the value was dropped.",
-        });
-    }
-    // Reasoning models (o1 / o3 / o4) and models with fixed sampling params
-    // (Kimi K2.5) reject sampling params outright. Emit warnings at build time
-    // so callers see *why* the value didn't apply rather than a 400 from the API.
-    if (dropSamplingParams) {
-        const dropped = [
-            ["temperature", "temperature"],
-            ["topP", "top_p"],
-            ["presencePenalty", "presence_penalty"],
-            ["frequencyPenalty", "frequency_penalty"],
-        ];
-        for (const [key, openaiName] of dropped) {
-            if (options[key] !== undefined) {
-                warnings.push({
-                    type: "unsupported-setting",
-                    provider: "openai",
-                    setting: key,
-                    details: fixedSampling
-                        ? `Dropped because this model uses fixed sampling parameters.`
-                        : `Dropped because OpenAI reasoning models reject ${openaiName}. Reasoning was active for this request.`,
-                });
-            }
-        }
-    }
-    const body = {
-        model: modelId,
-        messages: toOpenAICompatibleMessages(options.prompt),
-        ...(stream ? { stream: true, stream_options: { include_usage: true } } : {}),
-        ...(options.maxOutputTokens !== undefined
-            ? isNativeOpenAIModel(modelId)
-                ? { max_completion_tokens: options.maxOutputTokens }
-                : { max_tokens: options.maxOutputTokens }
-            : {}),
-        // Reasoning models and fixed-sampling models reject temperature / top_p /
-        // frequency / presence. Drop them rather than letting the API bounce.
-        ...(!dropSamplingParams && options.temperature !== undefined
-            ? { temperature: options.temperature }
-            : {}),
-        ...(!dropSamplingParams && options.topP !== undefined ? { top_p: options.topP } : {}),
-        ...(options.stopSequences && options.stopSequences.length > 0
-            ? { stop: options.stopSequences }
-            : {}),
-        ...(toOpenAICompatibleTools(options.tools)
-            ? { tools: toOpenAICompatibleTools(options.tools) }
-            : {}),
-        ...(options.toolChoice !== undefined ? { tool_choice: options.toolChoice } : {}),
-        ...(options.seed !== undefined ? { seed: options.seed } : {}),
-        ...(!dropSamplingParams && options.presencePenalty !== undefined
-            ? { presence_penalty: options.presencePenalty }
-            : {}),
-        ...(!dropSamplingParams && options.frequencyPenalty !== undefined
-            ? { frequency_penalty: options.frequencyPenalty }
-            : {}),
-        ...(reasoningEffort !== undefined ? { reasoning_effort: reasoningEffort } : {}),
-        ...(typeof options.userId === "string" && options.userId.length > 0
-            ? { user: options.userId }
-            : {}),
-        ...(options.serviceTier !== undefined ? { service_tier: options.serviceTier } : {}),
-        ...(options.parallelToolCalls !== undefined
-            ? { parallel_tool_calls: options.parallelToolCalls }
-            : {}),
-        ...(options.responseFormat && options.responseFormat.type !== "text"
-            ? {
-                response_format: options.responseFormat.type === "json" ? { type: "json_object" } : {
-                    type: "json_schema",
-                    json_schema: {
-                        name: options.responseFormat.name,
-                        ...(typeof options.responseFormat.description === "string"
-                            ? { description: options.responseFormat.description }
-                            : {}),
-                        schema: unwrapToolInputSchema(options.responseFormat.schema),
-                        ...(options.responseFormat.strict !== undefined
-                            ? { strict: options.responseFormat.strict }
-                            : {}),
-                    },
-                },
-            }
-            : {}),
-    };
-    const providerOpts = readProviderOptions(options.providerOptions, "openai", providerName);
-    // Normalize max_tokens → max_completion_tokens for native OpenAI models.
-    // Provider options can re-introduce max_tokens which newer models reject.
-    if (isNativeOpenAIModel(modelId) && "max_tokens" in providerOpts) {
-        if (!("max_completion_tokens" in providerOpts)) {
-            providerOpts.max_completion_tokens = providerOpts.max_tokens;
-        }
-        delete providerOpts.max_tokens;
-    }
-    Object.assign(body, providerOpts);
-    return body;
-}
 function toGoogleContents(prompt) {
     const systemParts = [];
     const contents = [];
@@ -1433,706 +1242,6 @@ async function* streamGoogleCompatibleParts(stream) {
         ...(usage ? { usage } : {}),
     };
 }
-function extractFirstChoice(payload) {
-    const record = readRecord(payload);
-    const choices = record?.choices;
-    if (!Array.isArray(choices) || choices.length === 0) {
-        return undefined;
-    }
-    const first = readRecord(choices[0]);
-    if (!first) {
-        return undefined;
-    }
-    return first;
-}
-function buildOpenAIGenerateResult(payload) {
-    const choice = extractFirstChoice(payload);
-    const message = readRecord(choice?.message);
-    const text = extractOpenAIContentText(message?.content);
-    const toolCalls = message ? extractOpenAIToolCalls(message) : [];
-    return {
-        content: [
-            ...(text.length > 0 ? [{ type: "text", text }] : []),
-            ...toolCalls.map((toolCall) => ({
-                type: "tool-call",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                input: toolCall.input,
-            })),
-        ],
-        finishReason: normalizeOpenAIFinishReason(choice?.finish_reason),
-        usage: extractOpenAIUsage(payload),
-    };
-}
-async function* streamOpenAICompatibleParts(stream) {
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const toolCalls = new Map();
-    let reasoningId = null;
-    let reasoningIndex = 0;
-    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);
-            usage = extractOpenAIUsage(record) ?? usage;
-            const choice = extractFirstChoice(record);
-            if (!choice) {
-                continue;
-            }
-            const delta = readRecord(choice.delta);
-            if (typeof delta?.reasoning_content === "string" && delta.reasoning_content.length > 0) {
-                if (!reasoningId) {
-                    reasoningId = `reasoning-${reasoningIndex++}`;
-                    yield {
-                        type: "reasoning-start",
-                        id: reasoningId,
-                    };
-                }
-                yield {
-                    type: "reasoning-delta",
-                    id: reasoningId,
-                    delta: delta.reasoning_content,
-                };
-            }
-            const textDelta = extractOpenAIContentText(delta?.content);
-            if (textDelta.length > 0) {
-                if (reasoningId) {
-                    yield {
-                        type: "reasoning-end",
-                        id: reasoningId,
-                    };
-                    reasoningId = null;
-                }
-                yield { type: "text-delta", delta: textDelta };
-            }
-            const rawToolCalls = Array.isArray(delta?.tool_calls) ? delta.tool_calls : [];
-            for (const rawToolCall of rawToolCalls) {
-                if (reasoningId) {
-                    yield {
-                        type: "reasoning-end",
-                        id: reasoningId,
-                    };
-                    reasoningId = null;
-                }
-                const toolCallRecord = readRecord(rawToolCall);
-                const index = typeof toolCallRecord?.index === "number" ? toolCallRecord.index : 0;
-                const current = toolCalls.get(index) ?? {
-                    id: typeof toolCallRecord?.id === "string" ? toolCallRecord.id : `tool-${index}`,
-                    name: "",
-                    arguments: "",
-                    started: false,
-                };
-                if (typeof toolCallRecord?.id === "string") {
-                    current.id = toolCallRecord.id;
-                }
-                const fn = readRecord(toolCallRecord?.function);
-                if (typeof fn?.name === "string") {
-                    current.name = fn.name;
-                }
-                if (!current.started && current.name.length > 0) {
-                    current.started = true;
-                    yield {
-                        type: "tool-input-start",
-                        id: current.id,
-                        toolName: current.name,
-                    };
-                }
-                if (typeof fn?.arguments === "string" && fn.arguments.length > 0) {
-                    current.arguments += fn.arguments;
-                    yield {
-                        type: "tool-input-delta",
-                        id: current.id,
-                        delta: fn.arguments,
-                    };
-                }
-                toolCalls.set(index, current);
-            }
-            const normalizedFinishReason = normalizeOpenAIFinishReason(choice.finish_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 = extractOpenAIUsage(record) ?? usage;
-        }
-    }
-    if (reasoningId) {
-        yield {
-            type: "reasoning-end",
-            id: reasoningId,
-        };
-    }
-    if (finishReason &&
-        typeof finishReason === "object" &&
-        finishReason.unified === "tool-calls") {
-        for (const toolCall of toolCalls.values()) {
-            yield {
-                type: "tool-call",
-                toolCallId: toolCall.id,
-                toolName: toolCall.name,
-                input: toolCall.arguments,
-            };
-        }
-    }
-    yield {
-        type: "finish",
-        finishReason,
-        ...(usage ? { usage } : {}),
-    };
-}
-export function createOpenAIModelRuntime(config, modelId) {
-    const fetchImpl = config.fetch ?? globalThis.fetch;
-    return {
-        provider: config.name ?? "openai",
-        modelId,
-        specificationVersion: "v3",
-        supportedUrls: {},
-        doGenerate(optionsForRuntime) {
-            const options = optionsForRuntime;
-            const url = getOpenAIChatCompletionsUrl(config.baseURL);
-            const warnings = createWarningCollector();
-            const body = buildOpenAIChatRequest(modelId, config.name ?? "openai", options, false, warnings);
-            return requestJson({
-                url,
-                fetchImpl,
-                providerLabel: config.name ?? "openai",
-                providerKind: "openai",
-                init: createOpenAIRequestInit({
-                    apiKey: config.apiKey,
-                    extraHeaders: options.headers,
-                    body: JSON.stringify(body),
-                    signal: options.abortSignal,
-                }),
-            }).then((payload) => {
-                const drained = warnings.drain();
-                return {
-                    ...buildOpenAIGenerateResult(payload),
-                    ...(drained.length > 0 ? { warnings: drained } : {}),
-                };
-            });
-        },
-        doStream(optionsForRuntime) {
-            const options = optionsForRuntime;
-            const url = getOpenAIChatCompletionsUrl(config.baseURL);
-            const warnings = createWarningCollector();
-            const body = buildOpenAIChatRequest(modelId, config.name ?? "openai", options, true, warnings);
-            return requestStream({
-                url,
-                fetchImpl,
-                providerLabel: config.name ?? "openai",
-                providerKind: "openai",
-                init: createOpenAIRequestInit({
-                    apiKey: config.apiKey,
-                    extraHeaders: options.headers,
-                    body: JSON.stringify(body),
-                    signal: options.abortSignal,
-                }),
-            }).then((responseStream) => {
-                const drained = warnings.drain();
-                return {
-                    stream: ReadableStream.from(withToolInputStatusTransitions(streamOpenAICompatibleParts(responseStream))),
-                    ...(drained.length > 0 ? { warnings: drained } : {}),
-                };
-            });
-        },
-    };
-}
-/**
- * Convert the unified RuntimePromptMessage[] to the Responses API `input`
- * array shape. Differences from Chat Completions:
- *  - System prompts go on the top-level `instructions` field, not inline.
- *  - Content parts use `input_text` / `output_text` discriminants instead
- *    of the Chat Completions plain-text shorthand.
- *  - Assistant tool calls become standalone `function_call` items in the
- *    input array, not nested `tool_calls` on a message.
- *  - Tool results become standalone `function_call_output` items.
- *  - Reasoning content parts roundtrip as `reasoning` items so callers can
- *    replay multi-turn conversations with chain-of-thought intact.
- */
-function toOpenAIResponsesInput(prompt) {
-    const instructionsParts = [];
-    const input = [];
-    for (const message of prompt) {
-        switch (message.role) {
-            case "system":
-                if (message.content.length > 0) {
-                    instructionsParts.push(message.content);
-                }
-                break;
-            case "user":
-                input.push({
-                    role: "user",
-                    content: [{ type: "input_text", text: readTextParts(message.content) }],
-                });
-                break;
-            case "assistant": {
-                const messageContent = [];
-                for (const part of message.content) {
-                    if (part.type === "text") {
-                        messageContent.push({ type: "output_text", text: part.text });
-                        continue;
-                    }
-                    if (part.type === "reasoning") {
-                        // Reasoning items are top-level entries in the input array,
-                        // not nested inside the assistant message — flush whatever
-                        // text we've accumulated first, then push the reasoning item.
-                        if (messageContent.length > 0) {
-                            input.push({ role: "assistant", content: [...messageContent] });
-                            messageContent.length = 0;
-                        }
-                        const summary = [];
-                        if (typeof part.text === "string" && part.text.length > 0) {
-                            summary.push({ type: "summary_text", text: part.text });
-                        }
-                        input.push({
-                            type: "reasoning",
-                            ...(typeof part.signature === "string" ? { encrypted_content: part.signature } : {}),
-                            summary,
-                        });
-                        continue;
-                    }
-                    // tool-call: flush message content, then push as standalone
-                    // function_call item per Responses API shape.
-                    if (messageContent.length > 0) {
-                        input.push({ role: "assistant", content: [...messageContent] });
-                        messageContent.length = 0;
-                    }
-                    input.push({
-                        type: "function_call",
-                        call_id: part.toolCallId,
-                        name: part.toolName,
-                        arguments: stringifyJsonValue(part.input),
-                    });
-                }
-                if (messageContent.length > 0) {
-                    input.push({ role: "assistant", content: messageContent });
-                }
-                break;
-            }
-            case "tool":
-                for (const part of message.content) {
-                    input.push({
-                        type: "function_call_output",
-                        call_id: part.toolCallId,
-                        output: stringifyJsonValue(part.output.value),
-                    });
-                }
-                break;
-        }
-    }
-    return {
-        ...(instructionsParts.length > 0 ? { instructions: instructionsParts.join("\n\n") } : {}),
-        input,
-    };
-}
-/**
- * Tools on the Responses API differ from Chat Completions: instead of
- * `{ type: "function", function: { name, parameters } }` the function
- * shape lifts the name/parameters/strict to the top of the entry. Native
- * tools (web_search, file_search, computer_use, code_interpreter) live
- * alongside function tools in the same array.
- */
-function toOpenAIResponsesTools(tools) {
-    if (!tools)
-        return undefined;
-    const normalized = [];
-    for (const tool of tools) {
-        if (tool.type === "function") {
-            normalized.push({
-                type: "function",
-                name: tool.name,
-                ...(typeof tool.description === "string" ? { description: tool.description } : {}),
-                parameters: unwrapToolInputSchema(tool.inputSchema),
-            });
-            continue;
-        }
-        if (!tool.id.startsWith("openai."))
-            continue;
-        const providerType = tool.id.slice("openai.".length);
-        if (providerType.length === 0)
-            continue;
-        normalized.push({
-            type: providerType,
-            ...toSnakeCaseRecord(tool.args),
-        });
-    }
-    return normalized.length > 0 ? normalized : undefined;
-}
-function buildOpenAIResponsesRequest(modelId, providerName, options, stream, warnings) {
-    const isReasoningModel = isOpenAIReasoningModel(modelId);
-    const reasoningEffort = resolveOpenAIReasoningEffort(options.reasoning);
-    const reasoningEnabled = isReasoningModel || reasoningEffort !== undefined;
-    // Same param-sanitization rules as Chat Completions: reasoning models
-    // reject sampling params. Drop with a warning.
-    if (options.topK !== undefined) {
-        warnings.push({
-            type: "unsupported-setting",
-            provider: "openai",
-            setting: "topK",
-            details: "OpenAI Responses API does not expose top_k; the value was dropped.",
-        });
-    }
-    if (reasoningEnabled) {
-        const dropped = [
-            ["temperature", "temperature"],
-            ["topP", "top_p"],
-            ["presencePenalty", "presence_penalty"],
-            ["frequencyPenalty", "frequency_penalty"],
-        ];
-        for (const [key, openaiName] of dropped) {
-            if (options[key] !== undefined) {
-                warnings.push({
-                    type: "unsupported-setting",
-                    provider: "openai",
-                    setting: key,
-                    details: `Dropped because OpenAI reasoning models reject ${openaiName}. Reasoning was active for this request.`,
-                });
-            }
-        }
-    }
-    const { instructions, input } = toOpenAIResponsesInput(options.prompt);
-    const responsesTools = toOpenAIResponsesTools(options.tools);
-    const body = {
-        model: modelId,
-        input,
-        ...(instructions !== undefined ? { instructions } : {}),
-        ...(stream ? { stream: true } : {}),
-        ...(options.maxOutputTokens !== undefined
-            ? { max_output_tokens: options.maxOutputTokens }
-            : {}),
-        ...(!reasoningEnabled && options.temperature !== undefined
-            ? { temperature: options.temperature }
-            : {}),
-        ...(!reasoningEnabled && options.topP !== undefined ? { top_p: options.topP } : {}),
-        ...(responsesTools ? { tools: responsesTools } : {}),
-        ...(options.toolChoice !== undefined ? { tool_choice: options.toolChoice } : {}),
-        // The Responses API surfaces reasoning effort + summary verbosity
-        // in a structured `reasoning` object instead of a flat field. We
-        // request "auto" summary so callers see structured summary parts
-        // without having to opt into them per request.
-        ...(reasoningEffort !== undefined
-            ? { reasoning: { effort: reasoningEffort, summary: "auto" } }
-            : {}),
-        ...(typeof options.userId === "string" && options.userId.length > 0
-            ? { user: options.userId }
-            : {}),
-        ...(options.serviceTier !== undefined ? { service_tier: options.serviceTier } : {}),
-        ...(options.parallelToolCalls !== undefined
-            ? { parallel_tool_calls: options.parallelToolCalls }
-            : {}),
-        // Responses API uses `text.format` instead of Chat Completions'
-        // `response_format`. The shape is similar but nested under `text`.
-        ...(options.responseFormat && options.responseFormat.type !== "text"
-            ? {
-                text: {
-                    format: options.responseFormat.type === "json" ? { type: "json_object" } : {
-                        type: "json_schema",
-                        name: options.responseFormat.name,
-                        ...(typeof options.responseFormat.description === "string"
-                            ? { description: options.responseFormat.description }
-                            : {}),
-                        schema: unwrapToolInputSchema(options.responseFormat.schema),
-                        ...(options.responseFormat.strict !== undefined
-                            ? { strict: options.responseFormat.strict }
-                            : {}),
-                    },
-                },
-            }
-            : {}),
-    };
-    Object.assign(body, readProviderOptions(options.providerOptions, "openai", providerName));
-    return body;
-}
-function buildOpenAIResponsesGenerateResult(payload) {
-    const record = readRecord(payload);
-    const output = Array.isArray(record?.output) ? record.output : [];
-    const content = [];
-    for (const item of output) {
-        const itemRecord = readRecord(item);
-        const itemType = typeof itemRecord?.type === "string" ? itemRecord.type : undefined;
-        if (itemType === "message" && Array.isArray(itemRecord?.content)) {
-            // A message item bundles one or more output_text parts. Concat
-            // their texts into a single text content entry.
-            let text = "";
-            for (const part of itemRecord.content) {
-                const p = readRecord(part);
-                if (typeof p?.type === "string" && p.type === "output_text" && typeof p.text === "string") {
-                    text += p.text;
-                }
-            }
-            if (text.length > 0) {
-                content.push({ type: "text", text });
-            }
-            continue;
-        }
-        if (itemType === "function_call") {
-            content.push({
-                type: "tool-call",
-                toolCallId: typeof itemRecord?.call_id === "string"
-                    ? itemRecord.call_id
-                    : (typeof itemRecord?.id === "string" ? itemRecord.id : ""),
-                toolName: typeof itemRecord?.name === "string" ? itemRecord.name : "",
-                input: typeof itemRecord?.arguments === "string"
-                    ? itemRecord.arguments
-                    : stringifyJsonValue(itemRecord?.arguments ?? {}),
-            });
-            continue;
-        }
-        if (itemType === "reasoning") {
-            const summary = Array.isArray(itemRecord?.summary) ? itemRecord.summary : [];
-            const summaries = [];
-            for (const s of summary) {
-                const sr = readRecord(s);
-                if (typeof sr?.text === "string" && sr.text.length > 0) {
-                    summaries.push({
-                        ...(typeof sr?.id === "string" ? { id: sr.id } : {}),
-                        text: sr.text,
-                    });
-                }
-            }
-            content.push({
-                type: "reasoning",
-                ...(summaries.length > 0 ? { summaries } : {}),
-                ...(typeof itemRecord?.encrypted_content === "string"
-                    ? { signature: itemRecord.encrypted_content }
-                    : {}),
-            });
-            continue;
-        }
-    }
-    return {
-        content,
-        finishReason: normalizeOpenAIResponsesFinishReason(record?.status),
-        usage: extractOpenAIResponsesUsage(payload),
-    };
-}
-/**
- * Parse the Responses API streaming event grammar into the same UI part
- * shapes the existing OpenAI / Anthropic / Google streams emit. The
- * Responses API uses a strict event-typed protocol — every event has a
- * `type` field naming the lifecycle phase — instead of the loose
- * `delta`-based shape Chat Completions uses.
- */
-async function* streamOpenAIResponsesParts(stream) {
-    const decoder = new TextDecoder();
-    let buffer = "";
-    const reasoningBlocks = new Map();
-    const functionCalls = new Map();
-    const startedToolCalls = new Set();
-    let finishReason = null;
-    let usage;
-    let reasoningCounter = 0;
-    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 type = typeof record?.type === "string" ? record.type : undefined;
-            if (!type)
-                continue;
-            // response.output_item.added: a new output item begins. Track
-            // function_call items so their argument deltas can be attributed,
-            // and reasoning items so summary deltas can group correctly.
-            if (type === "response.output_item.added") {
-                const item = readRecord(record?.item);
-                const itemType = typeof item?.type === "string" ? item.type : undefined;
-                const itemId = typeof item?.id === "string" ? item.id : undefined;
-                if (itemType === "function_call" && itemId) {
-                    const callId = typeof item?.call_id === "string" ? item.call_id : itemId;
-                    const name = typeof item?.name === "string" ? item.name : "";
-                    functionCalls.set(itemId, {
-                        id: itemId,
-                        toolCallId: callId,
-                        name,
-                        arguments: "",
-                    });
-                }
-                if (itemType === "reasoning" && itemId) {
-                    reasoningBlocks.set(itemId, {
-                        id: `reasoning-${reasoningCounter++}`,
-                        emittedStart: false,
-                    });
-                }
-                continue;
-            }
-            // response.output_text.delta: text chunk for a message item.
-            if (type === "response.output_text.delta" && typeof record?.delta === "string") {
-                if (record.delta.length > 0) {
-                    yield { type: "text-delta", delta: record.delta };
-                }
-                continue;
-            }
-            // response.reasoning_summary_text.delta: reasoning summary text
-            // chunk. The first delta on an item lazily emits the
-            // reasoning-start event so callers can group deltas into a part.
-            if (type === "response.reasoning_summary_text.delta" && typeof record?.delta === "string") {
-                const itemId = typeof record?.item_id === "string" ? record.item_id : undefined;
-                const state = itemId ? reasoningBlocks.get(itemId) : undefined;
-                if (state && record.delta.length > 0) {
-                    if (!state.emittedStart) {
-                        yield { type: "reasoning-start", id: state.id };
-                        state.emittedStart = true;
-                    }
-                    yield { type: "reasoning-delta", id: state.id, delta: record.delta };
-                }
-                continue;
-            }
-            // response.function_call_arguments.delta: tool call argument
-            // chunk. The first delta lazily emits tool-input-start.
-            if (type === "response.function_call_arguments.delta" && typeof record?.delta === "string") {
-                const itemId = typeof record?.item_id === "string" ? record.item_id : undefined;
-                const state = itemId ? functionCalls.get(itemId) : undefined;
-                if (state && record.delta.length > 0) {
-                    if (!startedToolCalls.has(state.id)) {
-                        yield {
-                            type: "tool-input-start",
-                            id: state.toolCallId,
-                            toolName: state.name,
-                        };
-                        startedToolCalls.add(state.id);
-                    }
-                    state.arguments += record.delta;
-                    yield {
-                        type: "tool-input-delta",
-                        id: state.toolCallId,
-                        delta: record.delta,
-                    };
-                }
-                continue;
-            }
-            // response.output_item.done: an item has finished emitting deltas.
-            // Close any reasoning or function-call streams that were open.
-            if (type === "response.output_item.done") {
-                const item = readRecord(record?.item);
-                const itemType = typeof item?.type === "string" ? item.type : undefined;
-                const itemId = typeof item?.id === "string" ? item.id : undefined;
-                if (itemType === "reasoning" && itemId) {
-                    const state = reasoningBlocks.get(itemId);
-                    if (state?.emittedStart) {
-                        yield { type: "reasoning-end", id: state.id };
-                    }
-                    reasoningBlocks.delete(itemId);
-                }
-                if (itemType === "function_call" && itemId) {
-                    const state = functionCalls.get(itemId);
-                    if (state) {
-                        yield {
-                            type: "tool-call",
-                            toolCallId: state.toolCallId,
-                            toolName: state.name,
-                            input: state.arguments,
-                        };
-                    }
-                    functionCalls.delete(itemId);
-                }
-                continue;
-            }
-            // response.completed: terminal event with the final response object
-            // (status + usage). Capture both for the final finish part.
-            if (type === "response.completed") {
-                usage = extractOpenAIResponsesUsage(record) ?? usage;
-                const responseRecord = readRecord(record?.response);
-                finishReason = normalizeOpenAIResponsesFinishReason(responseRecord?.status);
-                continue;
-            }
-            if (type === "response.failed" || type === "response.incomplete") {
-                const responseRecord = readRecord(record?.response);
-                finishReason = normalizeOpenAIResponsesFinishReason(responseRecord?.status) ??
-                    (type === "response.failed"
-                        ? { unified: "error", raw: "failed" }
-                        : { unified: "length", raw: "incomplete" });
-                usage = extractOpenAIResponsesUsage(record) ?? usage;
-                continue;
-            }
-        }
-    }
-    // Close any reasoning streams still open at end-of-stream (defensive
-    // — a clean Responses API stream always closes them via output_item.done).
-    for (const state of reasoningBlocks.values()) {
-        if (state.emittedStart) {
-            yield { type: "reasoning-end", id: state.id };
-        }
-    }
-    yield {
-        type: "finish",
-        finishReason,
-        ...(usage ? { usage } : {}),
-    };
-}
-export function createOpenAIResponsesRuntime(config, modelId) {
-    const fetchImpl = config.fetch ?? globalThis.fetch;
-    return {
-        provider: config.name ?? "openai",
-        modelId,
-        specificationVersion: "v3",
-        supportedUrls: {},
-        doGenerate(optionsForRuntime) {
-            const options = optionsForRuntime;
-            const url = getOpenAIResponsesUrl(config.baseURL);
-            const warnings = createWarningCollector();
-            const body = buildOpenAIResponsesRequest(modelId, config.name ?? "openai", options, false, warnings);
-            return requestJson({
-                url,
-                fetchImpl,
-                providerLabel: config.name ?? "openai",
-                providerKind: "openai",
-                init: createOpenAIRequestInit({
-                    apiKey: config.apiKey,
-                    extraHeaders: options.headers,
-                    body: JSON.stringify(body),
-                    signal: options.abortSignal,
-                }),
-            }).then((payload) => {
-                const drained = warnings.drain();
-                return {
-                    ...buildOpenAIResponsesGenerateResult(payload),
-                    ...(drained.length > 0 ? { warnings: drained } : {}),
-                };
-            });
-        },
-        doStream(optionsForRuntime) {
-            const options = optionsForRuntime;
-            const url = getOpenAIResponsesUrl(config.baseURL);
-            const warnings = createWarningCollector();
-            const body = buildOpenAIResponsesRequest(modelId, config.name ?? "openai", options, true, warnings);
-            return requestStream({
-                url,
-                fetchImpl,
-                providerLabel: config.name ?? "openai",
-                providerKind: "openai",
-                init: createOpenAIRequestInit({
-                    apiKey: config.apiKey,
-                    extraHeaders: options.headers,
-                    body: JSON.stringify(body),
-                    signal: options.abortSignal,
-                }),
-            }).then((responseStream) => {
-                const drained = warnings.drain();
-                return {
-                    stream: ReadableStream.from(withToolInputStatusTransitions(streamOpenAIResponsesParts(responseStream))),
-                    ...(drained.length > 0 ? { warnings: drained } : {}),
-                };
-            });
-        },
-    };
-}
 export function createAnthropicModelRuntime(config, modelId) {
     const fetchImpl = config.fetch ?? globalThis.fetch;
     return {
@@ -2250,45 +1359,6 @@ export function createGoogleModelRuntime(config, modelId) {
         },
     };
 }
-export function createOpenAIEmbeddingRuntime(config, modelId) {
-    const fetchImpl = config.fetch ?? globalThis.fetch;
-    return {
-        provider: config.name ?? "openai",
-        modelId,
-        supportsParallelCalls: true,
-        doEmbed({ values, abortSignal }) {
-            if (values.length === 0) {
-                return Promise.resolve({
-                    embeddings: [],
-                    warnings: [],
-                    rawResponse: { data: [] },
-                });
-            }
-            const url = getOpenAIEmbeddingUrl(config.baseURL);
-            return requestJson({
-                url,
-                fetchImpl,
-                providerLabel: config.name ?? "openai",
-                providerKind: "openai",
-                init: createOpenAIRequestInit({
-                    apiKey: config.apiKey,
-                    body: JSON.stringify({
-                        model: modelId,
-                        input: values,
-                    }),
-                    signal: abortSignal,
-                }),
-            }).then((payload) => ({
-                embeddings: extractOpenAIEmbeddings(payload),
-                usage: {
-                    tokens: extractOpenAIUsageTokens(payload),
-                },
-                rawResponse: payload,
-                warnings: [],
-            }));
-        },
-    };
-}
 export function createGoogleEmbeddingRuntime(config, modelId) {
     const fetchImpl = config.fetch ?? globalThis.fetch;
     return {