@providerkit/core 0.23.0 → 0.25.0

package/src/schema.ts

@@ -162,106 +162,234 @@ const SCHEMA_MAPS = ["properties", "patternProperties", "$defs", "definitions",
  * validation the caller's tool runner repeats anyway; the 400 costs the turn.
  */
 export function withoutPatterns(node: unknown): unknown {
-  if (!node || typeof node !== "object" || Array.isArray(node)) return node;
-  const { pattern: _pattern, ...schema } = node as Record<string, unknown>;
-  for (const key of SCHEMA_SLOTS) {
-    const value = schema[key];
+  if (!isSchemaObject(node)) return node;
+  const { pattern: _pattern, ...schema } = node;
+  mapChildren(schema, withoutPatterns);
+  return schema;
+}
+
+function isSchemaObject(node: unknown): node is Record<string, unknown> {
+  return typeof node === "object" && node !== null && !Array.isArray(node);
+}
+
+/** Replaces every child schema of `schema`, in place, with what `visit` returns for it. `slot`
+ *  is the keyword it sits under and `name` is its property name, for the keywords that map
+ *  names to schemas. */
+function mapChildren(
+  schema: Record<string, unknown>,
+  visit: (child: unknown, slot: string, name?: string) => unknown,
+): void {
+  for (const slot of SCHEMA_SLOTS) {
+    const value = schema[slot];
     if (value !== undefined) {
-      schema[key] = Array.isArray(value) ? value.map(withoutPatterns) : withoutPatterns(value);
+      schema[slot] = Array.isArray(value)
+        ? value.map((child) => visit(child, slot))
+        : visit(value, slot);
     }
   }
-  for (const key of SCHEMA_LISTS) {
-    const value = schema[key];
-    if (Array.isArray(value)) schema[key] = value.map(withoutPatterns);
+  for (const slot of SCHEMA_LISTS) {
+    const value = schema[slot];
+    if (Array.isArray(value)) schema[slot] = value.map((child) => visit(child, slot));
   }
-  for (const key of SCHEMA_MAPS) {
-    const value = schema[key];
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      schema[key] = Object.fromEntries(
-        Object.entries(value).map(([name, child]) => [name, withoutPatterns(child)]),
+  for (const slot of SCHEMA_MAPS) {
+    const value = schema[slot];
+    if (isSchemaObject(value)) {
+      schema[slot] = Object.fromEntries(
+        Object.entries(value).map(([name, child]) => [name, visit(child, slot, name)]),
       );
     }
   }
-  return schema;
 }
 
 /**
- * Sanitize a JSON Schema for Google Gemini's REST API.
+ * A JSON Schema for Gemini's `parametersJsonSchema` and `responseJsonSchema`, which take
+ * standard JSON Schema. It is sent as written except for the four shapes the API refuses.
+ * Measured on `gemini-3.8-flash` on 2026-10-21, in a tool and as a response schema alike;
+ * every other keyword tried (`$ref`, `$defs`, `oneOf`, `allOf`, `not`, `if`, `const`, numeric
+ * `enum`, `type: [..., "null"]`, `patternProperties`, `additionalProperties`, arrays without
+ * `items`) came back accepted:
+ *
+ * - `required` names a property that is not declared, at any depth: 400 "requires unspecified
+ *   property". The names with no property are dropped.
+ * - Draft-04 `exclusiveMinimum: true` (or `false`): 400 "must be a number". It becomes the
+ *   number form, `exclusiveMinimum: <minimum>`, and `minimum` goes.
+ * - A tuple, `items: [a, b]`: 400 "must be a boolean or an object". It becomes `prefixItems`,
+ *   and `additionalItems` becomes `items`, as in 2020-12.
+ * - A recursive `$ref` that is not behind an optional property or an array that may be empty:
+ *   400 "ref loops are only supported if ...". The self-reference becomes `{}`.
  *
- * Gemini's functionDeclarations schema parser only accepts a strict OpenAPI 3.0 subset.
- * It rejects:
- * - Nullable type arrays (`type: ["string", "null"]`), requiring `{ type: "string", nullable: true }`.
- * - Union types with null (`anyOf: [{ type: "string" }, { type: "null" }]`), requiring `{ type: "string", nullable: true }`.
- * - Numeric enums (`enum: [1, 2, 3]`), requiring string enums.
- * - `const: "val"`, requiring `enum: ["val"]`.
- * - Arrays without `items`, requiring an explicit items schema.
- * - Unsupported keywords ($schema, definitions, $defs, patternProperties, additionalProperties: true).
+ * This replaced a sanitizer written for the older `parameters` field, which accepts a small
+ * OpenAPI subset. Kept on `parametersJsonSchema`, it turned a numeric enum into a string enum
+ * (the model then sent `"2"` for `2`), forced string items onto an array of anything, and
+ * dropped every `$ref`, while still sending the 400s above.
  */
 export function toGeminiToolSchema(node: unknown): Record<string, unknown> {
-  if (!node || typeof node !== "object" || Array.isArray(node)) {
-    return { type: "object", properties: {} };
+  if (!isSchemaObject(node)) return { type: "object", properties: {} };
+  const root = geminiStandardForm(node);
+  for (const defs of ["$defs", "definitions"]) {
+    const entries = root[defs];
+    if (isSchemaObject(entries)) {
+      root[defs] = Object.fromEntries(
+        Object.entries(entries).map(([name, def]) => [
+          name,
+          cutRefLoops(def, `#/${defs}/${name}`, false),
+        ]),
+      );
+    }
   }
-  const schema = { ...(node as Record<string, unknown>) };
+  const cut = cutRefLoops(root, "#", false);
+  return isSchemaObject(cut) ? cut : root;
+}
 
-  delete schema.$schema;
-  delete schema.$id;
-  delete schema.$ref;
-  delete schema.definitions;
-  delete schema.$defs;
-  delete schema.patternProperties;
+function geminiStandardForm(node: Record<string, unknown>): Record<string, unknown> {
+  const schema = { ...node };
+  mapChildren(schema, (child) => (isSchemaObject(child) ? geminiStandardForm(child) : child));
 
-  if (schema.additionalProperties === true) {
-    delete schema.additionalProperties;
+  if (Array.isArray(schema.required)) {
+    const declared = isSchemaObject(schema.properties) ? schema.properties : {};
+    schema.required = schema.required.filter(
+      (name) => typeof name === "string" && Object.hasOwn(declared, name),
+    );
   }
 
-  if ("const" in schema && !("enum" in schema)) {
-    schema.enum = [String(schema.const)];
-    delete schema.const;
+  for (const [flag, bound] of [
+    ["exclusiveMinimum", "minimum"],
+    ["exclusiveMaximum", "maximum"],
+  ] as const) {
+    if (typeof schema[flag] !== "boolean") continue;
+    if (schema[flag] && typeof schema[bound] === "number") {
+      schema[flag] = schema[bound];
+      delete schema[bound];
+    } else {
+      delete schema[flag];
+    }
   }
 
-  const union = schema.anyOf ?? schema.oneOf;
-  if (Array.isArray(union)) {
-    const nonNullBranches = union.filter(
-      (b) => typeof b === "object" && b !== null && (b as Record<string, unknown>).type !== "null",
-    );
-    const hasNull = union.some(
-      (b) => typeof b === "object" && b !== null && (b as Record<string, unknown>).type === "null",
-    );
-    if (nonNullBranches.length === 1 && typeof nonNullBranches[0] === "object") {
-      const merged = toGeminiToolSchema(nonNullBranches[0]);
-      if (hasNull) merged.nullable = true;
-      return merged;
+  if (Array.isArray(schema.items)) {
+    schema.prefixItems = schema.items;
+    delete schema.items;
+    if ("additionalItems" in schema) {
+      const extra = schema.additionalItems;
+      schema.items = isSchemaObject(extra) ? geminiStandardForm(extra) : extra;
+      delete schema.additionalItems;
     }
   }
+  return schema;
+}
 
-  if (Array.isArray(schema.type)) {
-    const types = schema.type as string[];
-    const hasNull = types.includes("null");
-    const nonNull = types.filter((t) => t !== "null");
-    schema.type = nonNull[0] ?? "string";
-    if (hasNull) schema.nullable = true;
-  }
+/**
+ * Gemini takes a recursive `$ref` only when the loop passes through a property that is not
+ * required or an `items` that may be empty. Any other reference to `target` becomes `{}`.
+ *
+ * ponytail: this cuts a definition's reference to ITSELF. Two definitions that refer to each
+ * other through required properties still get the 400; follow the ref graph if one shows up.
+ */
+function cutRefLoops(node: unknown, target: string, safe: boolean): unknown {
+  if (!isSchemaObject(node)) return node;
+  if (!safe && node.$ref === target) return {};
+  const schema = { ...node };
+  const required = Array.isArray(schema.required) ? schema.required : [];
+  const mayBeEmpty = !(typeof schema.minItems === "number" && schema.minItems > 0);
+  mapChildren(schema, (child, slot, name) =>
+    cutRefLoops(
+      child,
+      target,
+      safe ||
+        (slot === "items" && mayBeEmpty) ||
+        (slot === "properties" && !required.includes(name)),
+    ),
+  );
+  return schema;
+}
 
-  if (Array.isArray(schema.enum)) {
-    schema.enum = schema.enum.map((val) => String(val));
-  }
+/**
+ * Sanitize a JSON Schema to the OpenAPI 3.0 subset Google's Cloud Code Assist
+ * (`antigravity`) accepts in its `parameters` field (`type`, `nullable`,
+ * `description`, `format`, `enum`, `properties`, `items`, `required`, `anyOf`).
+ * Mirrors cc-proxy's `clean_json_schema`, including the `{ type: "string" }`
+ * fallback when an array omits `items`.
+ */
+export function toAntigravityToolSchema(node: unknown): Record<string, unknown> {
+  if (!isSchemaObject(node)) return { type: "object" };
+  const out: Record<string, unknown> = {};
+  let nullable = node.nullable === true;
 
-  if (schema.type === "array" && !schema.items) {
-    schema.items = { type: "string" };
-  } else if (schema.items && typeof schema.items === "object") {
-    schema.items = toGeminiToolSchema(schema.items);
+  if (typeof node.type === "string") {
+    if (node.type === "null") nullable = true;
+    else out.type = node.type;
+  } else if (Array.isArray(node.type)) {
+    let picked: string | undefined;
+    for (const item of node.type) {
+      if (typeof item !== "string") continue;
+      if (item === "null") nullable = true;
+      else if (picked === undefined) picked = item;
+    }
+    if (picked !== undefined) out.type = picked;
   }
-
-  if (schema.properties && typeof schema.properties === "object") {
-    const props = schema.properties as Record<string, unknown>;
-    const sanitizedProps: Record<string, unknown> = {};
-    for (const [key, val] of Object.entries(props)) {
-      sanitizedProps[key] = toGeminiToolSchema(val);
+  if (nullable) out.nullable = true;
+  if (typeof node.description === "string" && node.description.length > 0) {
+    out.description = node.description;
+  }
+  if (node.format === "enum" || node.format === "date-time") {
+    out.format = node.format;
+  }
+  if (Array.isArray(node.enum)) {
+    const strings = node.enum.filter((v): v is string => typeof v === "string");
+    if (strings.length > 0) out.enum = strings;
+  } else if (typeof node.const === "string") {
+    out.enum = [node.const];
+  }
+  if (isSchemaObject(node.properties)) {
+    const cleanProps: Record<string, unknown> = {};
+    for (const [propName, propSchema] of Object.entries(node.properties)) {
+      cleanProps[propName] = toAntigravityToolSchema(propSchema);
     }
-    schema.properties = sanitizedProps;
+    if (Array.isArray(node.required)) {
+      const validReq = node.required.filter(
+        (k): k is string => typeof k === "string" && Object.hasOwn(cleanProps, k),
+      );
+      if (validReq.length > 0) out.required = validReq;
+    }
+    out.properties = cleanProps;
+    if (!("type" in out)) out.type = "object";
   }
-
-  return schema;
+  if ("items" in node && node.items !== undefined) {
+    out.items = Array.isArray(node.items)
+      ? node.items.length > 0
+        ? toAntigravityToolSchema(node.items[0])
+        : { type: "string" }
+      : toAntigravityToolSchema(node.items);
+    if (!("type" in out)) out.type = "array";
+  }
+  const union = Array.isArray(node.anyOf)
+    ? node.anyOf
+    : Array.isArray(node.oneOf)
+      ? node.oneOf
+      : undefined;
+  if (union) {
+    const branches: Record<string, unknown>[] = [];
+    for (const branch of union) {
+      if (isSchemaObject(branch) && branch.type === "null") {
+        out.nullable = true;
+        continue;
+      }
+      branches.push(toAntigravityToolSchema(branch));
+    }
+    if (branches.length === 1) {
+      for (const [k, v] of Object.entries(branches[0]!)) {
+        if (!(k in out)) out[k] = v;
+      }
+    } else if (branches.length > 0) {
+      out.anyOf = branches;
+    }
+  }
+  if (!("type" in out) && !("anyOf" in out)) {
+    out.type = "string";
+  }
+  if (out.type === "array" && !("items" in out)) {
+    out.items = { type: "string" };
+  }
+  return out;
 }
 
 /**

package/src/tools.ts

@@ -51,8 +51,16 @@ export interface ToolSpec<I, O> {
   summarize?: (output: O) => string;
   /** Default 60s. A tool with no ceiling can hang a whole run. */
   timeoutMs?: number;
+  /**
+   * The tool changes nothing. Default false: a flag that promises safety is
+   * true only when the tool says so. `repairHistory` tells the model an
+   * interrupted read-only call "changed nothing, so it is safe to call again",
+   * and a write that left this out used to be told that too.
+   */
   isReadOnly?: boolean;
   needsApproval?: boolean;
+  /** The tool may run in parallel with others. Default false, for the same
+   *  reason as `isReadOnly`: two writes run at once by omission can race. */
   isConcurrencySafe?: boolean;
   /** A terminal tool ends the run; its validated input is the run's output. */
   isTerminal?: boolean;
@@ -142,9 +150,9 @@ export function defineTool<I = unknown, O = unknown>(spec: ToolSpec<I, O>): Tool
     description: spec.description,
     inputSchema: spec.inputSchema,
     timeoutMs,
-    isReadOnly: spec.isReadOnly ?? true,
+    isReadOnly: spec.isReadOnly ?? false,
     needsApproval: spec.needsApproval ?? false,
-    isConcurrencySafe: spec.isConcurrencySafe ?? true,
+    isConcurrencySafe: spec.isConcurrencySafe ?? false,
     isTerminal: spec.isTerminal ?? false,
 
     definition() {

package/src/turn.ts

@@ -0,0 +1,166 @@
+// One turn, drained. Every agent loop reads a stream the same way: text and
+// reasoning joined, tool-call fragments put back together by index, usage and
+// finish taken from the last chunk that states them. The apps that use this
+// package each wrote that by hand, a little differently each time, and the
+// one in `drainStream` dropped the tool calls altogether.
+//
+// It assembles and nothing else. Arguments stay the raw string the seam
+// promises, because tool-args.ts heals them and tools.ts validates them. And a
+// turn that said nothing is not judged here: that is `requireContent`'s call
+// (invariant 13), made where the retry that can fix it still can.
+import { ProviderError } from "./errors.ts";
+import {
+  EMPTY_USAGE,
+  type ChatMessage,
+  type FinishReason,
+  type ProviderChunk,
+  type ReasoningItems,
+  type TokenUsage,
+  type ToolCall,
+} from "./types.ts";
+
+/** One drained turn: the message a loop appends, whose `toolCalls` are the
+ *  calls it runs, and what the turn cost. */
+export interface Turn {
+  /** Ready to append to history as it is. `toolCalls` holds the calls to run,
+   *  in the order the provider indexed them, and is absent when there are none. */
+  message: Extract<ChatMessage, { role: "assistant" }>;
+  /** The last usage the stream reported, or zeros when it reported none. */
+  usage: TokenUsage;
+  /** As the provider stated it, and null when it stated none. */
+  finishReason: FinishReason | null;
+  /** The endpoint and model that answered, when a fallback provider says. */
+  source?: { provider: string; model: string };
+}
+
+/**
+ * Drain one turn into the assistant message it produced, plus its usage,
+ * finish reason and source.
+ *
+ * ```ts
+ * const turn = await collectTurn(provider.createStream(history, tools));
+ * history.push(turn.message);
+ * for (const call of turn.message.toolCalls ?? []) history.push(await run(call));
+ * ```
+ *
+ * @throws {ProviderError} `overload` when a tool call ends the stream with no
+ * name. Whatever the stream itself throws passes through unchanged.
+ */
+export async function collectTurn(stream: AsyncIterable<ProviderChunk>): Promise<Turn> {
+  let content = "";
+  let reasoning = "";
+  // Not concatenated: this half of the record is a payload the provider owns,
+  // and it arrives whole on one delta rather than in fragments. Dropped here,
+  // a drained turn replays only half its own reasoning on the next round,
+  // which is the failure `reasoningDetails` exists to prevent.
+  let reasoningDetails: unknown[] | undefined;
+  let reasoningItems: ReasoningItems | undefined;
+  const calls = new Map<number, ToolCall>();
+  // Cumulative on some providers and final-only on others: the LAST one wins.
+  let usage: TokenUsage = EMPTY_USAGE;
+  let finishReason: FinishReason | null = null;
+  let source: Turn["source"];
+
+  // Read to the end, past the finish chunk: the OpenAI shape sends its usage
+  // after it, and a loop that stopped at the finish would bill every turn at zero.
+  for await (const chunk of stream) {
+    if (chunk.source) source = chunk.source;
+    if (chunk.content) content += chunk.content;
+    if (chunk.reasoning) reasoning += chunk.reasoning;
+    if (chunk.reasoningDetails?.length) reasoningDetails = chunk.reasoningDetails;
+    if (chunk.reasoningItems?.items.length) reasoningItems = chunk.reasoningItems;
+    for (const delta of chunk.toolCalls ?? []) {
+      const call = calls.get(delta.index) ?? { id: "", name: "", arguments: "" };
+      // Identity is the last value STATED, so an empty one never erases a real
+      // one: Anthropic opens a call with `""` for what it lacks, and the
+      // ChatGPT backend states the real call_id and name only on the call's
+      // closing event. A call that never states an id keeps `""`. The four
+      // adapters here mint one before their finish (`settleToolCalls`); for any
+      // other Provider, one made up here would be ours and not the wire's
+      // (invariant 10), and `repairHistory` already names it the same way on
+      // every send. Arguments are fragments, joined in arrival order.
+      if (delta.id) call.id = delta.id;
+      if (delta.name) call.name = delta.name;
+      if (delta.thoughtSignature) call.thoughtSignature = delta.thoughtSignature;
+      call.arguments += delta.arguments ?? "";
+      calls.set(delta.index, call);
+    }
+    if (chunk.usage) usage = chunk.usage;
+    if (chunk.finishReason) finishReason = chunk.finishReason;
+  }
+
+  // By index, not by arrival: parallel calls interleave their fragments.
+  const indexed = [...calls].sort(([a], [b]) => a - b);
+  const nameless = indexed.find(([, call]) => !call.name);
+  if (nameless) {
+    const [index, call] = nameless;
+    // `overload`, the kind for a provider's own anomaly inside a 200 (an empty
+    // body, a turn that completed with nothing): our request was fine, the
+    // vendor's frame was not. A retry may well get a whole call, and another
+    // model is a fair next try if this one keeps doing it. `invalid` would
+    // blame our request and stop the run over a fault that is not ours. The
+    // four adapters here fail such a call themselves, with the same kind
+    // (`settleToolCalls`); this gives any other Provider the same answer.
+    const provider = source?.provider ?? "turn";
+    const which = call.id || `at index ${index}`;
+    throw new ProviderError(
+      provider,
+      "overload",
+      `${provider}: tool call ${which} ended with no name, so there is no tool to run`,
+    );
+  }
+  const toolCalls = indexed.map(([, call]) => call);
+
+  return {
+    message: {
+      role: "assistant",
+      content,
+      ...(reasoning ? { reasoning } : {}),
+      ...(reasoningDetails ? { reasoningDetails } : {}),
+      ...(reasoningItems ? { reasoningItems } : {}),
+      ...(toolCalls.length > 0 ? { toolCalls } : {}),
+    },
+    usage,
+    finishReason,
+    ...(source ? { source } : {}),
+  };
+}
+
+export interface Completion {
+  text: string;
+  /** Present when the stream identifies the endpoint that answered. */
+  provider?: string;
+  reasoning: string;
+  /** Present only where the provider sent one. See ChatMessage.reasoningDetails. */
+  reasoningDetails?: unknown[];
+  /** Present only where the provider sent them. See ChatMessage.reasoningItems. */
+  reasoningItems?: ReasoningItems;
+  /** The calls the model asked for, in index order, and empty when it asked
+   *  for none. Before this field a drained turn that called a tool read as a
+   *  turn that said nothing. */
+  toolCalls: ToolCall[];
+  usage: TokenUsage;
+  finishReason: FinishReason | null;
+  model: string;
+}
+
+/** Drain a stream into a Completion: `collectTurn`, flattened for a caller
+ *  that wants the answer rather than a message to append. `model` names the
+ *  model unless a fallback provider stamped the one that answered. */
+export async function drainStream(
+  stream: AsyncIterable<ProviderChunk>,
+  model: string,
+): Promise<Completion> {
+  const { message, usage, finishReason, source } = await collectTurn(stream);
+  return {
+    text: message.content,
+    reasoning: message.reasoning ?? "",
+    ...(message.reasoningDetails ? { reasoningDetails: message.reasoningDetails } : {}),
+    ...(message.reasoningItems ? { reasoningItems: message.reasoningItems } : {}),
+    toolCalls: message.toolCalls ?? [],
+    usage,
+    finishReason,
+    model: source?.model ?? model,
+    ...(source ? { provider: source.provider } : {}),
+  };
+}

package/src/types.ts

@@ -71,8 +71,9 @@ export type ContentPart = TextPart | ImagePart | FilePart;
 
 /**
  * A tool the model asked to run. `arguments` is the RAW JSON string, not a
- * parsed object: it arrives in fragments and can be truncated mid-stream, so
- * assembly and validation are the consumer's job (see tools/define).
+ * parsed object: it arrives in fragments and can be truncated mid-stream.
+ * `collectTurn` joins the fragments; healing and validating them is the
+ * consumer's job (see tools/define).
  */
 export interface ToolCall {
   id: string;
@@ -151,7 +152,7 @@ export interface ToolDefinition {
 
 export type FinishReason = "stop" | "length" | "tool_calls" | "content_filter";
 
-/** Incremental tool-call fragment, assembled by `index` by the consumer. */
+/** Incremental tool-call fragment, assembled by `index`. `collectTurn` does it. */
 export interface ToolCallDelta {
   index: number;
   id?: string;
@@ -385,9 +386,10 @@ export interface StreamOptions {
    */
   jsonWithTools?: JsonWithTools;
   /**
-   * Stable id for the conversation or job this call belongs to. Sent only to
-   * endpoints whose preset names a `sessionHeader` (OpenCode Go routes and
-   * caches by it); every other endpoint ignores it.
+   * Stable id for the conversation or job this call belongs to. Sent in the
+   * `sessionHeader` of endpoints that name one (OpenCode Go routes and caches
+   * by it), and as `prompt_cache_key` on the Responses shape. A call without
+   * one sends the provider's `instanceSessionId` in that header instead.
    */
   sessionId?: string;
   /**
@@ -440,62 +442,6 @@ export interface Provider {
   ): AsyncIterable<ProviderChunk>;
 }
 
-export interface Completion {
-  text: string;
-  /** Present when the stream identifies the endpoint that answered. */
-  provider?: string;
-  reasoning: string;
-  /** Present only where the provider sent one. See ChatMessage.reasoningDetails. */
-  reasoningDetails?: unknown[];
-  /** Present only where the provider sent them. See ChatMessage.reasoningItems. */
-  reasoningItems?: ReasoningItems;
-  usage: TokenUsage;
-  finishReason: FinishReason | null;
-  model: string;
-}
-
-/** Drain a no-tools stream into a Completion. Usage chunks are cumulative on
- *  some providers and final-only on others: the LAST one wins. */
-export async function drainStream(
-  stream: AsyncIterable<ProviderChunk>,
-  model: string,
-): Promise<Completion> {
-  let text = "";
-  let reasoning = "";
-  // Not concatenated: this half of the record is a payload the provider owns,
-  // and it arrives whole on one delta rather than in fragments. Dropped here,
-  // a drained turn replays only half its own reasoning on the next round —
-  // which is the failure `reasoningDetails` exists to prevent.
-  let reasoningDetails: unknown[] | undefined;
-  let reasoningItems: ReasoningItems | undefined;
-  let usage: TokenUsage = EMPTY_USAGE;
-  let finishReason: FinishReason | null = null;
-  let source: ProviderChunk["source"];
-  for await (const chunk of stream) {
-    if (chunk.source) source = chunk.source;
-    if (chunk.type === "delta") {
-      if (chunk.content) text += chunk.content;
-      if (chunk.reasoning) reasoning += chunk.reasoning;
-      if (chunk.reasoningDetails?.length) reasoningDetails = chunk.reasoningDetails;
-      if (chunk.reasoningItems?.items.length) reasoningItems = chunk.reasoningItems;
-    } else if (chunk.type === "usage" && chunk.usage) {
-      usage = chunk.usage;
-    } else if (chunk.type === "finish" && chunk.finishReason) {
-      finishReason = chunk.finishReason;
-    }
-  }
-  return {
-    text,
-    reasoning,
-    ...(reasoningDetails ? { reasoningDetails } : {}),
-    ...(reasoningItems ? { reasoningItems } : {}),
-    usage,
-    finishReason,
-    model: source?.model ?? model,
-    ...(source ? { provider: source.provider } : {}),
-  };
-}
-
 /**
  * Prepare a history for a thinking-DISABLED turn: strip `reasoning` from every
  * assistant message.