@qjp88995/provider-client 0.0.0-stage → 0.1.0

package/src/vendors/minimax.adapter.ts

@@ -0,0 +1,193 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { type LanguageModel, wrapLanguageModel } from 'ai';
+
+import type { LlmProtocol } from '../types.js';
+import {
+  COMPATIBLE_RESPONSES_OPTIONS,
+  createResponsesModel,
+  responsesDefaultsMiddleware,
+} from './openai-responses.js';
+import { withReasoningTextResponsesShim } from './responses-reasoning-text-shim.js';
+import {
+  type CreateModelInput,
+  LlmVendorAdapter,
+  type ProviderOptions,
+  type ReasoningEffort,
+  unsupportedProtocol,
+} from './vendor-adapter.js';
+
+/**
+ * 工厂 `name`。决定 provider id（`minimax.chat`）与 providerOptions 的命名空间
+ * key（单词无连字符，`name` 与 `toCamelCase(name)` 相同），恰好等于 `kind`，
+ * 基类默认的 `optionsKey` 直接可用。
+ */
+const FACTORY_NAME = 'minimax';
+
+/**
+ * responses 协议下每次调用都必须带上的两项 providerOptions（挂法与方舟同一个
+ * 中间件，理由见 `responsesDefaultsMiddleware`）：
+ *
+ *   - **`store: false`**：文档的 `InputItem.type` 只有 `message / function_call /
+ *     function_call_output / reasoning` 四种，**没有 `item_reference`**；SDK 在
+ *     `store` 为 true（默认）时把上一轮带 itemId 的 assistant 正文发成
+ *     `{type:'item_reference', id}`，多步工具回环第二步就会撞上它。
+ *   - **`reasoningSummary: null`**：文档的 `reasoning` 对象只有 `effort` 一个键；
+ *     SDK 对推理模型默认附带 `reasoning.summary:'detailed'`。它认不认未知键
+ *     没有探过，方舟对同一个键是 400——传 null 让 SDK 整个不发，反正推理正文
+ *     由垫片从 `content[{reasoning_text}]` 里取，`summary` 我们不需要。
+ */
+export const MINIMAX_RESPONSES_DEFAULTS = {
+  store: false,
+  reasoningSummary: null,
+} as const;
+
+/**
+ * chat-completions 每次请求都必须带 `reasoning_split: true`。
+ *
+ * MiniMax 的 OpenAI 兼容面默认把思考**塞进 `content`**、用 `<think>…</think>`
+ * 包着（文档 guides/text-m3-function-call「原生格式」一节）：SDK 会把它当正文吐成
+ * text part，对话页里整段思考混在回答里、存下来的产出也会带着标签，而且投影层回传历史
+ * 时那段也跟着当正文发回去。开了这个开关，思考走 `reasoning_content`（SDK 原生
+ * 读的字段）+ `reasoning_details`（结构化，SDK 忽略）。**它不开关思考本身**，
+ * 只决定输出格式，所以与档位无关、与模型行有没有标 `reasoning` 也无关——
+ * 放在工厂的 `transformRequestBody` 里，而不是 `reasoning()`。
+ */
+export function withReasoningSplit(
+  body: Record<string, unknown>
+): Record<string, unknown> {
+  return { ...body, reasoning_split: true };
+}
+
+/**
+ * MiniMax（M 系：MiniMax-M3 / M2.7 / M2.5 / M2.1 / M2 及各 highspeed 版）。
+ *
+ * **AI SDK 没有它的官方 provider**（社区包跟不上大版本，不接）。承载包与智谱、方舟
+ * 同一套：chat-completions 走 `@ai-sdk/openai-compatible`（私有的 `thinking` /
+ * `reasoning_split` 靠它把未知键展开进请求体，`reasoning_content` 是它原生读的
+ * 字段），responses 走 `@ai-sdk/openai` + 「推理正文走 `reasoning_text`」的共享垫片。
+ * 文档还推荐 Anthropic 兼容面（`/anthropic`，支持 thinking 块与 interleaved
+ * thinking），本仓尚无 `anthropic-messages` 分支，先不接。
+ *
+ * 全部判据来自 2026-09-10 抓的官方文档（`platform.minimaxi.com/docs/llms.txt`
+ * 下 api-reference/text-chat-openai、responses-create、models/openai/list-models、
+ * guides/text-m3-function-call），**没有真 key 探针**——文档没写明的地方在各处注释
+ * 里标了「未探」，接真 key 后先跑一遍 `minimax.sdk-contract.spec.ts` 里列的探针项：
+ *
+ *   - **chat 的推理开关只有开/关，没有档位**：`thinking:{type:'disabled'|'adaptive'}`，
+ *     省略 = adaptive（默认开着推理，「不发 ≠ 关闭」在这家同样成立）。M3 才关得掉，
+ *     M2.x「thinking 无法关闭」——但 `disabled` 对 M2.x 是**被接受后忽略**（文档
+ *     原话「仍会保持开启」），不是 400，所以不按模型名分支。chat 面没有
+ *     `reasoning_effort` 参数，我们的五个非 off 档位一律 adaptive（如实反映：
+ *     这家不提供推理深度控制）。
+ *   - **responses 的默认值与 chat 相反**：`reasoning.effort` 省略 = `none`（关），
+ *     `minimal/low/medium/high` 都收、但「不会调节推理深度」；M2.x 同样关不掉。
+ *     `off` → `none` 是真正的关闭指令；`max` → `high`（它的枚举没有 max）。
+ *   - 响应侧：chat 开了 `reasoning_split` 后是 `message.reasoning_content` /
+ *     `delta.reasoning_content`（文档只给了非流式的字段说明，流式 delta 里叫什么
+ *     **未探**，按各家通例假定同名）；responses 的 reasoning item 是
+ *     `content:[{type:'reasoning_text'}]` + `summary`（文档 OutputItem），与
+ *     DeepSeek / 智谱同形，流式事件名文档没给（未探），垫片对原生 summary 事件
+ *     本就不动，两种形状都落得了位。
+ *   - **交错思维链的回传**：文档要求把 `reasoning_details` 完整回传给下一轮，否则
+ *     思维链「被打断」；SDK 回传的是 `reasoning_content`（3.0.35 dist:284）。这家
+ *     认不认 `reasoning_content` 作为输入**未探**——认则零改动，不认也只是降质
+ *     （文档说的是「发挥最佳性能」），不是失败。探明不认再在 `transformRequestBody`
+ *     里把它改写成 `reasoning_details:[{type:'reasoning.text', text}]`。
+ *   - `temperature` 范围 chat `[0, 2]`、responses `(0, 1]`；`top_p` `[0, 1]`。
+ *     `sampling` 只有「发不发」的粒度，responses 那条上限靠运营录参数时自觉。
+ *   - `max_tokens` 已弃用、改 `max_completion_tokens`；本仓刻意不传输出上限，
+ *     SDK 也就不会发旧参数。
+ *   - `GET /v1/models` 是标准 OpenAI 形状（`{object:'list', data:[{id}]}`），
+ *     默认目录逻辑直接可用；文档没有余额接口（账户 FAQ 只讲充值与预警），
+ *     中心不查余额。
+ *   - 错误在 200 里也可能带 `base_resp.status_code`（1004 鉴权 / 1008 余额不足 /
+ *     2013 参数错误…）——**未探**它对 OpenAI 兼容面是否改用标准 HTTP 状态码；
+ *     若真是 200 + base_resp，SDK 会当成一条空回复静默过去，那时要加响应垫片。
+ */
+export class MiniMaxAdapter extends LlmVendorAdapter {
+  readonly kind = 'minimax' as const;
+
+  override readonly supportedProtocols: readonly LlmProtocol[] = [
+    'openai-chat-completions',
+    'openai-responses',
+  ];
+
+  createModel(input: CreateModelInput): LanguageModel {
+    switch (input.protocol) {
+      case 'openai-chat-completions': {
+        const { baseUrl, apiKey, modelId, fetch } = input;
+        return createOpenAICompatible({
+          name: FACTORY_NAME,
+          baseURL: baseUrl,
+          apiKey,
+          fetch,
+          transformRequestBody: withReasoningSplit,
+        })(modelId);
+      }
+      case 'openai-responses':
+        return wrapLanguageModel({
+          model: createResponsesModel(
+            input,
+            withReasoningTextResponsesShim(input.fetch)
+          ) as Exclude<LanguageModel, string>,
+          middleware: responsesDefaultsMiddleware(MINIMAX_RESPONSES_DEFAULTS),
+        });
+      default:
+        throw unsupportedProtocol(this, input.protocol);
+    }
+  }
+
+  /**
+   * **chat-completions**：`off` 发显式的 `thinking:{type:'disabled'}`（它默认
+   * adaptive，「不发 ≠ 关闭」）；非 off 一律 `thinking:{type:'adaptive'}`——这家
+   * 没有档位参数，五档压成一档是如实反映而不是漏了映射。绝不发 `reasoning_effort`：
+   * 它不在文档的参数表里，2013「参数错误」的风险不值得赌。
+   *
+   * **responses**：只发 `reasoning.effort`，`off`→`none`（文档：关闭推理输出，
+   * 也是它的默认值）；`minimal/low/medium/high` 原生都收、直通；`max`→`high`。
+   * key 随承载包换成 `openai`，带 `COMPATIBLE_RESPONSES_OPTIONS`（不带则 SDK 按
+   * 模型名判成非推理模型、`reasoning` 整个不发——这家 responses 默认是关的，
+   * 所以后果是「档位调了没反应」而不是「关不掉」，同样静默）。`store:false` /
+   * `reasoningSummary:null` 由中间件兜底，这里不重复。
+   */
+  override reasoning(
+    _modelId: string,
+    effort: ReasoningEffort,
+    protocol: LlmProtocol
+  ): ProviderOptions {
+    switch (protocol) {
+      case 'openai-chat-completions':
+        return {
+          [this.optionsKey]: {
+            thinking: { type: effort === 'off' ? 'disabled' : 'adaptive' },
+          },
+        };
+      case 'openai-responses':
+        return {
+          openai: {
+            reasoningEffort: toMiniMaxEffort(effort),
+            ...COMPATIBLE_RESPONSES_OPTIONS,
+          },
+        };
+      default:
+        throw unsupportedProtocol(this, protocol);
+    }
+  }
+}
+
+/** 我们的六档 → 它 responses 面文档化的 `none/minimal/low/medium/high`。 */
+function toMiniMaxEffort(
+  effort: ReasoningEffort
+): 'none' | 'minimal' | 'low' | 'medium' | 'high' {
+  switch (effort) {
+    case 'off':
+      return 'none';
+    case 'minimal':
+    case 'low':
+    case 'medium':
+    case 'high':
+      return effort;
+    case 'max':
+      return 'high';
+  }
+}

