@providerkit/core 0.17.2 → 0.21.0

package/src/providers/factory.ts

@@ -10,6 +10,7 @@
 // `effort` passes through to the adapter unchanged — the per-endpoint
 // thinking dialects (Z.ai's explicit disabled marker, OpenRouter's floors)
 // are the adapters' knowledge, and this factory must not re-derive them.
+import { ProviderError } from "../errors.ts";
 import { createAnthropicProvider } from "./anthropic.ts";
 import { createGeminiProvider } from "./gemini.ts";
 import { createOpenAIProvider } from "./openai.ts";
@@ -17,15 +18,17 @@ import { createResponsesProvider } from "./responses.ts";
 import {
   PRESET_IDS,
   PROVIDER_PRESETS,
+  type PresetAuth,
+  type PresetShape,
   type ProviderPreset,
   type ProviderPresetId,
 } from "../presets.ts";
-import type { Effort, Provider } from "../types.ts";
+import type { Effort, Provider, ServiceTier } from "../types.ts";
 import { withConfiguredFallbacks, type ProviderFallbackConfig } from "../fallback.ts";
 
 export interface PresetProviderConfig extends ProviderFallbackConfig {
   /** The credential: an API key for `key`/`bearer` presets, an ACCESS TOKEN
-   *  for `oauth` ones. Acquiring the token is the caller's job. */
+   *  for `oauth` ones. `@providerkit/core/auth` signs in and renews it. */
   apiKey: string;
   /** Which model to run. Absent = the preset's `defaultModel`; a preset
    *  without either throws rather than sending a request nobody chose. */
@@ -34,6 +37,9 @@ export interface PresetProviderConfig extends ProviderFallbackConfig {
    *  take over in order when it fails (quota, rate, outage). Wins over `model`
    *  and the preset's `rotation`; `fallbacks` still run after the chain. */
   models?: readonly string[];
+  /** Replaces the preset's API root. For a vendor that gives each account its
+   *  own host (Copilot: `credential.baseUrl` from the sign-in). */
+  baseUrl?: string;
   effort?: Effort;
   /** Output ceiling. The Anthropic shape requires one; adapters default it. */
   maxTokens?: number;
@@ -57,6 +63,9 @@ export interface PresetProviderConfig extends ProviderFallbackConfig {
    *  between rounds — pinning keeps a conversation's rounds (and their cache)
    *  on one host. Empty/absent = default routing. */
   providerOrder?: string[];
+  /** Default `service_tier` for every call on the OpenAI and Responses shapes;
+   *  `StreamOptions.serviceTier` wins. Anthropic and Gemini presets refuse it. */
+  serviceTier?: ServiceTier;
   fetchImpl?: typeof fetch;
 }
 
@@ -85,7 +94,15 @@ export function createPresetProvider(id: ProviderPresetId, config: PresetProvide
   if (!model) {
     throw new Error(`[providerkit] Preset "${id}" has no defaultModel — pass a model.`);
   }
+  const wire = wireFor(preset, model);
+  if (config.serviceTier && (wire.shape === "anthropic" || wire.shape === "gemini")) {
+    throw new Error(
+      `[providerkit] Preset "${id}" speaks the ${wire.shape} shape, which has no service tier. ` +
+        "Remove serviceTier.",
+    );
+  }
   const headers = { ...preset.headers, ...config.headers };
+  const baseUrl = config.baseUrl ?? wire.baseUrl;
   const maxTokens = config.maxTokens ?? preset.maxTokens;
 
   const {
@@ -97,7 +114,7 @@ export function createPresetProvider(id: ProviderPresetId, config: PresetProvide
   } = config;
 
   let provider: Provider;
-  switch (preset.shape) {
+  switch (wire.shape) {
     case "anthropic":
       // `key` rides Anthropic's native x-api-key; coding plans and OAuth
       // tokens read Bearer (measured across the family's coding endpoints).
@@ -107,10 +124,11 @@ export function createPresetProvider(id: ProviderPresetId, config: PresetProvide
         model,
         effort: config.effort,
         maxTokens,
-        baseUrl: preset.baseUrl,
+        baseUrl,
         id,
         headers,
-        bearer: preset.auth !== "key",
+        bearer: wire.auth !== "key",
+        ...(preset.sessionHeader ? { sessionHeader: preset.sessionHeader } : {}),
         // The endpoint's thinking dialect rides the table (zai: silence means
         // the model default, which is ON — "none" must be said out loud).
         ...(preset.explicitNone ? { explicitNone: true } : {}),
@@ -125,11 +143,12 @@ export function createPresetProvider(id: ProviderPresetId, config: PresetProvide
         model,
         effort: config.effort,
         maxTokens,
-        baseUrl: preset.baseUrl,
-        ...(preset.path ? { path: preset.path } : {}),
+        baseUrl,
+        ...(wire.path ? { path: wire.path } : {}),
         headers,
         ...(config.providerOrder ? { providerOrder: config.providerOrder } : {}),
         ...(preset.sessionHeader ? { sessionHeader: preset.sessionHeader } : {}),
+        ...(preset.initiatorHeader ? { initiatorHeader: true } : {}),
         fetchImpl: config.fetchImpl,
       });
       break;
@@ -140,12 +159,13 @@ export function createPresetProvider(id: ProviderPresetId, config: PresetProvide
         model,
         effort: config.effort,
         maxTokens,
-        baseUrl: preset.baseUrl,
-        ...(preset.path ? { path: preset.path } : {}),
+        baseUrl,
+        ...(wire.path ? { path: wire.path } : {}),
         id,
         headers,
         ...(preset.sessionHeader ? { sessionHeader: preset.sessionHeader } : {}),
         ...(preset.imageLimits ? { imageLimits: preset.imageLimits } : {}),
+        ...(preset.replayReasoning ? { replayReasoning: true } : {}),
         fetchImpl: config.fetchImpl,
       });
       break;
@@ -155,7 +175,7 @@ export function createPresetProvider(id: ProviderPresetId, config: PresetProvide
         apiKey: config.apiKey,
         model,
         effort: config.effort,
-        baseUrl: preset.baseUrl,
+        baseUrl,
         id,
         headers,
         fetchImpl: config.fetchImpl,
@@ -163,5 +183,50 @@ export function createPresetProvider(id: ProviderPresetId, config: PresetProvide
       break;
   }
 
-  return withConfiguredFallbacks(provider, config);
+  return withConfiguredFallbacks(
+    preset.routes ? refuseOtherWires(provider, preset, wire) : provider,
+    config,
+  );
+}
+
+/** The endpoint a model is served from: its route when the preset has one for
+ *  it, else the preset's own. */
+function wireFor(preset: ProviderPreset, model: string): Wire {
+  const route = preset.routes?.find((r) => r.prefixes.some((prefix) => model.startsWith(prefix)));
+  return route
+    ? { ...route, auth: route.auth ?? preset.auth }
+    : { shape: preset.shape, baseUrl: preset.baseUrl, path: preset.path, auth: preset.auth };
+}
+
+interface Wire {
+  shape: PresetShape;
+  baseUrl: string;
+  path?: string;
+  auth: PresetAuth;
+}
+
+const sameWire = (a: Wire, b: Wire) =>
+  a.shape === b.shape && a.baseUrl === b.baseUrl && a.path === b.path;
+
+/**
+ * A per-call `model` that lives on another wire than the one this provider was
+ * built for would be posted to an endpoint that doesn't serve it, and the 404
+ * would read as an unknown model. Refuse it before any request goes out. To use
+ * a model on another wire, build a provider for it (a `models` chain does).
+ */
+function refuseOtherWires(provider: Provider, preset: ProviderPreset, bound: Wire): Provider {
+  return {
+    ...provider,
+    async *createStream(messages, tools, opts) {
+      if (opts?.model && !sameWire(wireFor(preset, opts.model), bound)) {
+        throw new ProviderError(
+          provider.id,
+          "invalid",
+          `${provider.id}: ${opts.model} is served on a different endpoint than ${provider.model}. ` +
+            `Build a provider for ${opts.model}, or put both in a models chain.`,
+        );
+      }
+      yield* provider.createStream(messages, tools, opts);
+    },
+  };
 }

package/src/providers/gemini.ts

@@ -320,6 +320,13 @@ export function createGeminiProvider(config: GeminiConfig): Provider {
         generationConfig.responseJsonSchema = toGeminiToolSchema(opts.json.schema);
       }
 
+      if (opts.serviceTier) {
+        throw new ProviderError(
+          id,
+          "invalid",
+          `${id}: Gemini has no service tier switch. Leave serviceTier unset for Gemini models.`,
+        );
+      }
       const request: Record<string, unknown> = { contents, generationConfig };
       // A Content, not the bare string the SDK accepts — REST rejects a string.
       // The prompt-carried schema rides as a second part, after the caller's

package/src/providers/openai.ts

@@ -3,7 +3,7 @@
 // This is the dialect most gateways speak, so one adapter serves OpenAI,
 // OpenRouter, DeepSeek, GLM, Kimi, Groq, Together, vLLM, Ollama and LM Studio.
 // Their divergences are small and named where they appear.
-import { fileRefused, streamCut, streamError } from "../errors.ts";
+import { fileRefused, ProviderError, streamCut, streamError } from "../errors.ts";
 import { streamSse, apiUrl } from "../transport.ts";
 import { attributionHeaders } from "../attribution.ts";
 import type {
@@ -14,6 +14,7 @@ import type {
   JsonWithTools,
   Provider,
   ProviderChunk,
+  ServiceTier,
   StreamOptions,
   ToolDefinition,
 } from "../types.ts";
@@ -104,6 +105,12 @@ export interface OpenAIConfig extends ProviderFallbackConfig {
    *  no sessionId, the provider's own per-instance id rides instead, so the
    *  gateway never sees a call without one. */
   sessionHeader?: string;
+  /** Send `X-Initiator`: `user` when the last message is the user's, else
+   *  `agent`. GitHub Copilot bills a premium request per `user` turn and lets
+   *  the agent's own follow-ups (tool results) ride free. */
+  initiatorHeader?: boolean;
+  /** Default `service_tier` for every call; `StreamOptions.serviceTier` wins. */
+  serviceTier?: ServiceTier;
 }
 
 const DEFAULT_BASE_URL = "https://api.openai.com";
@@ -153,7 +160,7 @@ export function openRouterHostFor(baseUrl: string, model: string): string | unde
 
 /** The spellings of "think this hard" across the dialects that share this
  *  adapter. `off` sends nothing and leaves the model on its own default. */
-export type EffortDialect = "openai" | "openrouter" | "deepseek" | "off";
+export type EffortDialect = "openai" | "openrouter" | "deepseek" | "opencode-go" | "off";
 
 /**
  * How `none` is said on OpenRouter, per model id: the `reasoning.effort` that
@@ -267,6 +274,8 @@ export function effortParams(
       return model !== undefined && OPENROUTER_NONE.has(model)
         ? { reasoning: { effort: OPENROUTER_NONE.get(model) } }
         : {};
+    case "opencode-go":
+      return goEffortParams(effort, model);
     case "openai":
       return { reasoning_effort: level ?? "none" };
     case "off":
@@ -274,11 +283,45 @@ export function effortParams(
   }
 }
 
+/**
+ * OpenCode Go's chat models each take a different set of `reasoning_effort`
+ * values (cc-proxy's table, measured on live traffic). A level a model can't
+ * take is refused here, rather than sent as a 400 or quietly changed into a
+ * level the caller didn't ask for.
+ *
+ * - GLM 5.2 and 5.3 take only `high` and `max`, with no way to turn thinking
+ *   off. `none` gets `high`, the least they offer.
+ * - DeepSeek V4 takes `low` to `max`. `none` gets `low`, its least.
+ * - MiMo takes `low`, `medium` and `high`, and `none` (measured 2026-09-27 on
+ *   `mimo-v2.6-flash`; cc-proxy maps it to `low` instead).
+ * - Every other Go chat model gets the OpenAI spelling, as before.
+ */
+function goEffortParams(effort: Effort, model = ""): Record<string, unknown> {
+  const id = model.toLowerCase();
+  const refuse = (allowed: string): never => {
+    throw new ProviderError(
+      "opencode-go",
+      "invalid",
+      `opencode-go: ${model} can't take reasoning effort "${effort}". Use ${allowed}.`,
+    );
+  };
+  const level = (value: string) => ({ reasoning_effort: value });
+  if (/glm-5[-.p]?[23]/.test(id)) {
+    if (effort === "none" || effort === "high") return level("high");
+    return effort === "max" ? level("max") : refuse("high or max");
+  }
+  if (id.includes("deepseek-v4")) return level(effort === "none" ? "low" : effort);
+  if (id.includes("mimo"))
+    return effort === "max" ? refuse("none, low, medium or high") : level(effort);
+  return level(effort === "max" ? "high" : effort);
+}
+
 /** Gateways named after their dialect get it for free; everything else keeps
  *  the dialect this adapter is named for. */
 function dialectFor(id: string): EffortDialect {
   if (id === "openrouter") return "openrouter";
   if (id === "deepseek") return "deepseek";
+  if (id === "opencode-go") return "opencode-go";
   return "openai";
 }
 
@@ -487,6 +530,8 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
       if (opts.temperature !== undefined) request.temperature = opts.temperature;
       if (opts.topP !== undefined) request.top_p = opts.topP;
       if (opts.stopSequences?.length) request.stop = opts.stopSequences;
+      const serviceTier = opts.serviceTier ?? config.serviceTier;
+      if (serviceTier) request.service_tier = serviceTier;
       Object.assign(request, effortParams(config.effortDialect ?? dialectFor(id), effort, model));
       if (tools.length > 0) {
         request.tools = tools.map((tool) => ({
@@ -582,6 +627,9 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
           ...(config.sessionHeader
             ? { [config.sessionHeader]: opts.sessionId ?? instanceSessionId }
             : {}),
+          ...(config.initiatorHeader
+            ? { "X-Initiator": messages.at(-1)?.role === "user" ? "user" : "agent" }
+            : {}),
           ...config.headers,
         },
         body: request,

package/src/providers/responses.ts

@@ -20,6 +20,7 @@ import type {
   ImagePart,
   Provider,
   ProviderChunk,
+  ServiceTier,
   StreamOptions,
   ToolDefinition,
 } from "../types.ts";
@@ -56,6 +57,12 @@ export interface ResponsesConfig extends ProviderFallbackConfig {
   /** What this backend accepts as an image. Each image it would refuse is
    *  replaced by a note naming the reason, instead of failing the request. */
   imageLimits?: ImageLimits;
+  /** Ask for the encrypted reasoning items and replay them on the next turn,
+   *  so the model keeps its chain of thought across a stateless turn. Only for
+   *  backends that accept `include: ["reasoning.encrypted_content"]`. */
+  replayReasoning?: boolean;
+  /** Default `service_tier` for every call; `StreamOptions.serviceTier` wins. */
+  serviceTier?: ServiceTier;
 }
 
 const DEFAULT_BASE_URL = "https://api.openai.com";
@@ -91,7 +98,33 @@ type ResponsesContentPart =
   | { type: "output_text"; text: string }
   | { type: "input_image"; image_url: string };
 
+/** A reasoning item the backend made, sent back as it came. */
+type ReplayedReasoning = { type: "reasoning" } & Record<string, unknown>;
+
+function isReplayedReasoning(item: unknown): item is ReplayedReasoning {
+  return typeof item === "object" && item !== null && "type" in item && item.type === "reasoning";
+}
+
+/** The most encrypted reasoning one request carries back. Newest turns win. */
+const MAX_REPLAY_BYTES = 8 * 1024 * 1024;
+
+/** Which assistant messages get their reasoning replayed: this provider's own,
+ *  newest first, until the cap. An older turn's reasoning is the cheapest to lose. */
+function replayable(messages: readonly ChatMessage[], provider: string): Set<ChatMessage> {
+  const keep = new Set<ChatMessage>();
+  let bytes = 0;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i]!;
+    if (message.role !== "assistant" || message.reasoningItems?.provider !== provider) continue;
+    bytes += JSON.stringify(message.reasoningItems.items).length;
+    if (bytes > MAX_REPLAY_BYTES) break;
+    keep.add(message);
+  }
+  return keep;
+}
+
 type ResponsesInputItem =
+  | ReplayedReasoning
   | { type: "message"; role: "user" | "assistant"; content: ResponsesContentPart[] }
   | { type: "function_call"; call_id: string; name: string; arguments: string }
   | { type: "function_call_output"; call_id: string; output: string | ResponsesContentPart[] };
@@ -141,6 +174,7 @@ export function toResponsesInput(
     .map((message) => message.content)
     .join("\n\n");
 
+  const replayed = replayable(messages, provider);
   const input: ResponsesInputItem[] = [];
   for (const message of messages) {
     switch (message.role) {
@@ -167,12 +201,15 @@ export function toResponsesInput(
         break;
 
       case "assistant": {
-        // Reasoning is deliberately NOT replayed. This shape wants the ORIGINAL
-        // reasoning item back — its `rs_…` id, and under `store: false` its
-        // `encrypted_content` blob — and the seam carries neither, only the
-        // plain summary text a caller renders. A synthesized reasoning item is
-        // rejected; omitting it costs only the model re-deriving its own chain
-        // of thought, which is what every stateless caller already lives with.
+        // `reasoning` (the summary a caller renders) is never replayed: this
+        // shape wants the ORIGINAL item back, `rs_…` id and `encrypted_content`
+        // blob included, and a synthesized one is rejected. `reasoningItems`
+        // are those originals, so they go back first, but only to the provider
+        // that made them. Without them the model re-derives its own chain of
+        // thought, which is what every stateless caller already lives with.
+        if (replayed.has(message)) {
+          input.push(...message.reasoningItems!.items.filter(isReplayedReasoning));
+        }
         if (message.content) {
           input.push({
             type: "message",
@@ -213,6 +250,7 @@ interface ResponsesItem {
   call_id?: string;
   name?: string;
   arguments?: string;
+  encrypted_content?: string;
 }
 
 interface ResponsesEvent {
@@ -350,6 +388,7 @@ export function createResponsesProvider(config: ResponsesConfig): Provider {
         store: false,
       };
       if (instructions) request.instructions = instructions;
+      if (config.replayReasoning) request.include = ["reasoning.encrypted_content"];
       const maxTokens = opts.maxTokens ?? config.maxTokens;
       if (maxTokens !== undefined) request.max_output_tokens = maxTokens;
       if (opts.temperature !== undefined) request.temperature = opts.temperature;
@@ -386,6 +425,8 @@ export function createResponsesProvider(config: ResponsesConfig): Provider {
       // The cache affinity key. Without one the backend spreads a
       // conversation's turns across cache shards, and a re-sent prefix misses.
       if (opts.sessionId) request.prompt_cache_key = opts.sessionId;
+      const serviceTier = opts.serviceTier ?? config.serviceTier;
+      if (serviceTier) request.service_tier = serviceTier;
       // Muse Contributor accepts only `auto`. `none` has an exact wire-level
       // equivalent: send no tools. Required/named choices stay explicit and let
       // the endpoint refuse a promise it cannot keep.
@@ -421,6 +462,11 @@ export function createResponsesProvider(config: ResponsesConfig): Provider {
       let sawToolCall = false;
       let wall: ProviderError | undefined;
       let produced = false;
+      const reasoningItems: unknown[] = [];
+      const reasoningChunk = (): ProviderChunk[] =>
+        reasoningItems.length
+          ? [{ type: "delta", reasoningItems: { provider: id, items: reasoningItems } }]
+          : [];
 
       for await (const data of streamSse({
         url: apiUrl(baseUrl, config.path ?? DEFAULT_PATH),
@@ -522,6 +568,12 @@ export function createResponsesProvider(config: ResponsesConfig): Provider {
 
           case "response.output_item.done": {
             const item = event.item;
+            // Kept whole and emitted once, at the end of the turn: it is the
+            // backend's own record, and it only means something complete.
+            if (config.replayReasoning && item?.type === "reasoning") {
+              reasoningItems.push(item);
+              break;
+            }
             if (item?.type !== "function_call") break;
             const known = pendingFor(item.id, item.call_id);
             if (item.id) pending.delete(item.id);
@@ -583,6 +635,7 @@ export function createResponsesProvider(config: ResponsesConfig): Provider {
             if (response?.status === "failed" || response?.error) {
               throw streamError(id, response.error ?? { message: "response failed" });
             }
+            yield* reasoningChunk();
             if (response?.usage) yield usageChunk(response.usage);
             if (response?.status === "incomplete") {
               yield {
@@ -602,6 +655,7 @@ export function createResponsesProvider(config: ResponsesConfig): Provider {
           case "response.incomplete": {
             // A turn that ran out of output tokens still billed for its input,
             // and this event carries usage in the same shape as `completed`.
+            yield* reasoningChunk();
             const usage = event.response?.usage;
             if (usage) yield usageChunk(usage);
             yield {

package/src/types.ts

@@ -108,6 +108,14 @@ export type ChatMessage =
        * continuity across a tool round. Absent on every other dialect.
        */
       reasoningDetails?: unknown[];
+      /**
+       * The ChatGPT backend's own reasoning items, encrypted, riding back
+       * UNMODIFIED on the next turn so the model keeps its chain of thought.
+       * Tagged with the provider that made them: only that provider replays
+       * them, because another vendor (after a fallback) would reject them.
+       * Opaque, like `reasoningDetails`.
+       */
+      reasoningItems?: ReasoningItems;
       toolCalls?: ToolCall[];
     }
   | {
@@ -119,6 +127,12 @@ export type ChatMessage =
       images?: ImagePart[];
     };
 
+/** Provider-owned reasoning items and the id of the provider that made them. */
+export interface ReasoningItems {
+  provider: string;
+  items: unknown[];
+}
+
 /** JSON Schema for an object — what every provider's tool contract wants. */
 export interface JsonObjectSchema {
   type: "object";
@@ -192,6 +206,8 @@ export interface ProviderChunk {
   /** OpenRouter's normalized reasoning payload — hand it back on the next
    *  turn's assistant message verbatim. See ChatMessage.reasoningDetails. */
   reasoningDetails?: unknown[];
+  /** Once per turn, where a provider replays its reasoning. See ChatMessage.reasoningItems. */
+  reasoningItems?: ReasoningItems;
   toolCalls?: ToolCallDelta[];
   usage?: TokenUsage;
   finishReason?: FinishReason;
@@ -387,8 +403,19 @@ export interface StreamOptions {
    * so it refuses `false` rather than silently ignore it.
    */
   parallelToolCalls?: boolean;
+  /**
+   * Which service tier to buy this call on: `priority` is faster and costs
+   * more, `flex` is slower and costs less. Sent as `service_tier` on the
+   * OpenAI and Responses shapes. Anthropic and Gemini refuse it with an
+   * `invalid` error: Anthropic's own `service_tier` means something else, and
+   * Gemini has no such switch. Overrides the provider's own setting.
+   */
+  serviceTier?: ServiceTier;
 }
 
+// ponytail: Codex's `ultrafast` tier (gpt-6-astra only) is the next value to add.
+export type ServiceTier = "priority" | "flex";
+
 export interface Provider {
   readonly id: string;
   readonly model: string;
@@ -406,6 +433,8 @@ export interface Completion {
   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;
@@ -424,6 +453,7 @@ export async function drainStream(
   // 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"];
@@ -433,6 +463,7 @@ export async function drainStream(
       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) {
@@ -443,6 +474,7 @@ export async function drainStream(
     text,
     reasoning,
     ...(reasoningDetails ? { reasoningDetails } : {}),
+    ...(reasoningItems ? { reasoningItems } : {}),
     usage,
     finishReason,
     model: source?.model ?? model,
@@ -465,11 +497,23 @@ export async function drainStream(
 export function stripReasoning(messages: readonly ChatMessage[]): ChatMessage[] {
   return messages.map((message) => {
     if (message.role !== "assistant") return message;
-    if (message.reasoning === undefined && message.reasoningDetails === undefined) return message;
-    // Both halves go. `reasoningDetails` is the same chain of thought in the
-    // provider's own words, so leaving it behind carries into a thinking-off
-    // turn exactly what stripping `reasoning` was meant to keep out.
-    const { reasoning: _text, reasoningDetails: _payload, ...rest } = message;
+    if (
+      message.reasoning === undefined &&
+      message.reasoningDetails === undefined &&
+      message.reasoningItems === undefined
+    ) {
+      return message;
+    }
+    // Every half goes. `reasoningDetails` and `reasoningItems` are the same
+    // chain of thought in the provider's own words, so leaving them behind
+    // carries into a thinking-off turn exactly what stripping `reasoning` was
+    // meant to keep out.
+    const {
+      reasoning: _text,
+      reasoningDetails: _payload,
+      reasoningItems: _items,
+      ...rest
+    } = message;
     return rest;
   });
 }