@visual-z/xeno 0.8.4 → 0.9.1

package/src/runtime/openai.ts

@@ -1,697 +0,0 @@
-/**
- * The OpenAI Chat Completions adapter.
- *
- * "OpenAI-compatible" names a family of dialects rather than a protocol. The
- * differences are small, undocumented in aggregate, and each one is a 400 or a
- * silently wrong number: which field caps the output, whether the system
- * prompt may use the `developer` role, where reasoning lives on the way out
- * and on the way back, which usage field carries a cache hit. So the accent is
- * carried as data on the model (`Compat`) and this file only reads it. The
- * alternative -- branching on the provider's name -- ends as a chain of `||`
- * that nobody can safely extend, which is where every adapter that started
- * that way has arrived.
- *
- * Two of the three functions here are pure. `buildRequest` turns the core's
- * provider-neutral messages into a request body and `parseResponse` turns a
- * response body back into a turn; only `OpenAICompletionsProvider.send` is
- * allowed to touch the network. That split is what lets the expensive mistakes
- * -- a missing field that costs a 400, a cache hit counted as fresh input --
- * be caught offline, without a key.
- */
-
-import type { Message, ContentBlock, FrozenPrefix } from "../core/project.ts";
-import { imageData } from "./images.ts";
-import type { AssistantBlock } from "../core/events.ts";
-import { assertNever } from "../core/exhaustive.ts";
-import { coherentTurn, type Provider, type ProviderConfig, type Turn, type ToolSchema, type OnDelta } from "./provider.ts";
-import { DEFAULT_COMPAT, type Compat, type Effort, type ModelSpec } from "./model.ts";
-import { withRetry, retryLabel, DEFAULT_RETRY, type RetryPolicy } from "./retry.ts";
-import { ConnectionReuse } from "./connection-reuse.ts";
-import { watchIdle, type IdleWatch } from "./stream-idle.ts";
-
-import type { ProviderSendOptions } from "./provider-tool-policy.ts";
-
-/** One message as Chat Completions wants it. */
-export interface WireMessage {
-  role: "system" | "developer" | "user" | "assistant" | "tool";
-  content?: string | null | ({ type: "text"; text: string } | { type: "image_url"; image_url: { url: string } })[];
-  reasoning_content?: string;
-  /** OpenRouter's structured reasoning, replayed as received. */
-  reasoning_details?: unknown;
-  tool_calls?: ({
-    id: string;
-    type: "function";
-    function: { name: string; arguments: string };
-  } & Record<string, unknown>)[];
-  tool_call_id?: string;
-}
-
-export interface WireRequest {
-  model: string;
-  messages: WireMessage[];
-  max_tokens?: number;
-  max_completion_tokens?: number;
-  tools?: unknown[];
-  tool_choice?: "none";
-  thinking?: { type: "enabled" | "disabled" };
-  reasoning_effort?: string;
-}
-
-/**
- * The shape this adapter puts in a thinking block's opaque `raw`.
- *
- * `raw` is the core's escape hatch for "whatever this provider needs to see
- * again, unchanged" -- the Anthropic adapter parks a signed block there. Here
- * it is the reasoning text, because that is what has to go back on the wire.
- * Each adapter recognises only its own, which is exactly why the field is
- * typed `unknown` in the core.
- */
-interface ReasoningRaw {
-  reasoning_content: string;
-  /** OpenRouter: structured, sometimes encrypted, reasoning it wants back verbatim. */
-  reasoning_details?: unknown;
-}
-
-function reasoningDetailsOf(raw: unknown): unknown {
-  if (typeof raw !== "object" || raw === null) return undefined;
-  return (raw as Partial<ReasoningRaw>).reasoning_details;
-}
-
-/**
- * A tool call's fields beyond the ones this adapter reads.
- *
- * Gemini's OpenAI-compatible endpoint puts a thought signature under
- * `extra_content` and rejects the next request if it is not echoed back.
- * Rather than learn each provider's extension, keep whatever else arrived and
- * send it back unchanged -- the same contract as a thinking block's raw.
- */
-function extraFields(call: Record<string, unknown>): Record<string, unknown> | undefined {
-  const extra: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(call)) {
-    if (key !== "id" && key !== "type" && key !== "function" && key !== "index") extra[key] = value;
-  }
-  return Object.keys(extra).length > 0 ? extra : undefined;
-}
-
-function reasoningOf(raw: unknown): string | null {
-  if (typeof raw !== "object" || raw === null) return null;
-  const value = (raw as Partial<ReasoningRaw>).reasoning_content;
-  return typeof value === "string" ? value : null;
-}
-
-/**
- * Chat Completions takes the whole tool list flat under `function`, where the
- * Anthropic shape nests the schema under `input_schema`. `strict` is omitted
- * rather than set false: providers in this family reject unknown fields, and
- * the ones that support strict mode are not the ones we talk to.
- */
-function toWireTools(tools: readonly unknown[]): unknown[] {
-  return tools.map((t) => {
-    const tool = t as ToolSchema;
-    return {
-      type: "function",
-      function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.input_schema,
-      },
-    };
-  });
-}
-
-/**
- * Flattens one assistant turn's blocks into the single string + tool_calls
- * pair this API expects.
- *
- * The content must be a plain string and not an array of `{type:"text"}`
- * blocks. The array form is legal OpenAI but some models in this family mirror
- * the structure literally into their own output, producing nested
- * `[{'type':'text','text':'[{...}]'}]` that then poisons every later turn.
- */
-function assistantMessage(content: readonly ContentBlock[], compat: Compat, reasoning: boolean): WireMessage {
-  const text: string[] = [];
-  const thinking: string[] = [];
-  const details: unknown[] = [];
-  const toolCalls: NonNullable<WireMessage["tool_calls"]> = [];
-
-  for (const b of content) {
-    switch (b.type) {
-      case "text":
-        text.push(b.text);
-        break;
-      case "thinking": {
-        const r = reasoningOf(b.raw);
-        if (r !== null && r.length > 0) thinking.push(r);
-        const d = reasoningDetailsOf(b.raw);
-        if (Array.isArray(d)) details.push(...d);
-        else if (d !== undefined) details.push(d);
-        break;
-      }
-      case "tool_use":
-        toolCalls.push({
-          ...(typeof b.wire === "object" && b.wire !== null ? b.wire as Record<string, unknown> : {}),
-          id: b.id,
-          type: "function",
-          function: { name: b.name, arguments: JSON.stringify(b.input) },
-        });
-        break;
-      case "tool_result":
-      case "image":
-        // A tool_result inside an assistant turn is not a shape the projection
-        // produces. Ignored rather than thrown: the request stays valid, and
-        // the pairing checks that would catch it live in the core.
-        break;
-      default:
-        return assertNever(b, "assistantMessage");
-    }
-  }
-
-  const message: WireMessage = { role: "assistant" };
-  if (text.length > 0) message.content = text.join("");
-  if (toolCalls.length > 0) message.tool_calls = toolCalls;
-
-  // The documented rule, and the reason this adapter exists in this shape:
-  // once `tools` is in the request, DeepSeek requires reasoning_content on
-  // EVERY assistant message in the history -- including turns that did no
-  // thinking and made no tool call -- and returns 400 without it. An empty
-  // string is the documented stand-in, not a guess.
-  if (compat.requiresReasoningContentOnAssistantMessages && reasoning) {
-    message.reasoning_content = thinking.join("\n");
-  } else if (thinking.length > 0) {
-    message.reasoning_content = thinking.join("\n");
-  }
-  if (details.length > 0) message.reasoning_details = details;
-
-  return message;
-}
-
-/**
- * Turns one projected user message into wire messages.
- *
- * The projection deliberately batches every tool result for a turn into a
- * single user message, because splitting them teaches the model to stop
- * issuing parallel calls. This API wants the opposite: one `tool` message per
- * result, keyed by call id. So the split happens here, at the wire boundary,
- * and the projection's property is left intact.
- */
-function userMessages(content: readonly ContentBlock[]): WireMessage[] {
-  const out: WireMessage[] = [];
-  const text: string[] = [];
-  const parts: NonNullable<Exclude<WireMessage["content"], string>> = [];
-
-  for (const b of content) {
-    switch (b.type) {
-      case "image": parts.push({ type: "image_url", image_url: { url: `data:${b.image.mimeType};base64,${imageData(b)}` } }); break;
-      case "tool_result":
-        out.push({
-          role: "tool",
-          tool_call_id: b.tool_use_id,
-          content: b.content,
-        });
-        break;
-      case "text":
-        text.push(b.text);
-        break;
-      case "thinking":
-      case "tool_use":
-        // Neither appears in a user turn in any projection this harness
-        // produces; dropping them keeps the request valid.
-        break;
-      default:
-        return assertNever(b, "userMessages");
-    }
-  }
-
-  if (parts.length) out.push({ role: "user", content: [...(text.length ? [{ type: "text" as const, text: text.join("\n") }] : []), ...parts] });
-  else if (text.length > 0) out.push({ role: "user", content: text.join("\n") });
-  return out;
-}
-
-/** Maps our effort onto what this model accepts; `null` in the map means "send nothing". */
-function wireEffort(spec: ModelSpec, effort: Effort): string | null {
-  const mapped = spec.thinkingLevelMap?.[effort];
-  if (mapped === null) return null;
-  return mapped ?? effort;
-}
-
-export function buildRequest(
-  config: ProviderConfig,
-  frozen: FrozenPrefix,
-  messages: readonly Message[],
-): WireRequest {
-  const spec = config.spec;
-  const compat = spec.compat ?? DEFAULT_COMPAT;
-
-  const wire: WireMessage[] = [
-    // The system prompt leads, which is all the prefix management this
-    // provider needs: its cache is automatic and keyed on the literal prefix,
-    // so the core's append-only property is what produces the hits. There is
-    // no breakpoint to place and none to get wrong.
-    {
-      role: compat.supportsDeveloperRole && spec.reasoning ? "developer" : "system",
-      content: frozen.system,
-    },
-  ];
-
-  for (const m of messages) {
-    if (m.role === "assistant") {
-      const built = assistantMessage(m.content, compat, spec.reasoning);
-      // Some providers reject an assistant message with neither content nor
-      // tool calls, which is what an aborted turn leaves behind.
-      if (built.content !== undefined || built.tool_calls !== undefined) wire.push(built);
-    } else {
-      wire.push(...userMessages(m.content));
-    }
-  }
-
-  const request: WireRequest = { model: spec.id, messages: wire };
-
-  if (compat.maxTokensField === "max_tokens") request.max_tokens = config.maxTokens;
-  else request.max_completion_tokens = config.maxTokens;
-
-  if (frozen.tools.length > 0) request.tools = toWireTools(frozen.tools);
-
-  if (spec.reasoning) {
-    if (compat.thinkingFormat === "deepseek") request.thinking = { type: config.effort === "off" ? "disabled" : "enabled" };
-    if (compat.supportsReasoningEffort && config.effort !== "off") {
-      const effort = wireEffort(spec, config.effort);
-      if (effort !== null) request.reasoning_effort = effort;
-    } else if (config.effort === "off" && compat.thinkingFormat !== "deepseek" && typeof spec.thinkingLevelMap?.off === "string") {
-      request.reasoning_effort = spec.thinkingLevelMap.off;
-    }
-  }
-
-  return request;
-}
-
-/** Only the fields we read, so a provider adding more cannot break parsing. */
-interface WireResponse {
-  choices?: {
-    message?: {
-      content?: string | null;
-      reasoning_content?: string | null;
-      /** OpenRouter's name for the reasoning text. */
-      reasoning?: string | null;
-      reasoning_details?: unknown;
-      tool_calls?: ({
-        id?: string;
-        function?: { name?: string; arguments?: string };
-      } & Record<string, unknown>)[];
-    };
-    finish_reason?: string | null;
-  }[];
-  usage?: {
-    prompt_tokens?: number;
-    completion_tokens?: number;
-    prompt_cache_hit_tokens?: number;
-    prompt_tokens_details?: { cached_tokens?: number };
-  };
-  error?: { message?: string };
-}
-
-/**
- * Decodes tool arguments, which arrive as a JSON string.
- *
- * A model can emit malformed JSON there. The raw string is kept rather than
- * dropped so the tool layer reports a bad argument, instead of the call
- * vanishing and the turn ending with an unanswered tool_use.
- */
-function decodeArguments(raw: string | undefined): unknown {
-  if (raw === undefined || raw.length === 0) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return { __unparsed_arguments: raw };
-  }
-}
-
-export function parseResponse(body: unknown, node: number, ms: number): Turn {
-  const response = body as WireResponse;
-  const message = response.choices?.[0]?.message;
-  const blocks: AssistantBlock[] = [];
-
-  // Reasoning first, matching the order the model produced it and the order
-  // the Anthropic adapter yields. `raw` is what goes back on the wire; `text`
-  // is only for display.
-  const reasoning = message?.reasoning_content ?? message?.reasoning;
-  const details = message?.reasoning_details;
-  if ((typeof reasoning === "string" && reasoning.length > 0) || details !== undefined) {
-    const text = typeof reasoning === "string" ? reasoning : "";
-    blocks.push({ type: "thinking", text,
-      raw: { reasoning_content: text, ...(details === undefined ? {} : { reasoning_details: details }) } });
-  }
-
-  const text = message?.content;
-  if (typeof text === "string" && text.length > 0) {
-    blocks.push({ type: "text", text });
-  }
-
-  (message?.tool_calls ?? []).forEach((call, index) => {
-    const wire = extraFields(call);
-    blocks.push({
-      type: "tool_use",
-      // A missing id would make every call in the batch pair with the same
-      // result. The position is deterministic, so a replay derives the same one.
-      call_id: typeof call.id === "string" && call.id.length > 0 ? call.id : `call_${index}`,
-      name: call.function?.name ?? "",
-      input: decodeArguments(call.function?.arguments),
-      ...(wire === undefined ? {} : { wire }),
-    });
-  });
-
-  const usage = response.usage;
-  const prompt = usage?.prompt_tokens ?? 0;
-  // DeepSeek reports hits in prompt_cache_hit_tokens; the rest of the family
-  // uses prompt_tokens_details.cached_tokens. Both mean the same thing, and
-  // both are already included in prompt_tokens -- so the uncached remainder
-  // is the difference, not the whole.
-  const cacheRead = usage?.prompt_cache_hit_tokens ?? usage?.prompt_tokens_details?.cached_tokens ?? 0;
-
-  return {
-    blocks,
-    stopReason: response.choices?.[0]?.finish_reason ?? null,
-    usage: {
-      input_tokens: Math.max(0, prompt - cacheRead),
-      output_tokens: usage?.completion_tokens ?? 0,
-      // This family bills nothing for a cache write and reports no count for
-      // one. Zero is the actual value, not a missing measurement.
-      cache_creation_input_tokens: 0,
-      cache_read_input_tokens: cacheRead,
-      node,
-      ms,
-    },
-  };
-}
-
-/** An API error that carries its status, so the retry layer can read it. */
-/**
- * A failure the server reported after answering 200, as an error object in
- * the stream. It has no HTTP status, so retry.ts decides from `code` (the
- * provider's error type) and the message whether it is worth another attempt.
- */
-export class StreamError extends Error {
-  readonly code: string | undefined;
-  constructor(message: string, code?: string) {
-    super(message);
-    this.name = "StreamError";
-    this.code = code;
-  }
-}
-
-export class HttpError extends Error {
-  readonly status: number;
-  readonly headers: Headers;
-
-  constructor(status: number, headers: Headers, message: string) {
-    super(message);
-    this.name = "HttpError";
-    this.status = status;
-    this.headers = headers;
-  }
-}
-
-export class OpenAICompletionsProvider implements Provider {
-  readonly config: ProviderConfig;
-  private readonly apiKey: string;
-  private readonly fetchImpl: typeof fetch;
-  private readonly connections = new ConnectionReuse();
-  private readonly retry: RetryPolicy;
-  private readonly onRetry: ((attempt: number, delayMs: number, error: unknown) => void) | undefined;
-  private readonly streamIdleMs: number | undefined;
-
-  constructor(
-    config: ProviderConfig,
-    apiKey: string,
-    options: {
-      fetchImpl?: typeof fetch;
-      retry?: RetryPolicy;
-      onRetry?: (attempt: number, delayMs: number, error: unknown) => void;
-      /** Silence after which one attempt is abandoned; tests shorten it (stream-idle.ts). */
-      streamIdleMs?: number;
-    } = {},
-  ) {
-    this.config = config;
-    this.apiKey = apiKey;
-    this.fetchImpl = options.fetchImpl ?? fetch;
-    this.retry = options.retry ?? DEFAULT_RETRY;
-    this.onRetry = options.onRetry;
-    this.streamIdleMs = options.streamIdleMs;
-  }
-
-  send(
-    frozen: FrozenPrefix,
-    messages: readonly Message[],
-    node: number,
-    signal?: AbortSignal,
-    onDelta?: OnDelta,
-    options?: ProviderSendOptions,
-  ): Promise<Turn> {
-    // The clock starts inside the retried request, so a reported duration is
-    // one attempt rather than the sum of the ones that failed.
-    return withRetry(
-      () => watchIdle(signal, this.streamIdleMs, idle => this.attempt(frozen, messages, node, idle, onDelta, options)).catch((error: unknown) => { this.connections.note(error); throw error; }),
-      this.retry,
-      undefined,
-      (attempt, delayMs, error) => {
-        onDelta?.({ kind: "discard" });
-        onDelta?.({ kind: "retry", attempt, delayMs, max: this.retry.maxRetries, reason: retryLabel(error) });
-        this.onRetry?.(attempt, delayMs, error);
-      },
-      signal,
-    );
-  }
-
-  private async attempt(
-    frozen: FrozenPrefix,
-    messages: readonly Message[],
-    node: number,
-    idle: IdleWatch,
-    onDelta?: OnDelta,
-    options?: ProviderSendOptions,
-  ): Promise<Turn> {
-    const started = Date.now();
-    const baseUrl = this.config.spec.baseUrl;
-    if (baseUrl === undefined) {
-      throw new Error(`model ${this.config.spec.id} has no baseUrl to send to`);
-    }
-
-    const compat = this.config.spec.compat ?? DEFAULT_COMPAT;
-    const payload: WireRequest & {
-      stream: true;
-      stream_options?: { include_usage: true };
-    } = { ...buildRequest(this.config, frozen, messages), stream: true };
-    if (options?.toolUse === "disabled") payload.tool_choice = "none";
-    // Without include_usage an OpenAI-dialect stream never reports usage, and
-    // the loop would treat the resulting zeros as a real prompt size. Servers
-    // that 400 on the field opt out via Compat.supportsUsageInStreaming.
-    if (compat.supportsUsageInStreaming) {
-      payload.stream_options = { include_usage: true };
-    }
-
-    const init: RequestInit = {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify(payload),
-      signal: idle.signal,
-    };
-
-    const response = await this.fetchImpl(`${baseUrl.replace(/\/$/, "")}/chat/completions`, this.connections.init(init));
-
-    if (!response.ok) {
-      const text = await response.text();
-      throw new HttpError(response.status, response.headers, errorMessage(response.status, text));
-    }
-
-    if (response.body === null) {
-      throw new Error(`${baseUrl} returned a streaming 200 with no body`);
-    }
-
-    const assembled = await readCompletionsSse(idle.body(response.body), onDelta);
-    return coherentTurn(parseResponse(assembled, node, Date.now() - started), assembled.usage !== undefined);
-  }
-}
-
-function errorMessage(status: number, text: string): string {
-  try {
-    const parsed = JSON.parse(text) as { error?: { message?: string } };
-    const detail = parsed.error?.message;
-    if (typeof detail === "string" && detail.length > 0) return `HTTP ${status}: ${detail}`;
-  } catch {
-    // Fall through to the raw body.
-  }
-  return `HTTP ${status}: ${text.slice(0, 200)}`;
-}
-
-/**
- * Incremental SSE decoder. A TCP chunk is not a frame: the last line of one
- * read is often the first half of the next, and parsing each read as JSON
- * is how a valid stream becomes "non-JSON 200".
- *
- * Ported from pi (earendil-works/pi, MIT) — packages/ai/src/api/anthropic-messages.ts
- * (line-split / half-frame handling). The `data:` / `[DONE]` dialect is ours.
- */
-export function pushSse(buffer: string, chunk: string): { buffer: string; payloads: string[] } {
-  buffer += chunk;
-  const payloads: string[] = [];
-  for (;;) {
-    const nl = buffer.search(/\r\n|\n|\r/);
-    if (nl < 0) break;
-    const crlf = buffer.startsWith("\r\n", nl) ? 2 : 1;
-    const line = buffer.slice(0, nl);
-    buffer = buffer.slice(nl + crlf);
-    if (line.length === 0 || line.startsWith(":")) continue;
-    if (line.startsWith("data:")) {
-      payloads.push(line.startsWith("data: ") ? line.slice(6) : line.slice(5));
-    }
-  }
-  return { buffer, payloads };
-}
-
-interface StreamAcc {
-  text: string;
-  thinking: string;
-  details: unknown[];
-  finishReason: string | null;
-  usage: WireResponse["usage"];
-  tools: Map<number, { id: string; name: string; arguments: string; extra: Record<string, unknown> }>;
-  /** Index of the call a chunk without `index` continues. */
-  lastIndex: number;
-}
-
-function applyCompletionChunk(chunk: WireStreamChunk, acc: StreamAcc, onDelta?: OnDelta): void {
-  // A server that fails mid-stream sends an error object instead of a choice.
-  // Ignoring it left finish_reason null and the cause invisible -- including
-  // an overflow the loop could otherwise recover from.
-  if (chunk.error !== undefined) {
-    const message = typeof chunk.error.message === "string" ? chunk.error.message : JSON.stringify(chunk.error);
-    const code = typeof chunk.error.type === "string" ? chunk.error.type : typeof chunk.error.code === "string" ? chunk.error.code : undefined;
-    throw new StreamError(`stream error: ${message}`, code);
-  }
-  if (chunk.usage !== undefined) acc.usage = chunk.usage;
-  const choice = chunk.choices?.[0];
-  if (choice === undefined) return;
-  if (choice.finish_reason) acc.finishReason = choice.finish_reason;
-  const delta = choice.delta;
-  if (delta === undefined) return;
-
-  const reasoning = delta.reasoning_content ?? delta.reasoning;
-  if (typeof reasoning === "string" && reasoning.length > 0) {
-    acc.thinking += reasoning;
-    onDelta?.({ kind: "thinking", text: reasoning });
-  }
-  if (Array.isArray(delta.reasoning_details)) acc.details.push(...delta.reasoning_details);
-  if (typeof delta.content === "string" && delta.content.length > 0) {
-    acc.text += delta.content;
-    onDelta?.({ kind: "text", text: delta.content });
-  }
-  for (const call of delta.tool_calls ?? []) {
-    // Without an index, a chunk carrying an id the current call does not
-    // have starts a new call; one without an id continues the current one.
-    // Defaulting every index-less chunk to 0 merged parallel calls into one.
-    let index = call.index;
-    if (index === undefined) {
-      const current = acc.tools.get(acc.lastIndex);
-      index = current === undefined ? 0 : call.id && current.id && call.id !== current.id ? acc.lastIndex + 1 : acc.lastIndex;
-    }
-    acc.lastIndex = index;
-    let tool = acc.tools.get(index);
-    if (tool === undefined) {
-      tool = { id: call.id ?? "", name: call.function?.name ?? "", arguments: "", extra: {} };
-      acc.tools.set(index, tool);
-    }
-    if (call.id) tool.id = call.id;
-    if (call.function?.name) tool.name = call.function.name;
-    if (call.function?.arguments) tool.arguments += call.function.arguments;
-    onDelta?.({ kind: "tool", id: tool.id || String(index), name: tool.name, arguments: tool.arguments });
-    Object.assign(tool.extra, extraFields(call as Record<string, unknown>) ?? {});
-  }
-}
-
-interface WireStreamChunk {
-  choices?: {
-    delta?: {
-      content?: string | null;
-      reasoning_content?: string | null;
-      reasoning?: string | null;
-      reasoning_details?: unknown[];
-      tool_calls?: {
-        index?: number;
-        id?: string;
-        function?: { name?: string; arguments?: string };
-      }[];
-    };
-    finish_reason?: string | null;
-  }[];
-  usage?: WireResponse["usage"];
-  error?: { message?: unknown; type?: unknown; code?: unknown };
-}
-
-async function readCompletionsSse(
-  body: ReadableStream<Uint8Array>,
-  onDelta: OnDelta | undefined,
-): Promise<WireResponse> {
-  const acc: StreamAcc = {
-    text: "",
-    thinking: "",
-    details: [],
-    finishReason: null,
-    usage: undefined,
-    tools: new Map(),
-    lastIndex: 0,
-  };
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      const { value, done } = await reader.read();
-      const piece = decoder.decode(value ?? new Uint8Array(), { stream: !done });
-      const pushed = pushSse(buffer, piece);
-      buffer = pushed.buffer;
-      for (const payload of pushed.payloads) {
-        if (payload === "[DONE]") return toWireResponse(acc);
-        if (payload.length === 0) continue;
-        applyCompletionChunk(JSON.parse(payload) as WireStreamChunk, acc, onDelta);
-      }
-      if (done) break;
-    }
-    for (const payload of pushSse(buffer, "\n").payloads) {
-      if (payload === "[DONE]") break;
-      if (payload.length === 0) continue;
-      applyCompletionChunk(JSON.parse(payload) as WireStreamChunk, acc, onDelta);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  return toWireResponse(acc);
-}
-
-function toWireResponse(acc: StreamAcc): WireResponse {
-  const tools = [...acc.tools.entries()].sort(([a], [b]) => a - b).map(([, tool]) => tool);
-  const response: WireResponse = {
-    choices: [
-      {
-        message: {
-          content: acc.text.length > 0 ? acc.text : null,
-          ...(acc.thinking.length > 0 ? { reasoning_content: acc.thinking } : {}),
-          ...(acc.details.length > 0 ? { reasoning_details: acc.details } : {}),
-          ...(tools.length > 0
-            ? {
-                tool_calls: tools.map((t) => ({
-                  ...t.extra,
-                  id: t.id,
-                  function: { name: t.name, arguments: t.arguments },
-                })),
-              }
-            : {}),
-        },
-        finish_reason: acc.finishReason,
-      },
-    ],
-  };
-  if (acc.usage !== undefined) response.usage = acc.usage;
-  return response;
-}