package/src/vendors/moonshotai.adapter.ts

@@ -0,0 +1,84 @@
+import { createMoonshotAI } from '@ai-sdk/moonshotai';
+import type { LanguageModel } from 'ai';
+
+import type { LlmProtocol } from '../types.js';
+import {
+  assertChatCompletions,
+  type CreateModelInput,
+  LlmVendorAdapter,
+  type ProviderOptions,
+  type ReasoningEffort,
+  type SamplingSupport,
+} from './vendor-adapter.js';
+
+/**
+ * Kimi 的推理开关是**模型级**的三种互斥形态，判据只住在这里
+ * （`referenes/kimi-request.md` 的分模型对照表）：
+ *
+ *   - `effort`：K3 专属。不支持 `thinking`，传入报错；只认顶层 `reasoning_effort`。
+ *   - `forced`：k2.7-code 系列。思考强制开启，传 `thinking:{type:'disabled'}` 报错。
+ *   - `toggle`：k2.5 / k2.6。`thinking` 的 `enabled`/`disabled` 都合法。
+ *
+ * 模型名换了就改这一个函数。`moonshot-v1-*` 那批老模型本就没有推理能力，
+ * 走不到这里（resolver 只对标了 `reasoning` 能力的模型问推理选项）。
+ */
+type ThinkingStyle = 'effort' | 'forced' | 'toggle';
+
+export function moonshotThinkingStyle(modelId: string): ThinkingStyle {
+  const id = modelId.toLowerCase();
+  if (id.startsWith('kimi-k3')) return 'effort';
+  if (id.includes('k2.7-code')) return 'forced';
+  return 'toggle';
+}
+
+export class MoonshotAiAdapter extends LlmVendorAdapter {
+  readonly kind = 'moonshotai' as const;
+
+  /**
+   * **Kimi 全系禁止 temperature/top_p，传参直接返回参数非法**
+   * （`referenes/kimi-request.md` 避坑提示第 1 条；实际值固定 1.0，
+   * k2.5/k2.6 非思考模式为 0.6）。AI SDK 不会替我们挡——实测
+   * `generateText({temperature:0.7})` 会原样发出 `"temperature":0.7`，
+   * 所以这道声明就是唯一的防线。
+   */
+  readonly sampling: SamplingSupport = { temperature: false, topP: false };
+
+  createModel(input: CreateModelInput): LanguageModel {
+    assertChatCompletions(this, input.protocol);
+    const { baseUrl, apiKey, modelId, fetch } = input;
+    return createMoonshotAI({ baseURL: baseUrl, apiKey, fetch })(modelId);
+  }
+
+  override reasoning(
+    modelId: string,
+    effort: ReasoningEffort,
+    _protocol: LlmProtocol
+  ): ProviderOptions | undefined {
+    switch (moonshotThinkingStyle(modelId)) {
+      case 'effort':
+        // K3 **没有关闭开关**（`reasoning_effort` 只有 low/high/max，默认 max），
+        // 故 off 只能不发——这是如实反映厂商限制，不是漏了关闭指令。
+        if (effort === 'off') return undefined;
+        return { moonshotai: { reasoningEffort: toK3Effort(effort) } };
+      case 'forced':
+        // 思考关不掉，而"开"就是默认值——发什么都是多余，发 disabled 还会报错。
+        return undefined;
+      case 'toggle':
+        return {
+          moonshotai: {
+            thinking: { type: effort === 'off' ? 'disabled' : 'enabled' },
+          },
+        };
+    }
+  }
+}
+
+/**
+ * 我们的档位 → K3 的原生三档 `low/high/max`（默认 max）。`max` 直通——
+ * 用户选了最高档就该拿到最高档，别替他降一级。
+ */
+function toK3Effort(effort: ReasoningEffort): string {
+  if (effort === 'minimal' || effort === 'low') return 'low';
+  if (effort === 'max') return 'max';
+  return 'high';
+}

