@qjp88995/provider-client 0.0.0-stage → 0.1.0

package/dist/vendors/zhipu.adapter.d.ts

@@ -0,0 +1,81 @@
+import type { LanguageModel } from 'ai';
+import type { LlmProtocol } from '../types.js';
+import { type CreateModelInput, LlmVendorAdapter, type ProviderOptions, type ReasoningEffort } from './vendor-adapter.js';
+/**
+ * 智谱的推理开关是**模型级**的两种形态（2026-08-27 用真实 API 探针钉住，
+ * 文档见 <https://docs.bigmodel.cn/cn/guide/capabilities/thinking-mode.md>）：
+ *
+ *   - `forced`：glm-5.3 / glm-5.3-flash。**思考关不掉**——发 `thinking:{type:'disabled'}`
+ *     直接 400（code 1210「该模型始终思考，不支持关闭思考；请使用 low、high 或 max」），
+ *     只认 `reasoning_effort`。
+ *   - `toggle`：glm-5.2 及更早的推理模型（5.1 / 5 / 4.7 / 4.6 / 4.5）。`thinking` 的
+ *     `enabled`/`disabled` 都合法，且**默认是 enabled**（不发 = 开着推理，探针
+ *     `reasoning_tokens: 62`），档位同样走 `reasoning_effort`（4.7、5.2 实测都收）。
+ *
+ * 模型名换了就改这一个函数。没有推理能力的老模型（glm-4-flash 那批）走不到这里
+ * ——resolver 只对标了 `reasoning` 能力的模型问推理选项。
+ */
+type ThinkingStyle = 'forced' | 'toggle';
+export declare function zhipuThinkingStyle(modelId: string): ThinkingStyle;
+/**
+ * 智谱 BigModel（GLM 系）。
+ *
+ * 承载包是 `@ai-sdk/openai-compatible`，**不是**社区的 `zhipu-ai-provider`（维护
+ * 停滞、跟不上 AI SDK 大版本）。选它的依据是一条实测过的 SDK 行为：它把
+ * `providerOptions[name]` 里**不在自己 schema 里的键原样展开进请求体**
+ * （dist 里 `...Object.fromEntries(Object.entries(providerOptions[...]).filter(...))`），
+ * 所以智谱私有的 `thinking` 参数不必写一整套 LanguageModel 就能下发；
+ * `reasoningEffort` 则在 schema 里、由 SDK 翻成 `reasoning_effort`。响应侧
+ * `reasoning_content`（非流式 message 与流式 delta 都是这个字段名）也正是
+ * 该包原生读取的字段——同目录 `zhipu.sdk-contract.spec.ts` 跑真实 SDK 钉这两条。
+ *
+ * 接入面：文档的「HTTP 原生」与「OpenAI 兼容」是**同一个端点**
+ * `/api/paas/v4/chat/completions`，前者只是多了几个私有参数，合为 chat-completions
+ * 一个分支；Responses 端点（`/api/v1/responses`）**没有任何文档页**，只在模型页的
+ * 接入方式表与 Codex 接入指南里各出现一次，全部判据来自 2026-08-27 的探针（见
+ * `reasoning()` 注释与 providers.md）；Anthropic 兼容面（`/api/anthropic`）本仓
+ * 尚无 `anthropic-messages` 分支，用户拍板先不做。
+ *
+ * Responses 面的两条运维事实：① GLM-5.3 模型页接入表下的 `<Note>` 原文——「如果您
+ * 有订阅过 GLM Coding Plan（含已过期），那么**暂时**您只能通过 OpenAI Chat Completion
+ * 协议调用模型 API，我们将在近期迭代优化」，是临时限制，那种账号在 responses 端点
+ * 失败时先想到它；② 探针约 30 次调用里有 3 次非流式请求挂到超时（重打即成功），
+ * 是厂商侧偶发，不是形状问题。
+ *
+ * **`temperature` 只收 `[0,1]`**（超出直接 400「temperature参数非法」，实测），
+ * 与 OpenAI 的 `[0,2]` 不同；`sampling` 只有「发不发」的粒度，这条限制目前靠
+ * 运营录参数时自觉，未做钳位。
+ */
+export declare class ZhipuAdapter extends LlmVendorAdapter {
+    readonly kind: "zhipu";
+    readonly supportedProtocols: readonly LlmProtocol[];
+    /**
+     * responses 走 `@ai-sdk/openai` + 与 DeepSeek 共用的响应侧垫片：智谱的推理正文
+     * 同样以 reasoning item 的 `content[{reasoning_text}]` 返回、流式事件同样是
+     * `response.reasoning_text.delta`（探针逐字段核对过），不垫就是推理整段消失。
+     * 请求侧不动：四种回传形状（原样 output / 只回 function_call / `item_reference`
+     * / 流式）全部 200；与 DeepSeek 不同的是它**会消费**发回去的 reasoning item
+     * （input_tokens 恰好多出上一轮的 reasoning_tokens），SDK 默认发什么就发什么。
+     */
+    createModel(input: CreateModelInput): LanguageModel;
+    /**
+     * **chat-completions**：`off` 在 toggle 模型上必须发**显式的**
+     * `thinking:{type:'disabled'}`——它默认开着推理，「不发 ≠ 关闭」在这家再次成立；
+     * forced 模型没有关闭开关，off 只能不发（如实反映厂商限制，不是漏了关闭指令）。
+     * 非 off 一律 `thinking:enabled` + `reasoning_effort`：厂商原生三档 `low/high/max`
+     * （glm-5.3 默认 `max`），我们的五档压进去；`max` 直通。`medium` 实测 5.2 也收，
+     * 但 5.3 的 400 文案只认三档，统一映射不赌宽容度。
+     *
+     * **responses**：只有 `reasoning.effort` 一个开关，且**这个面上推理关不掉**——
+     * 探针在 glm-5.2 上把 `effort:'none'`、体内 `thinking:{type:'disabled'}`、两者同发
+     * 全试过，reasoning_tokens 纹丝不动（100）；glm-5.3 系收到 `none` 则直接 400
+     * 「该模型始终思考」。所以 `off` 在 responses 下**不发**：发 `none` 在 5.2 上
+     * 是无效指令、在 5.3 上是错误，两边都不是「关闭」。这是本协议面的已知限制，
+     * 要真关推理请给模型只声明 chat-completions。档位 key 随承载包换成 `openai`，
+     * 并带 `COMPATIBLE_RESPONSES_OPTIONS`（否则 SDK 按模型名判成非推理模型、
+     * `reasoning` 整个不发；`developer` 角色实测也收，但只保证 `system`）。
+     */
+    reasoning(modelId: string, effort: ReasoningEffort, protocol: LlmProtocol): ProviderOptions | undefined;
+}
+export {};
+//# sourceMappingURL=zhipu.adapter.d.ts.map

