veryfront 0.1.283 → 0.1.285

package/src/src/provider/runtime-loader.ts

@@ -4,38 +4,34 @@ import {
   getGoogleEmbeddingUrl,
   getGoogleGenerateContentUrl,
   getGoogleStreamGenerateContentUrl,
-  getOpenAIChatCompletionsUrl,
-  getOpenAIEmbeddingUrl,
-  getOpenAIResponsesUrl,
 } from "./runtime-loader/provider-endpoints.js";
 import {
   extractGoogleEmbedding,
   extractGoogleUsageTokens,
-  extractOpenAIEmbeddings,
-  extractOpenAIUsageTokens,
+  isNumberArray,
 } 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 { parseSseChunk } from "./runtime-loader/provider-sse.js";
 import {
   extractAnthropicUsage,
   extractGoogleUsage,
-  extractOpenAIResponsesUsage,
-  extractOpenAIUsage,
   mergeUsage,
   type RuntimeUsage,
 } from "./runtime-loader/provider-usage.js";
 import type { ProviderKind } from "./runtime-loader/provider-http.js";
-import { requestJson, requestStream } from "./runtime-loader/provider-http.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,
@@ -50,13 +46,15 @@ export {
   ProviderRequestError,
 } from "./runtime-loader/provider-http.js";
 export { TOOL_INPUT_PENDING_THRESHOLD_MS, withToolInputStatusTransitions };
