@sema-agent/server 7.130.0 → 7.132.0

package/dist/mcp-assertion-header.d.ts

@@ -15,7 +15,7 @@
  *  · **fresh 提交腿**:判出问题 ⇒ 同步 400(同设 `request.body_shape`;值不是字符串 `request.field_invalid`)。
  *  · **其余腿(耐久 resume 重放存量 body)**:**不拒、不丢 server** —— 存量 body 里这个键当时是被静默忽略的,server 当时是挂着的;
  *    此刻把 server 摘掉,一条 park 在该 server 工具审批上的任务批准后会撞 `resume.tool_unavailable` 并重开检查点,而每次重试重放同一份 body ⇒ 永远卡住。
- *    所以读器 {@link readMcpIdentityHeaders} 的处置是**降级到升级前的读法**:`principalHeader` 胜(照挂,与升级前逐字相同),`assertionHeader` 不生效;
+ *    所以读器(契约包的 `readMcpIdentityHeaders`,`normalizeServer` 的 http 传输读两个身份头用它)的处置是**降级到升级前的读法**:`principalHeader` 胜(照挂,与升级前逐字相同),`assertionHeader` 不生效;
  *    不静默 —— 真挂上的这类条目由 {@link noteMcpAssertionHeaderIgnored} 说一行 warn(部署声明面没有这一格:配置不是被重放的存量任务,契约包解析期那一刀直接丢这一条)。
  *
  * ## 发送归引擎座(本版只承载,不发送)
@@ -56,18 +56,10 @@ export type McpIdentityHeadersIssue = "both_set" | "not_a_string";
  * 两类同时成立时报 `both_set`(先名字后值)。stdio 传输不判(两键在 stdio 形上本就不存在,契约包同判)。
  */
 export declare function mcpIdentityHeadersIssue(transport: Record<string, unknown>): McpIdentityHeadersIssue | undefined;
-/**
- * 读器的这一格(`normalizeServer` 的 http 传输读两个身份头):字符串才收;**`principalHeader` 胜**——它在场(不论值形)时 `assertionHeader` 不收。
- * 于是 normalize 后的形**结构上不可能同带两键**(`mcpIdentityHeadersIssue` 的 `both_set` 在读器之后不存在),重放存量 body 的处置因此就是升级前的读法。
- */
-export declare function readMcpIdentityHeaders(transport: Record<string, unknown>): {
-    principalHeader?: string;
-    assertionHeader?: string;
-};
 /** 同设的拒句 —— 对契约包解析期那一句**逐字**(`server` = 条目名,调用方负责清洗后传入)。 */
 export declare function describeMcpIdentityHeadersConflict(server: string): string;
-/** `assertionHeader` 值不是字符串的拒句(值的形状只说种类,不回显值本身:它是一个调用方写的头名位置,可能是任何东西)。 */
-export declare function describeMcpAssertionHeaderNotAString(server: string, value: unknown): string;
+/** `assertionHeader` 值不是字符串的**原因句**(不带条目名与键路径:点名由请求面统一的拒形 `entryFieldRefusal` 负责;值的形状只说种类,不回显值本身:它是一个调用方写的头名位置,可能是任何东西)。 */
+export declare function describeMcpAssertionHeaderNotAString(value: unknown): string;
 /** 这一条请求面条目是否声明了 `assertionHeader`(= 铸 core 规格时会被剥掉、需要说一行的那一类)。 */
 export declare function declaresMcpAssertionHeader(spec: RequestMcpServerSpec): boolean;
 /** 请求面条目 → 交给引擎的规格:剥掉 `assertionHeader`(引擎无座);其余逐字不动。声明过它的条目由调用方另说一行 info。 */

package/dist/mcp-assertion-header.js

@@ -7,18 +7,12 @@ export function mcpIdentityHeadersIssue(transport) {
         return "not_a_string";
     return undefined;
 }
-export function readMcpIdentityHeaders(transport) {
-    return {
-        ...(typeof transport.principalHeader === "string" ? { principalHeader: transport.principalHeader } : {}),
-        ...(transport.principalHeader === undefined && typeof transport.assertionHeader === "string" ? { assertionHeader: transport.assertionHeader } : {}),
-    };
-}
 export function describeMcpIdentityHeadersConflict(server) {
     return `mcp server "${server}" sets both principalHeader and assertionHeader — an http entry names ONE header for the identity it sends: keep principalHeader (the end-user principal) or assertionHeader (the connector assertion), not both`;
 }
