@visual-z/xeno 0.1.0

package/src/runtime/openai.ts

@@ -0,0 +1,675 @@
+/**
+ * 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 type { AssistantBlock } from "../core/events.ts";
+import { assertNever } from "../core/exhaustive.ts";
+import type { Provider, ProviderConfig, Turn, ToolSchema, OnDelta } from "./provider.ts";
+import { DEFAULT_COMPAT, type Compat, type Effort, type ModelSpec } from "./model.ts";
+import { withRetry, DEFAULT_RETRY, type RetryPolicy } from "./retry.ts";
+
+/** One message as Chat Completions wants it. */
+export interface WireMessage {
+  role: "system" | "developer" | "user" | "assistant" | "tool";
+  content?: string | null;
+  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[];
+  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":
+        // 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[] = [];
+
+  for (const b of content) {
+    switch (b.type) {
+      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 (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: "enabled" };
+    if (compat.supportsReasoningEffort) {
+      const effort = wireEffort(spec, config.effort);
+      if (effort !== null) request.reasoning_effort = effort;
+    }
+  }
+
+  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 retry: RetryPolicy;
+  private readonly onRetry: ((attempt: number, delayMs: number, error: unknown) => void) | undefined;
+
+  constructor(
+    config: ProviderConfig,
+    apiKey: string,
+    options: {
+      fetchImpl?: typeof fetch;
+      retry?: RetryPolicy;
+      onRetry?: (attempt: number, delayMs: number, error: unknown) => void;
+    } = {},
+  ) {
+    this.config = config;
+    this.apiKey = apiKey;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.retry = options.retry ?? DEFAULT_RETRY;
+    this.onRetry = options.onRetry;
+  }
+
+  send(
+    frozen: FrozenPrefix,
+    messages: readonly Message[],
+    node: number,
+    signal?: AbortSignal,
+    onDelta?: OnDelta,
+  ): 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(
+      () => this.attempt(frozen, messages, node, signal, onDelta),
+      this.retry,
+      undefined,
+      (attempt, delayMs, error) => {
+        onDelta?.({ kind: "discard" });
+        this.onRetry?.(attempt, delayMs, error);
+      },
+      signal,
+    );
+  }
+
+  private async attempt(
+    frozen: FrozenPrefix,
+    messages: readonly Message[],
+    node: number,
+    signal?: AbortSignal,
+    onDelta?: OnDelta,
+  ): 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 };
+    // 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),
+    };
+    if (signal !== undefined) init.signal = signal;
+
+    const response = await this.fetchImpl(`${baseUrl.replace(/\/$/, "")}/chat/completions`, 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(response.body, onDelta);
+    return parseResponse(assembled, node, Date.now() - started);
+  }
+}
+
+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;
+    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;
+}