package/dist/vendors/zhipu.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zhipu.adapter.d.ts","sourceRoot":"","sources":["../../src/vendors/zhipu.adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM/C,OAAO,EACL,KAAK,gBAAgB,EACrB,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,eAAe,EAErB,MAAM,qBAAqB,CAAC;AAS7B;;;;;;;;;;;;;GAaG;AACH,KAAK,aAAa,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEzC,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAIjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;IAChD,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAU;IAEjC,SAAkB,kBAAkB,EAAE,SAAS,WAAW,EAAE,CAG1D;IAEF;;;;;;;OAOG;IACH,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG,aAAa;IAqBnD;;;;;;;;;;;;;;;;OAgBG;IACM,SAAS,CAChB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,eAAe,EACvB,QAAQ,EAAE,WAAW,GACpB,eAAe,GAAG,SAAS;CA4B/B"}

package/dist/vendors/zhipu.adapter.js

@@ -0,0 +1,133 @@
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { COMPATIBLE_RESPONSES_OPTIONS, createResponsesModel, } from './openai-responses.js';
+import { withReasoningTextResponsesShim } from './responses-reasoning-text-shim.js';
+import { LlmVendorAdapter, unsupportedProtocol, } from './vendor-adapter.js';
+/**
+ * 工厂 `name`。它同时决定 provider id（`zhipu.chat`）与 providerOptions 的
+ * 命名空间 key（SDK 认 `name` 与 `toCamelCase(name)`，单词无连字符两者相同），
+ * 恰好等于我们的 `kind`，故基类默认的 `optionsKey` 直接可用。
+ */
+const FACTORY_NAME = 'zhipu';
+export function zhipuThinkingStyle(modelId) {
+    const id = modelId.toLowerCase();
+    if (id.startsWith('glm-5.3'))
+        return 'forced';
+    return 'toggle';
+}
+/**
+ * 智谱 BigModel（GLM 系）。
+ *
+ * 承载包是 `@ai-sdk/openai-compatible`，**不是**社区的 `zhipu-ai-provider`（维护
+ * 停滞、跟不上 AI SDK 大版本）。选它的依据是一条实测过的 SDK 行为：它把
+ * `providerOptions[name]` 里**不在自己 schema 里的键原样展开进请求体**
+ * （dist 里 `...Object.fromEntries(Object.entries(providerOptions[...]).filter(...))`），
+ * 所以智谱私有的 `thinking` 参数不必写一整套 LanguageModel 就能下发；
+ * `reasoningEffort` 则在 schema 里、由 SDK 翻成 `reasoning_effort`。响应侧
+ * `reasoning_content`（非流式 message 与流式 delta 都是这个字段名）也正是
+ * 该包原生读取的字段——同目录 `zhipu.sdk-contract.spec.ts` 跑真实 SDK 钉这两条。
+ *
+ * 接入面：文档的「HTTP 原生」与「OpenAI 兼容」是**同一个端点**
+ * `/api/paas/v4/chat/completions`，前者只是多了几个私有参数，合为 chat-completions
+ * 一个分支；Responses 端点（`/api/v1/responses`）**没有任何文档页**，只在模型页的
+ * 接入方式表与 Codex 接入指南里各出现一次，全部判据来自 2026-08-27 的探针（见
+ * `reasoning()` 注释与 providers.md）；Anthropic 兼容面（`/api/anthropic`）本仓
+ * 尚无 `anthropic-messages` 分支，用户拍板先不做。
+ *
+ * Responses 面的两条运维事实：① GLM-5.3 模型页接入表下的 `<Note>` 原文——「如果您
+ * 有订阅过 GLM Coding Plan（含已过期），那么**暂时**您只能通过 OpenAI Chat Completion
+ * 协议调用模型 API，我们将在近期迭代优化」，是临时限制，那种账号在 responses 端点
+ * 失败时先想到它；② 探针约 30 次调用里有 3 次非流式请求挂到超时（重打即成功），
+ * 是厂商侧偶发，不是形状问题。
+ *
+ * **`temperature` 只收 `[0,1]`**（超出直接 400「temperature参数非法」，实测），
+ * 与 OpenAI 的 `[0,2]` 不同；`sampling` 只有「发不发」的粒度，这条限制目前靠
+ * 运营录参数时自觉，未做钳位。
+ */
+export class ZhipuAdapter extends LlmVendorAdapter {
+    kind = 'zhipu';
+    supportedProtocols = [
+        'openai-chat-completions',
+        'openai-responses',
+    ];
+    /**
+     * responses 走 `@ai-sdk/openai` + 与 DeepSeek 共用的响应侧垫片：智谱的推理正文
+     * 同样以 reasoning item 的 `content[{reasoning_text}]` 返回、流式事件同样是
+     * `response.reasoning_text.delta`（探针逐字段核对过），不垫就是推理整段消失。
+     * 请求侧不动：四种回传形状（原样 output / 只回 function_call / `item_reference`
+     * / 流式）全部 200；与 DeepSeek 不同的是它**会消费**发回去的 reasoning item
+     * （input_tokens 恰好多出上一轮的 reasoning_tokens），SDK 默认发什么就发什么。
+     */
+    createModel(input) {
+        switch (input.protocol) {
+            case 'openai-chat-completions': {
+                const { baseUrl, apiKey, modelId, fetch } = input;
+                return createOpenAICompatible({
+                    name: FACTORY_NAME,
+                    baseURL: baseUrl,
+                    apiKey,
+                    fetch,
+                })(modelId);
+            }
+            case 'openai-responses':
+                return createResponsesModel(input, withReasoningTextResponsesShim(input.fetch));
+            default:
+                throw unsupportedProtocol(this, input.protocol);
+        }
+    }
+    /**
+     * **chat-completions**：`off` 在 toggle 模型上必须发**显式的**
+     * `thinking:{type:'disabled'}`——它默认开着推理，「不发 ≠ 关闭」在这家再次成立；
+     * forced 模型没有关闭开关，off 只能不发（如实反映厂商限制，不是漏了关闭指令）。
+     * 非 off 一律 `thinking:enabled` + `reasoning_effort`：厂商原生三档 `low/high/max`
+     * （glm-5.3 默认 `max`），我们的五档压进去；`max` 直通。`medium` 实测 5.2 也收，
+     * 但 5.3 的 400 文案只认三档，统一映射不赌宽容度。
+     *
+     * **responses**：只有 `reasoning.effort` 一个开关，且**这个面上推理关不掉**——
+     * 探针在 glm-5.2 上把 `effort:'none'`、体内 `thinking:{type:'disabled'}`、两者同发
+     * 全试过，reasoning_tokens 纹丝不动（100）；glm-5.3 系收到 `none` 则直接 400
+     * 「该模型始终思考」。所以 `off` 在 responses 下**不发**：发 `none` 在 5.2 上
+     * 是无效指令、在 5.3 上是错误，两边都不是「关闭」。这是本协议面的已知限制，
+     * 要真关推理请给模型只声明 chat-completions。档位 key 随承载包换成 `openai`，
+     * 并带 `COMPATIBLE_RESPONSES_OPTIONS`（否则 SDK 按模型名判成非推理模型、
+     * `reasoning` 整个不发；`developer` 角色实测也收，但只保证 `system`）。
+     */
+    reasoning(modelId, effort, protocol) {
+        switch (protocol) {
+            case 'openai-chat-completions': {
+                const style = zhipuThinkingStyle(modelId);
+                if (effort === 'off') {
+                    if (style === 'forced')
+                        return undefined;
+                    return { [this.optionsKey]: { thinking: { type: 'disabled' } } };
+                }
+                return {
+                    [this.optionsKey]: {
+                        thinking: { type: 'enabled' },
+                        reasoningEffort: toZhipuEffort(effort),
+                    },
+                };
+            }
+            case 'openai-responses': {
+                if (effort === 'off')
+                    return undefined;
+                return {
+                    openai: {
+                        reasoningEffort: toZhipuEffort(effort),
+                        ...COMPATIBLE_RESPONSES_OPTIONS,
+                    },
+                };
+            }
+            default:
+                throw unsupportedProtocol(this, protocol);
+        }
+    }
+}
+/** 我们的档位 → 智谱原生三档 `low/high/max`。`max` 直通——用户选了最高档就该拿到最高档。 */
+function toZhipuEffort(effort) {
+    if (effort === 'minimal' || effort === 'low')
+        return 'low';
+    if (effort === 'max')
+        return 'max';
+    return 'high';
+}
+//# sourceMappingURL=zhipu.adapter.js.map