package/src/vendors/openai-responses.ts

@@ -0,0 +1,82 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import type { JSONValue, LanguageModel, LanguageModelMiddleware } from 'ai';
+
+import type { CreateModelInput } from './vendor-adapter.js';
+
+/**
+ * `createOpenAI` 接受的自定义 fetch。类型从工厂签名上取，不为此多引一个
+ * `@ai-sdk/provider-utils` 依赖——它是 `@ai-sdk/openai` 的内部依赖，版本跟着走。
+ */
+export type ResponsesFetch = NonNullable<
+  Parameters<typeof createOpenAI>[0]
+>['fetch'];
+
+/**
+ * `openai-responses` 协议的句柄，三家（openai / generic / deepseek）共用：
+ * 线格式由 OpenAI 定义，别家只是「兼容」，所以承载它的包也只有 `@ai-sdk/openai`
+ * 这一个——`@ai-sdk/deepseek` 3.0.x 只有 chat-completions（已核 dist：路径里只有
+ * `/chat/completions`，`DeepSeekProvider` 也只暴露 `chat()`），别去那里找开关。
+ *
+ * 兼容厂商的差异用 `fetch` 垫片在 HTTP 层抹平（见 `responses-reasoning-text-shim.ts`），
+ * SDK 一行不动。
+ */
+export function createResponsesModel(
+  input: CreateModelInput,
+  fetch?: ResponsesFetch
+): LanguageModel {
+  const { baseUrl, apiKey, modelId } = input;
+  // 垫片自己以 `input.fetch` 为 base（见各家 createModel），没有垫片时直接用它。
+  return createOpenAI({
+    baseURL: baseUrl,
+    apiKey,
+    fetch: fetch ?? input.fetch,
+  }).responses(modelId);
+}
+
+/**
+ * 兼容厂商走 responses 协议时 `providerOptions.openai` 里必带的两项。
+ *
+ *   - **`forceReasoning: true`**：`@ai-sdk/openai` 的 responses 模型按**模型名**
+ *     判断「是不是推理模型」（`o` 系 / `gpt-5+`），不是就**整个不发 `reasoning`
+ *     参数**——`deepseek-v4-flash` 这种名字下档位与关闭指令会静默丢光，而
+ *     DeepSeek 默认开着推理，「不发 ≠ 关闭」在这里再次成立。已核 4.0.46 dist
+ *     （`isReasoningModel = forceReasoning ?? modelCapabilities.isReasoningModel`）。
+ *     代价：SDK 在推理模型上会剥掉 `temperature`/`top_p` 并打 warning——DeepSeek
+ *     文档本就声明思考模式下二者无效，可接受；`off` 时也会被剥，记为已知限制。
+ *   - **`systemMessageMode: 'system'`**：推理模型默认把 system 消息发成
+ *     `developer` 角色，那是 OpenAI 自家的规矩，兼容厂商只保证认 `system`。
+ *
+ * OpenAI 官方**不**用这组：它的模型名 SDK 认得，强制反而会给 `gpt-4.1` 这类
+ * 非推理模型发 `reasoning` 参数而 400。
+ */
+export const COMPATIBLE_RESPONSES_OPTIONS = {
+  forceReasoning: true,
+  systemMessageMode: 'system',
+} as const;
+
+/**
+ * 给 responses 句柄挂一层「每次调用必带的 `providerOptions.openai` 默认值」。
+ *
+ * 用它而不是把默认值放进 `reasoning()`：那条只对标了 `reasoning` 能力的模型行
+ * 才会被问，而这些默认值**与有没有推理无关**（方舟不带 `store:false` 多步工具
+ * 回环第二步就 400，MiniMax 的 InputItem 根本没有 `item_reference` 这一型）。
+ * 调用方显式给的同名选项优先（spread 在后）。首个使用者是方舟
+ * （`ARK_RESPONSES_DEFAULTS`），MiniMax 用同一组值。
+ */
+export function responsesDefaultsMiddleware(
+  defaults: Readonly<Record<string, JSONValue>>
+): LanguageModelMiddleware {
+  return {
+    specificationVersion: 'v4',
+    transformParams: ({ params }) => {
+      const openai = params.providerOptions?.openai ?? {};
+      return Promise.resolve({
+        ...params,
+        providerOptions: {
+          ...params.providerOptions,
+          openai: { ...defaults, ...openai },
+        },
+      });
+    },
+  };
+}

