@providerkit/core 0.12.1 → 0.12.3

package/dist/types.js

@@ -9,7 +9,10 @@
 /**
  * How hard the model thinks before answering. Absent = the provider's own
  * default (never sent). Passed through verbatim on OpenAI-shape
- * (`reasoning_effort`); mapped to thinking budgets on Anthropic-shape.
+ * (`reasoning_effort`). On Anthropic-shape, mapped to adaptive thinking and
+ * `output_config.effort` for current Claude models, where `none` is the lowest
+ * effort on a model that cannot stop thinking; and to thinking budgets for
+ * Claude 4.5 and older and for every other vendor on that wire.
  * Support varies per model — an unsupported level comes back as a clean 400.
  *
  * Ordered least → most; the type derives from the array so the runtime guard
@@ -25,6 +28,86 @@ export const EMPTY_USAGE = {
     cachedInputTokens: 0,
     outputTokens: 0,
 };
+/**
+ * Read the JSON out of a model's answer. Models wrap it: a ```json fence, an
+ * unmarked fence, a sentence before it, notes after it. This takes the first
+ * fenced block marked `json` or not marked at all. With no such block, it
+ * takes the text from the first `{` or `[` to the bracket that closes it, and
+ * with no bracket either, the whole answer (a bare number, say). Then it
+ * parses that.
+ *
+ * It returns `unknown` on purpose: parsed is not validated, and a model's JSON
+ * has the schema's shape only once the caller has checked it.
+ *
+ * @throws {JsonAnswerError} when that text is not JSON. The error carries the
+ * answer, so a log shows what the model actually said.
+ */
+export function parseJsonAnswer(text) {
+    const candidate = fencedJson(text) ?? bracketed(text);
+    try {
+        return JSON.parse(candidate);
+    }
+    catch (error) {
+        throw new JsonAnswerError(text, error);
+    }
+}
+/** An answer `parseJsonAnswer` found no JSON in. `text` is the answer, cut to
+ *  2,000 characters like a provider's error body; `cause` is the SyntaxError. */
+export class JsonAnswerError extends Error {
+    text;
+    constructor(text, cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        super(`The model's answer is not JSON: ${reason}`, { cause });
+        this.name = "JsonAnswerError";
+        this.text = text.slice(0, 2_000);
+    }
+}
+/** A fenced block, whose fences count only at the start of a line. A JSON
+ *  string can't hold a raw newline, so no line of JSON starts with a fence, and
+ *  a value carrying one (a code sample) never ends the block early. `[^\S\n]`
+ *  is a space, a tab, or the `\r` of a CRLF line. */
+const FENCED_BLOCK = /^[^\S\n]*```[^\S\n]*([^\s`]*)[^\n]*\n([\s\S]*?)^[^\S\n]*```/gm;
+function fencedJson(text) {
+    for (const [, info = "", body = ""] of text.matchAll(FENCED_BLOCK)) {
+        const language = info.toLowerCase();
+        if (language === "" || language === "json")
+            return body;
+    }
+    return undefined;
+}
+/** From the first `{` or `[` to the bracket that closes it, skipping brackets
+ *  inside strings. An answer cut off before it closes keeps its tail, and
+ *  JSON.parse says what is wrong with it.
+ *
+ *  ponytail: the FIRST opener wins, so prose with a bracket before the JSON
+ *  ("see [1]: {…}") picks the prose's. The upgrade is to try the next opener
+ *  when one fails to parse, once a model that writes that turns up. */
+function bracketed(text) {
+    const start = text.search(/[[{]/);
+    if (start === -1)
+        return text;
+    let depth = 0;
+    let inString = false;
+    for (let i = start; i < text.length; i++) {
+        const char = text[i];
+        if (inString) {
+            if (char === "\\")
+                i++;
+            else if (char === '"')
+                inString = false;
+        }
+        else if (char === '"')
+            inString = true;
+        else if (char === "{" || char === "[")
+            depth++;
+        else if (char === "}" || char === "]") {
+            depth--;
+            if (depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return text.slice(start);
+}
 /** 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, model) {

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,2EAA2E;AAC3E,mEAAmE;AACnE,EAAE;AACF,8EAA8E;AAC9E,8EAA8E;AAC9E,6EAA6E;AAC7E,0BAA0B;AAE1B;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAU,CAAC;AAGzE,2EAA2E;AAC3E,MAAM,UAAU,QAAQ,CAAC,KAAa;IACpC,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,KAAK,KAAK,CAAC,CAAC;AACpD,CAAC;AAqHD,MAAM,CAAC,MAAM,WAAW,GAAe;IACrC,WAAW,EAAE,CAAC;IACd,iBAAiB,EAAE,CAAC;IACpB,YAAY,EAAE,CAAC;CAChB,CAAC;AA6GF;kEACkE;AAClE,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,MAAoC,EACpC,KAAa;IAEb,IAAI,IAAI,GAAG,EAAE,CAAC;IACd,IAAI,SAAS,GAAG,EAAE,CAAC;IACnB,4EAA4E;IAC5E,4EAA4E;IAC5E,yEAAyE;IACzE,6DAA6D;IAC7D,IAAI,gBAAuC,CAAC;IAC5C,IAAI,KAAK,GAAe,WAAW,CAAC;IACpC,IAAI,YAAY,GAAwB,IAAI,CAAC;IAC7C,IAAI,MAA+B,CAAC;IACpC,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACjC,IAAI,KAAK,CAAC,MAAM;YAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QACxC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC3B,IAAI,KAAK,CAAC,OAAO;gBAAE,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC;YACzC,IAAI,KAAK,CAAC,SAAS;gBAAE,SAAS,IAAI,KAAK,CAAC,SAAS,CAAC;YAClD,IAAI,KAAK,CAAC,gBAAgB,EAAE,MAAM;gBAAE,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC;QAChF,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;YACjD,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACtB,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,YAAY,EAAE,CAAC;YACzD,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;QACpC,CAAC;IACH,CAAC;IACD,OAAO;QACL,IAAI;QACJ,SAAS;QACT,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACjD,KAAK;QACL,YAAY;QACZ,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,KAAK;QAC7B,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KACjD,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgC;IAC7D,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;QAC9B,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW;YAAE,OAAO,OAAO,CAAC;QACjD,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,IAAI,OAAO,CAAC,gBAAgB,KAAK,SAAS;YAAE,OAAO,OAAO,CAAC;QAC9F,yEAAyE;QACzE,yEAAyE;QACzE,iEAAiE;QACjE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC;QAC1E,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,SAAS,CAAC,IAAe;IACvC,OAAO,QAAQ,IAAI,CAAC,QAAQ,WAAW,IAAI,CAAC,IAAI,EAAE,CAAC;AACrD,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@providerkit/core",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "The layer under your agent loop: one seam for every LLM provider, plus the failure handling you only learn in production.",
   "type": "module",
   "license": "MIT",

package/src/context.ts

@@ -26,8 +26,8 @@ export function estimateTokens(text: string): number {
 
 function textOf(message: ChatMessage): string {
   if (message.role === "user" && typeof message.content !== "string") {
-    // Only the words are countable; an image's cost is the provider's own
-    // arithmetic and no character count approximates it.
+    // Only the words are countable; an image's or a file's cost is the
+    // provider's own arithmetic and no character count approximates it.
     return message.content.map((part) => (part.type === "text" ? part.text : "")).join("");
   }
   return typeof message.content === "string" ? message.content : "";

package/src/errors.ts

@@ -11,6 +11,7 @@
 // empty balance, "check your key" for a plan that never included the API).
 
 import { parseUsageLimitBody, type RateLimitWindow } from "./rate-limit.ts";
+import type { FilePart } from "./types.ts";
 
 /** What kind of failure this is, named by what actually fixes it. */
 export type ErrorKind =
@@ -691,3 +692,18 @@ export function describeProviderError(err: unknown): Record<string, unknown> {
   }
   return { error: messageOf(err), kind: classify(err) };
 }
+
+/**
+ * A file part on a wire that cannot carry one. Refused, never dropped: a
+ * dropped attachment is a model answering about a file it never saw, on the
+ * happy path, where nothing retries and nothing logs. `adapter` names the
+ * wire, because `provider` is often a gateway's id rather than the shape's.
+ */
+export function fileRefused(provider: string, adapter: string, part: FilePart): ProviderError {
+  return new ProviderError(
+    provider,
+    "invalid",
+    `${provider}: the ${adapter} adapter can't send a file (${part.mimeType}). Only the Gemini ` +
+      "adapter takes files. Send this request to a Gemini model, or leave the file out.",
+  );
+}