package/dist/vendors/zhipu.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zhipu.adapter.js","sourceRoot":"","sources":["../../src/vendors/zhipu.adapter.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@qjp88995/provider-client",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Client for the provider center: vendor adapters for the AI SDK, model resolution through the center's catalog and passthrough proxy, and a direct mode for local development.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qjp88995/provider-center.git",
+    "directory": "packages/client"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.spec.ts"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=22.12"
+  },
+  "dependencies": {
+    "@ai-sdk/alibaba": "^2.0.75",
+    "@ai-sdk/deepseek": "^3.0.72",
+    "@ai-sdk/google": "^4.0.104",
+    "@ai-sdk/moonshotai": "^3.0.76",
+    "@ai-sdk/openai": "^4.0.101",
+    "@ai-sdk/openai-compatible": "^3.0.77"
+  },
+  "peerDependencies": {
+    "ai": "^7.0.150"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.5",
+    "ai": "^7.0.150",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10",
+    "zod": "^4.4.3",
+    "@pc/shared": "0.1.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist *.tsbuildinfo && tsc -p tsconfig.build.json",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist .turbo *.tsbuildinfo"
+  }
 }

package/src/center-fetch.ts

@@ -0,0 +1,69 @@
+import { PC_HEADERS, PROXY_ROUTE_PREFIX } from './types.js';
+import type { VendorFetch } from './vendors/index.js';
+
+/** 厂商 SDK 可能放厂商 key 的头。中心反正会剥，这里先剥掉：假 key 不出本进程。 */
+const VENDOR_AUTH_HEADERS = [
+  'authorization',
+  'x-goog-api-key',
+  'x-api-key',
+  'api-key',
+];
+
+export interface CenterFetchOptions {
+  /** 中心的根地址，如 `https://provider.example.com`。 */
+  centerUrl: string;
+  /** 接入方 API key（`pc_…`）。 */
+  apiKey: string;
+  /** 厂商 slug（透传路由段）。 */
+  vendor: string;
+  /**
+   * 这家所有端点的 baseUrl。只改写落在这些 origin 上的请求；别的 origin 直接报错——那是适配器拼错了地址，
+   * 悄悄发出去就是带着中心的 key 打到别处。
+   */
+  baseUrls: readonly string[];
+  /** 会话粘性键（`x-pc-affinity`）。 */
+  affinity?: string;
+  /** 钉住某把 key（`x-pc-pin`）。 */
+  pin?: string;
+  /** 每次响应回来时告诉调用方实际用的是哪把 key（`x-pc-credential`）。 */
+  onCredential?: (ref: string) => void;
+  /** 发往中心用的 fetch；默认全局 fetch。 */
+  fetch?: VendorFetch;
+}
+
+/**
+ * 中心模式的出站 fetch，交给适配器的 `CreateModelInput.fetch`：把厂商 URL 的 origin 换成
+ * `<中心>/v1/proxy/<slug>`（pathname 与查询串原样），剥掉厂商鉴权头，加上 `x-pc-key` 与粘性 / pin 头。
+ * 适配器本身一个字不改——这就是「厂商的每一条出站请求都走 `CreateModelInput.fetch`」那条红线的用处。
+ */
+export function createCenterFetch(options: CenterFetchOptions): VendorFetch {
+  const center = options.centerUrl.replace(/\/+$/, '');
+  const prefix = `${center}${PROXY_ROUTE_PREFIX}/${encodeURIComponent(options.vendor)}`;
+  const origins = new Set(options.baseUrls.map(u => new URL(u).origin));
+  const send = options.fetch ?? globalThis.fetch;
+
+  return async (input, init) => {
+    const request = input instanceof Request ? input : null;
+    const url = new URL(request ? request.url : input.toString());
+    if (!origins.has(url.origin)) {
+      throw new Error(
+        `refusing to route ${url.origin} through the provider center: not an endpoint of vendor "${options.vendor}"`
+      );
+    }
+    const headers = new Headers(request?.headers);
+    new Headers(init?.headers).forEach((v, k) => headers.set(k, v));
+    for (const h of VENDOR_AUTH_HEADERS) headers.delete(h);
+    url.searchParams.delete('key');
+    headers.set(PC_HEADERS.key, options.apiKey);
+    if (options.affinity) headers.set(PC_HEADERS.affinity, options.affinity);
+    if (options.pin) headers.set(PC_HEADERS.pin, options.pin);
+
+    const target = `${prefix}${url.pathname}${url.search}`;
+    const res = request
+      ? await send(new Request(target, request), { ...init, headers })
+      : await send(target, { ...init, headers });
+    const ref = res.headers.get(PC_HEADERS.credential);
+    if (ref) options.onCredential?.(ref);
+    return res;
+  };
+}