package/src/vendors/openai.adapter.ts

@@ -0,0 +1,235 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { type LanguageModel, wrapLanguageModel } from 'ai';
+
+import type { LlmProtocol } from '../types.js';
+import {
+  createResponsesModel,
+  responsesDefaultsMiddleware,
+} from './openai-responses.js';
+import {
+  type AdviceModelView,
+  type CreateModelInput,
+  LlmVendorAdapter,
+  type ModelAdvice,
+  type ProviderOptions,
+  type ReasoningEffort,
+  unsupportedProtocol,
+} from './vendor-adapter.js';
+
+/** OpenAI 线上的档位取值（`reasoning_effort` / `reasoning.effort` 同一套）。 */
+type OpenAiEffort =
+  'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+
+/** 所有推理模型都认的三档；认不出的模型只发这几个。 */
+const COMMON: readonly OpenAiEffort[] = ['low', 'medium', 'high'];
+
+/** `gpt-<major>[.<minor>][-<variant>]`（SDK 同一条正则）拆出来的样子。 */
+interface GptName {
+  major: number;
+  /** 没写小版本号时为 0（gpt-5 = 5.0）。 */
+  minor: number;
+  variant: string;
+  /** gpt-5+ 且不是 chat 别名（`gpt-5-chat-latest`）就是推理模型。 */
+  reasoning: boolean;
+}
+
+function parseGpt(modelId: string): GptName | null {
+  const m = /^gpt-(\d+)(?:\.(\d+))?(?:-(.+))?$/.exec(modelId);
+  if (!m) return null;
+  const major = Number(m[1]);
+  const variant = m[3] ?? '';
+  const chatAlias =
+    major === 5 && m[2] === undefined && variant.startsWith('chat');
+  return {
+    major,
+    minor: m[2] === undefined ? 0 : Number(m[2]),
+    variant,
+    reasoning: major >= 5 && !chatAlias,
+  };
+}
+
+/**
+ * Chat Completions 带工具时只认 `none` 的家族：gpt-5.4 起（含 gpt-6 系）。探针：
+ * gpt-5.4 / 5.4-mini / 5.5 开任何推理档都 400「Function tools with reasoning_effort
+ * are not supported … use /v1/responses or set reasoning_effort to 'none'」，
+ * gpt-5.6 与 gpt-6-sol 连不发都 400（默认 medium），gpt-5.2 及更早、o 系不受限。
+ */
+function chatToolsNeedNone(modelId: string): boolean {
+  const gpt = parseGpt(modelId);
+  if (!gpt?.reasoning) return false;
+  return gpt.major >= 6 || gpt.minor >= 4;
+}
+
+/**
+ * 这个模型在**服务端**认哪些档位（不含 `max` 的协议差异，见 `effortsFor`）。
+ * `null` = 不是推理模型（`gpt-4.1` 这类收到任何推理参数都 400）。
+ *
+ * 全部来自 2026-10-23 真 key 探针（16 个文本模型 × 7 档 × 两种协议 + nano /
+ * codex / pro 变体，两种协议的结论一致）：
+ *
+ *   - o 系（o3 / o4-mini）：只有 low / medium / high。
+ *   - gpt-5 / -mini / -nano：`minimal` 有、`none` 没有、`xhigh` 没有。
+ *   - gpt-5.1：`none` 有、`minimal` 没了、`xhigh` 还没有。
+ *   - gpt-5.2 ~ 5.5（含 -mini / -nano / 5.3-codex）：none + 三档 + xhigh。
+ *   - gpt-5.6-* 与 gpt-6-sol / gpt-6-luna：再加 `max`。
+ *   - 其余 gpt-6+（gpt-6-astra、gpt-6.1-sol）：没有 `none`（官方文档也这么写）。
+ *   - pro：gpt-5-pro 只认 high；更新的 pro（5.5-pro 探过）认 medium / high / xhigh。
+ *
+ * 名字按 SDK 同一条正则拆（`gpt-<major>[.<minor>][-<variant>]`，带日期后缀的
+ * 快照也落在同一档）；拆不出的 gpt 名字与未来的家族按 `COMMON` 走——猜成
+ * 「认」是 400，猜成「不认」只是退到相邻一档。
+ */
+function serverEfforts(modelId: string): readonly OpenAiEffort[] | null {
+  if (/^o\d+(?:-|$)/.test(modelId)) return COMMON;
+  const gpt = parseGpt(modelId);
+  if (!gpt) return COMMON;
+  const { major, minor, variant } = gpt;
+  if (!gpt.reasoning) return null;
+  if (variant.startsWith('pro')) {
+    return major === 5 && minor === 0 ? ['high'] : ['medium', 'high', 'xhigh'];
+  }
+  if (major >= 6) {
+    const withNone = modelId === 'gpt-6-sol' || modelId === 'gpt-6-luna';
+    return [
+      ...(withNone ? (['none'] as const) : []),
+      ...COMMON,
+      'xhigh',
+      'max',
+    ];
+  }
+  if (minor === 0) return ['minimal', ...COMMON];
+  if (minor === 1) return ['none', ...COMMON];
+  if (minor <= 5) return ['none', ...COMMON, 'xhigh'];
+  return ['none', ...COMMON, 'xhigh', 'max'];
+}
+
+/**
+ * 某协议下实际能发的档位：**Chat Completions 在任何模型上都不认 `max`**（连
+ * gpt-6 系也 400，Responses 才收）。SDK 4.0.101 对 gpt-6 系把 `max` 列为支持，
+ * 走 chat 时会原样发出去，所以这里先剔掉。
+ */
+function effortsFor(
+  modelId: string,
+  protocol: LlmProtocol
+): readonly OpenAiEffort[] | null {
+  const efforts = serverEfforts(modelId);
+  if (!efforts || protocol === 'openai-responses') return efforts;
+  return efforts.filter(e => e !== 'max');
+}
+
+/**
+ * 我们的档位 → 按偏好依次尝试的 OpenAI 档位，取第一个这个模型认的。`off` 先找
+ * 真关闭（`none`），没有就退到最少的那档——没有关闭开关的模型（gpt-5、gpt-6-astra、
+ * o 系）只能做到这一步；`max` 先找原生 `max`，再退 `xhigh` / `high`。
+ */
+const PREFERENCE: Record<ReasoningEffort, readonly OpenAiEffort[]> = {
+  off: ['none', 'minimal', 'low', 'medium', 'high'],
+  minimal: ['minimal', 'low', 'medium', 'high'],
+  low: ['low', 'medium', 'high'],
+  medium: ['medium', 'high', 'low'],
+  high: ['high', 'xhigh', 'medium'],
+  max: ['max', 'xhigh', 'high', 'medium'],
+};
+
+/**
+ * Responses 每次调用必带 `store: false`。不发时服务端按默认把请求与响应存 30 天，
+ * 而我们每轮发全量历史、从不引用存档（`previous_response_id` / `item_reference`）
+ * ——存了只是让对话内容平白留在 OpenAI 那边。探针：功能不变，提示词缓存照样
+ * 命中（缓存与 `store` 无关）。放中间件而不是 `reasoning()`：与推理无关，没标
+ * `reasoning` 能力的模型行也要带。
+ */
+const OPENAI_RESPONSES_DEFAULTS = { store: false } as const;
+
+export class OpenAiAdapter extends LlmVendorAdapter {
+  readonly kind = 'openai' as const;
+  override readonly supportedProtocols: readonly LlmProtocol[] = [
+    'openai-chat-completions',
+    'openai-responses',
+  ];
+
+  createModel(input: CreateModelInput): LanguageModel {
+    switch (input.protocol) {
+      case 'openai-chat-completions': {
+        const { baseUrl, apiKey, modelId, fetch } = input;
+        // **必须 `.chat()`**：`@ai-sdk/openai` 4.x 里直接调用工厂造的是
+        // Responses 模型——这一行曾写成 `createOpenAI(...)(modelId)`，后台选了
+        // Chat Completions 的模型实际一直在打 `/responses`（2026-10-23 契约
+        // 测试回放 chat 抓包时 SDK 报「Received a Chat Completions stream while
+        // using the OpenAI Responses API」才发现）。
+        return createOpenAI({ baseURL: baseUrl, apiKey, fetch }).chat(modelId);
+      }
+      case 'openai-responses':
+        return wrapLanguageModel({
+          model: createResponsesModel(input) as Exclude<LanguageModel, string>,
+          middleware: responsesDefaultsMiddleware(OPENAI_RESPONSES_DEFAULTS),
+        });
+      default:
+        throw unsupportedProtocol(this, input.protocol);
+    }
+  }
+
+  /**
+   * 判据与 `reasoning()` 同源（`parseGpt` / `serverEfforts` / `chatToolsNeedNone`）：
+   * 实际走 chat 而型号在 chat 下带不了工具（报错原文让改用 Responses）、非推理模型
+   * 标了推理（档位不会下发）、推理模型没标推理（档位不会下发，按默认档跑）。
+   */
+  override adviseModel(model: AdviceModelView): ModelAdvice[] {
+    const out: ModelAdvice[] = [];
+    const id = model.modelId;
+    if (
+      model.effectiveProtocol === 'openai-chat-completions' &&
+      chatToolsNeedNone(id)
+    ) {
+      out.push({
+        severity: 'warn',
+        message: serverEfforts(id)?.includes('none')
+          ? `「${id}」在 Chat Completions 下带工具时只能关闭推理（none），而 Agent 每轮都带工具，请改用 Responses。`
+          : `「${id}」在 Chat Completions 下不支持工具（需 none 档，而它没有），请改用 Responses。`,
+      });
+    }
+    const known = /^o\d+(?:-|$)/.test(id) || parseGpt(id) !== null;
+    const reasoningModel = serverEfforts(id) !== null;
+    const marked = model.capabilities.includes('reasoning');
+    if (known && !reasoningModel && marked) {
+      out.push({
+        severity: 'info',
+        message: `「${id}」不是推理模型，标记「推理」也不会下发推理档位。`,
+      });
+    }
+    if (known && reasoningModel && !marked) {
+      out.push({
+        severity: 'info',
+        message: `「${id}」是推理模型，未标记「推理」时推理档位不会下发，按模型默认档。`,
+      });
+    }
+    return out;
+  }
+
+  /**
+   * **档位是模型级的**（判据见 `serverEfforts`）：同一个「关闭」，gpt-5.5 发
+   * `none`、gpt-5 只能发 `minimal`、gpt-6-astra 只能发 `low`；同一个「最高」，
+   * gpt-5.2 发 `xhigh`、gpt-6 走 responses 发 `max`。发了模型不认的档位，
+   * 服务端 400；gpt-6 系还有一层 SDK 自己的校验，不认的档位**静默丢掉**只打
+   * warning，模型按默认档跑——两种都不报到我们这边来，所以在这里按模型算好。
+   *
+   * 不是推理模型（`gpt-4.1`）时什么都不发：后台把它误标成 reasoning 也不该 400。
+   * 两种协议的 key 都是 `openai`；**不**带 `forceReasoning`：SDK 认得自家模型名，
+   * 强制会给非推理模型发 `reasoning` 而 400。
+   */
+  override reasoning(
+    modelId: string,
+    effort: ReasoningEffort,
+    protocol: LlmProtocol
+  ): ProviderOptions | undefined {
+    if (
+      protocol !== 'openai-chat-completions' &&
+      protocol !== 'openai-responses'
+    ) {
+      throw unsupportedProtocol(this, protocol);
+    }
+    const supported = effortsFor(modelId, protocol);
+    if (!supported) return undefined;
+    const sent = PREFERENCE[effort].find(e => supported.includes(e));
+    return sent ? { openai: { reasoningEffort: sent } } : undefined;
+  }
+}