package/src/presets.ts

@@ -56,8 +56,9 @@ export interface ProviderPreset {
    *  `thinking: { type: "disabled" }` marker when effort is none. For
    *  endpoints where an ABSENT field means the model's default — thinking ON
    *  for reasoning-mandatory models (measured on Z.ai's coding endpoint:
-   *  omit → thinking block; disabled → none). Native Anthropic defaults to
-   *  off when the field is absent and must stay unset. */
+   *  omit → thinking block; disabled → none). Leave it unset for native
+   *  Anthropic: the adapter spells none per Claude model, and ignores this
+   *  flag for every Claude from 4.6 on. */
   explicitNone?: boolean;
   /** Output ceiling when the caller sets none. Thinking and the answer share
    *  it, so a model that reasons past the adapter's default ends the turn with

package/src/providers/anthropic.ts

@@ -1,5 +1,5 @@
 // Anthropic-shape adapter — SSE from POST /v1/messages.
-import { streamError } from "../errors.ts";
+import { fileRefused, streamError } from "../errors.ts";
 import { schemaPrompt, toAnthropicToolSchema } from "../schema.ts";
 import { parseToolArgs } from "../tool-args.ts";
 import { streamSse, apiUrl } from "../transport.ts";
@@ -55,9 +55,10 @@ export interface AnthropicConfig extends ProviderFallbackConfig {
    *  where an absent field means the MODEL's default, not off — Z.ai's coding
    *  endpoint reads silence as thinking ON for reasoning-mandatory models like
    *  GLM 5.3 Flash (measured 2026-09-13: omit → thinking block; disabled →
-   *  none), and it accepts the marker natively. Native Anthropic has no such
-   *  marker and defaults to off when the field is absent, so leave this unset
-   *  there. */
+   *  none), and it accepts the marker natively. Ignored for a Claude id that
+   *  thinks adaptively (4.6 and later): each has its own spelling of none (see
+   *  `CLAUDE_THINKING`), and several reject this marker outright. Claude 4.5
+   *  and older accept it, and get it. */
   explicitNone?: boolean;
 }
 