package/src/direct-resolver.ts

@@ -0,0 +1,90 @@
+import {
+  buildHandle,
+  findModel,
+  type ModelHandle,
+  type ModelRef,
+  type ModelResolver,
+  type ResolveOptions,
+} from './model-handle.js';
+import type {
+  CatalogEndpoint,
+  CatalogModel,
+  CatalogVendor,
+  LlmCapability,
+  VendorKind,
+} from './types.js';
+import type { VendorFetch } from './vendors/index.js';
+
+/** 直连模式下的一家厂商：目录条目的形状，外加厂商 key。 */
+export interface DirectVendor {
+  slug: string;
+  /** 显示名，默认 = slug。 */
+  name?: string;
+  kind: VendorKind;
+  /** 厂商的 API key。 */
+  apiKey: string;
+  endpoints: CatalogEndpoint[];
+  /** 只写 `modelId` 与 `protocols` 也行，其余取默认（无能力、无上限、无单价）。 */
+  models: DirectModel[];
+  /** 出站 fetch（网络代理）；默认全局 fetch。 */
+  fetch?: VendorFetch;
+}
+
+export type DirectModel = Pick<CatalogModel, 'modelId' | 'protocols'> &
+  Partial<Omit<CatalogModel, 'modelId' | 'protocols'>>;
+
+/**
+ * 直连模式：不经中心，拿厂商 key 直接调。给本地开发、测试与没有中心的环境；与 `ProviderClient` 同一个
+ * `ModelResolver` 接口、同一套适配器，换模式不改调用方。没有 key 池、没有故障切换。
+ */
+export class DirectModelResolver implements ModelResolver {
+  private readonly vendors: (CatalogVendor & {
+    apiKey: string;
+    fetch?: VendorFetch;
+  })[];
+
+  constructor(vendors: readonly DirectVendor[]) {
+    this.vendors = vendors.map(v => ({
+      slug: v.slug,
+      name: v.name ?? v.slug,
+      kind: v.kind,
+      apiKey: v.apiKey,
+      fetch: v.fetch,
+      endpoints: v.endpoints,
+      models: v.models.map(m => ({
+        displayName: m.modelId,
+        capabilities: [],
+        maxContextTokens: null,
+        maxOutputTokens: null,
+        pricing: null,
+        ...m,
+      })),
+    }));
+  }
+
+  // async：找不到厂商 / 模型时以 rejected promise 报出，与中心模式一致。
+
+  async resolve(
+    ref: ModelRef,
+    options: ResolveOptions = {}
+  ): Promise<ModelHandle> {
+    findModel(this.vendors, ref);
+    const vendor = this.vendors.find(v => v.slug === ref.vendor)!;
+    const model = vendor.models.find(m => m.modelId === ref.modelId)!;
+    return buildHandle({
+      ref,
+      vendor,
+      model,
+      apiKey: vendor.apiKey,
+      fetchFor: () => vendor.fetch,
+      reasoningEffort: options.reasoningEffort,
+    });
+  }
+
+  capabilitiesOf(ref: ModelRef): Promise<LlmCapability[]> {
+    const model = this.vendors
+      .find(v => v.slug === ref.vendor)
+      ?.models.find(m => m.modelId === ref.modelId);
+    return Promise.resolve(model ? [...model.capabilities] : []);
+  }
+}

