@sema-agent/server 7.146.0 → 7.148.0

package/dist/memory-sync-client.d.ts

@@ -25,8 +25,9 @@ export declare function buildMemorySyncEnabledFields(peer: string, scope: string
 };
 /**
  * fetch transport(core `MemorySyncTransport` 的部署实现)。`peer` = {@link memorySyncPeerOf}(`url`)(建时铸一次;拒的地址在这里抛,一个请求都不发),
- * `post` 打 `${peer}${path}`(core 传来的 path 以 `/` 开头);`token` 走 Authorization: Bearer(与中心侧 gatedPrincipal 的 verified-principal 门对齐)。
- * 非 2xx throw(status + body 前 200 字节——中心 4xx/5xx 的 typed error body 就是最好的诊断线索);2xx 返回解码后的 JSON(形状校验在 core
+ * `post` 打 `${peer}${path}`(core 传来的 path 以 `/` 开头);`token` 走 Authorization: Bearer(与中心侧 gatedSubject 的 verified-principal 门对齐)。
+ * 非 2xx throw(status + 体长 —— 体的字节不进报错句,与配置中心拉取同一条律:摘录在座前切会把跨界的令牌切成脱敏器认不出的前缀,座后切又会因前面的凭据被压短而
+ * 越过原来的源界、带出词表不认的形;对端是本服务的 `MEMORY_SYNC_SERVE`,拒因在对端自己的运维行);2xx 返回解码后的 JSON(解码经上游读口,不是 JSON ⇒ 句子只带体长;形状校验在 core
  * parseMemorySyncResponse,职责不重复)。`timeoutMs`(缺省 60s,AbortSignal.timeout)是活性保护:fire-and-forget 轮挂死会把 inflight 节流永久卡住
  * (undici 默认 headers 超时 300s 太钝)。
  */