@@ -67,9 +68,10 @@ const DEFAULT_VERSION = "2023-06-01";
 const DEFAULT_MAX_TOKENS = 8_192;
 
 /**
- * Thinking budgets, in output tokens. Thinking and the answer SHARE
- * `max_tokens`, so a budget is always left below the ceiling — a budget at or
- * above it leaves no room to answer, and the turn ends mid-thought.
+ * Thinking budgets, in output tokens, for extended thinking — Claude 4.5 and
+ * older, and every non-Claude endpoint on this wire. Thinking and the answer
+ * SHARE `max_tokens`, so a budget is always left below the ceiling — a budget
+ * at or above it leaves no room to answer, and the turn ends mid-thought.
  */
 const THINKING_BUDGET: Record<Exclude<Effort, "none">, number> = {
   low: 2_048,
@@ -78,6 +80,98 @@ const THINKING_BUDGET: Record<Exclude<Effort, "none">, number> = {
   max: 32_768,
 };
 
+/** How one Claude model that thinks adaptively takes `effort`. */
+interface ClaudeThinking {
+  /** How `effort: "none"` is said: nothing, an explicit off, or the lowest
+   *  effort where there is no off to ask for. */
+  none: "omit" | "disabled" | "low";
+  /** Whether a non-default temperature or top_p survives while thinking is off. */
+  sampling: boolean;
+}
+
+const ALWAYS_ON: ClaudeThinking = { none: "low", sampling: false };
+
+/**
+ * Claude models that take adaptive thinking, keyed by id. A graded effort is
+ * said the same way on all of them — `thinking: { type: "adaptive" }` plus
+ * `output_config.effort` — which every one accepts, and which the docs say to
+ * use wherever a model also takes `budget_tokens`. What differs is `none`,
+ * because what each model does when told nothing differs. Documented (Anthropic per-model table, read
+ * 2026-09-27: platform.claude.com/docs/en/build-with-claude/thinking-troubleshooting);
+ * none of it was measured live.
+ *
+ * `sampling: false` marks the models where a non-default temperature, top_p or
+ * top_k is a 400 on every request, thinking or not. Documented on the same date
+ * (…/build-with-claude/thinking, "Sampling parameters").
+ */
+const CLAUDE_THINKING: ReadonlyMap<string, ClaudeThinking> = new Map([
+  // Always on: `enabled` and `disabled` are both 400s (Mythos Preview still
+  // takes `enabled`), so there is no off to ask for. `none` is the lowest
+  // effort rather than silence, because silence runs the model's own default —
+  // `high`, or `medium` on Opus 5.5 — which is the request `none` exists to
+  // refuse (invariant 12).
+  ["claude-fable-5-1", ALWAYS_ON],
+  ["claude-mythos-5-1", ALWAYS_ON],
+  ["claude-fable-5", ALWAYS_ON],
+  ["claude-mythos-5", ALWAYS_ON],
+  ["claude-mythos-preview", ALWAYS_ON],
+  ["claude-opus-5-5", ALWAYS_ON],
+  // On by default, and `disabled` is accepted at effort high or below. `none`
+  // still says `low`: with thinking disabled, Opus 5 occasionally writes a tool
+  // call into its visible text instead of a tool_use block, most often on
+  // tool-heavy work (documented, same page). That call never runs and nothing
+  // errors, so the turn reads as a clean answer — a failure on the happy path,
+  // in exactly the loop this package sits under. Anthropic's own advice is to
+  // keep thinking on and lower effort; at `low` the model can still skip
+  // thinking on a turn it judges simple.
+  ["claude-opus-5", ALWAYS_ON],
+  // On by default; `disabled` is accepted, with no such warning attached.
+  ["claude-sonnet-5", { none: "disabled", sampling: false }],
+  // Off by default, so saying nothing already is none.
+  ["claude-opus-4-8", { none: "omit", sampling: false }],
+  ["claude-opus-4-7", { none: "omit", sampling: false }],
+  // These still take `budget_tokens`, deprecated. Adaptive is the mode the docs
+  // say to use where both exist, and it drops extended mode's rule that the
+  // final assistant turn open with a thinking block — which this adapter,
+  // replaying no thinking, can never satisfy.
+  ["claude-opus-4-6", { none: "omit", sampling: true }],
+  ["claude-sonnet-4-6", { none: "omit", sampling: true }],
+]);
+
+/** Claude 4.5 and everything before it: extended thinking only (`adaptive` is
+ *  a 400), off by default. The budget dialect below was written for these. */
+const CLAUDE_EXTENDED_ONLY = /^claude-(3-|(opus|sonnet|haiku)-4(-[0-5])?$)/;
+
+/**
+ * The adaptive-thinking rule for a Claude id, or `undefined` for every id that
+ * keeps the budget dialect: Claude 4.5 and older, and every other vendor's
+ * model on this wire (their endpoints' dialects are their own).
+ *
+ * An id that starts with `claude-` but is in neither list is a Claude newer
+ * than this table, and it is treated as always on. Every Claude since Opus 4.7
+ * rejects `enabled`; the newest reject `disabled` too; and `output_config.effort`
+ * is accepted by every model that thinks adaptively. So an unknown id gets the
+ * one request none of them has refused, and no sampling fields, since every
+ * Claude since Opus 4.7 answers a non-default one with a 400. A model that
+ * turns out to differ will say so with a 400 of its own, and earn a row.
+ */
+function claudeThinking(model: string): ClaudeThinking | undefined {
+  if (!model.startsWith("claude-")) return undefined;
+  const family = model.replace(/-\d{8}$/, ""); // a dated snapshot is its family
+  if (CLAUDE_EXTENDED_ONLY.test(family)) return undefined;
+  return CLAUDE_THINKING.get(family) ?? ALWAYS_ON;
+}
+
+/** Whether a request continues a tool loop: its last assistant message made
+ *  tool calls, so the request carries their results inside the same turn. */
+function continuesToolLoop(messages: readonly ChatMessage[]): boolean {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role === "assistant") return (message.toolCalls?.length ?? 0) > 0;
+  }
+  return false;
+}
+
 function mapStopReason(reason: string | undefined): FinishReason | undefined {
   switch (reason) {
     case "end_turn":
@@ -94,16 +188,16 @@ function mapStopReason(reason: string | undefined): FinishReason | undefined {
   }
 }
 
-function partsToAnthropic(content: string | ContentPart[]): unknown[] {
+function partsToAnthropic(content: string | ContentPart[], provider: string): unknown[] {
   if (typeof content === "string") return [{ type: "text", text: content }];
-  return content.map((part) =>
-    part.type === "text"
-      ? { type: "text", text: part.text }
-      : {
-          type: "image",
-          source: { type: "base64", media_type: part.mimeType, data: part.data },
-        },
-  );
+  return content.map((part) => {
+    if (part.type === "text") return { type: "text", text: part.text };
+    if (part.type === "file") throw fileRefused(provider, "Anthropic", part);
+    return {
+      type: "image",
+      source: { type: "base64", media_type: part.mimeType, data: part.data },
+    };
+  });
 }
 
 /**
@@ -145,7 +239,10 @@ function jsonBlock(json: JsonOutput): unknown {
   return { type: "text", text: schemaPrompt(json.schema) };
 }
 
-export function toAnthropicMessages(messages: readonly ChatMessage[]): {
+export function toAnthropicMessages(
+  messages: readonly ChatMessage[],
+  provider = "anthropic",
+): {
   system?: unknown[];
   messages: unknown[];
 } {
@@ -164,7 +261,7 @@ export function toAnthropicMessages(messages: readonly ChatMessage[]): {
   for (const message of messages) {
     if (message.role === "system") continue;
     if (message.role === "user") {
-      pushBlocks("user", partsToAnthropic(message.content));
+      pushBlocks("user", partsToAnthropic(message.content, provider));
       continue;
     }
     if (message.role === "tool") {
@@ -243,8 +340,8 @@ export function createAnthropicProvider(config: AnthropicConfig): Provider {
     ): AsyncIterable<ProviderChunk> {
       const model = opts.model ?? config.model;
       const maxTokens = opts.maxTokens ?? config.maxTokens ?? DEFAULT_MAX_TOKENS;
-      const effort = opts.effort ?? config.effort ?? "none";
-      const { system, messages: body } = toAnthropicMessages(messages);
+      const effort = opts.effort ?? config.effort;
+      const { system, messages: body } = toAnthropicMessages(messages, id);
 
       const request: Record<string, unknown> = {
         model,
@@ -272,15 +369,47 @@ export function createAnthropicProvider(config: AnthropicConfig): Provider {
               ? { type: "any" }
               : { type: "tool", name: opts.toolChoice.name };
       }
-      if (effort !== "none") {
+      const claude = claudeThinking(model);
+      // Extended mode, which is all Claude 4.5 and older have, can't think on
+      // two kinds of request this adapter sends, so those run without thinking.
+      // Documented (Anthropic Thinking page, read 2026-09-27):
+      // - One that continues a tool loop. A thinking request's final assistant
+      //   turn must open with a thinking block, and this adapter sends none back
+      //   (see toAnthropicMessages). Turning thinking off mid-turn is documented
+      //   not to error, and the next user turn thinks again.
+      // - One whose tool choice forces a tool: `any` or `tool` "results in an
+      //   error because these options force tool use, which is incompatible with
+      //   manual extended thinking." The caller asked for the tool, so it wins.
+      // ponytail: every loop step after the first goes unthought on these
+      // models. The upgrade is replaying the signed thinking blocks.
+      const forcesTool = opts.toolChoice === "required" || typeof opts.toolChoice === "object";
+      const unthought =
+        !claude && model.startsWith("claude-") && (forcesTool || continuesToolLoop(messages));
+      if (claude) {
+        // An effort the caller never set sends nothing: the model keeps its own
+        // default, which on most of these is thinking ON.
+        if (effort === "none") {
+          if (claude.none === "disabled") request.thinking = { type: "disabled" };
+          if (claude.none === "low") request.output_config = { effort: "low" };
+        } else if (effort) {
+          request.thinking = { type: "adaptive" };
+          request.output_config = { effort };
+        }
+        const thinking = effort !== undefined && effort !== "none";
+        if (thinking || !claude.sampling) {
+          delete request.temperature;
+          delete request.top_p;
+        }
+      } else if (effort && effort !== "none" && !unthought) {
         const budget = Math.min(THINKING_BUDGET[effort], Math.floor(maxTokens * 0.8));
         request.thinking = { type: "enabled", budget_tokens: budget };
         // Thinking and sampling are mutually exclusive on this shape.
         delete request.temperature;
         delete request.top_p;
       } else if (config.explicitNone) {
-        // The one dialect where silence means the model default — which is ON
-        // for a reasoning-mandatory model — so "none" has to be said out loud.
+        // Z.ai's coding endpoint: silence means the model default — which is
+        // ON for a reasoning-mandatory model — so "none" has to be said out
+        // loud. An effort nobody set reads as none here, as it always has.
         request.thinking = { type: "disabled" };
       }
 

package/src/providers/gemini.ts

@@ -147,6 +147,8 @@ export function toGeminiContents(messages: readonly ChatMessage[]): {
         break;
 
       case "user":
+        // An image and a file ride the same way, as bytes and their media
+        // type. This is the one wire that takes a file.
         contents.push({
           role: "user",
           parts:

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 { streamError } from "../errors.ts";
+import { fileRefused, streamError } from "../errors.ts";
 import { streamSse, apiUrl } from "../transport.ts";
 import { attributionHeaders } from "../attribution.ts";
 import type {
@@ -151,25 +151,66 @@ export function openRouterHostFor(baseUrl: string, model: string): string | unde
  *  adapter. `off` sends nothing and leaves the model on its own default. */
 export type EffortDialect = "openai" | "openrouter" | "deepseek" | "off";
 
+/**
+ * How `none` is said on OpenRouter, per model id: the `reasoning.effort` that
+ * turns the model's thinking off, or the lowest measured one where every off
+ * is refused.
+ *
+ * An id that is not listed sends nothing, and that default is the point. An
+ * explicit off is a 400 on a model whose reasoning is mandatory: GLM 5.3 Flash
+ * and gpt-5-mini both answer "Reasoning is mandatory for this endpoint and
+ * cannot be disabled." So a universal off would break every call to one. An
+ * omitted field only costs reasoning tokens, and only on a model that thinks by
+ * default. So an id gets a row once it is measured both ways: with the field
+ * omitted, and with the spelling in its row.
+ *
+ * An adopter's matrix, 2026-09-27: one pinned host per model
+ * (`allow_fallbacks: false`), two runs per cell, reasoning tokens with the
+ * field omitted and with each of three offs (top-level `reasoning_effort:
+ * "none"`, `reasoning.effort: "none"`, `reasoning.enabled: false`).
+ *
+ * - GLM 5.3 Flash @Together: 516, and 2,000 (cut off at `max_tokens`), with
+ *   the field omitted. Every off was a 400. In the 2026-09-26 sweep (a
+ *   production classify body sent to each of 28 hosts alone), 18 hosts thought
+ *   with the field omitted (a 2026-09-14 reading, host unknown, saw no
+ *   thinking), and `low` gave 0 reasoning tokens on every host that answered
+ *   it but Sail Research (1) and Wafer (inverted: about 420 with `low`, 1
+ *   omitted).
+ * - gpt-5-mini @OpenAI: 320 and 320 with the field omitted, and every off was
+ *   a 400. A follow-up the same day, same host, two runs: `minimal` gave 0 and
+ *   0 (48 and 50 output tokens), `low` 64 and 64. So `minimal` is its floor.
+ *   Only this exact id: gpt-5 and gpt-5-nano were not measured.
+ * - MiMo v2.6 Flash @Xiaomi: 57 and 47 with the field omitted (103–151
+ *   @DeepInfra in the 2026-09-26 sweep), 0 with every off. Its row names
+ *   `none`, so the table varies one field.
+ * - Not listed, on purpose. DeepSeek V4 Flash @DeepInfra: 0 in every cell, and
+ *   the 2026-09-26 sweep saw it think at `low`. Gemini 2.5 Flash and Flash
+ *   Lite @AI Studio: 0 in every cell.
+ */
+const OPENROUTER_NONE: ReadonlyMap<string, "low" | "minimal" | "none"> = new Map([
+  ["z-ai/glm-5.3-flash", "low"],
+  ["openai/gpt-5-mini", "minimal"],
+  ["xiaomi/mimo-v2.6-flash", "none"],
+]);
+
 /**
  * Effort → the request fields THIS endpoint accepts.
  *
  * One knob, three incompatible spellings, and the differences are not cosmetic:
  *
- * - **On OpenRouter, GLM's off switch is the ABSENT field.** Not setting
- *   `reasoning` at all disables thinking for GLM 5.3 Flash (measured live
- *   2026-09-14). Naming a level raises it — the accepted values are
- *   `low`, `high` and `max` (`medium` and `xhigh` are accepted too, but our
- *   vocabulary has no use for them). `none` is NOT sendable there: the model
- *   answers
- *   `400 "Reasoning is mandatory for this endpoint and cannot be disabled."`
- *   to `reasoning.effort: "none"` exactly as it does to
- *   `reasoning.enabled: false` — so "do not think" on this dialect is said by
- *   omitting the field, never by naming a level. See `effortParams`, where the
- *   numbers live.
- * - **DeepSeek V4 defaults thinking ON**, so `none` has to be an explicit
- *   refusal. That is the case proving OpenRouter's absent-field off switch is
- *   a real dialect fact and not a preference for always thinking.
+ * - **On OpenRouter, "do not think" has no spelling that works on every
+ *   model.** GLM 5.3 Flash and gpt-5-mini answer every explicit off with
+ *   `400 "Reasoning is mandatory for this endpoint and cannot be disabled."`,
+ *   MiMo v2.6 Flash takes one, and DeepSeek V4 Flash thinks at `low` and not
+ *   with the field omitted. So `none` is said per model, from
+ *   `OPENROUTER_NONE`, which also says why an unlisted model gets nothing.
+ *   Naming a level raises it — the accepted values are `low`, `high` and
+ *   `max` (`medium` and `xhigh` are accepted too, but our vocabulary has no
+ *   use for them).
+ * - **DeepSeek V4 defaults thinking ON** on its own API, so `none` has to be an
+ *   explicit refusal there. The same word is a different request on each
+ *   dialect, and on OpenRouter on each model: the spelling belongs to the
+ *   endpoint, never to the caller.
  * - **OpenAI** takes `reasoning_effort`, and `none` is one of its values — not
  *   the absence of the field. GPT-5.1 both accepted `none` and made it the
  *   default; everything from GPT-5 back still defaults to `medium`. So sending
@@ -178,15 +219,19 @@ export type EffortDialect = "openai" | "openrouter" | "deepseek" | "off";
  *   answer. A capped turn then spends its whole allowance thinking and returns
  *   empty with `finish_reason: "length"`.
  *
- * An absent effort sends nothing on every dialect: the seam's rule is that a
- * knob the caller never touched is a knob the provider still owns. On
- * OpenRouter that makes `none` and "never asked" the same request — on this
- * dialect, not thinking IS the default state, so there is no third spelling
- * to invent.
+ * An absent effort sends nothing on every dialect and for every model: the
+ * seam's rule is that a knob the caller never touched is a knob the provider
+ * still owns. On OpenRouter that makes `none` and "never asked" the same
+ * request for every model outside `OPENROUTER_NONE`, and a different one for
+ * the models in it.
+ *
+ * `model` is the id the request names. Without it, `none` on OpenRouter sends
+ * nothing, as it always has.
  */
 export function effortParams(
   dialect: EffortDialect,
   effort: Effort | undefined,
+  model?: string,
 ): Record<string, unknown> {
   if (!effort) return {};
   const level = effort === "max" ? "high" : effort === "none" ? null : effort;
@@ -202,19 +247,22 @@ export function effortParams(
         ? { thinking: { type: "enabled" } }
         : { thinking: { type: "enabled" }, reasoning_effort: level };
     case "openrouter":
-      // GLM's off switch here is the ABSENT field (measured live 2026-09-14:
-      // omit `reasoning` → thinking disabled for glm-5.3-flash), so `none`
-      // sends nothing — the same request as a caller who never asked, which on
-      // this dialect is the same state. Naming a level RAISES it: the accepted
-      // values are low, high and max (`medium` and `xhigh` exist on the wire
+      // `none` is said per model (see OPENROUTER_NONE): an explicit off where
+      // one was measured to work, the lowest measured level where every off is
+      // a 400, and nothing for a model nobody measured. Naming a level RAISES
+      // it: the accepted values are low, high and max (`medium`, `xhigh` and
+      // `minimal` exist on the wire too; `minimal` rides only as a row's none).
       // The refusal that once looked like "OpenRouter cannot be told not to
-      // think" was `reasoning.enabled: false` — a different field, never sent
-      // (pinned by the test below).
+      // think" was `reasoning.enabled: false` — never sent (pinned by the test
+      // below).
       //
       // `max` rides verbatim here — the enum clamp below is DeepSeek/OpenAI's
       // shape (DeepSeek auto-bumps past its own top, OpenAI's top IS high);
       // OpenRouter takes `max` as named (measured live 2026-09-14).
-      return effort === "none" ? {} : { reasoning: { effort } };
+      if (effort !== "none") return { reasoning: { effort } };
+      return model !== undefined && OPENROUTER_NONE.has(model)
+        ? { reasoning: { effort: OPENROUTER_NONE.get(model) } }
+        : {};
     case "openai":
       return { reasoning_effort: level ?? "none" };
     case "off":
@@ -246,13 +294,13 @@ function mapFinishReason(reason: string | null | undefined): FinishReason | unde
   }
 }
 
-function partsToOpenAI(content: string | ContentPart[]): unknown {
+function partsToOpenAI(content: string | ContentPart[], provider: string): unknown {
   if (typeof content === "string") return content;
-  return content.map((part) =>
-    part.type === "text"
-      ? { type: "text", text: part.text }
-      : { type: "image_url", image_url: { url: toDataUri(part) } },
-  );
+  return content.map((part) => {
+    if (part.type === "text") return { type: "text", text: part.text };
+    if (part.type === "file") throw fileRefused(provider, "OpenAI", part);
+    return { type: "image_url", image_url: { url: toDataUri(part) } };
+  });
 }
 
 /**
@@ -261,7 +309,7 @@ function partsToOpenAI(content: string | ContentPart[]): unknown {
  * made a tool call. A caller running a turn with thinking OFF must strip it
  * first (`stripReasoning`); the two cannot be mixed.
  */
-export function toOpenAIMessages(messages: readonly ChatMessage[]): unknown[] {
+export function toOpenAIMessages(messages: readonly ChatMessage[], provider = "openai"): unknown[] {
   const out: unknown[] = [];
   for (const message of messages) {
     switch (message.role) {
@@ -270,7 +318,7 @@ export function toOpenAIMessages(messages: readonly ChatMessage[]): unknown[] {
         break;
 
       case "user":
-        out.push({ role: "user", content: partsToOpenAI(message.content) });
+        out.push({ role: "user", content: partsToOpenAI(message.content, provider) });
         break;
 
       case "tool":
@@ -404,7 +452,7 @@ export function createOpenAIProvider(config: OpenAIConfig): Provider {
       const effort = opts.effort ?? config.effort;
       const model = opts.model ?? config.model;
 
-      const body = toOpenAIMessages(messages);
+      const body = toOpenAIMessages(messages, id);
       const request: Record<string, unknown> = {
         model,
         messages: body,
@@ -418,7 +466,7 @@ 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;
-      Object.assign(request, effortParams(config.effortDialect ?? dialectFor(id), effort));
+      Object.assign(request, effortParams(config.effortDialect ?? dialectFor(id), effort, model));
       if (tools.length > 0) {
         request.tools = tools.map((tool) => ({
           type: "function",