package/src/errors.ts

@@ -0,0 +1,88 @@
+import { CENTER_ERROR_CODES, type CenterErrorCode } from './types.js';
+
+/**
+ * - 中心的错误码（`CenterErrorCode`），如 `unauthorized`（key 不对或已吊销）、`vendor_not_allowed`、
+ *   `no_credential`（池里没有可用的 key）、`pinned_credential_unavailable`。
+ * - `unknown_vendor` / `unknown_model`：目录里没有（或这个接入方看不到）这家 / 这个模型。
+ * - `protocol_unavailable`：模型声明的协议里，没有一个是这家有端点且适配器已实现的。
+ * - `unsupported_vendor_kind`：这个版本的 client 没有该厂商类型的适配器（中心比 client 新）。
+ * - `network`：连不上中心（`cause` 里是原始错误）。
+ * - `unexpected`：回了不认识的东西（非 JSON 的错误页、不认识的错误码……），`status` 照填。
+ */
+export type ProviderClientErrorCode =
+  | CenterErrorCode
+  | 'unknown_vendor'
+  | 'unknown_model'
+  | 'protocol_unavailable'
+  | 'unsupported_vendor_kind'
+  | 'network'
+  | 'unexpected';
+
+export class ProviderClientError extends Error {
+  override readonly name: string = 'ProviderClientError';
+
+  constructor(
+    readonly code: ProviderClientErrorCode,
+    message: string,
+    /** HTTP 状态码；不是 HTTP 层的错误（或没拿到响应）时为 null。 */
+    readonly status: number | null,
+    options?: { cause?: unknown }
+  ) {
+    super(message, options);
+  }
+}
+
+/** 模型声明的协议与这家可用的端点 / 适配器没有交集。不静默退回某个协议。 */
+export class ProtocolUnavailableError extends ProviderClientError {
+  override readonly name = 'ProtocolUnavailableError';
+
+  constructor(
+    readonly modelId: string,
+    readonly protocols: readonly string[],
+    readonly vendorKind: string
+  ) {
+    super(
+      'protocol_unavailable',
+      `Model "${modelId}" declares protocols [${protocols.join(', ')}] but vendor "${vendorKind}" has no usable endpoint for any of them`,
+      null
+    );
+  }
+}
+
+const KNOWN = new Set<string>(CENTER_ERROR_CODES);
+
+/** 从中心的错误响应体（`{ code, message }`）认出错误码；认不出给 null。 */
+export function parseCenterError(
+  body: unknown
+): { code: CenterErrorCode; message: string } | null {
+  if (!body || typeof body !== 'object') return null;
+  const { code, message } = body as { code?: unknown; message?: unknown };
+  if (typeof code !== 'string' || !KNOWN.has(code)) return null;
+  return {
+    code: code as CenterErrorCode,
+    message: typeof message === 'string' ? message : code,
+  };
+}
+
+/** 把中心的一个非 2xx 响应变成错误。会读掉响应体。 */
+export async function errorFromResponse(
+  res: Response
+): Promise<ProviderClientError> {
+  const text = await res.text().catch(() => '');
+  let body: unknown = null;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    // 不是 JSON：落到 unexpected。
+  }
+  const known = parseCenterError(body);
+  if (known) {
+    return new ProviderClientError(known.code, known.message, res.status);
+  }
+  const snippet = text.slice(0, 200).trim();
+  return new ProviderClientError(
+    'unexpected',
+    `provider center answered ${res.status}${snippet ? `: ${snippet}` : ''}`,
+    res.status
+  );
+}