@@ -40,6 +41,8 @@ export declare function createMemorySyncTransport(opts: {
 /** 一层的游标文件路径:引擎根 `memoryEngineDir`(= `RunnerDeps.memoryEngineDir` 的那一个值)下 `sync-cursors/<scope 摘要>.json`。一层一只,不随对端变、不随店变。
  *  落在子目录里:与更早的根下一层文件名 `sync-cursor-<peer>.json` 的空间不相交。 */
 export declare function memorySyncCursorPath(memoryEngineDir: string, scope: string): string;
+/** 全部游标文件的父目录 `<引擎根>/sync-cursors`(游标路径与一次性迁移 M39 的名册同读这一只;缺省 File 记忆引擎根 = 数据根 ⇒ `<数据根>/sync-cursors`)。 */
+export declare function memorySyncCursorDirFor(memoryEngineDir: string): string;
 /**
  * ⑦ 停驻层的出路(闭集;今天唯一成员)。`delete_cursor` = 删掉这一层的游标文件,下一轮从空基线重收敛。读面 `memorySync.parked[].wayOut` 与运维行同读这只词;
  * 加一个词 ⇒ {@link wayOutSentence} 的穷尽 switch 编译红(句子先写好,词才上得了 wire)。

package/dist/memory-sync-client.js

@@ -1,13 +1,16 @@
-import { createHash, randomBytes } from "node:crypto";
-import { mkdir, readFile, readdir, rename, rmdir, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { readFile, readdir, rename, rmdir, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { carriesCredential, syncMemoryScope, } from "@sema-agent/core";
+import { carriesCredential, ensureDir, syncMemoryScope, } from "@sema-agent/core";
 import { replicationCovers } from "./memory-scope.js";
 import { parseProjectLayerKey } from "./project-layer-key.js";
+import { atomicWriteFileAsync } from "./plugins/owner-only-file-mode.js";
 import { ONE_TIME_MIGRATIONS, migrationWindowOpen } from "./plugins/one-time-migrations.js";
 import { buildMemorySyncIdentityBootRefusal, readMemorySyncIdentity } from "./memory-sync-identity.js";
 import { buildDisplaySafeUrl } from "./trace/redact.js";
+import { createEgressFetch } from "./egress-redirect.js";
 import { errorText } from "./observability/err-text.js";
+import { buildBodyWithheldNote, parseUpstreamJson } from "./upstream-body.js";
 export function memorySyncPeerOf(url) {
     const r = readMemorySyncIdentity(url);
     if ("flaw" in r) {
@@ -21,7 +24,8 @@ export function buildMemorySyncEnabledFields(peer, scope, cursorPath) {
 }
 export function createMemorySyncTransport(opts) {
     const peer = memorySyncPeerOf(opts.url);
-    const fetchImpl = opts.fetchImpl ?? fetch;
+    const injected = opts.fetchImpl;
+    const fetchImpl = createEgressFetch("declare the final address as MEMORY_SYNC_URL", injected === undefined ? undefined : (input, init) => injected(typeof input === "string" ? input : input instanceof URL ? input.href : input.url, init ?? {}));
     const timeoutMs = opts.timeoutMs ?? 60_000;
     return Object.freeze({
         peer,
@@ -34,8 +38,8 @@ export function createMemorySyncTransport(opts) {
             });
             const text = await res.text();
             if (!res.ok)
-                throw new Error(`memory sync POST ${path}: HTTP ${res.status} ${text.slice(0, 200)}`);
-            return JSON.parse(text);
+                throw new Error(`memory sync POST ${path}: HTTP ${res.status} ${buildBodyWithheldNote(text)}`);
+            return parseUpstreamJson(text);
         },
     });
 }
@@ -44,7 +48,10 @@ function scopeDigest(scope) {
     return createHash("sha256").update(scope, "utf8").digest("hex").slice(0, 32);
 }
 export function memorySyncCursorPath(memoryEngineDir, scope) {
-    return join(memoryEngineDir, SYNC_CURSOR_DIR, `${scopeDigest(scope)}.json`);
+    return join(memorySyncCursorDirFor(memoryEngineDir), `${scopeDigest(scope)}.json`);
+}
+export function memorySyncCursorDirFor(memoryEngineDir) {
+    return join(memoryEngineDir, SYNC_CURSOR_DIR);
 }
 const CURSOR_AXES = { scope: true, peer: true, store: true, incarnation: true };
 const CURSOR_FOUND = { absent: true, other: true };
@@ -142,10 +149,8 @@ async function loadLayerBaseline(path, scope) {
     return { kind: "cursor", cursor };
 }
 async function saveCursor(path, cursor) {
-    await mkdir(dirname(path), { recursive: true });
-    const tmp = `${path}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
-    await writeFile(tmp, JSON.stringify(cursor), "utf8");
-    await rename(tmp, path);
+    ensureDir(dirname(path));
+    await atomicWriteFileAsync(path, JSON.stringify(cursor), { durability: "best-effort" });
 }
 const LEGACY_PEER_SEGMENT = "central";
 const LEGACY_ROOT_CURSOR_FILE = "sync-cursor-central.json";
@@ -191,7 +196,7 @@ export async function relocateSyncCursorsM31(memoryEngineDir, log, opts) {
             log.warn("memory_sync_cursor_not_relocated", { path: from, to, note: "this layer already has a cursor at its path, so the file written by an earlier version stays where it is and no round reads it; delete it" });
             return;
         }
-        await mkdir(dirname(to), { recursive: true });
+        ensureDir(dirname(to));
         try {
             await rename(from, to);
         }
@@ -203,7 +208,7 @@ export async function relocateSyncCursorsM31(memoryEngineDir, log, opts) {
         moved += 1;
         log.info("memory_sync_cursor_relocated", { from, to });
     };
-    const legacyDir = join(memoryEngineDir, SYNC_CURSOR_DIR, LEGACY_PEER_SEGMENT);
+    const legacyDir = join(memorySyncCursorDirFor(memoryEngineDir), LEGACY_PEER_SEGMENT);
     let names = [];
     try {
         names = await readdir(legacyDir);
@@ -214,7 +219,7 @@ export async function relocateSyncCursorsM31(memoryEngineDir, log, opts) {
     }
     for (const name of [...names].sort()) {
         if (/^[0-9a-f]{32}\.json$/.test(name))
-            await move(join(legacyDir, name), join(memoryEngineDir, SYNC_CURSOR_DIR, name));
+            await move(join(legacyDir, name), join(memorySyncCursorDirFor(memoryEngineDir), name));
     }
     if (names.length > 0) {
         try {

package/dist/memory-sync.js

@@ -219,7 +219,7 @@ export async function performMemorySync(backend, sync, scope, req, now = Date.no
     const patches = [
         ...plan.pull.map((e) => {
             const base = req.baseRevs[e.id];
-            return base !== undefined ? { op: "update", id: e.id, entry: e, baseRev: base } : { op: "add", id: e.id, entry: e };
+            return base !== undefined ? { op: "update", id: e.id, entry: e, baseRev: base } : { op: "add", id: e.id, entry: e, guard: "absent" };
         }),
         ...plan.deleteLocal.map((d) => ({ op: "delete", id: d.id, baseRev: d.baseRev })),
     ];

package/dist/model-compat.d.ts

@@ -1,6 +1,8 @@
 /**
- * `Model.compat` —— 一只模型对 **openai-completions 线路**的兼容声明(core `OpenAICompletionsCompat`;
- * 声明面 settings-schema 1.10.0 `ModelEntry.compat`)。本模块是**两条腿共用的唯一判据点 + 唯一铸点**,
+ * `Model.compat` —— 一只模型对**它那条线路**的兼容声明(声明面 settings-schema 1.10.0 `ModelEntry.compat`,契约包解析透明、形归本服务):
+ * openai-completions 条目读 core `OpenAICompletionsCompat`,anthropic-messages 条目读 core `AnthropicMessagesCompat`(**按线路读**,
+ * 线路 = 条目的 `api`:core 的 `Model.compat` 按 `TApi` 分型,契约 `ModelEntry` 强制 `provider:"anthropic"` ⟺ `api:"anthropic-messages"`)。
+ * 本模块是**两条腿共用的唯一判据点 + 唯一铸点**,
  * 与 `toolFaces` 的读法(引擎根导出的 `readToolFaces`,`task-mcp.ts` / `skills-mcp.ts` 两腿同问)同一个「判据单点、多腿一致」的形。
  *
  * ## 它治的病(1.10.0 CHANGELOG + core 型面顶注双向亲读)
@@ -11,10 +13,10 @@
  * 真需求 = vLLM / Qwen 类**缺省开思考**的网关:关思考只能靠 `chat_template_kwargs.enable_thinking=false`
  * (`thinkingFormat: "qwen-chat-template"`),否则 auto 档每一轮都白烧一段思考。
  *
- * ## 三张对表全部**从 core 的型面铸**,本仓一个词都不枚举
- * `THINKING_LEVEL_TABLE` / `THINKING_FORMAT_TABLE` / `MAX_TOKENS_FIELD_TABLE` 都是 `Record<闭集词, true>`,
- * `COMPAT_KEY_READERS` 是 `{ [K in keyof Required<OpenAICompletionsCompat>]: 读器 }` 的**映射型**:
- * core 加词/删词、加键/删键,四张表当场 tsc 红(`MODEL_DEGRADE_ON` 的 `Set<DegradeReason>` 同款纪律)。
+ * ## 对表全部**从 core 的型面铸**,本仓一个词都不枚举
+ * `THINKING_TIER_TABLE` / `MODEL_THINKING_LEVEL_TABLE` / `THINKING_FORMAT_TABLE` / `MAX_TOKENS_FIELD_TABLE` / `THINKING_MODE_TABLE` 都是 `Record<闭集词, true>`,
+ * `COMPAT_KEY_READERS` 是 `{ [A in 线路]: { [K in keyof Required<Model<A>["compat"]>]: 读器 } }` 的**映射型**(线路 = 契约 `ModelEntry.api` 的闭集):
+ * core 加词/删词、加键/删键,或契约加一条线路,表当场 tsc 红(`MODEL_DEGRADE_ON` 的 `Set<DegradeReason>` 同款纪律)。
  * 映射型这一步是刻意的 —— 只钉「键集相等」会留下一个洞:core 加一键、有人把它补进白名单却忘了写读器,
  * 于是这个键被**允许但不读** = 静默丢。读器与键集是**同一张表**,那个洞在结构上不存在。
  *
@@ -27,20 +29,35 @@
  * 反方向(整只模型不进)的代价则不成比例:一个拼错的 `thinkingFormat` 会让这只模型从目录里消失,
  * 用户面直接是 `request.unknown_reference`。
  *
- * 判形**整只判**:任一键不合 ⇒ 整只声明不收(和 `toolFaces` 每只工具「applied whole or not at all」
+ * 判形**整只判**(每条线路内):任一键不合 —— 含写了另一条线路的键 —— ⇒ 整只声明不收(和 `toolFaces` 每只工具「applied whole or not at all」
  * 同律)。留下好的那几键 = 让运维以为整条声明生效了,而实际发出去的请求是半张脸。
  */
-import type { Model } from "@sema-agent/core";
-/** core `OpenAICompletionsCompat` —— core 的 index 没有按名导出它,从 `Model` 的**型面**取
- *  (`Model<TApi>` 的 `compat` 按 api 分叉;openai 那支就是它)。这不是抄一份结构,是引用同一个型。 */
-export type OpenAICompletionsCompat = NonNullable<Model<"openai-completions">["compat"]>;
-/** 六档思考梯(core `ThinkingLevel`)。`MODEL_DEFAULT_THINKING` / `MODEL_REASONING_EFFORT_LEVELS` /
- *  `compat.reasoningEffortLevels` 三处共用**这一张**表 —— [ref] 件⑤ 起就是「上游加一档而这里不补 ⇒
- *  编译红」的锁步姿势,本模块只是把它挪到了它真正的家(compat 的一个键)。 */
+import { type Model } from "@sema-agent/core";
+import type { ModelEntry } from "@sema-agent/settings-schema";
+/** 目录条目的线路闭集 = 契约 `ModelEntry.api`(契约加一条线路 ⇒ 读器表缺一行 ⇒ tsc 红)。 */
+export type CatalogApi = ModelEntry["api"];
+/** 一条线路的 compat 型 —— core 的 index 没有按名导出它们,从 `Model` 的**型面**取(`Model<TApi>` 的 `compat` 按 api 分叉)。这不是抄一份结构,是引用同一个型。 */
+export type CompatOf<A extends CatalogApi> = NonNullable<Model<A>["compat"]>;
+/** core `OpenAICompletionsCompat`。 */
+export type OpenAICompletionsCompat = CompatOf<"openai-completions">;
+/** core `AnthropicMessagesCompat`。 */
+export type AnthropicMessagesCompat = CompatOf<"anthropic-messages">;
+/** 六档思考**梯**(core `ThinkingLevel`:一个端点吃得下哪几档的 effort 梯子)。型取自梯子座本身 —— `compat.reasoningEffortLevels`
+ *  (anthropic 线路的 `effortLevels` 同型)—— 而不是模型缺省档座:core 7.66.0 [ref] HB-1 起两座分家,缺省档多一档 `off`,梯子仍是六档
+ *  (`off` 永远不是梯子上的一级)。`MODEL_REASONING_EFFORT_LEVELS` / `compat.reasoningEffortLevels` / `compat.effortLevels` 共用**这一张**表;
+ *  上游加一档而这里不补 ⇒ 编译红([ref] 件⑤ 起的锁步姿势)。 */
+export type ThinkingTier = NonNullable<OpenAICompletionsCompat["reasoningEffortLevels"]>[number];
+/** 六档梯闭集(有序:低→高,取自上表的书写序),梯子两根旋钮的拒因文案与读器的单一真源。 */
+export declare const THINKING_LEVELS: readonly ThinkingTier[];
+export declare const isThinkingTier: (w: unknown) => w is ThinkingTier;
+/** 模型**缺省档**(core `ModelThinkingLevel` = `off` + 六档;`Model.defaultThinking` 的型):请求与角色都没点档时这只模型的请求走哪一档,
+ *  `off` = 缺省关(引擎发线路上的显式关),**不是**「没有缺省」—— 没有缺省 = 不铸键(core 7.66.0 [ref])。表 = 梯子六档 + `off`(展开同一张梯表,不写第二份);
+ *  core 给缺省档座加 / 删一词而这里不跟 ⇒ 编译红。 */
 export type ModelThinkingLevel = NonNullable<Model["defaultThinking"]>;
-/** 六档闭集(有序:低→高,取自上表的书写序),目录行 `enumValues` 与拒因文案的单一真源。 */
-export declare const THINKING_LEVELS: readonly ModelThinkingLevel[];
-export declare const isThinkingTier: (w: unknown) => w is ModelThinkingLevel;
+/** 七档缺省闭集(六档梯在前、`off` 在末,取自上表的书写序):`MODEL_DEFAULT_THINKING` 的目录 `enumValues` 与拒因文案的单一真源。 */
+export declare const MODEL_THINKING_LEVELS: readonly ModelThinkingLevel[];
+/** 七档判词 = core 包根的 `isThinkingLevel`(引擎自己判这七档的那一只;上表只留作有序列表与编译期锁步,不另写第二只判词)。 */
+export declare const isModelThinkingLevel: (w: unknown) => w is ModelThinkingLevel;
 /** `thinkingFormat` 七词闭集(core:openai / openrouter / deepseek / together / zai / qwen / qwen-chat-template)。 */
 export type ModelThinkingFormat = NonNullable<OpenAICompletionsCompat["thinkingFormat"]>;
 export declare const THINKING_FORMATS: readonly ModelThinkingFormat[];
@@ -48,34 +65,40 @@ export declare const isThinkingFormat: (w: unknown) => w is ModelThinkingFormat;
 /** `maxTokensField` 两词闭集(缺席 ⇒ core 按模型 id 推断,见 `inferMaxTokensField`)。 */
 export type ModelMaxTokensField = NonNullable<OpenAICompletionsCompat["maxTokensField"]>;
 export declare const MAX_TOKENS_FIELDS: readonly ModelMaxTokensField[];
-type CompatKey = keyof Required<OpenAICompletionsCompat>;
-/** 五键闭集(书写序取自上表),未知键拒因文案的单一真源。 */
-export declare const MODEL_COMPAT_KEYS: readonly CompatKey[];
+/** anthropic 线路 `thinkingMode` 两词闭集(core:`budget` = `thinking:{type:"enabled",budget_tokens}`;`adaptive` = `thinking:{type:"adaptive"}`、无 budget、关不掉)。 */
+export type AnthropicThinkingMode = NonNullable<AnthropicMessagesCompat["thinkingMode"]>;
+export declare const ANTHROPIC_THINKING_MODES: readonly AnthropicThinkingMode[];
+type CompatKey<A extends CatalogApi> = keyof Required<CompatOf<A>>;
+/** 每条线路的键闭集(书写序取自上表),未知键拒因文案与铸点遍历的单一真源。 */
+export declare const MODEL_COMPAT_KEYS: {
+    readonly [A in CatalogApi]: readonly CompatKey<A>[];
+};
 /**
  * 一条目录条目的 `compat` 判形结果:
  *  · `{ ok: true, compat }` —— 合形(`compat` 缺席 = 这条条目没有声明,或声明了一个**空**对象:
  *    两者对 core 同义,都不铸键);
  *  · `{ ok: false, issue }` —— 判不出形,调用方**整只丢**这条声明并留一句 warn(见模块头注)。
- *    `issue` 只带键名与哪一段不合,**不带值** —— 与 `source` / `toolFaces` 同一条留痕纪律。
+ *    `issue` 只带线路、键名与哪一段不合,**不带值** —— 与 `source` / `toolFaces` 同一条留痕纪律。
  */
-export type ModelCompatRead = {
+export type ModelCompatRead<A extends CatalogApi> = {
     ok: true;
-    compat?: OpenAICompletionsCompat;
+    compat?: CompatOf<A>;
 } | {
     ok: false;
     issue: string;
 };
-/** 从任一腿的原始条目里读出 `compat` —— **本地 config.d 腿与 center 腿共用的唯一判据点**。 */
-export declare function readModelCompat(v: unknown): ModelCompatRead;
+/** 从任一腿的原始条目里读出 `compat`(按条目的线路)—— **本地 config.d 腿与 center 腿共用的唯一判据点**。 */
+export declare function readModelCompat<A extends CatalogApi>(api: A, v: unknown): ModelCompatRead<A>;
 /**
- * `Model.compat` 的**唯一铸点**(env 腿与目录腿都经这里)。层序 = 优先级,**前层逐键赢、后层补缺席**
+ * `Model.compat` 的**唯一铸点**(env 腿与目录腿都经这里;按线路)。层序 = 优先级,**前层逐键赢、后层补缺席**
  * (BL-8:目录条目声明 ?? env 缺省 —— 不是整只替换,否则一条只写了 `thinkingFormat` 的目录条目会把
  * 部署级的 `MODEL_REASONING_EFFORT_LEVELS` 静默吃掉,正是 `contextWindow`/`maxTokens` 那一族的老病)。
+ * 层必须是同一条线路的声明(调用方只把同线路的 env 缺省叠进来 —— 见 `toModel`)。
  *
  * 归一两条(两腿因此对同一个空值给出同一个下场):值 `undefined` = 这一层没声明这一键;
- * `reasoningEffortLevels` 为**空表** = 没声明这一键(env 腿的空 CSV 与目录腿的 `[]` 同义)。
+ * 数组值为**空表** = 没声明这一键(`reasoningEffortLevels` / `effortLevels`;env 腿的空 CSV 与目录腿的 `[]` 同义)。
  * 全空 ⇒ 回 `undefined` = **不铸这个键**(缺席 = core 走自己的推断 = 今日行为)。
  */
-export declare function buildModelCompat(...layers: ReadonlyArray<OpenAICompletionsCompat | undefined>): OpenAICompletionsCompat | undefined;
+export declare function buildModelCompat<A extends CatalogApi>(api: A, ...layers: ReadonlyArray<CompatOf<A> | undefined>): CompatOf<A> | undefined;
 export {};
 //# sourceMappingURL=model-compat.d.ts.map

package/dist/model-compat.js

@@ -1,52 +1,84 @@
-const THINKING_LEVEL_TABLE = { minimal: true, low: true, medium: true, high: true, xhigh: true, max: true };
-export const THINKING_LEVELS = Object.keys(THINKING_LEVEL_TABLE);
+import { isThinkingLevel } from "@sema-agent/core";
+const THINKING_TIER_TABLE = { minimal: true, low: true, medium: true, high: true, xhigh: true, max: true };
+export const THINKING_LEVELS = Object.keys(THINKING_TIER_TABLE);
 export const isThinkingTier = (w) => typeof w === "string" && THINKING_LEVELS.includes(w);
+const MODEL_THINKING_LEVEL_TABLE = { ...THINKING_TIER_TABLE, off: true };
+export const MODEL_THINKING_LEVELS = Object.keys(MODEL_THINKING_LEVEL_TABLE);
+export const isModelThinkingLevel = (w) => isThinkingLevel(w);
 const THINKING_FORMAT_TABLE = { openai: true, openrouter: true, deepseek: true, together: true, zai: true, qwen: true, "qwen-chat-template": true };
 export const THINKING_FORMATS = Object.keys(THINKING_FORMAT_TABLE);
 export const isThinkingFormat = (w) => typeof w === "string" && THINKING_FORMATS.includes(w);
 const MAX_TOKENS_FIELD_TABLE = { max_tokens: true, max_completion_tokens: true };
 export const MAX_TOKENS_FIELDS = Object.keys(MAX_TOKENS_FIELD_TABLE);
+const THINKING_MODE_TABLE = { budget: true, adaptive: true };
+export const ANTHROPIC_THINKING_MODES = Object.keys(THINKING_MODE_TABLE);
+const readBoolean = (v) => (typeof v === "boolean" ? v : undefined);
+const readLadder = (v) => (Array.isArray(v) && v.every(isThinkingTier) ? v : undefined);
 const COMPAT_KEY_READERS = {
-    supportsReasoningEffort: (v) => (typeof v === "boolean" ? v : undefined),
-    requiresReasoningContentOnAssistantMessages: (v) => (typeof v === "boolean" ? v : undefined),
-    maxTokensField: (v) => (typeof v === "string" && MAX_TOKENS_FIELDS.includes(v) ? v : undefined),
-    thinkingFormat: (v) => (isThinkingFormat(v) ? v : undefined),
-    reasoningEffortLevels: (v) => (Array.isArray(v) && v.every(isThinkingTier) ? v : undefined),
+    "openai-completions": {
+        supportsReasoningEffort: readBoolean,
+        requiresReasoningContentOnAssistantMessages: readBoolean,
+        maxTokensField: (v) => (typeof v === "string" && MAX_TOKENS_FIELDS.includes(v) ? v : undefined),
+        thinkingFormat: (v) => (isThinkingFormat(v) ? v : undefined),
+        reasoningEffortLevels: readLadder,
+    },
+    "anthropic-messages": {
+        thinkingMode: (v) => (typeof v === "string" && ANTHROPIC_THINKING_MODES.includes(v) ? v : undefined),
+        effortLevels: readLadder,
+        supportsTemperature: readBoolean,
+        contextManagement: readBoolean,
+        interleavedThinking: readBoolean,
+    },
 };
-export const MODEL_COMPAT_KEYS = Object.keys(COMPAT_KEY_READERS);
-const isCompatKey = (k) => MODEL_COMPAT_KEYS.includes(k);
-export function readModelCompat(v) {
+export const MODEL_COMPAT_KEYS = {
+    "openai-completions": Object.keys(COMPAT_KEY_READERS["openai-completions"]),
+    "anthropic-messages": Object.keys(COMPAT_KEY_READERS["anthropic-messages"]),
+};
+const isKeyOf = (table, k) => Object.hasOwn(table, k);
+export function readModelCompat(api, v) {
     if (v === undefined)
         return { ok: true };
     if (v === null || typeof v !== "object" || Array.isArray(v))
         return { ok: false, issue: `compat is ${v === null ? "null" : Array.isArray(v) ? "an array" : typeof v}, not an object of wire-compat keys` };
+    return COMPAT_LEGS[api].read(v);
+}
+function readCompatWith(api, readers, v) {
     const out = {};
     for (const [k, raw] of Object.entries(v)) {
-        if (!isCompatKey(k))
-            return { ok: false, issue: `unknown key ${JSON.stringify(k)} (valid: ${MODEL_COMPAT_KEYS.join(" | ")})` };
-        const read = COMPAT_KEY_READERS[k](raw);
+        if (!isKeyOf(readers, k))
+            return { ok: false, issue: `unknown key ${JSON.stringify(k)} for an ${api} entry (valid: ${Object.keys(readers).join(" | ")})` };
+        const read = readers[k](raw);
         if (read === undefined)
-            return { ok: false, issue: `key ${JSON.stringify(k)} does not fit the wire-compat shape` };
+            return { ok: false, issue: `key ${JSON.stringify(k)} does not fit the ${api} wire-compat shape` };
         out[k] = read;
     }
     return Object.keys(out).length > 0 ? { ok: true, compat: out } : { ok: true };
 }
-export function buildModelCompat(...layers) {
+export function buildModelCompat(api, ...layers) {
+    return COMPAT_LEGS[api].build(layers);
+}
+const declaresKey = (v) => v !== undefined && !(Array.isArray(v) && v.length === 0);
+function buildCompatWith(keys, layers) {
     const out = {};
     for (const layer of layers) {
         if (layer === undefined)
             continue;
-        for (const k of MODEL_COMPAT_KEYS) {
-            if (k in out)
+        for (const k of keys) {
+            if (Object.hasOwn(out, k) || !declaresKey(layer[k]))
                 continue;
-            const v = layer[k];
-            if (v === undefined)
-                continue;
-            if (k === "reasoningEffortLevels" && Array.isArray(v) && v.length === 0)
-                continue;
-            out[k] = v;
+            out[k] = layer[k];
         }
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
+const COMPAT_LEGS = {
+    "openai-completions": {
+        read: (v) => readCompatWith("openai-completions", COMPAT_KEY_READERS["openai-completions"], v),
+        build: (layers) => buildCompatWith(MODEL_COMPAT_KEYS["openai-completions"], layers),
+    },
+    "anthropic-messages": {
+        read: (v) => readCompatWith("anthropic-messages", COMPAT_KEY_READERS["anthropic-messages"], v),
+        build: (layers) => buildCompatWith(MODEL_COMPAT_KEYS["anthropic-messages"], layers),
+    },
+};
 //# sourceMappingURL=model-compat.js.map

package/dist/model-context-window.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The window this server ASSUMES for a model whose context window nobody declared — ONE spelling of the number.
+ *
+ * Three readers fall back to it and nothing else may carry a copy: the env leg (`config.ts`: `MODEL_CONTEXT_WINDOW` unset ⇒ this value,
+ * and the `MODEL_MAX_TOKENS` default `min(32000, window)` reads the SAME resolved window), the center leg (`web-admin-client/apply-effective.ts`:
+ * `entry.contextWindow ?? env model's window ?? this value`) and the config catalog's default note (`config-catalog.ts`). A literal copied
+ * into any of them is a second source that drifts the day the assumption changes — a center roster would then assume one window while
+ * the env model assumes another, and the operator-facing default note would name a third.
+ *
+ * This is a conservative CEILING GUESS, not a measurement: the engine needs a window to size its compaction trigger and the tool-schema
+ * defer threshold, and an undeclared window must never be read optimistically — so every model that reaches the engine carries SOME window,
+ * declared or this one (a catalog entry may omit `contextWindow`; the readers above fill it). Whether the value is conservative for a
+ * given model is a per-model question this constant does not answer.
+ *
+ * Pure leaf: no imports.
+ */
+export declare const ASSUMED_CONTEXT_WINDOW = 262144;
+//# sourceMappingURL=model-context-window.d.ts.map

package/dist/model-context-window.js

@@ -0,0 +1,2 @@
+export const ASSUMED_CONTEXT_WINDOW = 262144;
+//# sourceMappingURL=model-context-window.js.map

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

@@ -1,3 +1,44 @@
+/**
+ * [ref](7.108.0;cli [ref] [ref],server [ref] ② 认领)—— 模型目录条目 `headers`:**部署 ↔ 供应商**的附加请求头。
+ * 本模块是它的**唯一判据点**(白名单 + 形)与**唯一铸点**(铸进 core `Model.headers` 的那张袋)。
+ *
+ * ## 病
+ * core 的三只一方 brain 早有附加头的座(构造项 `headers` 与 per-model 的 `Model.headers`,三只 adapter 都按
+ * `mergeHeaders(model.headers, config.headers, options.headers)` 合并;anthropic 腿再把 `anthropic-beta` 与它自己的 beta
+ * 按 core [ref] 的读并合并律并成一个头),本仓零读点 ⇒ 壳的 `--betas` / `ANTHROPIC_BETAS`(开 1M 上下文等 beta)进不了引擎发出的请求。
+ *
+ * ## 座位:per-model(`Model.headers`),不是 per-route(brain 构造项 `headers`)
+ * 目录条目是**一只模型**的声明;brain 构造项的那个袋是**整条路由**共享的(一台部署一只 anthropic brain,所有 anthropic 条目都走它)——
+ * 放在那里会把一条条目的 beta 发给同路由的每一只模型。core 的 per-model 座就是为这件事开的(`Model.headers`,core 型面注:
+ * 「Cannot override auth / content-type / version」—— 鉴权头与结构头在合并之后由 brain 硬锁)。
+ *
+ * ## 白名单:闭集,每个名字带「读它的线路」({@link CATALOG_ENTRY_HEADER_LANES})
+ *  · 名字闭集 —— 表外一律拒。这不是洁癖,是**凭据轴**:`Model.headers` 上的 `authorization` / `x-api-key` 会被 core 的配对法读成
+ *    per-model 凭据(「构造即配对」,off-root 也放行),等于在托管钥匙(`sealedApiKey` / `apiKeyEnv`)之外开一条明文凭据的路;
+ *    路由 / 追踪类头同理是部署的事,要一条一条想清楚再进表。
+ *  · 只认**规范拼写**(小写):HTTP 头名大小写不敏感,两种拼法并存 = 同一只袋里两个写者;`Anthropic-Beta` 按表外拒(拒句给出规范拼写)。
+ *  · 名字带线路:`anthropic-beta` 只有 Anthropic Messages 线路读(`api: "anthropic-messages"`)。声明在不读它的条目上 ⇒ 拒 ——
+ *    否则运维以为开了 1M 上下文、请求发出去什么都没变(一个只声明不生效的旋钮,正是本仓 `model_compat_dropped` 那一族立案的病)。
+ *  · 值:可见 ASCII(首尾非空白,中间可有空格),≤ {@link MAX_HEADER_VALUE_CHARS} —— CR / LF / NUL 这类会让传输层在每次请求时才抛的值
+ *    在配置期就拒;值**逐字**透传(不改大小写、不去重 —— 合并是 core 的事)。
+ *
+ * ## 坏声明的方向:条目整条不可用(`config.model_entry_invalid`),不是「丢头、条目照常」
+ * 与 `compat` 的降级通道刻意分歧:本座一半是凭据轴(表外名字里有鉴权头),另一半是「运维以为生效了」—— 丢头照常服务正是修前的病形。
+ * 执法点 = [ref] 的逐条判据 `judgeCatalogEntry`(同一个码、同一条 warn、同一条「显式选中它 ⇒ `request.model_unavailable`」的路),
+ * 其余条目照常服务。拒因与 warn **只回显名字**(过 {@link displayHeaderName}),从不回显值。
+ *
+ * ## 两条读腿今天到不了这里(候裁「settings-schema `ModelEntry` 加 `headers`」,[ref] 字段归 server 自持)
+ * settings-schema 6.3.0 的 `ModelEntry` 没有这个键 ⇒ 远端 `readEffectiveWire` 与本地 `FileConfigStore` 都 strip 它(并报未知键)。
+ * 本模块服务的输入今天只有绕过读腿的那几条(盘上 LKG / 手写 effective);字段进 schema 之日,`config-provider.ts` 的本地投影加一行即通,
+ * `test/catalog-entry-headers.test.ts` 的 🚧 [ref]-schema 两格翻红逼销账。**词表不在 schema 里另抄一份**:schema 的那个键应当是
+ * 承载形(与 `compat` 同一种 parse-transparent + 自由形安全判),判据仍是本模块这一处 —— 或者整张表搬进 schema、本仓 import;
+ * 二选一候裁,不许两处各有一份。
+ *
+ * 依赖纪律:叶(只 type-import core、值引 `trace/redact.ts` 的名字回显尺)。
+ */
+import type { Model } from "@sema-agent/core";
+/** 条目的线路词(core `Model["api"]`,不手抄)。 */
+type ModelApi = Model["api"];
 /**
  * 白名单 = 名字 → 读它的线路(闭集;**加一个名字 = 加一行并写明哪条线路读它、为什么是部署的事**)。
  * `anthropic-beta`:Anthropic Messages 的 beta 开关(逗号分隔的 beta 名;core anthropic 腿会把自己的 beta 并进同一个头)。
@@ -28,17 +69,18 @@ export type CatalogEntryHeadersVerdict = {
     readonly issue: string;
 };
 /**
- * **唯一判据**:条目的 `headers` 原值(`unknown`:承载形,不信类型)+ 条目的线路词原值(`api`;两条读腿恒补齐它,
- * 绕过读腿的输入缺它 ⇒ 按「没有线路读它」拒 —— 判据与铸点读同一个原值,不另补一份 schema 缺省)。
+ * **唯一判据**:条目的 `headers`(`unknown`:承载形,不信类型)+ 条目的线路词(`api`)—— 两者都取判官那一次 settings-schema 解析的读数
+ * (缺席的 `api` 即 schema 的缺省),判据与铸点读同一只值,见 `judgeCatalogEntry`。
  * 整只判:任一名字 / 值不合 ⇒ 整只不收(留下好的那几个 = 让运维以为整袋生效了)。坏字段逐个列出(`headers.<名>`)。
  */
-export declare function readCatalogEntryHeaders(raw: unknown, api: unknown): CatalogEntryHeadersVerdict;
+export declare function readCatalogEntryHeaders(raw: unknown, api: ModelApi): CatalogEntryHeadersVerdict;
 /**
  * **唯一铸点**(`toModel` 调):判过的袋 → `Model.headers` 的键。缺席 ⇒ 不铸键(一个 `undefined` 值的键也不铸:
  * 缺席只有一种拼法)。判不过 ⇒ **抛**:到这里的条目已经过 [ref] 逐条判据(判不过的进 `modelRefusals`、到不了 `toModel`),
  * 抛 = 两处判据分叉了,stage 整候选拒、响亮,不静默丢头。
  */
-export declare function buildModelHeadersKey(entryName: string, raw: unknown, api: unknown): {
+export declare function buildModelHeadersKey(entryName: string, raw: unknown, api: ModelApi): {
     headers?: Record<string, string>;
 };
+export {};
 //# sourceMappingURL=model-entry-headers.d.ts.map

package/dist/model-entry-headers.js

@@ -35,9 +35,9 @@ export function readCatalogEntryHeaders(raw, api) {
             continue;
         }
         const lanes = CATALOG_ENTRY_HEADER_LANES[name];
-        if (typeof api !== "string" || !lanes.includes(api)) {
+        if (!lanes.includes(api)) {
             fields.push(field);
-            issues.push(`${field}: only read on the ${lanes.join(" / ")} lane — this entry ${typeof api === "string" ? `is api "${api}"` : "declares no api"}, where the header would be sent and do nothing`);
+            issues.push(`${field}: only read on the ${lanes.join(" / ")} lane — this entry is api "${api}", where the header would be sent and do nothing`);
             continue;
         }
         if (typeof value !== "string" || value.length > MAX_HEADER_VALUE_CHARS || !HEADER_VALUE_SHAPE.test(value)) {

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

@@ -1,6 +1,7 @@
-import { type ModelEntryRefusalCode, type ModelPlaneRefusalCode, type ModelRefusalsSignal } from "@sema-agent/settings-schema";
+import { ModelEntry, 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";
+import type { CandidateRejectionNote } from "./web-admin-client/candidate-gate.js";
 /**
  * 条目拒因码 → 本仓铸它的成因 —— **以码为键**([ref]):码闭集的属主是 settings-schema(`MODEL_ENTRY_REFUSAL_CODES`,6.2.0 起;此前本仓
  * 自持一份同名码表,撞名已消灭、零别名)。那边加一个条目码 ⇒ 本表缺键 ⇒ 本仓 tsc 红(只拿 `satisfies` 约束码值证明的是「子集」,
@@ -40,31 +41,38 @@ export interface CatalogEntryVerdictCtx {
     /** anthropic 路由装上了没有(= `config.anthropic` 在场,`createBrain` 同判)。 */
     readonly anthropicRouteMounted: boolean;
 }
-/** 条目最小读面(`CenterModel` 与本地投影都结构满足;形判走 settings-schema,不信这张型)。 */
+/** 条目的承载形最小读面(`CenterModel` 与本地投影都结构满足)。判据只从 settings-schema 的那一次解析读条目;承载形上只读拒因的键
+ *  (`name`)与形判不过时拒因句要的身份(`id` / `provider`,按 `typeof` 读,不信这张型)。 */
 export interface CatalogEntryLike {
     readonly name: string;
     readonly id: string;
     readonly provider: string;
-    /** [ref]:线路词(`headers` 的线路判据读它;原值,不信这张型)。 */
-    readonly api?: unknown;
-    /** [ref]:供应商附加头的承载形(`unknown`:判据在 `model-entry-headers.ts`,不信这张型)。 */
-    readonly headers?: unknown;
-    /** 引擎已退役的每模型引导句(core 7.56.0 [ref];settings-schema 的 `ModelEntry` 仍收它)—— 只读在场与否,见 {@link judgeCatalogEntry}。 */
-    readonly promptGuidance?: unknown;
 }
+/** 一条条目的判决:可用 ⇒ 判官那一次 settings-schema 解析读出的条目(**铸点只从它铸 Model** —— 判与铸读同一只值);不可用 ⇒ 拒因。 */
+export type CatalogEntryVerdict = {
+    readonly ok: true;
+    readonly entry: ModelEntry;
+} | {
+    readonly ok: false;
+    readonly refusal: ModelEntryRefusal;
+};
 /**
- * **逐条判据**:`undefined` = 本部署能完整服务它。判序即语义:先形(不合形的条目谈不上走哪条腿),再腿。
+ * **逐条判据**:`ok` = 本部署能完整服务它(连同判出它的那一份读数)。判序即语义:先形(不合形的条目谈不上走哪条腿),再腿。
  * 形分两段、同一个码(`config.model_entry_invalid`):settings-schema 的 `ModelEntry`,再是 [ref] 的 `headers`(白名单 + 线路 + 值形,
  * 判据单属主 `model-entry-headers.ts`;settings-schema 6.3.0 的 `ModelEntry` 还没有这个键 —— 候裁加字段,届时词表不另抄)。
  *
- * 形判的属主是 settings-schema 的 `ModelEntry`(两条读腿用的就是它)—— 本仓不手抄任何一条字段规则;这里只是
- * 在第二道边界(绕过读腿的输入)上**再问一次同一个属主**,并把答案变成一条带码的拒因。只取 `success` 与 issue
- * 坐标,不取它的输出(输出会补缺省、剥扩展键,那是读腿的事)。
+ * 形判的属主是 settings-schema 的 `ModelEntry`(两条读腿用的就是它)—— 本仓不手抄任何一条字段规则;这里在第二道边界(绕过读腿的
+ * 输入)上**再问一次同一个属主**:不过 ⇒ 一条带码的拒因;过 ⇒ 它的输出就是这条条目**唯一的读数**,其后的每一判与铸点都读它。
+ *
+ * **一种读法**:两条读腿交来的条目本就是这份输出;绕过读腿的输入(盘上被手改的 LKG、手写 effective、夹具)在这里得到同一份 ——
+ * schema 补的缺省(`api` / `tier` / `provider` / `quotaWeight` …)随这一次读法进 Model,不存在「判按缺省、铸按原值」的第二读法
+ * (修前:缺 `api` 的条目形判放行、铸点按原值读 ⇒ 整只候选 stage 抛;缺 `tier` 的条目铸出无 `params.tier` 的 Model,按档位选的缺省选不中 ⇒ 模型面整组拒)。
  */
-export declare function judgeCatalogEntry(m: CatalogEntryLike, ctx: CatalogEntryVerdictCtx): ModelEntryRefusal | undefined;
+export declare function judgeCatalogEntry(m: CatalogEntryLike, ctx: CatalogEntryVerdictCtx): CatalogEntryVerdict;
 /** 一批已启用条目的判决:可用的(保序)、不可用的(按 catalog name)、被丢目录条目的载体行(形对的,保序),以及形不对的载体行(坐标)。 */
-export interface CatalogEntriesVerdict<M extends CatalogEntryLike> {
-    readonly usable: readonly M[];
+export interface CatalogEntriesVerdict {
+    /** 可用条目判官那一次 schema 解析的读数(保序)—— 模型面 stage 只从这里铸 Model(承载形不再被读)。 */
+    readonly usable: readonly ModelEntry[];
     /** 键 = catalog name(**每一个**名,含秘密形 / 空串 / `__proto__`:引擎自己的判决保持完整 —— [ref] 不变量与选择面的「让出」都读它;
      *  名筛只在出口,见 {@link buildModelRefusalsSignal})。键以自有数据属性写入(`__proto__` 不走原型 setter)。 */
     readonly refused: Readonly<Record<string, ModelEntryRefusal>>;
@@ -75,6 +83,12 @@ export interface CatalogEntriesVerdict<M extends CatalogEntryLike> {
     /** [ref]:载体里形对的行(保序)—— 模型面 stage 把它与 `models` 同 commit 进 `config.droppedCatalogEntries`(`GET /v1/models.droppedEntries`
      *  的源):载体只在这里被判形、被读一次,墓碑与 wire 读的是同一批行。 */
     readonly dropped: readonly DroppedCatalogEntry[];
+    /**
+     * **这份候选管不管模型面** —— 唯一判决位(铸在这里一次;模型面 stage 的捷径、dry-run 的 `wouldOverrideModels`、世代账的模型面结局都读它,
+     * 墓碑判据与它读同一个行谓词 {@link droppedRowEnabled})。管 ⇔ 有一条启用条目(幸存的,或被读腿丢掉的 —— 有名无名都算),或载体形不对
+     * (改过的行原本代表谁说不清,按「管」判、随后组拒,fail-closed)。不管 ⇒ 上一代 / env 继续服务,不是拒。
+     */
+    readonly manages: boolean;
 }
 /**
  * 批量形(模型面 stage 与 dry-run 共用这一只 —— 报数与真 apply 永不撕裂)。
@@ -89,7 +103,7 @@ export interface CatalogEntriesVerdict<M extends CatalogEntryLike> {
  *    秘密形或非标识符,被扣下的名字无从被铸出;代价只是显式点它的请求拿到「未知模型」而不是 `request.model_unavailable`。
  * 与一条可用 / 已判不可用条目同名时不覆盖(可用条目仍可用;同名撞车由不变量 `refused-names-not-minted` 响亮拒)。
  */
-export declare function judgeCatalogEntries<M extends CatalogEntryLike>(enabled: readonly M[], ctx: CatalogEntryVerdictCtx, dropped?: unknown): CatalogEntriesVerdict<M>;
+export declare function judgeCatalogEntries(enabled: readonly CatalogEntryLike[], ctx: CatalogEntryVerdictCtx, dropped?: unknown): CatalogEntriesVerdict;
 /** [ref]:一次 apply 对「最新交到手的那份候选目录」的模型拒因判决(纯数据;`ApplyReport.modelRefusals`)。 */
 export interface ModelRefusalVerdict {
     /** 那份候选的逐条判决(键 = catalog name,**完整**,未过名筛 —— 名筛在出口 {@link buildModelRefusalsSignal})。 */
@@ -132,10 +146,23 @@ export declare function echoModelRef(ref: string): string;
  * 别名段(`(catalog entry …)`)的判断读原形:ref 与条目名逐字相同 ⇒ 不带,不因回显截短而误判成「另有条目」。
  */
 export declare function modelUnavailableMessage(field: string, requested: string, name: string, r: ModelEntryRefusal): string;
-/** 缺省模型不变量读的切面(`ServiceConfig` 与 `CrossInvariantView` 都结构满足)。 */
+/**
+ * 一次**用户选择**(显式 ref / `@name` / `compactionModel`)落在 `models.atMention` 许可之外时的拒因句 —— HTTP `request.model_not_allowed` 的 `error`
+ * 与 run-local 的 stderr 同一句(与 {@link modelUnavailableMessage} 同一种铸法:`field` = 调用方的通道名,`requested` = 原形,本函数回显时过 {@link echoModelRef};
+ * `resolved` = 选择归一到的目录名,即这次真会跑的那只)。
+ */
+export declare function modelNotAllowedMessage(field: string, requested: string, resolved: string): string;
+/** 缺省模型不变量读的切面(`ServiceConfig` 与 `CrossInvariantView` 都结构满足;可选成员缺席 = 没有被拒的候选)。 */
 export interface DefaultModelView {
     readonly models: Readonly<Record<string, unknown>>;
     readonly modelRefusals: Readonly<Record<string, ModelEntryRefusal>>;
+    /**
+     * [ref] ① —— **为何这张 env 表上没有目录**:候选判官整拒了最近一份候选(一个域都没应用),于是回落 env。值是判官交出的拒因列(`rejected.errors`,与 `config_candidate_rejected`
+     * 行体的 `errors` 同一份事实)经 `buildCandidateRejectionNotes` 投成的纯数据 —— 每个被拒文档一格:文档名 · 拒码 · 原因类词 · 文档路径(本地读腿)。**不含 `error` 原文**:
+     * 契约 / 读腿的原句可能点名链接指向的目标路径等操作数,只留在 warn 行(那里已过产出边界脱敏);句子函数不读日志、不读原句、不自铸第二份。
+     * 缺席 / 空 = 没有被拒的候选(纯 env 部署、候选被收下、dry-run)⇒ 拒因句逐字不变。只有 `env` 腿的句子读它(`catalog` 腿说的是目录候选自己没有缺省,与候选被整拒无关)。
+     */
+    readonly candidateRejectionNotes?: readonly CandidateRejectionNote[];
 }
 /**
  * 🔴 [ref] —— **这张模型表有没有一只缺省模型**(`models.default`)。`undefined` = 有。
@@ -146,6 +173,8 @@ export interface DefaultModelView {
  *
  * 拒因一句:码 + 这条腿上**真实**的出路 + 若目录在场但每条都不可用,点名它们与各自的码。env 腿句首保留 `MODEL_ID is required`
  * 这个既有的可 grep 片段(壳与运维脚本认它);目录腿不提 `MODEL_ID`(见 {@link ModelTableLeg})。
+ * env 腿若是因「候选被判官整拒」才回落到这张表({@link DefaultModelView.candidateRejectionNotes}),同一行再追加「回落原因」:被拒的文档名 + 拒码 + 原因类词 + 文档路径 ——
+ * 不带配置值、不带链接指向的目标路径、不抄任何 `error` 原文;只追加,句首的 grep 锚不动,没有被拒候选时整句逐字不变。
  */
 export declare function defaultModelRefusal(view: DefaultModelView, leg: ModelTableLeg): string | undefined;
 /** 一个被铸出的被拒名字:`name` = 被拒条目的名字,`target` = 增广把它指向的那条条目,`via` = 它是以什么身份被铸出的。 */