@sema-agent/server 7.88.2 → 7.90.0

package/dist/boot/fatal-exit.d.ts

@@ -0,0 +1,3 @@
+/** `err` 的 fatal 日志文本:`String(err)` 过形状律一次。纯函数,零副作用。 */
+export declare function buildFatalErrorText(err: unknown): string;
+//# sourceMappingURL=fatal-exit.d.ts.map

package/dist/boot/fatal-exit.js

@@ -0,0 +1,5 @@
+import { redactSecrets } from "../trace/redact.js";
+export function buildFatalErrorText(err) {
+    return redactSecrets(String(err));
+}
+//# sourceMappingURL=fatal-exit.js.map

package/dist/boot/resolve-spec.js

@@ -303,6 +303,7 @@ export function createResolveSpec(ctx) {
             ...(retainBackgroundProcessesFromBody(body.retainBackgroundProcesses, config.requirePrincipal, (event, fields) => logger.warn(event, { ...fields, sessionId: auth?.sessionId ?? null })) === true
                 ? { retainBackgroundProcesses: true }
                 : {}),
+            ...(body.excludeAllTools === true ? { excludeAllTools: true } : {}),
             ...(() => { const v = toolNameListFromBody(body.excludeTools); return v ? { excludeTools: v } : {}; })(),
             ...(() => { const v = toolNameListFromBody(body.deferTools); return v ? { deferTools: v } : {}; })(),
             ...(() => { const v = promptProfileFromBody(body.promptProfile); return v ? { promptProfile: v } : {}; })(),
@@ -541,6 +542,7 @@ export function createResolveSpec(ctx) {
             declaredCapable: effectiveMemoryPersistenceCapable(config),
             hands: gated.hands,
             handsReadOnly: governed.handsReadOnly === true,
+            excludeAllTools: governed.excludeAllTools === true,
             excludeTools: governed.excludeTools,
             remoteExecutionEnv: config.remoteExec !== undefined,
         })) {

package/dist/boot/stage-06-runners.js

@@ -7,7 +7,7 @@ import { redactSecrets } from "../trace/redact.js";
 import { hasServiceAuth } from "../http/server.js";
 import { workflowModelAllowlistFor } from "../task-workflow.js";
 import { backendOwnsControlPlane } from "../memory-operator-faces.js";
-import { createHookLlm } from "../hooks/hook-llm.js";
+import { createHookLlm, buildHookFailureText } from "../hooks/hook-llm.js";
 import { assertRetentionLaneWirable } from "./retention-lane.js";
 import { assertConsolidationDriverWirable, buildConsolidationValveAudit, createMemoryConsolidationFaces, resolveConsolidationDriverSeat } from "./memory-consolidation.js";
 import { createPerModelAuthSeat } from "./side-query-lane.js";
@@ -132,7 +132,7 @@ export function runStage06(ctx) {
     const runnerTierFrozen = Object.keys(config.tiers).length > 0;
     const { hookModelFor, hookLlm } = createHookLlm({ config, getKeyResolver: () => configCenter.getKeyResolver(), metrics });
     const hookAgentRunner = new Runner({ ...runnerDeps, sessionStore: new TtlSessionStore({ defaultTtlDays: 1 / 24 }) });
-    const hookAgent = async ({ prompt, model, timeoutMs, system }) => {
+    const agentHookCall = async ({ prompt, model, timeoutMs, system }) => {
         const pick = hookModelFor(model);
         if (!pick.ok)
             return pick;
@@ -150,7 +150,7 @@ export function runStage06(ctx) {
             metrics.inc("hook_llm_calls_total", { type: "agent" });
             if (result.terminal.kind !== "completed") {
                 const plane = terminalProjection(result.terminal);
-                return { ok: false, error: `hook agent ${plane.status}: ${clipHookErr(plane.errorMessage)}` };
+                return { ok: false, error: `hook agent ${plane.status}: ${plane.errorMessage ?? ""}` };
             }
             return { ok: true, text: result.result ?? "" };
         }
@@ -158,6 +158,10 @@ export function runStage06(ctx) {
             return { ok: false, error: String(e) };
         }
     };
+    const hookAgent = async (opts) => {
+        const out = await agentHookCall(opts);
+        return out.ok ? out : { ...out, error: clipHookErr(buildHookFailureText(out.error)) };
+    };
     const clipHookErr = (s) => (s ?? "").slice(0, 300);
     const titleCapable = sessionStore;
     const sessionTitler = config.sessionAutoTitle && titleCapable.setTitleIfNull && titleCapable.probeTitle

package/dist/brain.js

@@ -1,22 +1,31 @@
 import { adjudicateModelRoute, createAnthropicBrain, createCircuitBreakerBrain, createDegradingBrain, createFailoverBrain, createOpenAIBrain, createRoutingBrain, hasAuthCarrier, resolveRouteCredential, routeRefusalText, } from "@sema-agent/core";
-import { normalizeBaseUrl } from "@sema-agent/core";
+import { routeKeyOf } from "@sema-agent/core";
 import { buildDefaultResilience } from "./config-types.js";
 import { resolveModelApiKey } from "./key-resolver.js";
 import { catalogBrainLane } from "./model-provider.js";
-import { buildDisplaySafeUrl, redactSecrets } from "./trace/redact.js";
+import { buildDisplaySafeRefusal, buildDisplaySafeUrl } from "./trace/redact.js";
 function isOffDeploymentRoot(baseUrl, config) {
     if (!baseUrl)
         return false;
-    const entry = normalizeBaseUrl(baseUrl);
+    const entry = routeKeyOf(baseUrl);
     if (entry === "")
         return false;
-    return ![config.gatewayBaseUrl, ...config.gatewayFallbackUrls].some((u) => normalizeBaseUrl(u) === entry);
+    return ![config.gatewayBaseUrl, ...config.gatewayFallbackUrls].some((u) => routeKeyOf(u) === entry);
 }
 function degradeDeclaredRoot(fallbackBaseUrl, config) {
     const armed = Boolean(config.gatewayApiKey) && isOffDeploymentRoot(fallbackBaseUrl, config);
     return armed ? config.gatewayBaseUrl : (fallbackBaseUrl || config.gatewayBaseUrl);
 }
 export const FAST_FAIL_MAX_RETRIES = 2;
+function constructRouteBrain(label, sourceUrls, construct) {
+    try {
+        return construct();
+    }
+    catch (e) {
+        const text = buildDisplaySafeRefusal(e instanceof Error ? e.message : String(e), sourceUrls.map((u) => u ?? ""));
+        throw new Error(`${label}: ${text}`, { cause: undefined });
+    }
+}
 const DEFAULT_RESILIENCE = buildDefaultResilience();
 export function createBrain(config, deps = {}) {
     const { fetchImpl, breakerState } = deps;
@@ -34,7 +43,7 @@ export function createBrain(config, deps = {}) {
             : {};
     const routes = [config.gatewayBaseUrl, ...config.gatewayFallbackUrls];
     const openaiBrains = routes.map((baseUrl, i) => {
-        const brain = createOpenAIBrain({
+        const brain = constructRouteBrain(i === 0 ? "gateway route" : `gateway fallback route[${i - 1}]`, [baseUrl], () => createOpenAIBrain({
             baseUrl,
             get apiKey() {
                 return config.gatewayApiKey;
@@ -42,7 +51,7 @@ export function createBrain(config, deps = {}) {
             ...retryCap,
             fetchImpl,
             ...timeouts,
-        });
+        }));
         const isLast = i === routes.length - 1;
         return r.circuitBreaker && !isLast
             ? createCircuitBreakerBrain(brain, {
@@ -54,18 +63,19 @@ export function createBrain(config, deps = {}) {
             : brain;
     });
     const gatewayBrain = openaiBrains.length > 1 ? createFailoverBrain(openaiBrains) : openaiBrains[0];
-    const anthropicBrain = config.anthropic
-        ? createAnthropicBrain({
-            ...(config.anthropic.authToken
-                ? { headers: { Authorization: `Bearer ${config.anthropic.authToken}` } }
-                : { apiKey: config.anthropic.apiKey }),
-            baseUrl: config.anthropic.baseUrl ?? "https://api.anthropic.com",
-            version: config.anthropic.version,
-            cacheBreakpoints: config.anthropic.cacheBreakpoints,
-            ...(config.anthropic.maxRetries !== undefined ? { maxRetries: config.anthropic.maxRetries } : {}),
+    const anthropicCfg = config.anthropic;
+    const anthropicBrain = anthropicCfg
+        ? constructRouteBrain("anthropic route", [anthropicCfg.baseUrl], () => createAnthropicBrain({
+            ...(anthropicCfg.authToken
+                ? { headers: { Authorization: `Bearer ${anthropicCfg.authToken}` } }
+                : { apiKey: anthropicCfg.apiKey }),
+            baseUrl: anthropicCfg.baseUrl ?? "https://api.anthropic.com",
+            version: anthropicCfg.version,
+            cacheBreakpoints: anthropicCfg.cacheBreakpoints,
+            ...(anthropicCfg.maxRetries !== undefined ? { maxRetries: anthropicCfg.maxRetries } : {}),
             fetchImpl,
             ...timeouts,
-        })
+        }))
         : undefined;
     let brain = anthropicBrain
         ? createRoutingBrain({ anthropic: anthropicBrain }, { fallback: gatewayBrain })
@@ -81,7 +91,7 @@ export function createBrain(config, deps = {}) {
             const fallback = fallbackLane === "anthropic" && anthropicBrain
                 ?
                     anthropicBrain
-                : createOpenAIBrain({
+                : constructRouteBrain(`degrade target "${degradeTo}"`, [fallbackModel.baseUrl, config.gatewayBaseUrl], () => createOpenAIBrain({
                     get baseUrl() {
                         return degradeDeclaredRoot(fallbackModel.baseUrl, config);
                     },
@@ -91,7 +101,7 @@ export function createBrain(config, deps = {}) {
                     ...(config.gatewayMaxRetries !== undefined ? { maxRetries: config.gatewayMaxRetries } : {}),
                     fetchImpl,
                     ...timeouts,
-                });
+                }));
             const degradeEntryModel = {
                 ...fallbackModel,
                 get headers() {
@@ -158,7 +168,10 @@ export function brainSummary(config) {
             const verdict = adjudicateModelRoute({ id: target.id, baseUrl: target.baseUrl }, resolveRouteCredential({ ...(config.gatewayApiKey ? { configApiKey: config.gatewayApiKey } : {}) }), { baseUrl: degradeDeclaredRoot(target.baseUrl, config) });
             return verdict.ok
                 ? { reactiveDegradeRoutePairing: `ok:${verdict.posture}`, reactiveDegradeRouteRefusal: null }
-                : { reactiveDegradeRoutePairing: `broken:${verdict.code}`, reactiveDegradeRouteRefusal: redactSecrets(routeRefusalText(verdict)) };
+                : {
+                    reactiveDegradeRoutePairing: `broken:${verdict.code}`,
+                    reactiveDegradeRouteRefusal: buildDisplaySafeRefusal(routeRefusalText(verdict), [target.baseUrl ?? "", degradeDeclaredRoot(target.baseUrl, config)]),
+                };
         })()),
     };
 }

package/dist/capabilities/center-plugins.d.ts

@@ -1,5 +1,15 @@
 import type { Logger } from "../observability/logger.js";
 import { type LoadedSkill } from "./skills.js";
+/**
+ * 声明面的 `source.url` 长度上限(S-483)—— **界在声明关口,不在每个出口各切一刀**。
+ *
+ * 由来:出口上原有一刀 `.slice(0, 80)`,而它做了两件坏事(① 把 display-safe 铸点的 `«redacted…»` 记号截成
+ * 半只;② 与同一条 URL 在别处的处置成了两把尺)。删掉它之后,这个 **center 下发**值在日志行与
+ * `failures[]` 回执上就再没有界 —— 于是界回到它该在的地方:**声明被接收的那一刻**(与 hook 条目的 url
+ * 同形 —— `parseHooksConfig` 用 `MAX_HOOK_COMMAND_CHARS` 在解析期就拒)。2048 = URL 的事实上限
+ * (同一个数在 `http/routes/sessions.ts` 的对端 endpoint 读面上也在用);超界的 git clone URL 不存在真部署。
+ */
+export declare const MAX_PLUGIN_SOURCE_URL_CHARS = 2048;
 /** 缺省 clone host 白名单(契约条款 1;国内镜像走本名单加 https 镜像域,不开 http 口)。 */
 export declare const DEFAULT_PLUGIN_ALLOW_HOSTS: readonly string[];
 /** wire 上的插件声明(registry-core PluginSpec 的宽读形——本模块只消费不裁决,未知键忽略)。 */

package/dist/capabilities/center-plugins.js

@@ -3,8 +3,17 @@ import { promisify } from "node:util";
 import { promises as fsp, realpathSync, existsSync, readFileSync, lstatSync, statSync } from "node:fs";
 import { join, resolve, isAbsolute, sep } from "node:path";
 import { assertConfined, loadSkills } from "./skills.js";
+import { buildDisplaySafeUrl, redactSecrets } from "../trace/redact.js";
 const execFileP = promisify(execFile);
+export const MAX_PLUGIN_SOURCE_URL_CHARS = 2048;
 export const DEFAULT_PLUGIN_ALLOW_HOSTS = ["github.com"];
+function wireTypeWord(v) {
+    if (v === null)
+        return "null";
+    if (Array.isArray(v))
+        return "array";
+    return typeof v;
+}
 export function validatePluginDecl(decl, allowHosts) {
     const name = typeof decl.name === "string" && decl.name !== "" ? decl.name : "(unnamed)";
     if (decl.enabled === false)
@@ -16,8 +25,14 @@ export function validatePluginDecl(decl, allowHosts) {
     if (kind !== "git")
         return { ok: false, name, reason: `unsupported source.kind ${String(kind)}` };
     const url = decl.source?.url;
-    if (typeof url !== "string" || !/^https:\/\//i.test(url)) {
-        return { ok: false, name, reason: `plugin source must be an https:// URL (contract: https-only; got ${String(url).slice(0, 80)})` };
+    if (typeof url !== "string") {
+        return { ok: false, name, reason: `plugin source.url must be a string (got ${wireTypeWord(url)})` };
+    }
+    if (url.length > MAX_PLUGIN_SOURCE_URL_CHARS) {
+        return { ok: false, name, reason: `plugin source url exceeds ${MAX_PLUGIN_SOURCE_URL_CHARS} chars (got ${url.length}) — a clone URL that long is a declaration error, and it would ride every log line and failure receipt verbatim` };
+    }
+    if (!/^https:\/\//i.test(url)) {
+        return { ok: false, name, reason: `plugin source must be an https:// URL (contract: https-only; got ${buildDisplaySafeUrl(url)})` };
     }
     let host;
     try {
@@ -140,13 +155,14 @@ export async function applyCenterPlugins(baseline, eff, opts) {
         }
         catch (err) {
             await fsp.rm(staging, { recursive: true, force: true }).catch(() => undefined);
+            const safeErr = redactSecrets(err instanceof Error ? err.message : String(err));
             if (existsSync(liveDir)) {
-                opts.logger?.warn("center_plugin_fetch_failed_lkg", { plugin: v.name, error: err instanceof Error ? err.message : String(err) });
+                opts.logger?.warn("center_plugin_fetch_failed_lkg", { plugin: v.name, error: safeErr });
                 out.lkgUsed.push(v.name);
             }
             else {
-                opts.logger?.warn("center_plugin_fetch_failed", { plugin: v.name, error: err instanceof Error ? err.message : String(err) });
-                out.failures.push({ plugin: v.name, reason: `fetch failed: ${err instanceof Error ? err.message : String(err)}` });
+                opts.logger?.warn("center_plugin_fetch_failed", { plugin: v.name, error: safeErr });
+                out.failures.push({ plugin: v.name, reason: `fetch failed: ${safeErr}` });
                 continue;
             }
         }

package/dist/capabilities/memory-notice.d.ts

@@ -51,6 +51,12 @@ export interface MemoryFaceFacts {
     hands: ScenarioHands;
     /** 折完 governance+settings 后的最终 `handsReadOnly`(plan 模式 / autonomy 收窄)。手带只剩读腿。 */
     handsReadOnly: boolean;
+    /** 折完之后的最终 `TaskSpec.excludeAllTools`(S-493;core 7.8.0 [ref])。`true` = **整只**工具面卸空
+     *  (core `prepareDeferClassify` 对它直接 `roster.unmountWhere(() => true)`)⇒ 手带在场也一条落盘路都不剩。
+     *  🔴 它与下面那张名单是**同一个语义面**(「哪些工具不在 roster 上」)的两种声明,判据合成一只
+     *  {@link isUnmounted} —— 上游同版的姊妹谓词 `fullShellReachable` 也正是把 `spec.excludeAllTools !== true`
+     *  当一个合取项(`prepare-inherited-gate.js:174` 亲读),本仓与它同口径。 */
+    excludeAllTools: boolean;
     /** 折完之后的最终 `TaskSpec.excludeTools`(roster 真卸载,不是延迟披露)。**全部**已知落盘路都被排掉
      *  ⇒ 手带在场也等于没有写通道 —— core 的 `rosterCanPersist` 也是按排除后的 roster 算的,这里跟上。 */
     excludeTools: readonly string[] | undefined;
@@ -71,7 +77,7 @@ export interface MemoryFaceFacts {
  *  ① engine 在场 ⇒ **否**(引擎的座位,见文件头注);
  *  ② 部署显式声明 ⇒ 声明说了算(`true` 撤回 / `false` 强制)—— operator 的部署事实压过我们的推断,
  *     与 core 对 `memoryPersistenceCapable` 的处置同向;
- *  ③ 否则推断:有已知落盘路(手带在场且不是只读)⇒ 否;没有 ⇒ 是。
+ *  ③ 否则推断:有已知落盘路(手带在场、不是只读、不在 remote 车道、且没被卸载决定卸光)⇒ 否;没有 ⇒ 是。
  */
 export declare function shouldDiscloseNoPersistentMemory(facts: MemoryFaceFacts): boolean;
 /**

package/dist/capabilities/memory-notice.js

@@ -2,11 +2,11 @@ import { NO_PERSISTENT_MEMORY_NOTICE } from "@sema-agent/core";
 import { hasConstitutionAnchors } from "../task-settings.js";
 export const KNOWN_PERSISTENCE_TOOL_NAMES = ["Write", "Edit", "NotebookEdit", "Bash"];
 export const NO_PERSISTENT_MEMORY_SECTION_ID = "sema/memory.no-persistent";
-function anyPersistenceToolSurvives(excludeTools) {
-    if (excludeTools === undefined || excludeTools.length === 0)
-        return true;
-    const excluded = new Set(excludeTools);
-    return KNOWN_PERSISTENCE_TOOL_NAMES.some((name) => !excluded.has(name));
+function isUnmounted(facts, name) {
+    return facts.excludeAllTools || (facts.excludeTools?.includes(name) ?? false);
+}
+function anyPersistenceToolSurvives(facts) {
+    return KNOWN_PERSISTENCE_TOOL_NAMES.some((name) => !isUnmounted(facts, name));
 }
 export function shouldDiscloseNoPersistentMemory(facts) {
     if (facts.memoryFaceMounted)
@@ -17,7 +17,7 @@ export function shouldDiscloseNoPersistentMemory(facts) {
         return true;
     if (facts.remoteExecutionEnv)
         return true;
-    return !anyPersistenceToolSurvives(facts.excludeTools);
+    return !anyPersistenceToolSurvives(facts);
 }
 const NOTICE_BLOCK = { id: NO_PERSISTENT_MEMORY_SECTION_ID, slot: "behavior", text: NO_PERSISTENT_MEMORY_NOTICE };
 function mountNotice(decls) {

package/dist/capabilities/team.d.ts

@@ -20,6 +20,43 @@ import type { Logger } from "../observability/logger.js";
  * registerTeams` 那条消费腿——本文件旧注里「registry pushes more at runtime via GET /api/config/effective → teams」
  * 是 doc-rot。今天 `registerTeams` 只剩公共信任边界这一层意义(调用方=测试),注册表在生产上恒等于 BUILTIN_TEAMS;
  * 中心侧的多 agent 讨论配置面是 `collab` 域(0.7 继任者),投影成命名 workflow(capabilities/collab-workflows.ts)。
+ *
+ * 🔴 **成员重派阶梯收窄(core 7.24.0 [ref];本仓 7.90.0 提货批的读数说明,零改动)** —— 一次讨论**花的子 run
+ * 数掉一半**,上游实测:两成员一轮的讨论从 **6 个子 run 变 3 个**。原因:`runTurn` 此前对**每一个**没有
+ * 「completed 且有正文」落地的成员轮都重派一次(同目标、同提示词、同模型、同工具面),包括那些**结局上
+ * 不可能变**的终局;现在只对引擎能**肯定**认出是确定性的两种终局拒绝重派(`blocked` 因由 = 宿主
+ * `UserPromptSubmit` 的拒绝,照字面信;`failed` 且治理表判 TERMINAL 的码,读 `classifySubagentError`)。
+ *
+ * 🔴 **这不是「丢了重试」,读数变低也不是故障**(写在这里是因为它唯一会被误读的地方就是账单与子代行数):
+ *  · 其余一切**照旧**保留第二次尝试 —— 那个分类器的 `logic`/`unknown` 桶是**else 臂**(它不认识的码全落
+ *    那里),把「永不重派」挂在 else 臂上会让**将来每一个新码**默默变成不可重派,所以那条判决留在表里。
+ *    ⚠️ **本句在 7.90.0(core 7.24.2 / [ref])修了措辞**:上一版写的是「`stream_torn` 住在 `logic` 桶里
+ *    (else 臂)…负控挑它最有判别力」—— core 本版给三个 in-band 终局输出码**各自开了行**
+ *    (`stream_torn → network`(transient)/ `refusal → logic` / `length_empty → logic`),所以
+ *    `stream_torn` **已经不在 else 臂上了**(本车亲跑差分实测:`classifySubagentError({code:"stream_torn"})`
+ *    从 7.24.1 的 `{errorKind:"logic", retryable:false}` 变 7.24.2 的 `{errorKind:"network", retryable:true}`
+ *    —— 注意 `errorKind` 与 `retryable` **两个字段都翻了**,提货单只点了后者)。
+ *    **结局没变**(`stream_torn` 照旧重派 ⇒ 仍 6):重派闸 `canDifferOnRetry` 判的是「`blocked` 因由 + 治理表
+ *    判 TERMINAL」,从不读桶名 —— 变的是**理由**(从「掉进 else 臂」变成「表里那一行说它 transient」)。
+ *    ⇒ 拿 `stream_torn` 当 **else 臂**负控从本版起**没有判别力了**(它是一条有行的码);要挑 else 臂代表,
+ *    挑**未知码** / **无码的 `failed`** / **空正文的 `completed`** —— 那三形才真的落 else 臂。
+ *  · `[unavailable: <status>/<code>]` 标记、讨论转录、预算记账的**形一个字节没变**。
+ *  · **本仓没有任何按子 run 数计费 / 计量的座**(2026-09-19 车JG 亲扫:`billable` 是 `http/route-table.ts` 上
+ *    「这条路由算不算一次计费提交」的路由性质,与子 run 无关;`council_runs_total` 数的是**议会被调用了几次**,
+ *    不是子代;成员轮不建 run-store 行,它们是 TaskRegistry 上的 `a*` 句柄)。⇒ 本版在本仓**零改动**,
+ *    唯一会动的读数是 `GET /v1/runs/:id/subagents` 的**行数**与经 `stats` 透传的**用量/花费**(都变低),
+ *    两者都是上游事实的透传、本仓不据行数做任何裁决。
+ *
+ * 🔴 **判据按「前缀族」写,不按具体码字**(test 仓对 core 7.24.0 的实测②,本仓照此记账;将来真在本仓开
+ * 计量点时钉法同此):引擎读的是治理表对**码**的裁决,而裁决是按**前缀族**给的 —— 一个族里凭空合成的码
+ * (test 实测的 `usage.FAKE_prefix_only`)照样判 TERMINAL ⇒ **3**。所以正控/负控各挑**一个**代表就够,
+ * 逐字抄那张码表只会在上游加一行的那天变成谎:
+ *  · **⇒ 3(不重派)**:`blocked` 因由,以及 7 个被治理表判 TERMINAL 的前缀族失败码(合成同前缀码同判);
+ *  · **⇒ 仍 6(照旧两次)**:两个 transient 码 `memory.admission_required` / `config.compliance_required`,
+ *    以及 `stream_torn` / `refusal` / `length_empty` / 未知码 / 无码的 `failed` / 空正文的 `completed`。
+ *    🔴 **这六形自 core 7.24.2([ref])起不再同源**:前三形在分类器里**各有一行**
+ *    (`stream_torn → network` transient / `refusal`、`length_empty` → `logic`),后三形才是真的 **else 臂**。
+ *    结局(仍 6)对六形都没变,但**负控要挑真 else 臂**:未知码 / 无码的 `failed` / 空正文的 `completed`。
  */
 type TeamFn = typeof runTeamDiscussion;
 export interface TeamMemberTemplate {

package/dist/config-catalog.js

@@ -5,6 +5,7 @@ import { webSearchConfigFromEnv, WEB_SEARCH_PROVIDERS } from "./plugins/web-sear
 import { REMOTE_EXEC_PROVIDER_WORDS } from "./execution-lane-caps.js";
 import { CENTER_READ_FACE_LIVE_KEYS } from "./config-center/read-face.js";
 import { MODEL_PROVIDER_WORDS } from "./model-provider.js";
+import { buildDisplaySafeUrl } from "./trace/redact.js";
 export const CATALOG_VALUE_TYPES = ["boolean", "number", "string", "enum", "csv", "json", "path", "url", "secret", "opaque"];
 export const CATALOG_TIMINGS = ["hot", "restart", "deploy", "inert"];
 export const CATALOG_DANGER_AXES = ["security", "billing", "data"];
@@ -55,7 +56,7 @@ export const CONFIG_CATALOG = [
     r("ALLOW_UNAUTHED_WRITES", "auth", "boolean", "无 service token 时仍接受任务提交(本地开发逃生口;缺省 fail-closed 拒提交)", { staticDefault: "false", danger: SEC, configKey: "allowUnauthedWrites" }),
     r("ANTHROPIC_API_KEY", "modelPlane", "secret", "Anthropic 协议路线的 x-api-key 凭据(与 AUTH_TOKEN 二选一,AUTH_TOKEN 优先;与 BASE_URL 同在时可推断 provider)", { danger: [...SEC, ...BILL] }),
     r("ANTHROPIC_AUTH_TOKEN", "modelPlane", "secret", "Anthropic 兼容生态的 Bearer 凭据(设了则不发 x-api-key)", { danger: [...SEC, ...BILL] }),
-    r("ANTHROPIC_BASE_URL", "modelPlane", "url", "Anthropic 协议路线 base URL(与凭据同在且 MODEL_PROVIDER 未设 ⇒ 推断 provider=anthropic 并 boot notice;S-475:带 userinfo 拒启,机读码 `config.gateway_url_userinfo`)"),
+    r("ANTHROPIC_BASE_URL", "modelPlane", "url", "Anthropic 协议路线 base URL(与凭据同在且 MODEL_PROVIDER 未设 ⇒ 推断 provider=anthropic 并 boot notice;S-475:带 userinfo 拒启,机读码 `config.gateway_url_userinfo`;S-483:解析不动/不透明形拒启,机读码 `config.model_route_url_invalid`;S-514:带 `#fragment` 拒启,机读码 `config.model_route_url_fragment` —— fragment 从不上线,后缀会落进被丢弃的那一半)"),
     r("ANTHROPIC_CACHE_BREAKPOINTS", "modelPlane", "boolean", "Anthropic 路线 prompt-cache breakpoints 开关", { staticDefault: "true" }),
     r("ANTHROPIC_MAX_RETRIES", "modelPlane", "number", "Anthropic 路线 SDK 每次调用重试上限", { derivedDefaultNote: "缺席 ⇒ 不传引擎,core/SDK 默认当家" }),
     r("ANTHROPIC_VERSION", "modelPlane", "string", "Anthropic API version 头(缺省由 SDK 定)"),
@@ -72,7 +73,7 @@ export const CONFIG_CATALOG = [
     r("ATTACHMENT_ORPHAN_GRACE_MS", "limitsHttp", "number", "附件孤儿对象 GC 宽限(ms;0=关本腿,坏值回默认+warn)", { staticDefault: "3600000", danger: DATA, center: cLimits("attachmentOrphanGraceMs") }),
     r("ATTACHMENT_UNBOUND_TTL_MS", "limitsHttp", "number", "未绑定附件的 TTL(ms)", { staticDefault: String(24 * 3600 * 1000), danger: DATA, configKey: "attachmentUnboundTtlMs", center: cLimits("attachmentUnboundTtlMs") }),
     r("AUTH_BRIDGE_AUDIENCE", "auth", "string", "registry SSO-JWT 验签期望 aud", { danger: SEC }),
-    r("AUTH_BRIDGE_ISSUER", "auth", "string", "registry SSO-JWT issuer(auth bridge 的开关之一)", { danger: SEC, derivedDefaultNote: "缺席 ⇒ 用 configCenter.baseUrl(配了 center 即默认开桥)" }),
+    r("AUTH_BRIDGE_ISSUER", "auth", "url", "registry SSO-JWT issuer(auth bridge 的开关之一)", { danger: SEC, derivedDefaultNote: "缺席 ⇒ 用 configCenter.baseUrl(配了 center 即默认开桥)" }),
     r("AUTH_BRIDGE_JWKS_URL", "auth", "url", "registry SSO-JWT 的 JWKS 地址(缺省从 issuer 派生)", { danger: SEC }),
     r("AUTONOMY", "auth", "enum", "运维 autonomy 模式,tighten-only 叠到每个 TaskSpec(read-only/plan ⇒ 只读手,ask ⇒ 恒 shellGate);center 腿热且 non-sticky", { danger: SEC, enumValues: ["read-only", "ask", "plan", "auto"], configKey: "autonomy", center: cGov("autonomy") }),
     r("AUTO_MODE_CLASSIFIER_FALLBACK", "approval", "enum", "auto 分类器席答不出裁决时的梯子(main=主模型代判 / none=只留分类器那一级,整条拒)", { enumValues: ["main", "none"], danger: SEC, derivedDefaultNote: "未设/空串 ⇒ 不铸键,跟随引擎缺省 main(core 7.18.0 起;空串按未设,与其余词表旋钮同判);none = 7.77.0 及以前的行为逐字;词表外的值启动期拒启。权限轴放宽,升级须知见 DEPLOY-PREREQS", configKey: "autoModeClassifierFallback" }),
@@ -282,8 +283,8 @@ export const CONFIG_CATALOG = [
     r("MODEL_EXTRA_BODY", "modelPlane", "opaque", "生成参数直通 JSON(top_k/logit_bias 等;必须静态 —— 前缀缓存键序)", { danger: SEC }),
     r("MODEL_FIRST_TOKEN_TIMEOUT_MS", "modelPlane", "number", "首 token 超时(ms;0=关 —— 开流不吐字的唯一看门狗;自托管长 prefill 后端按此档留足)", { staticDefault: String(RESILIENCE_DEFAULTS.firstTokenTimeoutMs.value) }),
     r("MODEL_FREQUENCY_PENALTY", "modelPlane", "number", "frequency_penalty 直通(压过 EXTRA_BODY 同键)"),
-    r("MODEL_GATEWAY_BASEURL", "modelPlane", "url", "openai 兼容网关 base URL(默认 localhost 占位 —— 公开分发不烤内网坐标;S-475:带 userinfo 拒启,机读码 `config.gateway_url_userinfo` —— WHATWG 禁止用带凭据的 URL 构造 fetch Request,凭据放 MODEL_API_KEY)", { staticDefault: "http://127.0.0.1:8000/v1", configKey: "gatewayBaseUrl", center: cModels("models[].baseUrl") }),
-    r("MODEL_GATEWAY_FALLBACK_URLS", "modelPlane", "url", "网关故障转移地址表(CSV;S-475:**逐项**判 userinfo,任一项带 ⇒ 拒启,机读码 `config.gateway_url_userinfo`)", { configKey: "gatewayFallbackUrls" }),
+    r("MODEL_GATEWAY_BASEURL", "modelPlane", "url", "openai 兼容网关 base URL(默认 localhost 占位 —— 公开分发不烤内网坐标;S-475:带 userinfo 拒启,机读码 `config.gateway_url_userinfo` —— WHATWG 禁止用带凭据的 URL 构造 fetch Request,凭据放 MODEL_API_KEY;S-483:解析不动/不透明形拒启,机读码 `config.model_route_url_invalid`;S-514:带 `#fragment` 拒启,机读码 `config.model_route_url_fragment`)", { staticDefault: "http://127.0.0.1:8000/v1", configKey: "gatewayBaseUrl", center: cModels("models[].baseUrl") }),
+    r("MODEL_GATEWAY_FALLBACK_URLS", "modelPlane", "url", "网关故障转移地址表(CSV;S-475:**逐项**判 userinfo,任一项带 ⇒ 拒启,机读码 `config.gateway_url_userinfo`;S-483:逐项判可解析性,机读码 `config.model_route_url_invalid`;S-514:**逐项**判 `#fragment`,机读码 `config.model_route_url_fragment`)", { configKey: "gatewayFallbackUrls" }),
     r("MODEL_ID", "modelPlane", "string", "主模型 id(3.0.0 起无出厂缺省,缺 ⇒ 拒启指路)", { configKey: "model", resolve: (c) => c.model.id, center: cModels("models[].id") }),
     r("MODEL_IDLE_TIMEOUT_MS", "modelPlane", "number", "流中静默看门狗(ms;0=关)", { staticDefault: String(RESILIENCE_DEFAULTS.idleTimeoutMs.value) }),
     r("MODEL_MAX_TOKENS", "modelPlane", "number", "主模型输出上限", { derivedDefaultNote: "缺席 ⇒ min(32000, contextWindow)", resolve: (c) => c.model.maxTokens ?? null, center: cModels("models[].maxTokens") }),
@@ -478,19 +479,6 @@ function primitiveConfigValue(config, key) {
         return v;
     return undefined;
 }
-const REDACTED_UNPARSEABLE_URL = "(redacted:unparseable-url)";
-function stripUrlUserinfo(v) {
-    if (!URL.canParse(v))
-        return REDACTED_UNPARSEABLE_URL;
-    const u = new URL(v);
-    u.username = "";
-    u.password = "";
-    if (u.search === "" && u.hash === "" && u.href === v)
-        return v;
-    u.search = "";
-    u.hash = "";
-    return u.href;
-}
 function sanitizeEnumValue(spec, v) {
     const words = spec.echoWords ?? spec.enumValues;
     if (v === null)
@@ -511,9 +499,9 @@ function sanitizeValue(spec, v) {
     const type = spec.type;
     if (type === "url") {
         if (typeof v === "string")
-            return { value: v.includes(",") ? v.split(",").map((s) => stripUrlUserinfo(s.trim())).filter((s) => s.length > 0) : stripUrlUserinfo(v) };
+            return { value: v.includes(",") ? v.split(",").map((s) => buildDisplaySafeUrl(s.trim())).filter((s) => s.length > 0) : buildDisplaySafeUrl(v) };
         if (Array.isArray(v))
-            return { value: v.map((s) => stripUrlUserinfo(s)) };
+            return { value: v.map((s) => buildDisplaySafeUrl(s)) };
         return { value: v };
     }
     if (type === "csv" && typeof v === "string")

package/dist/config-center/apply-effective.js

@@ -203,7 +203,7 @@ function stageEffective(config, eff, logger, opts) {
                 if (ok)
                     logger?.warn("sema_registry_model_base_url", { model: m.name, baseUrl: buildDisplaySafeUrl(rawBaseUrl), hint: "registry-directed gateway override — this model's key authenticates AGAINST THIS URL" });
                 else {
-                    logger?.warn("sema_registry_model_base_url_rejected", { model: m.name, baseUrl: buildDisplaySafeUrl(String(rawBaseUrl)).slice(0, 120), hint: "only http(s) URLs are honored — falling back to the boot-env gateway" });
+                    logger?.warn("sema_registry_model_base_url_rejected", { model: m.name, baseUrl: buildDisplaySafeUrl(String(rawBaseUrl)), hint: "only http(s) URLs are honored — falling back to the boot-env gateway" });
                     safeUrl = undefined;
                 }
             }

package/dist/config.d.ts

@@ -1,5 +1,5 @@
 import { type Model, type PathRuleBases, type RuleBehavior } from "@sema-agent/core";
-import type { Autonomy } from "./runtime-governance.js";
+import { type Autonomy } from "./runtime-governance.js";
 import type { ServiceConfig, ServiceConfigFlat, ServiceConfigGroups } from "./config-types.js";
 /** [ref] A1: the config TYPE face lives in the leaf module config-types.ts; re-exported here so
  *  every existing `from "./config.js"` importer compiles unchanged (pure-type consumers should prefer

package/dist/config.js

@@ -17,9 +17,10 @@ import { readFaceForPosture } from "./read-face-posture.js";
 import { THINKING_LEVELS, THINKING_FORMATS, buildModelCompat, isThinkingFormat, isThinkingTier } from "./model-compat.js";
 import {} from "./posture-source.js";
 import { CONTROL_AND_BIDI_STRIP_RE } from "./text-bidi.js";
+import { AUTONOMY_MODES } from "./runtime-governance.js";
 import { modelProviderRefusal } from "./model-provider.js";
 import { modelRouteUrlRefusal } from "./model-route-url.js";
-import { buildDisplaySafeUrl } from "./trace/redact.js";
+import { buildDisplaySafeUrl, redactSecrets } from "./trace/redact.js";
 export { RETENTION_MODES, MEMORY_CONSOLIDATION_MIN_INTERVAL_SEC } from "./config-types.js";
 function csv(name) {
     return (process.env[name] ?? "")
@@ -27,7 +28,6 @@ function csv(name) {
         .map((s) => s.trim())
         .filter(Boolean);
 }
-const AUTONOMY_MODES = ["read-only", "ask", "plan", "auto"];
 export function parseAutonomy(raw) {
     const v = raw?.trim();
     if (!v)
@@ -1334,12 +1334,12 @@ function parseMemoryEmbedder(ctx) {
         throw new Error(`MEMORY_EMBEDDER_* is half-configured — missing ${missing.join(", ")}. The memory vector plane needs all three of MEMORY_EMBEDDER_ENDPOINT, MEMORY_EMBEDDER_MODEL, MEMORY_EMBEDDER_DIM; refusing to start rather than silently running lexical-only retrieval while the deployment believes vectors are on (#228).`);
     }
     if (!URL.canParse(endpoint)) {
-        throw new Error(`MEMORY_EMBEDDER_ENDPOINT="${endpoint}" is not a valid URL (expected e.g. https://embeddings.example.com/v1 — the OpenAI-compatible base, or the full .../embeddings endpoint)`);
+        throw new Error(`MEMORY_EMBEDDER_ENDPOINT="${buildDisplaySafeUrl(endpoint)}" is not a valid URL (expected e.g. https://embeddings.example.com/v1 — the OpenAI-compatible base, or the full .../embeddings endpoint)`);
     }
     const parsedEndpoint = new URL(endpoint);
     const proto = parsedEndpoint.protocol;
     if (proto !== "http:" && proto !== "https:") {
-        throw new Error(`MEMORY_EMBEDDER_ENDPOINT="${endpoint}" must be http(s) (got "${proto}") — the embedder leg is an HTTP POST to an OpenAI-compatible /embeddings face`);
+        throw new Error(`MEMORY_EMBEDDER_ENDPOINT="${buildDisplaySafeUrl(endpoint)}" must be http(s) (got "${proto}") — the embedder leg is an HTTP POST to an OpenAI-compatible /embeddings face`);
     }
     if (parsedEndpoint.username !== "" || parsedEndpoint.password !== "") {
         throw new Error("MEMORY_EMBEDDER_ENDPOINT must not carry credentials in the URL (user:password@host) — URL userinfo leaks into transport errors, logs and memory conflict reports. Use MEMORY_EMBEDDER_API_KEY (sent as a Bearer header) instead.");
@@ -1966,12 +1966,18 @@ function parseA2aServe() {
         parsed = undefined;
     }
     if (parsed === undefined || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) {
-        throw new Error(`A2A_SERVE_URL must be a parseable http(s) URL (e.g. "https://agent.example.com/v1/a2a"); got ${JSON.stringify(rawUrl)}`);
+        throw new Error(`A2A_SERVE_URL must be a parseable http(s) URL (e.g. "https://agent.example.com/v1/a2a"); got ${JSON.stringify(buildDisplaySafeUrl(rawUrl))}`);
     }
     if (parsed.username !== "" || parsed.password !== "") {
         throw new Error(`A2A_SERVE_URL must not carry userinfo (credentials before "@") — it is published verbatim on the ANONYMOUSLY readable agent card, so those credentials would be handed to every discovery caller. ` +
             `Inbound authentication on this endpoint is header-shaped (a service credential), not URL-embedded; strip the userinfo and keep the secret in the caller's headers.`);
     }
+    const a2aCredentialScan = redactSecrets(parsed.href);
+    if (a2aCredentialScan !== parsed.href) {
+        throw new Error(`A2A_SERVE_URL carries something the credential-redaction law recognizes (${a2aCredentialScan}) — this address is published VERBATIM on the ANONYMOUSLY readable agent card (the card's url is a functional address: peers fetch it, so it is never rewritten for display), ` +
+            `so it must not carry credentials of ANY shape: no userinfo, no credential-named query parameter (api_key/token/…), no token-shaped path segment or parameter value. ` +
+            `Keep A2A_SERVE_URL to scheme://host[:port][/path] and move the secret into the caller's headers.`);
+    }
     return {
         name: env("A2A_SERVE_NAME", "sema-server"),
         ...(process.env.A2A_SERVE_DESCRIPTION ? { description: process.env.A2A_SERVE_DESCRIPTION } : {}),

package/dist/hooks/hook-llm.d.ts

@@ -24,6 +24,31 @@ export type HookModelPick = {
     ok: false;
     error: string;
 };
+/**
+ * 🔴 **hook 失败展示文本的唯一铸点**(S-494;`build*` = 返回纯数据的一只纯函数)。
+ *
+ * 病(codex 对 7.88.1/7.88.2 的补审抓出,存量泄漏,本车红先复现):这一族失败文本是**拼**出来的 ——
+ * 料有四种:core 的路由拒绝文案(`routeRefusalText` 的 `fixHint` 逐字带 `config.baseUrl` 的值)、
+ * 原生 `fetch` 的**构造期异常正文**(WHATWG:`…includes credentials: <整条 URL>`,口令逐字)、
+ * 它的 `cause`、per-model key 解析错。改前只有**两个 URL 位**走了 display-safe 铸点 —— 那是名单制:
+ * 组装料换一种(异常正文、cause)就漏,而它的出口是 `hook_runner` 的 `hook_llm_failed` warn 与
+ * `noteHookFailure` 的 stderr 位。⇒ 把尺放到**出口**:整段组装完了过**一次**律,规则从「N 个 URL 位」
+ * 减到「一只出口」(那两个 display-safe 调用随之删)。
+ *
+ * 用的是自由文本那一条律({@link redactSecrets})—— `buildDisplaySafeUrl` 是它加两道 URL 专属闸的
+ * **已知是一条 URL** 的那个特例,而这里的料是自由文本(一段异常正文里可能一个 URL 都没有,也可能有三个)。
+ * 同一张名表、同一批记号,不是第二把尺。
+ *
+ * 🔴 **脱敏器抛 ⇒ 响亮扣下**(不回原串、不 fail-open):文案形与 7.88.1 的
+ * `fail-open.ts` `renderDetail` 逐字同族(`[… withheld: redactor threw <Name>]`)—— 运维丢掉的是细节、
+ * 不是「这次失败了」这件事,而一个字节的原串都不会漏出去。
+ *
+ * 🚧 **已知射程边界(登记,另车修在源头)**:自由文本律对**非规范拼法**的 URL
+ * (`https:alice:pw@h/v1` 省了 `//`、authority 里夹 tab)认不出结构 ⇒ 那两形若出现在料里(目录下发的
+ * `models[].baseUrl` 今天原样存,`apply-effective.ts` 只校验 `protocol`)仍会原样。修在源头 =
+ * 目录 baseUrl 落库前归一成 `new URL(raw).href`(S-483 收车档未闭环项),不是在这里再加一把尺。
+ */
+export declare function buildHookFailureText(raw: string): string;
 /** The live object `createHookLlm` produces — model-pick resolution + the direct completion call, both capturing the hot-refreshed keyResolver/fetchImpl in closure. */
 export interface HookLlm {
     hookModelFor: (requested?: string) => HookModelPick;

package/dist/hooks/hook-llm.js

@@ -1,6 +1,16 @@
-import { adjudicateModelRoute, normalizeBaseUrl, resolveRouteCredential, routeRefusalText } from "@sema-agent/core";
+import { adjudicateModelRoute, joinRequestUrl, resolveRouteCredential, routeKeyOf, routeRefusalText } from "@sema-agent/core";
 import { matchCatalogModel } from "../model-select.js";
-import { buildDisplaySafeUrl } from "../trace/redact.js";
+import { buildDisplaySafeRefusal, redactSecrets } from "../trace/redact.js";
+export function buildHookFailureText(raw) {
+    if (raw === "")
+        return raw;
+    try {
+        return redactSecrets(raw);
+    }
+    catch (err) {
+        return `[hook failure text withheld: redactor threw ${err instanceof Error ? err.name : typeof err}]`;
+    }
+}
 export function createHookLlm(deps) {
     const { config, metrics } = deps;
     const anthropicRouteBaseUrl = () => config.anthropic ? config.anthropic.baseUrl || "https://api.anthropic.com" : undefined;
@@ -43,12 +53,16 @@ export function createHookLlm(deps) {
         });
         const verdict = adjudicateModelRoute({ id: pick.catalogRef, baseUrl: pick.baseUrl }, credential, { ...(declaredRoot !== undefined ? { baseUrl: declaredRoot } : {}) });
         if (!verdict.ok) {
-            return { ok: false, error: `hook model "${pick.catalogRef}" cannot be routed — ${routeRefusalText(verdict)}` };
+            return {
+                ok: false,
+                error: `hook model "${pick.catalogRef}" cannot be routed (${verdict.code}) — ` +
+                    buildDisplaySafeRefusal(routeRefusalText(verdict), [pick.baseUrl, declaredRoot ?? ""]),
+            };
         }
-        if ((verdict.posture === "unpinned" || verdict.posture === "keyless") && normalizeBaseUrl(pick.baseUrl) !== normalizeBaseUrl(declaredRoot)) {
+        if ((verdict.posture === "unpinned" || verdict.posture === "keyless") && routeKeyOf(pick.baseUrl) !== routeKeyOf(declaredRoot)) {
             return {
                 ok: false,
-                error: `hook model "${pick.catalogRef}" points at ${buildDisplaySafeUrl(pick.baseUrl)}, which this deployment did not declare as its own endpoint, ` +
+                error: `hook model "${pick.catalogRef}" points at ${pick.baseUrl}, which this deployment did not declare as its own endpoint, ` +
                     `and no per-model credential resolved — refusing to send the prompt there (it embeds user content; an unauthenticated ` +
                     `request still hands that content to whoever operates that URL)`,
             };
@@ -56,7 +70,7 @@ export function createHookLlm(deps) {
         return { ok: true, credential };
     };
     const fetchImpl = deps.fetchImpl ?? fetch;
-    const hookLlm = async ({ prompt, model, timeoutMs, system, maxOutputTokens }) => {
+    const callLlm = async ({ prompt, model, timeoutMs, system, maxOutputTokens }) => {
         const pick = hookModelFor(model);
         if (!pick.ok)
             return pick;
@@ -81,7 +95,7 @@ export function createHookLlm(deps) {
                 const routed = judgeRoute(pick, perModelKey, config.anthropic?.authToken ?? config.anthropic?.apiKey, routeBase);
                 if (!routed.ok)
                     return routed;
-                url = `${pick.baseUrl.replace(/\/+$/, "")}/v1/messages`;
+                url = joinRequestUrl(pick.baseUrl, "/v1/messages");
                 headers = {
                     "content-type": "application/json",
                     "anthropic-version": config.anthropic?.version ?? "2023-06-01",
@@ -102,7 +116,7 @@ export function createHookLlm(deps) {
                 if (!routed.ok)
                     return routed;
                 const hookKey = routed.credential.apiKey;
-                url = `${pick.baseUrl.replace(/\/+$/, "")}/chat/completions`;
+                url = joinRequestUrl(pick.baseUrl, "/chat/completions");
                 headers = { "content-type": "application/json", ...(hookKey ? { authorization: `Bearer ${hookKey}` } : {}) };
                 body = JSON.stringify({ model: pick.providerModelId, ...(maxOutputTokens !== undefined ? { max_tokens: maxOutputTokens } : {}), messages: [...(system ? [{ role: "system", content: system }] : []), { role: "user", content: prompt }], stream: false });
             }
@@ -126,13 +140,17 @@ export function createHookLlm(deps) {
             const cause = e?.cause;
             return {
                 ok: false,
-                error: ac.signal.aborted ? "hook llm timeout" : `hook llm request to ${buildDisplaySafeUrl(pick.baseUrl)} failed: ${String(e)}${cause ? ` (${String(cause)})` : ""}`,
+                error: ac.signal.aborted ? "hook llm timeout" : `hook llm request to ${pick.baseUrl} failed: ${String(e)}${cause ? ` (${String(cause)})` : ""}`,
             };
         }
         finally {
             clearTimeout(t);
         }
     };
+    const hookLlm = async (opts) => {
+        const out = await callLlm(opts);
+        return out.ok ? out : { ...out, error: buildHookFailureText(out.error) };
+    };
     return { hookModelFor, hookLlm };
 }
 //# sourceMappingURL=hook-llm.js.map