-export function describeMcpAssertionHeaderNotAString(server, value) {
-    const kind = value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
-    return `mcp server "${server}" sets assertionHeader to a ${kind} — it must be a string (the HTTP header NAME the connector assertion travels in); omit the key to send no assertion header`;
+export function describeMcpAssertionHeaderNotAString(value) {
+    const kind = value === null ? "null" : Array.isArray(value) ? "an array" : `a ${typeof value}`;
+    return `must be a string (the HTTP header NAME the connector assertion travels in) — got ${kind}; omit the key to send no assertion header`;
 }
 export function declaresMcpAssertionHeader(spec) {
     return spec.transport.kind === "http" && spec.transport.assertionHeader !== undefined;

package/dist/mcp-tool-faces.d.ts

@@ -58,6 +58,11 @@ export type McpToolFacesRead = {
 /**
  * 从任一腿的原始条目里读出 `toolFaces` —— **三条腿共用的唯一判据点**。
  * 缺席 ⇒ 合形无覆盖层;整只不是对象 / **任一只**工具的面判不出形 ⇒ `ok:false`(调用方整条 server 不收)。
+ *
+ * 🔴 工具名是 `__proto__` ⇒ 同样判不出形,**响亮拒**:按名存面的记录装不下它 —— JSON 的自有键 `"__proto__"` 写进记录那一步走的是原型的设置器,
+ * 键从结果里消失而判官答 `ok`,那条 server 照挂、收窄面叠层被无声丢掉。方向与本模块头注同(收窄声明在场就必须原样可用)。
+ * 只拒这一个名字:`constructor` / `toString` 等其余根原型成员名写进记录是普通自有键、不丢,引擎按名查面也取得到 —— 拒它们是给重放存量 body 的腿
+ * 新添一条「整条 server 不进」,不是修这个病。
  */
 export declare function readMcpToolFaces(v: unknown): McpToolFacesRead;
 export {};

package/dist/mcp-tool-faces.js

@@ -1,4 +1,5 @@
 import { TOOL_APPROVAL_CARDS, TOOL_FAMILIES, TOOL_PATH_ABSENCES, TOOL_PATH_ACCESSES, TOOL_PATH_BASES } from "@sema-agent/core";
+import { quotedCallerText } from "./caller-text-echo.js";
 function isRecord(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
 }
@@ -92,9 +93,12 @@ export function readMcpToolFaces(v) {
         return { ok: false, problem: `toolFaces is ${Array.isArray(v) ? "an array" : typeof v}, not an object of per-tool faces` };
     const faces = {};
     for (const [tool, raw] of Object.entries(v)) {
+        if (tool === "__proto__") {
+            return { ok: false, problem: `toolFaces names tool "__proto__" — a per-tool record cannot hold a face under that name (writing it sets the record's prototype instead of a key), so the declaration would silently vanish` };
+        }
         const face = readOneFace(raw);
         if (face === undefined)
-            return { ok: false, problem: `the declared face for tool ${JSON.stringify(tool)} does not fit the tool-face shape` };
+            return { ok: false, problem: `the declared face for tool ${quotedCallerText(tool)} does not fit the tool-face shape` };
         faces[tool] = face;
     }
     return Object.keys(faces).length > 0 ? { ok: true, faces } : { ok: true };

package/dist/memory-scope.d.ts

@@ -286,7 +286,7 @@ declarations?: {
 /**
  * 「这一腿挂不挂记忆面」的**唯一属主**(合并复审 车HF F1,2026-09-18):与 core `prepareMemory` 的判据同源 ——
  * `normalizeMemorySpec(spec)?.enabled === true`。S-405 之后 `memory:"off"` 铸的是「键在场 + `enabled:false`」(保留事实),
- * 任何按「键在不在场」判挂没挂的读者从那一天起都读错(改前 `memory-notice` 正是那样,把无记忆面的披露一起吞掉)。
+ * 任何按「键在不在场」判挂没挂的读者从那一天起都读错(改前本仓的记忆披露判别式正是那样,把无记忆面的披露一起吞掉;那只判别式已随引擎接管披露退役)。
  * 消费方拿本函数的布尔,不拿 `spec.memory` 自己判。
  *
  * ⚠️ **本函数会抛,而「抛」本身就是一条判据**(S-424 补注)。`normalizeMemorySpec` 对两形直接 throw

package/dist/model-entry-refusal.d.ts

@@ -1,5 +1,6 @@
 import { type ModelEntryRefusalCode, type ModelPlaneRefusalCode, type ModelRefusalsSignal } from "@sema-agent/settings-schema";
 import { type DroppedCatalogEntry } from "./web-admin-client/read-warnings.js";
+import { type ModelTableLeg } from "./model-select.js";
 /**
  * 条目拒因码 → 本仓铸它的成因 —— **以码为键**(S-768):码闭集的属主是 settings-schema(`MODEL_ENTRY_REFUSAL_CODES`,6.2.0 起;此前本仓
  * 自持一份同名码表,撞名已消灭、零别名)。那边加一个条目码 ⇒ 本表缺键 ⇒ 本仓 tsc 红(只拿 `satisfies` 约束码值证明的是「子集」,
@@ -126,13 +127,6 @@ export interface DefaultModelView {
     readonly models: Readonly<Record<string, unknown>>;
     readonly modelRefusals: Readonly<Record<string, ModelEntryRefusal>>;
 }
-/**
- * 这张表是从哪条腿来的(闭集 —— 拒因句的出路按腿分:加腿不补 {@link defaultModelRefusal} 的臂 = 编译红)。
- *  · `env` —— 进程此刻服务的表**没有目录在管**(没配目录 / 目录迟到且无 LKG / 目录的模型面这一组被拒):`MODEL_ID` 是出路之一;
- *  · `catalog` —— 判的是一份**目录候选**(模型面 stage):目录一旦生效就整张换掉 env 表,`MODEL_ID` 救不了这份候选 ——
- *    出路只在目录里(修条目 / 换绑)。opus 腿 ④(7.101.0 合并复审):此前两腿同一句,目录腿教「设 MODEL_ID 即可」是假话。
- */
-export type ModelTableLeg = "env" | "catalog";
 /**
  * 🔴 S-705 —— **这张模型表有没有一只缺省模型**(`models.default`)。`undefined` = 有。
  *

package/dist/model-provider.d.ts

@@ -77,20 +77,47 @@ export declare function modelBrainLane(provider: ModelProvider): ModelBrainLane;
  */
 export declare function catalogBrainLane(provider: string | undefined): ModelBrainLane;
 /**
- * 🔴 S-623 —— 一条目录条目在**本部署**上真正落哪条 brain 腿(= `createBrain` 的组装事实,不是词面)。
+ * 🔴 **本部署装上的路由表的唯一铸法**(core 7.53.0 #1842;S-623 的「词 ∧ 路由装上」合取由此收成「问表」)。
  *
- * `createBrain` 只在 anthropic 路由**装上**(`ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` 在场 ⇒
- * `config.anthropic` 在场)时才铸 `createRoutingBrain({anthropic}, {fallback: gatewayStack})`;没装时整台机器
- * 只有网关栈这一只 brain,**一切**条目(包括 `provider:"anthropic"` 的)都落 openai 兼容腿 ——
- * `apply-effective.ts` 那条 `web_admin_model_no_brain` warn 说的「mis-routes to the gateway brain」即此。
+ * 键 = `createRoutingBrain` 选线读的那个词(`model.provider`),值 = 那条路由上的东西 —— `createBrain` 铸 brain 交给路由器,判词侧(启动摘要、端点判官、
+ * hook 选线)铸路由自己的配置交给 {@link brainLaneFor}(core 的判官从不读值,只问 `Object.hasOwn(routes, word)`)。两侧走同一只函数 ⇒ 同一组键,
+ * 「哪条路由装上了」只有这里一处写法。
  *
- * 所以「这条路由要不要一个 openai 端点」的判据必须同时看词与装配:词判 {@link catalogBrainLane},
- * 装配判路由在不在。本函数是这一合取的**唯一**写法 —— 端点判官(`model-route-endpoint.ts`)、降级腿与
- * 启动摘要(`brain.ts`)都调它,不再各写一个 `=== "anthropic" && config.anthropic`。
+ * `anthropic` 键在场 ⇔ anthropic 路由装上(`ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` 在场 ⇒ `config.anthropic` 在场);没装时**键缺席**,
+ * 绝不写成 `{ anthropic: undefined }` —— core 7.53.0 起「装上的键而值不是 brain」是一条坏线路(该请求 error terminal),不再回落网关
+ * (core CHANGELOG #1842「the key must be absent, not `undefined`」)。视图上 `anthropic` 的自有键带 `undefined`(配置对象的形)照样读成没装。
+ */
+export declare function mountRoutes<R extends object, T>(view: {
+    readonly anthropic?: R | undefined;
+}, mount: (route: R) => T): Readonly<Record<string, T>>;
+/**
+ * 🔴 **anthropic 路由的请求根** —— 唯一读法(S-1655 / core 7.53.0 #1905)。声明了 `ANTHROPIC_BASE_URL` ⇒ 它;没声明 ⇒ core 包根导出的 `ANTHROPIC_DEFAULT_BASE_URL`
+ * (引擎的 Anthropic brain 的请求根与配对律的车道缺省、`fable5Model` 预设的 `baseUrl` 读的同一只常量)。「没声明」按引擎的读法:缺席、空串、纯空白都是没声明
+ * (core 原话:「nothing, an empty string and whitespace read as undeclared」)。修前本仓两处手抄字面量:主路由的声明根(`brain.ts`,`??`)与 hook 的 anthropic 腿根
+ * (`hooks/hook-llm.ts`,`||`)—— 一个根、两份拷贝、两种合取。
+ */
+export declare function anthropicRouteRoot(route: {
+    readonly baseUrl?: string | undefined;
+}): string;
+/** 判词侧的路由表:值 = 路由自己的配置({@link mountRoutes} 的恒等铸法 —— 判官不读值,只问键)。 */
+export declare function routeTableOf<R extends object>(view: {
+    readonly anthropic?: R | undefined;
+}): Readonly<Record<string, R>>;
+/**
+ * 🔴 **一条目录条目在本部署上真正落哪条 brain 腿**(= 引擎路由器对同一只表的答案,不是词面)—— 唯一判词。
+ *
+ * 判据是 core 包根导出的 `brainLaneOf({ provider }, routes)`(core 7.53.0 #1842):`createRoutingBrain` 对每个请求问的正是它,所以引擎主路由与本仓的
+ * 四处调用点(主路由降级腿与启动摘要在 `brain.ts`、端点判官 `model-route-endpoint.ts`、hook 选线 `hooks/hook-llm.ts`)读**一个**答案。修前本仓自写一只
+ * 合取 `dispatchBrainLane(provider, anthropicRouteMounted)`(`catalogBrainLane(provider) === "anthropic" ∧ 路由装上`)—— 两份写法,S-1630 那次真病
+ * (hook 面按词面判线、主路由按装配判线)就是两份写法分叉的样子。
+ *
+ * core 的答案是路由名或 `undefined`(网关 fallback 服务它:词下没装路由,或没有 string 词)。本部署只装 `anthropic` 一条路由(表的唯一铸法 {@link mountRoutes}),
+ * 所以答案映到本仓两词闭集:`"anthropic"` ⇒ anthropic 腿,`undefined` ⇒ 网关腿;别的名字结构上不可能(表里没有那个键),真撞上 ⇒ **响亮抛**([ref]:运行期
+ * miss 臂必须说出来,不静默折网关)。
  *
- * 🔴 S-704(7.101.0):**目录条目**已到不了「anthropic 词、路由没装」这一格 —— 模型面 stage 的逐条判据把它判成不可用
- * (`config.model_no_brain`,不进 `config.models`)。这一格今天只剩 **env 腿**:`MODEL_PROVIDER=anthropic` 而没配 anthropic
- * 凭据的部署,env 模型落网关腿、用的是网关自己的 `MODEL_API_KEY`(凭据与端点同属网关,不越界;是否也该拒启另车)。
+ * S-704(7.101.0):**目录条目**到不了「anthropic 词、路由没装」这一格 —— 模型面 stage 的逐条判据把它判成不可用(`config.model_no_brain`,那一判问的是
+ * 「词想要的腿装没装」,{@link catalogBrainLane},与本判词是两个问题)。这一格今天只剩 **env 腿**:`MODEL_PROVIDER=anthropic` 而没配 anthropic 凭据的部署,
+ * env 模型落网关腿、用的是网关自己的 `MODEL_API_KEY`(凭据与端点同属网关,不越界)。
  */
-export declare function dispatchBrainLane(provider: string | undefined, anthropicRouteMounted: boolean): ModelBrainLane;
+export declare function brainLaneFor(provider: string | undefined, routes: Readonly<Record<string, unknown>>): ModelBrainLane;
 //# sourceMappingURL=model-provider.d.ts.map

package/dist/model-provider.js

@@ -1,3 +1,4 @@
+import { ANTHROPIC_DEFAULT_BASE_URL, brainLaneOf } from "@sema-agent/core";
 export const MODEL_PROVIDER_WORDS = ["gateway", "vllm", "anthropic"];
 export function isModelProvider(word) {
     return word !== undefined && MODEL_PROVIDER_WORDS.includes(word);
@@ -23,7 +24,23 @@ export function modelBrainLane(provider) {
 export function catalogBrainLane(provider) {
     return isModelProvider(provider) ? modelBrainLane(provider) : "gateway";
 }
-export function dispatchBrainLane(provider, anthropicRouteMounted) {
-    return anthropicRouteMounted && catalogBrainLane(provider) === "anthropic" ? "anthropic" : "gateway";
+export function mountRoutes(view, mount) {
+    const route = view.anthropic;
+    return route !== undefined ? { anthropic: mount(route) } : {};
+}
+export function anthropicRouteRoot(route) {
+    const declared = route.baseUrl;
+    return declared !== undefined && declared.trim() !== "" ? declared : ANTHROPIC_DEFAULT_BASE_URL;
+}
+export function routeTableOf(view) {
+    return mountRoutes(view, (route) => route);
+}
+export function brainLaneFor(provider, routes) {
+    const line = brainLaneOf({ provider }, routes);
+    if (line === undefined)
+        return "gateway";
+    if (line === "anthropic")
+        return "anthropic";
+    throw new Error(`brainLaneFor: the engine's route judge answered route "${line}", which this deployment never mounts (the route table holds only the anthropic route) — the table was built outside mountRoutes`);
 }
 //# sourceMappingURL=model-provider.js.map

package/dist/model-route-endpoint.d.ts

@@ -15,12 +15,15 @@
  * (`MODEL_GATEWAY_FALLBACK_URLS`)是主网关的镜像,没有主就没有镜像 ⇒ 拒。
  *
  * ## 执法点(判据只在这里,执法点在调用处 —— 与 S-475 `gateway-url-userinfo` 同形)
- *  · boot:`config.ts` 九域解析之后的跨域不变量区(锚 `CROSS-INVARIANT:model-route-endpoint`)⇒ 拒启;经 `model-route-gap.ts`
- *    的 {@link judgeModelRouteGap}(env 读成本文件判据要的切面,与包根导出的纯判官是**同一只**);严格名册
- *    布防(`isRosterGateArmed`)时 env 腿是占位、从不被派发 ⇒ 不判它(备用网关那一条照判);
- *  · 热路径:`web-admin-client/apply-effective.ts` 的模型面 stage ⇒ 模型面组拒(opus 腿 O3:同候选其余组照落)、上一代模型面继续服务;
- *  · run-local:配置源解析完之后按真要派发的表再判一次(`run-local.ts`,7.98.0 合并复审 F2)—— 本入口没有名册门,
- *    loadConfig 对严格名册布防的占位豁免在这里兑现不了;没布防时恒惰性;
+ * **判官只判「将要服务的那张表」,拒因句按视图说真话**(视图词 = {@link ModelTableLeg} 两词,进判据入参,不靠调用方拼句):
+ *  · boot:装配第 2 段**目录应用之后**的跨域不变量区(`boot/stage-02-web-admin-pull.ts`,锚 `CROSS-INVARIANT:model-route-endpoint`)⇒ 拒启 ——
+ *    经 {@link judgeServedModelRoute}:目录被采纳 ⇒ 判目录表(目录视图),目录缺席 / 被整拒 / 没有启用条目 ⇒ 判 env 表(env 视图);
+ *    严格名册布防(`isRosterGateArmed`)时 env 表是占位、从不被派发 ⇒ 不判它(备用网关那一条与表无关,照判)。
+ *    不在 `loadConfig()`:那是目录应用**之前**,env 表还不知道会不会服务(目录一旦采纳就整张换掉它);
+ *  · 包根导出的 `judgeModelRouteGap(env)`(`model-route-gap.ts`)问的是**env 腿**:「这份 env 交给引擎、没有目录时起不起得来」—— 同一只判据的 env 视图,
+ *    目录在场时起服以目录为准;
+ *  · 热路径:`web-admin-client/apply-effective.ts` 的模型面 stage ⇒ 模型面组拒(opus 腿 O3:同候选其余组照落)、上一代模型面继续服务(目录视图);
+ *  · run-local:配置源解析完之后按真要派发的表判(`run-local.ts`)—— 本入口没有名册门,不豁免占位;
  *  · 登记:`config-invariants.ts` 的 `model-route-endpoint` 条(表的「不许有表外不变量」职责);
  *  · 派发面:titler / hook 选模型(`hooks/hook-llm.ts`)与降级腿 / 启动摘要(`brain.ts`)求有效端点时调
  *    {@link openaiRouteBaseUrl},不再各写一个 `model.baseUrl || gatewayBaseUrl`。
@@ -34,6 +37,7 @@
  * `brain.ts` / `hooks/hook-llm.ts` 都可以安全引它。
  */
 import type { Model } from "@sema-agent/core";
+import { type ModelTableLeg } from "./model-select.js";
 /** 机读码(拼法随 `config.*` 家族,按**规则**命名不按键名):一条 openai 路由解析不到端点。 */
 export declare const MODEL_ROUTE_ENDPOINT_MISSING_CODE = "config.model_route_endpoint_missing";
 /** 同族第二码:备用网关设了、主网关没设。与上一码分开是因为出路不同(补主网关 / 撤备用 vs 补主网关 / 给条目 baseUrl)。 */
@@ -43,7 +47,7 @@ export declare const GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE = "config.gateway_fal
  *
  * 与上面的**码**是两根轴:码是组拒的机读词(`ModelPlaneRefusalCode`,settings-schema 属主),这里是**出路**:
  *  · `endpoint_missing` —— 缺的是网关端点:openai 兼容腿上的条目解析不到 base URL(或备用网关设了、主网关没设);
- *    出路 = 设 `MODEL_GATEWAY_BASEURL`,或给条目自己的 `baseUrl`;
+ *    出路 = 设 `MODEL_GATEWAY_BASEURL`,或(目录视图)给条目自己的 `baseUrl` / (env 视图)挂 anthropic 路由、或不设 `MODEL_ID` 让目录缺省服务;
  *  · `lane_credential_missing` —— 缺的是**车道凭据**:条目的 provider 词是 `anthropic`(用户选的是 anthropic 车道),
  *    却因 `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` 都没有而没装上 anthropic 路由、落进了 openai 腿,那条腿又没有端点;
  *    出路 = 补那两把钥匙之一(设网关是另一条出路,拒因句一并给);
@@ -75,8 +79,11 @@ export type OpenaiRouteEndpoint = {
     readonly ok: false;
     readonly refusal: string;
 };
-/** 单条 openai 路由的有效端点 / 拒因(拒因与部署级判据是**同一只**铸点 {@link routeEndpointMissingRefusal})。 */
-export declare function resolveOpenaiRouteEndpoint(routeName: string, routeBaseUrl: string | undefined, gatewayBaseUrl: string | undefined): OpenaiRouteEndpoint;
+/**
+ * 单条 openai 路由的有效端点 / 拒因(拒因与部署级判据是**同一只**铸点 {@link routeEndpointMissingRefusal};`leg` = 这条路由所在的表的视图词)。
+ * `route` = 这条路由的条目(只读 `baseUrl` 与 `provider`);条目都没有(模型名解不出)⇒ 传 `undefined`,按「无自有 baseUrl、非 anthropic 词」判。
+ */
+export declare function resolveOpenaiRouteEndpoint(routeName: string, route: Pick<Model, "baseUrl" | "provider"> | undefined, gatewayBaseUrl: string | undefined, leg: ModelTableLeg): OpenaiRouteEndpoint;
 /** 部署级判据读的切面(`ServiceConfig` 与 `CrossInvariantView` 都结构满足)。 */
 export interface ModelRouteEndpointView {
     readonly gatewayBaseUrl?: string;
@@ -90,13 +97,13 @@ export interface ModelRouteEndpointView {
  *
  * 判序即语义:
  *  ① 备用网关设了、主网关没设 ⇒ `config.gateway_fallback_without_primary`(备用是主的镜像,这一条与条目无关,先说);
- *  ② 逐条目:按 {@link dispatchBrainLane} 落 openai 腿、且 {@link openaiRouteBaseUrl} 解析不到 ⇒ 收集名字,
+ *  ② 逐条目:按 {@link brainLaneFor}(引擎路由器对本部署路由表的答案)落 openai 腿、且 {@link openaiRouteBaseUrl} 解析不到 ⇒ 收集名字,
  *     一句话**全部点名**(运维一次改完,而不是改一个撞下一个)。
  *
  * `default` 键是目录里另一条的别名(env 腿 `{default: m, [m.id]: m}`、center 腿 `models.default = models[picked]`),
  * 与别的键指同一只对象时不重复点名;只有它一个键时(手搓夹具)照样点名 `default`。
  */
-export declare function modelRouteEndpointRefusal(view: ModelRouteEndpointView): string | undefined;
+export declare function modelRouteEndpointRefusal(view: ModelRouteEndpointView, leg: ModelTableLeg): string | undefined;
 /** S-768:部署级判决的结构化形 —— 码与拒因句由**同一次**判决给出(一个不变量 id 两个码,组拒码在判决那刻当数据带出,不从句子里抠)。 */
 export interface ModelRouteEndpointVerdict {
     readonly code: typeof GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE | typeof MODEL_ROUTE_ENDPOINT_MISSING_CODE;
@@ -107,6 +114,39 @@ export interface ModelRouteEndpointVerdict {
 /**
  * **判据属主**(S-768 起的结构化形;{@link modelRouteEndpointRefusal} 是它的句子投影):`undefined` = 通过。判序即 {@link modelRouteEndpointRefusal}
  * 头注所列 —— ① 备用无主先说,② 逐条目解析不到端点全部点名。加一枝 = 在这里同时给出码与句(返回型强制两者同在)。
+ * `leg` = `view.models` 是哪一张表({@link ModelTableLeg}):判据本身两视图同一把,**句子**按视图铸(出路在 env 表与目录表上不是同一组)。
+ */
+export declare function judgeModelRouteEndpoint(view: ModelRouteEndpointView, leg: ModelTableLeg): ModelRouteEndpointVerdict | undefined;
+/** {@link judgeServedModelRoute} 读的切面:路由判据的切面 + 「服务的是哪张表」的事实(`ServiceConfig` 结构满足)。 */
+export interface ServedModelRouteView extends ModelRouteEndpointView {
+    readonly model: object;
+    readonly envModel: object;
+}
+/** {@link judgeServedModelRoute} 的旁路入参。 */
+export interface ServedModelRouteOptions {
+    /**
+     * env 表是不是**占位**(只在服务的是 env 表时有意义)。严格名册布防(`isRosterGateArmed`:远程 registry ∧ 非 dryRun ∧ `CONFIG_REQUIRE_ROSTER=true`)=
+     * 运维声明 env `MODEL_ID` 是占位:名册落地前计费提交 503、落地后整表换装 ⇒ env 表从不被派发,不在「能派发到的」射程里(备用网关那一条与表无关,照判)。
+     * 布防是中心接入的事实,配置读不出 ⇒ 由调用方给。没有名册门的入口(run-local)传 `false`。
+     */
+    readonly envTableIsPlaceholder: boolean;
+}
+/**
+ * **起服段的路由判官:只判「将要服务的那张表」**。`undefined` = 通过。
+ *
+ * 服务的是哪张表由 {@link servedModelTableLeg} 读出来,判据与句子随它走(同一只属主判据 {@link judgeModelRouteEndpoint},零第二判官):
+ *  · 目录被采纳 ⇒ 判目录表(目录视图;模型面 stage 已对同一张表判过同一只判据,这里是装配终点上的复核);
+ *  · 目录缺席 / 被整拒 / 没有启用条目 ⇒ 判 env 表(env 视图);占位豁免见 {@link ServedModelRouteOptions.envTableIsPlaceholder}。
+ *
+ * 必须在**目录应用之后**调(装配第 2 段 / run-local 配置源解析完):在那之前没有「将要服务的表」可判 ——
+ * 对 env 表提前拒启,会把「条目写进目录、再设 `MODEL_ID`」的部署无谓拒掉(目录一旦采纳,引擎从不读 env `MODEL_ID`)。
+ */
+export declare function judgeServedModelRoute(config: ServedModelRouteView, opts: ServedModelRouteOptions): ModelRouteEndpointVerdict | undefined;
+/**
+ * **没有目录要应用的直接装配**(开发脚本 / 基准 / 嵌入方的纯 env 形:`loadConfig()` → `createBrain` → `Runner`)的拒启口:服务的表就是 `loadConfig()` 铸的 env 表,
+ * 判决 ⇒ 抛(`Error.message` = 判决的 `reason` 原样)。`loadConfig()` 不判路由 —— 没有这一步,缺端点的 env 行会一路跑到第一次模型调用才失败(基准里是十次失败调用、
+ * 全零统计、退出 0)。装配第 2 段与 `run-local` 要锚、要在目录应用之后判,调的是 {@link judgeServedModelRoute};本函数只是它的抛出形。
+ * 源码类钉(`test/served-model-route.test.ts` ⑨):`src/` 与 `scripts/` 里每个调 `loadConfig()` 的入口,要么在同文件里判过路由,要么是登记在册的例外。
  */
-export declare function judgeModelRouteEndpoint(view: ModelRouteEndpointView): ModelRouteEndpointVerdict | undefined;
+export declare function assertServedModelRoute(config: ServedModelRouteView, opts: ServedModelRouteOptions): void;
 //# sourceMappingURL=model-route-endpoint.d.ts.map

package/dist/model-route-endpoint.js

@@ -1,5 +1,5 @@
-import { dispatchBrainLane } from "./model-provider.js";
-import { DEFAULT_MODEL_REF } from "./model-select.js";
+import { brainLaneFor, catalogBrainLane, routeTableOf } from "./model-provider.js";
+import { DEFAULT_MODEL_REF, servedModelTableLeg } from "./model-select.js";
 export const MODEL_ROUTE_ENDPOINT_MISSING_CODE = "config.model_route_endpoint_missing";
 export const GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE = "config.gateway_fallback_without_primary";
 export const MODEL_ROUTE_GAP_WORDS = ["endpoint_missing", "lane_credential_missing", "none"];
@@ -10,14 +10,19 @@ function declared(url) {
 export function openaiRouteBaseUrl(routeBaseUrl, gatewayBaseUrl) {
     return declared(routeBaseUrl) ?? declared(gatewayBaseUrl);
 }
-export function resolveOpenaiRouteEndpoint(routeName, routeBaseUrl, gatewayBaseUrl) {
-    const baseUrl = openaiRouteBaseUrl(routeBaseUrl, gatewayBaseUrl);
-    return baseUrl !== undefined ? { ok: true, baseUrl } : { ok: false, refusal: routeEndpointMissingRefusal([`"${routeName}"`]) };
+function unresolvedRouteLabel(name, provider) {
+    return catalogBrainLane(provider) === "anthropic"
+        ? `"${name}" (provider "anthropic", but no Anthropic route is mounted — ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN are unset — so it falls to the openai-compatible lane)`
+        : `"${name}"`;
 }
-export function modelRouteEndpointRefusal(view) {
-    return judgeModelRouteEndpoint(view)?.reason;
+export function resolveOpenaiRouteEndpoint(routeName, route, gatewayBaseUrl, leg) {
+    const baseUrl = openaiRouteBaseUrl(route?.baseUrl, gatewayBaseUrl);
+    return baseUrl !== undefined ? { ok: true, baseUrl } : { ok: false, refusal: routeEndpointMissingRefusal([unresolvedRouteLabel(routeName, route?.provider)], leg) };
 }
-export function judgeModelRouteEndpoint(view) {
+export function modelRouteEndpointRefusal(view, leg) {
+    return judgeModelRouteEndpoint(view, leg)?.reason;
+}
+export function judgeModelRouteEndpoint(view, leg) {
     const gateway = declared(view.gatewayBaseUrl);
     if (gateway === undefined && view.gatewayFallbackUrls.length > 0) {
         const reason = (`env MODEL_GATEWAY_FALLBACK_URLS is set but MODEL_GATEWAY_BASEURL is not [${GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE}] — ` +
@@ -27,39 +32,56 @@ export function judgeModelRouteEndpoint(view) {
             "or unset MODEL_GATEWAY_FALLBACK_URLS.");
         return { code: GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE, gap: "endpoint_missing", reason };
     }
-    const anthropicMounted = view.anthropic !== undefined;
+    const routes = routeTableOf(view);
     const entries = Object.entries(view.models ?? {});
     const unresolved = [];
     let laneCredentialMissing = false;
     for (const [name, m] of entries) {
         if (name === DEFAULT_MODEL_REF && entries.some(([k, other]) => k !== name && other === m))
             continue;
-        if (dispatchBrainLane(m.provider, anthropicMounted) !== "gateway")
+        if (brainLaneFor(m.provider, routes) !== "gateway")
             continue;
         if (openaiRouteBaseUrl(m.baseUrl, gateway) !== undefined)
             continue;
-        const anthropicWordWithoutRoute = m.provider === "anthropic";
-        laneCredentialMissing ||= anthropicWordWithoutRoute;
-        unresolved.push(anthropicWordWithoutRoute
-            ? `"${name}" (provider "anthropic", but no Anthropic route is mounted — ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN are unset — so it falls to the openai-compatible lane)`
-            : `"${name}"`);
+        laneCredentialMissing ||= catalogBrainLane(m.provider) === "anthropic";
+        unresolved.push(unresolvedRouteLabel(name, m.provider));
     }
     if (unresolved.length === 0)
         return undefined;
-    return { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, gap: laneCredentialMissing ? "lane_credential_missing" : "endpoint_missing", reason: routeEndpointMissingRefusal(unresolved) };
+    return { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, gap: laneCredentialMissing ? "lane_credential_missing" : "endpoint_missing", reason: routeEndpointMissingRefusal(unresolved, leg) };
 }
-function routeEndpointMissingRefusal(quotedNames) {
+function routeEndpointMissingRefusal(quotedNames, leg) {
     const one = quotedNames.length === 1;
     const subject = one ? `model ${quotedNames[0]} rides` : `models ${quotedNames.join(", ")} ride`;
-    return (`${subject} the openai-compatible lane but ${one ? "resolves" : "resolve"} to no endpoint ` +
-        `[${MODEL_ROUTE_ENDPOINT_MISSING_CODE}] — ${one ? "it has no" : "none has a"} baseUrl of its own, and MODEL_GATEWAY_BASEURL is unset. ` +
-        "MODEL_GATEWAY_BASEURL has no factory default: the former silent placeholder (this machine's port 8000) let such a " +
+    const head = `${subject} the openai-compatible lane but ${one ? "resolves" : "resolve"} to no endpoint [${MODEL_ROUTE_ENDPOINT_MISSING_CODE}] — `;
+    const noDefault = "MODEL_GATEWAY_BASEURL has no factory default: the former silent placeholder (this machine's port 8000) let such a " +
         "deployment start fine and then fail on the first model call, far from the cause (\"fetch failed … ECONNREFUSED\", or " +
-        "a container dialling its own loopback when compose passes an empty value). " +
-        `Set it explicitly — for a gateway on this machine: ${LOCAL_GATEWAY_HINT} — or give ${one ? "that model" : "each named model"} its own baseUrl in the catalog. ` +
-        "(A model defined by MODEL_ID / MODEL_CHEAP_ID has no baseUrl of its own: it needs the gateway, or MODEL_PROVIDER=anthropic " +
-        "with ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN. It is judged at boot even when a catalog will replace it later — it is what this " +
-        "process serves whenever no catalog lands: the config source unreachable, a refused candidate, or zero enabled models — unless " +
-        "CONFIG_REQUIRE_ROSTER=true on a remote registry declares it a placeholder that is never served.)");
+        "a container dialling its own loopback when compose passes an empty value). ";
+    switch (leg) {
+        case "catalog":
+            return (head +
+                `${one ? "it has no" : "none has a"} baseUrl of its own, and MODEL_GATEWAY_BASEURL is unset. ` +
+                noDefault +
+                `Set it explicitly — for a gateway on this machine: ${LOCAL_GATEWAY_HINT} — or give ${one ? "that model" : "each named model"} its own baseUrl in the catalog.`);
+        case "env":
+            return (head +
+                `${one ? "it is" : "they are"} defined by env (MODEL_ID / MODEL_CHEAP_ID), which gives ${one ? "it" : "them"} no baseUrl of its own, and MODEL_GATEWAY_BASEURL is unset. ` +
+                noDefault +
+                `This process serves the env model table because no catalog is in force (none configured, the config source unreachable, the candidate refused, or no enabled model in it). Pick one way out: ` +
+                `(1) set MODEL_GATEWAY_BASEURL explicitly — for a gateway on this machine: ${LOCAL_GATEWAY_HINT}; ` +
+                "(2) mount the Anthropic route — MODEL_PROVIDER=anthropic with ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN (plus ANTHROPIC_BASE_URL for a non-default endpoint); " +
+                "(3) leave MODEL_ID unset and let the default entry of a catalog (config.d/models.json, or the web-admin) serve — a catalog in force replaces the env model table. " +
+                "(With CONFIG_REQUIRE_ROSTER=true on a remote registry the env model is declared a placeholder that is never served, and is not judged here.)");
+    }
+}
+export function judgeServedModelRoute(config, opts) {
+    const leg = servedModelTableLeg(config);
+    const view = leg === "env" && opts.envTableIsPlaceholder ? { ...config, models: {} } : config;
+    return judgeModelRouteEndpoint(view, leg);
+}
+export function assertServedModelRoute(config, opts) {
+    const verdict = judgeServedModelRoute(config, opts);
+    if (verdict !== undefined)
+        throw new Error(verdict.reason);
 }
 //# sourceMappingURL=model-route-endpoint.js.map

package/dist/model-route-gap.d.ts

@@ -81,8 +81,8 @@ export interface ModelRouteGapOptions {
 /**
  * 判官的读数(闭集三词,穷举 switch 消费):
  *  · `none` —— 无缺口,仅此一键;
- *  · 缺口两词 —— `code` = 起服拒启的机读码(与 `reason` 里的方括号码同一个词;`lane_credential_missing` 也带 `config.model_route_endpoint_missing`),
- *    `reason` = 起服拒启句原文(点名条目与出路)。
+ *  · 缺口两词 —— `code` = 机读码(与 `reason` 里的方括号码同一个词;`lane_credential_missing` 也带 `config.model_route_endpoint_missing`),
+ *    `reason` = 起服判官对 env 表拒启时的句子原文(env 视图:点名条目与三条 env 出路)。
  */
 export type ModelRouteGapReading = {
     readonly gap: "none";
@@ -94,9 +94,10 @@ export type ModelRouteGapReading = {
     };
 }[ModelRouteGapBreach];
 /**
- * **起服前可调的模型路由缺口纯判官**(与起服判官同一实现;包根导出)。
+ * **起服前可调的模型路由缺口纯判官**(与起服判官判 env 表时同一实现、同一句拒因;包根导出)。答的是 **env 腿**:没有目录在管时,这份 env 起不起得来
+ * (目录在场时起服以目录为准,见文件头注)。
  *
- * @param env 一份 env 快照(只读 {@link MODEL_ROUTE_ENV_KEYS} 那八把键;`process.env` 也行 —— 起服段就是这样调的)。
+ * @param env 一份 env 快照(只读 {@link MODEL_ROUTE_ENV_KEYS} 那八把键;`process.env` 也行)。
  * @returns 三词之一;有缺口时带 `code` 与 `reason`(见 {@link ModelRouteGapReading})。
  */
 export declare function judgeModelRouteGap(env: ModelRouteEnv, opts?: ModelRouteGapOptions): ModelRouteGapReading;

package/dist/model-route-gap.js

@@ -72,7 +72,7 @@ export function judgeModelRouteGap(env, opts = {}) {
         gatewayFallbackUrls: r.gatewayFallbackUrls,
         anthropic: r.anthropicRouteMounted ? {} : undefined,
         models,
-    });
+    }, "env");
     if (verdict === undefined)
         return { gap: "none" };
     return { gap: verdict.gap, code: verdict.code, reason: verdict.reason };

package/dist/model-select.d.ts

@@ -34,6 +34,41 @@ export declare function readAtMention(raw: unknown): AtMention | undefined;
  *  `resolveModel("default", catalog)` 解它)。**单点**:读面要说「这台部署的主模型是谁」时读同一个词
  *  (`auto-mode-face.ts` 的席解析器入参),两处各写一个 `"default"` 字面串正是漂移的成因。 */
 export declare const DEFAULT_MODEL_REF = "default";
+/**
+ * **进程服务的是哪一张模型表**(闭集两词,消费方用穷举 switch —— 加一词不补臂 ⇒ 编译红)。路由端点判官与缺省模型判官的「视图词」:
+ * 拒因句的出路按视图说真话,不靠调用方拼句。
+ *  · `env` —— env 表(`MODEL_ID` / `MODEL_CHEAP_ID` 铸的 `{default, [id]}`):**没有目录在管** —— 没配目录、配置源不可达且无 LKG、
+ *    候选被整拒、或候选没有一条启用条目。env 行永远没有自己的 `baseUrl`;
+ *  · `catalog` —— 目录表:一份目录的模型面落地之后**整张换掉** env 表(`config.model = config.models.default`),引擎从不读 env `MODEL_ID`。
+ */
+export declare const MODEL_TABLE_LEGS: readonly ["env", "catalog"];
+export type ModelTableLeg = (typeof MODEL_TABLE_LEGS)[number];
+/**
+ * 这个进程**此刻**服务的是哪一张表。读法只有一个事实:`config.model` 与 `config.envModel` 是不是同一个对象 ——
+ * `envModel` 在 `loadConfig` 铸一次、此后永不换,并与 `model` 在 boot 那一刻是同一只引用;`model` 的唯一写口是目录的模型面落地
+ * (`web-admin-client/apply-effective.ts` 的 commit 段,`config.model = config.models.default`)。所以「`model` 还是那只 env 模型」⇔
+ * 没有任何一份目录落过模型面 ⇔ 服务的是 env 表。不另记一个会与它漂开的「目录采纳了吗」旗子。
+ */
+export declare function servedModelTableLeg(config: {
+    readonly model: object;
+    readonly envModel: object;
+}): ModelTableLeg;
+/**
+ * 目录服务、而 env 里还设着 `MODEL_ID` ⇒ 启动时说一行(沿 `config_env_set_but_ineffective` 通告族:值合法、却不参与服务)。
+ * 这不是拒:目录一旦被采纳就整张换掉 env 表,`MODEL_ID` 在这一形下本来就不是缺省来源(缺省来自目录)—— 运维该知道自己的那一行
+ * 没在服务,否则会以为改它有效。env 表服务(或没设 `MODEL_ID`)⇒ `undefined`。
+ *
+ * 不读 `process.env`:env 的读数在 `loadConfig` 铸 `envModel` 时已定(`envModel.id` 就是 `MODEL_ID`,空串 = 没设)。
+ * 返回 plain data(事件名 + 字段)。**唯一发声点** = `web-admin-client/apply-effective.ts` 的 `applyEffective` commit 之后、服务表由 env 换成目录的那一拍(进程一生至多一次):
+ * 启动(含 LKG / 按组回落)、`run-local`、迟到 boot、refresh 都经那一个函数,「恰好一次」是构造出来的,没有去重表。
+ */
+export declare function buildEnvModelIdNotServedNotice(config: {
+    readonly model: Pick<Model, "id" | "name">;
+    readonly envModel: Pick<Model, "id">;
+}): {
+    readonly event: string;
+    readonly fields: Record<string, unknown>;
+} | undefined;
 /**
  * 本仓给一条**没选模型**的 task 铸的主模型 —— {@link DEFAULT_MODEL_REF} 在**展开**目录上(与引擎构造期 `expandTiers(models, tiers)`
  * 之后再解逐字同源)解到的那只**目录条目**(对象引用)。`boot/resolve-spec.ts` 每条 spec 都盖 `spec.model`,所以引擎眼里的 main
@@ -153,6 +188,29 @@ export type ModelImageInput = (typeof MODEL_IMAGE_INPUTS)[number];
 export declare function modelImageInput(model: {
     input?: unknown;
 } | undefined): ModelImageInput;
+/**
+ * 「这个目录条目的 `reasoning` 位声明了什么」的**唯一读法**:`true` / `false` 原样,**缺席 = 未声明 = `undefined`**(不替没声明的模型答「是」也不答「否」)。
+ * `GET /v1/models` 的 `reasoning` 列与 `GET /v1/config/catalog` 的 `MODEL_REASONING` 行都投影它。非布尔(手写错形)与条目不在,同归未声明:没有可信的声明。
+ */
+export declare function modelReasoningDecl(model: {
+    reasoning?: unknown;
+} | undefined): boolean | undefined;
+/** 两个能力位的**声明**(三态:`true` / `false` / 缺席 = 未声明)—— 铸 `Model` 上对应键的输入,见 {@link mintCapabilityKeys}。 */
+export interface ModelCapabilityDecl {
+    readonly reasoning?: boolean;
+    readonly vision?: boolean;
+}
+/**
+ * 能力位声明 ⇒ `Model` 上的两个键,**缺席不铸键**:`reasoning` 原样;`vision` 翻成 `input`(`true` ⇒ `["text","image"]`,`false` ⇒ `["text"]`)。
+ * env 腿(`MODEL_REASONING` / `MODEL_VISION`)、cheap 槽(`MODEL_CHEAP_*`)与中心腿(`models[].reasoning` / `vision`)都经它铸 —— 三条腿一个铸法、一个「缺席」的意思。
+ * 读回的唯一读法是 {@link modelReasoningDecl} 与 {@link modelImageInput}(带图预检与 `GET /v1/models` 同读后者)。
+ *
+ * 🔴 **本仓唯一的类型接缝**:引擎 7.51.2 的 `Model` 型面把 `reasoning` / `input` 写成必填,而它自己的读法对缺席有定义 ——
+ * `input` 缺席 ⇒ 支持图(`modelSupportsVision`:`model?.input === undefined ? true : …`),`reasoning` 缺席 ⇒ 真值判假(`!!model.reasoning`)。所以交给引擎的目录里缺席的键是安全的,
+ * 只是型面还没跟上;返回型因此对 `Pick<Model, …>` 说了一句「可能为空」的谎,把断言收在这一处 —— 调用点的 `Model` 字面量照旧带 `Model` 注解(其余每个键仍被 tsc 逐个核,
+ * 读表门按注解收字面量的 core 键)。型面归引擎:引擎把这两位放成可选之日,本接缝(返回型 + 这一处断言)整件删除。
+ */
+export declare function mintCapabilityKeys(decl: ModelCapabilityDecl): Pick<Model, "reasoning" | "input">;
 /**
  * 带图预检:只有目录条目**明说**不收图({@link modelImageInput} 为 `"no"`)才为假 —— 提交时据此计数并告警(引擎会把这些图换成给模型的
  * 占位句);没声明的条目为真(不出信号,图原样交给模型)。

package/dist/model-select.js

@@ -7,6 +7,25 @@ export function readAtMention(raw) {
     return r.success ? r.data : undefined;
 }
 export const DEFAULT_MODEL_REF = "default";
+export const MODEL_TABLE_LEGS = ["env", "catalog"];
+export function servedModelTableLeg(config) {
+    return config.model === config.envModel ? "env" : "catalog";
+}
+export function buildEnvModelIdNotServedNotice(config) {
+    if (servedModelTableLeg(config) !== "catalog" || config.envModel.id === "")
+        return undefined;
+    const served = config.model.name || config.model.id;
+    return {
+        event: "config_env_set_but_ineffective",
+        fields: {
+            env: "MODEL_ID",
+            raw: config.envModel.id,
+            problem: `a catalog is in force and replaces the env model table — the catalog default "${served}" serves this process, and MODEL_ID (with MODEL_CHEAP_ID) takes no part in it; remove the env line or point the catalog's default at the model you mean`,
+            servedBy: "catalog",
+            catalogDefault: served,
+        },
+    };
+}
 export function resolveMainModel(plane) {
     const expanded = expandTiers(plane.models, plane.tiers ?? {}) ?? plane.models;
     return coreResolveTaskModel({ model: DEFAULT_MODEL_REF }, { ...(expanded !== undefined ? { models: expanded } : {}) }).model;
@@ -101,6 +120,18 @@ export function modelImageInput(model) {
         return "undeclared";
     return model.input.includes("image") ? "yes" : "no";
 }
+export function modelReasoningDecl(model) {
+    return typeof model?.reasoning === "boolean" ? model.reasoning : undefined;
+}
+const CAPABILITY_MODEL_KEYS = { reasoning: "reasoning", input: "input" };
+export function mintCapabilityKeys(decl) {
+    const keys = {};
+    if (decl.reasoning !== undefined)
+        keys[CAPABILITY_MODEL_KEYS.reasoning] = decl.reasoning;
+    if (decl.vision !== undefined)
+        keys[CAPABILITY_MODEL_KEYS.input] = decl.vision ? ["text", "image"] : ["text"];
+    return keys;
+}
 export function modelSupportsImages(model) {
     return modelImageInput(model) !== "no";
 }