package/src/index.ts

@@ -0,0 +1,54 @@
+export { type CenterFetchOptions, createCenterFetch } from './center-fetch.js';
+export {
+  type DirectModel,
+  DirectModelResolver,
+  type DirectVendor,
+} from './direct-resolver.js';
+export {
+  ProtocolUnavailableError,
+  ProviderClientError,
+  type ProviderClientErrorCode,
+} from './errors.js';
+export {
+  type ModelFileStore,
+  type ModelHandle,
+  type ModelRef,
+  type ModelResolver,
+  type ResolveOptions,
+  type UploadedFile,
+} from './model-handle.js';
+export {
+  ProviderClient,
+  type ProviderClientOptions,
+} from './provider-client.js';
+export { toProviderClientError } from './to-error.js';
+export {
+  type CatalogEndpoint,
+  type CatalogModel,
+  type CatalogResponse,
+  type CatalogVendor,
+  CENTER_ERROR_CODES,
+  type CenterErrorCode,
+  LLM_CAPABILITIES,
+  LLM_PROTOCOLS,
+  type LlmCapability,
+  type LlmProtocol,
+  type ModelPricing,
+  PC_HEADERS,
+  PROXY_ROUTE_PREFIX,
+  REASONING_EFFORTS,
+  type ReasoningEffort,
+  VENDOR_KINDS,
+  type VendorKind,
+} from './types.js';
+export {
+  type AdviceModelView,
+  findVendorAdapter,
+  getVendorAdapter,
+  LlmVendorAdapter,
+  type ModelAdvice,
+  type ProviderOptions,
+  type SamplingParams,
+  VENDOR_ADAPTERS,
+  type VendorFetch,
+} from './vendors/index.js';