-
-export interface OpenAIRuntimeConfig {
-  apiKey: string;
-  baseURL?: string;
-  name?: string;
-  fetch?: typeof globalThis.fetch;
-}
+export {
+  buildProviderError,
+  isNumberArray,
+  mergeUsage,
+  parseRetryAfterMs,
+  readRecord,
+  requestJson,
+  requestStream,
+};
 
 export interface AnthropicRuntimeConfig {
   apiKey?: string;
@@ -73,7 +71,7 @@ export interface GoogleRuntimeConfig {
   fetch?: typeof globalThis.fetch;
 }
 
-type RuntimePromptMessage =
+export type RuntimePromptMessage =
   | { role: "system"; content: string }
   | { role: "user"; content: Array<{ type: "text"; text: string }> }
   | {
@@ -323,7 +321,7 @@ type OpenAICompatibleLanguageOptions = {
    */
   mcpServers?: Array<Record<string, unknown>>;
 };
-type OpenAICompatibleChatMessage =
+export type OpenAICompatibleChatMessage =
   | { role: "system"; content: string }
   | { role: "user"; content: string }
   | {
@@ -343,7 +341,7 @@ type OpenAICompatibleChatMessage =
     tool_call_id: string;
     content: string;
   };
-type OpenAICompatibleChatRequest = {
+export type OpenAICompatibleChatRequest = {
   model: string;
   messages: OpenAICompatibleChatMessage[];
   stream?: boolean;
@@ -369,17 +367,6 @@ type OpenAICompatibleChatRequest = {
   frequency_penalty?: number;
   [key: string]: unknown;
 };
-type OpenAICompatibleChoice = {
-  message?: unknown;
-  delta?: unknown;
-  finish_reason?: unknown;
-};
-type OpenAIStreamToolCallState = {
-  id: string;
-  name: string;
-  arguments: string;
-  started: boolean;
-};
 type AnthropicCompatibleMessage = {
   role: "user" | "assistant";
   content: Array<Record<string, unknown>>;
@@ -452,7 +439,7 @@ type WarningCollector = {
   drain(): ProviderWarning[];
 };
 
-function createWarningCollector(): WarningCollector {
+export function createWarningCollector(): WarningCollector {
   const list: ProviderWarning[] = [];
   return {
     push(warning) {
@@ -464,7 +451,7 @@ function createWarningCollector(): WarningCollector {
   };
 }
 
-function stringifyJsonValue(value: unknown): string {
+export function stringifyJsonValue(value: unknown): string {
   if (typeof value === "string") {
     return value;
   }
@@ -472,7 +459,7 @@ function stringifyJsonValue(value: unknown): string {
   return JSON.stringify(value);
 }
 
-function readTextParts(parts: Array<{ type: string; text?: string }>): string {
+export function readTextParts(parts: Array<{ type: string; text?: string }>): string {
   let text = "";
   for (const part of parts) {
     if (part.type === "text" && typeof part.text === "string") {
@@ -482,7 +469,9 @@ function readTextParts(parts: Array<{ type: string; text?: string }>): string {
   return text;
 }
 
-function toOpenAICompatibleMessages(prompt: RuntimePromptMessage[]): OpenAICompatibleChatMessage[] {
+export function toOpenAICompatibleMessages(
+  prompt: RuntimePromptMessage[],
+): OpenAICompatibleChatMessage[] {
   const messages: OpenAICompatibleChatMessage[] = [];
 
   for (const message of prompt) {
@@ -542,7 +531,7 @@ function toOpenAICompatibleMessages(prompt: RuntimePromptMessage[]): OpenAICompa
   return messages;
 }
 
-function toOpenAICompatibleTools(
+export function toOpenAICompatibleTools(
   tools: RuntimeToolDefinition[] | undefined,
 ): OpenAICompatibleChatRequest["tools"] | undefined {
   if (!tools) {
@@ -565,7 +554,7 @@ function toOpenAICompatibleTools(
   return functions.length > 0 ? functions : undefined;
 }
 
-function readProviderOptions(
+export function readProviderOptions(
   providerOptions: Record<string, unknown> | undefined,
   ...providerNames: string[]
 ): Record<string, unknown> {
@@ -1465,228 +1454,6 @@ async function* streamAnthropicCompatibleParts(
   };
 }
 
-function extractOpenAIContentText(content: unknown): string {
-  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: Record<string, unknown>): Array<{
-  toolCallId: string;
-  toolName: string;
-  input: string;
-}> {
-  const toolCalls = message.tool_calls;
-  if (!Array.isArray(toolCalls)) {
-    return [];
-  }
-
-  const normalized: Array<{ toolCallId: string; toolName: string; input: string }> = [];
-  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: string): boolean {
-  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: string): boolean {
-  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: string): boolean {
-  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: ProviderReasoningOption | undefined,
-): "low" | "medium" | "high" | undefined {
-  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: string,
-  providerName: string,
-  options: OpenAICompatibleLanguageOptions,
-  stream: boolean,
-  warnings: WarningCollector,
-): OpenAICompatibleChatRequest {
-  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: Array<[keyof typeof options, string]> = [
-      ["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: OpenAICompatibleChatRequest = {
-    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: RuntimePromptMessage[],
 ): {
@@ -2178,224 +1945,23 @@ async function* streamGoogleCompatibleParts(
   };
 }
 
-function extractFirstChoice(payload: unknown): OpenAICompatibleChoice | undefined {
-  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: unknown): {
-  content: Array<
-    { type: "text"; text: string } | {
-      type: "tool-call";
-      toolCallId: string;
-      toolName: string;
-      input: string;
-    }
-  >;
-  finishReason?: string | { unified: string; raw: string } | null;
-  usage?: RuntimeUsage;
-} {
-  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" as const, text }] : []),
-      ...toolCalls.map((toolCall) => ({
-        type: "tool-call" as const,
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        input: toolCall.input,
-      })),
-    ],
-    finishReason: normalizeOpenAIFinishReason(choice?.finish_reason),
-    usage: extractOpenAIUsage(payload),
-  };
-}
-
-async function* streamOpenAICompatibleParts(
-  stream: ReadableStream<Uint8Array>,
-): AsyncIterable<unknown> {
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const toolCalls = new Map<number, OpenAIStreamToolCallState>();
-  let reasoningId: string | null = null;
-  let reasoningIndex = 0;
-  let finishReason: string | { unified: string; raw: string } | null = null;
-  let usage: RuntimeUsage | undefined;
-
-  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: OpenAIRuntimeConfig,
+export function createAnthropicModelRuntime(
+  config: AnthropicRuntimeConfig,
   modelId: string,
 ): ModelRuntime {
   const fetchImpl = config.fetch ?? globalThis.fetch;
   return {
-    provider: config.name ?? "openai",
+    provider: config.name ?? "anthropic",
     modelId,
     specificationVersion: "v3",
     supportedUrls: {},
     doGenerate(optionsForRuntime: unknown) {
       const options = optionsForRuntime as OpenAICompatibleLanguageOptions;
-      const url = getOpenAIChatCompletionsUrl(config.baseURL);
+      const url = getAnthropicMessagesUrl(config.baseURL);
       const warnings = createWarningCollector();
-      const body = buildOpenAIChatRequest(
+      const body = buildAnthropicMessagesRequest(
         modelId,
-        config.name ?? "openai",
+        config.name ?? "anthropic",
         options,
         false,
         warnings,
@@ -2403,10 +1969,11 @@ export function createOpenAIModelRuntime(
       return requestJson({
         url,
         fetchImpl,
-        providerLabel: config.name ?? "openai",
-        providerKind: "openai",
-        init: createOpenAIRequestInit({
+        providerLabel: config.name ?? "anthropic",
+        providerKind: "anthropic",
+        init: createAnthropicRequestInit({
           apiKey: config.apiKey,
+          authToken: config.authToken,
           extraHeaders: options.headers,
           body: JSON.stringify(body),
           signal: options.abortSignal,
@@ -2414,689 +1981,18 @@ export function createOpenAIModelRuntime(
       }).then((payload) => {
         const drained = warnings.drain();
         return {
-          ...buildOpenAIGenerateResult(payload),
+          ...buildAnthropicGenerateResult(payload),
           ...(drained.length > 0 ? { warnings: drained } : {}),
         };
       });
     },
     doStream(optionsForRuntime: unknown) {
       const options = optionsForRuntime as OpenAICompatibleLanguageOptions;
-      const url = getOpenAIChatCompletionsUrl(config.baseURL);
+      const url = getAnthropicMessagesUrl(config.baseURL);
       const warnings = createWarningCollector();
-      const body = buildOpenAIChatRequest(
+      const body = buildAnthropicMessagesRequest(
         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 } : {}),
-        };
-      });
-    },
-  };
-}
-
-// =============================================================================
-// OpenAI Responses API runtime (#1077, deferred from #1052 C4)
-// =============================================================================
-//
-// The Responses API (/v1/responses) is a different surface than Chat
-// Completions. Same provider, different request shape, different streaming
-// event grammar, different response shape, and different reasoning-summary
-// surface. This runtime is parallel to createOpenAIModelRuntime so each
-// path stays focused on one wire format.
-//
-// Why parallel runtimes instead of a flag? See the rationale in #1077.
-//
-// docs: https://platform.openai.com/docs/api-reference/responses
-
-type OpenAIResponsesInputItem = Record<string, unknown>;
-
-type OpenAIResponsesRequest = {
-  model: string;
-  input: OpenAIResponsesInputItem[];
-  instructions?: string;
-  stream?: boolean;
-  max_output_tokens?: number;
-  temperature?: number;
-  top_p?: number;
-  tools?: Array<Record<string, unknown>>;
-  tool_choice?: unknown;
-  reasoning?: { effort?: string; summary?: string };
-  metadata?: Record<string, string>;
-  user?: string;
-  service_tier?: string;
-  parallel_tool_calls?: boolean;
-  text?: { format: Record<string, unknown> };
-  [key: string]: unknown;
-};
-
-/**
- * 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: RuntimePromptMessage[],
-): { instructions?: string; input: OpenAIResponsesInputItem[] } {
-  const instructionsParts: string[] = [];
-  const input: OpenAIResponsesInputItem[] = [];
-
-  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: Array<Record<string, unknown>> = [];
-        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: Array<Record<string, unknown>> = [];
-            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: RuntimeToolDefinition[] | undefined,
-): Array<Record<string, unknown>> | undefined {
-  if (!tools) return undefined;
-  const normalized: Array<Record<string, unknown>> = [];
-  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: string,
-  providerName: string,
-  options: OpenAICompatibleLanguageOptions,
-  stream: boolean,
-  warnings: WarningCollector,
-): OpenAIResponsesRequest {
-  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: Array<[keyof typeof options, string]> = [
-      ["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: OpenAIResponsesRequest = {
-    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;
-}
-
-type OpenAIResponsesContentPart =
-  | { type: "text"; text: string }
-  | {
-    type: "reasoning";
-    summaries?: Array<{ id?: string; text: string }>;
-    signature?: string;
-  }
-  | { type: "tool-call"; toolCallId: string; toolName: string; input: string };
-
-function buildOpenAIResponsesGenerateResult(payload: unknown): {
-  content: OpenAIResponsesContentPart[];
-  finishReason?: string | { unified: string; raw: string } | null;
-  usage?: RuntimeUsage;
-} {
-  const record = readRecord(payload);
-  const output = Array.isArray(record?.output) ? record.output : [];
-  const content: OpenAIResponsesContentPart[] = [];
-
-  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: Array<{ id?: string; text: string }> = [];
-      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),
-  };
-}
-
-type OpenAIResponsesStreamReasoningState = {
-  id: string;
-  emittedStart: boolean;
-};
-
-type OpenAIResponsesStreamFunctionCallState = {
-  id: string;
-  toolCallId: string;
-  name: string;
-  arguments: string;
-};
-
-/**
- * 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: ReadableStream<Uint8Array>,
-): AsyncIterable<unknown> {
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const reasoningBlocks = new Map<string, OpenAIResponsesStreamReasoningState>();
-  const functionCalls = new Map<string, OpenAIResponsesStreamFunctionCallState>();
-  const startedToolCalls = new Set<string>();
-  let finishReason: string | { unified: string; raw: string } | null = null;
-  let usage: RuntimeUsage | undefined;
-  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: OpenAIRuntimeConfig,
-  modelId: string,
-): ModelRuntime {
-  const fetchImpl = config.fetch ?? globalThis.fetch;
-  return {
-    provider: config.name ?? "openai",
-    modelId,
-    specificationVersion: "v3",
-    supportedUrls: {},
-    doGenerate(optionsForRuntime: unknown) {
-      const options = optionsForRuntime as OpenAICompatibleLanguageOptions;
-      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: unknown) {
-      const options = optionsForRuntime as OpenAICompatibleLanguageOptions;
-      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: AnthropicRuntimeConfig,
-  modelId: string,
-): ModelRuntime {
-  const fetchImpl = config.fetch ?? globalThis.fetch;
-  return {
-    provider: config.name ?? "anthropic",
-    modelId,
-    specificationVersion: "v3",
-    supportedUrls: {},
-    doGenerate(optionsForRuntime: unknown) {
-      const options = optionsForRuntime as OpenAICompatibleLanguageOptions;
-      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: unknown) {
-      const options = optionsForRuntime as OpenAICompatibleLanguageOptions;
-      const url = getAnthropicMessagesUrl(config.baseURL);
-      const warnings = createWarningCollector();
-      const body = buildAnthropicMessagesRequest(
-        modelId,
-        config.name ?? "anthropic",
+        config.name ?? "anthropic",
         options,
         true,
         warnings,
@@ -3198,50 +2094,6 @@ export function createGoogleModelRuntime(
   };
 }
 
-export function createOpenAIEmbeddingRuntime(
-  config: OpenAIRuntimeConfig,
-  modelId: string,
-): EmbeddingRuntime {
-  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: GoogleRuntimeConfig,
   modelId: string,