@sema-agent/server 7.131.0 → 7.132.0

package/dist/hooks/classic-stations.js

@@ -0,0 +1,27 @@
+export const CLASSIC_STATION_ROLE = {
+    "classic.PreToolUse": "chain",
+    "classic.PostToolUse": "chain",
+    "classic.PostToolUseFailure": "chain",
+    "classic.PostToolBatch": "chain",
+    "classic.UserPromptSubmit": "chain",
+    "classic.Stop": "chain",
+    "classic.SubagentStop": "chain",
+    "classic.StopFailure": "observe",
+    "classic.PreCompact": "chain",
+    "classic.PostCompact": "observe",
+    "classic.PermissionDenied": "observe",
+};
+export function hangClassic(on, station, answer) {
+    if (CLASSIC_STATION_ROLE[station] === "observe") {
+        observeClassic(on, station, async (e) => void (await answer(e)));
+        return;
+    }
+    on(station, async (_$, e, next) => (await answer(e)) ?? next(e));
+}
+export function observeClassic(on, station, watch) {
+    on(station, async (_$, e) => {
+        await watch(e);
+        return undefined;
+    }, { observe: true });
+}
+//# sourceMappingURL=classic-stations.js.map

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

@@ -1,6 +1,6 @@
 import type { ModelKeyRef } from "../key-resolver.js";
 import type { ServiceConfig } from "../config-types.js";
-import type { HookLlmCall } from "./hook-runner.js";
+import type { HookLlmCall, HookLlmFailureCode } from "./hook-runner.js";
 /**
  * hookLlm(prompt 条目/session titler 的模型载体)= 直连一次非流式 completion,从 main.ts 抽出成可注入
  * 单元(fetchImpl/keyResolver 可假),因为这条 wire 在每个默认部署上都活(titler),必须可单测。
@@ -16,13 +16,13 @@ import type { HookLlmCall } from "./hook-runner.js";
  *
  * 🔴 **选线 = 引擎主路由同一只判词**(S-1630):「这只模型走 openai-completions 还是 anthropic-messages」不是本面的事,
  * 是引擎主路由的事 —— `brain.ts` 按 `model.provider` 在「anthropic 路由(仅当 ANTHROPIC 凭据把它装上)/ 网关栈」之间选,
- * 路由没装时整台机器只有网关这一只 brain,**连 `provider:"anthropic"` 的模型也落网关**(`dispatchBrainLane` 的合取,
+ * 路由没装时整台机器只有网关这一只 brain,**连 `provider:"anthropic"` 的模型也落网关**(判词 `brainLaneFor` = 引擎 `brainLaneOf` 对装上的路由表的答案,
  * 端点判官 / 降级腿 / 启动摘要读的是同一只)。本面此前自己按 `provider === "anthropic"` / `api === "anthropic-messages"`
  * 字面判线 ⇒ 在 `MODEL_PROVIDER=anthropic` 而只配了网关的部署上,主请求去网关、标题与 hooks 的 llm 面却要找一条没装的
  * anthropic 路由,整条拒发(零请求,只落 fail-open 标签)。现在本面只问那一只判词,不留第二个读法 —— 含 `api` 词:
  * 引擎不按 `api` 选线(core 的 `createRoutingBrain` 缺省按 `provider` 键),settings-schema 的 `ModelEntry` 又强制两个词同真同假。
- * (core 目前只导出 `createRoutingBrain` 这个组合子,没有「给定模型与已装路由 → 哪条腿 / 哪个根」的判官;它导出之日,
- * `dispatchBrainLane` 连同本调用点一并改为问它。)
+ * (S-1630 的 (a) 路已兑现:core 7.53.0 #1842 根导出了那只判官 `brainLaneOf(model, routes)` —— `createRoutingBrain` 对每个请求问的就是它;
+ * 本仓自写的合取 `dispatchBrainLane` 随之退役,本调用点与另三处一并改问它。)
  */
 export type HookModelPick = {
     ok: true;
@@ -30,9 +30,12 @@ export type HookModelPick = {
     providerModelId: string;
     baseUrl: string;
     api: "openai-completions" | "anthropic-messages";
-} | {
+}
+/** 选不出来的那一臂自带失败码(S-1635):两个载体(prompt 直连 / agent 子代理)共用这一只选模闸,同一只判词同一个码。 */
+ | {
     ok: false;
     error: string;
+    code: Extract<HookLlmFailureCode, "model_unresolved">;
 };
 /**
  * 🔴 **hook 失败展示文本的唯一铸点**(S-494;`build*` = 返回纯数据的一只纯函数)。

package/dist/hooks/hook-llm.js

@@ -1,10 +1,11 @@
-import { adjudicateModelRoute, joinRequestUrl, resolveRouteCredential, routeKeyOf, routeRefusalText } from "@sema-agent/core";
+import { admitRouteRequest, BrainError, joinRequestUrl, resolveRouteCredential, routeKeyOf } from "@sema-agent/core";
 import { matchCatalogModel, refusedCatalogEntry, servedModelTableLeg } from "../model-select.js";
 import { modelUnavailableMessage } from "../model-entry-refusal.js";
 import { resolveOpenaiRouteEndpoint } from "../model-route-endpoint.js";
-import { dispatchBrainLane } from "../model-provider.js";
+import { anthropicRouteRoot, brainLaneFor, routeTableOf } from "../model-provider.js";
 import { egressRedirectRefusal } from "../egress-redirect.js";
 import { buildDisplaySafeRefusal, redactSecrets } from "../trace/redact.js";
+const unresolvedPick = (error) => ({ ok: false, error, code: "model_unresolved" });
 export function buildHookFailureText(raw) {
     if (raw === "")
         return raw;
@@ -15,68 +16,86 @@ export function buildHookFailureText(raw) {
         return `[hook failure text withheld: redactor threw ${err instanceof Error ? err.name : typeof err}]`;
     }
 }
+const ROUTE_REFUSAL_CODES = {
+    "route.credential_mismatch": true,
+    "route.credential_missing": true,
+    "route.credential_origin_mismatch": true,
+    "route.credential_answer_conflict": true,
+};
+const ROUTE_REFUSAL_LEAD = "[invalid_request] ";
+function gateRefusal(pick, e, declaredRoot) {
+    const raw = e instanceof Error ? e.message : String(e);
+    const text = e instanceof BrainError && raw.startsWith(ROUTE_REFUSAL_LEAD) ? raw.slice(ROUTE_REFUSAL_LEAD.length) : raw;
+    const code = Object.keys(ROUTE_REFUSAL_CODES).find((c) => text.startsWith(`${c}:`)) ?? "unclassified";
+    return {
+        ok: false,
+        code: "route_refused",
+        error: `hook model "${pick.catalogRef}" cannot be routed (${code}) — ` + buildDisplaySafeRefusal(text, [pick.baseUrl, declaredRoot ?? ""]),
+    };
+}
 export function createHookLlm(deps) {
     const { config, metrics } = deps;
-    const anthropicRouteBaseUrl = () => config.anthropic?.baseUrl || "https://api.anthropic.com";
-    const shapeFrom = (catalogRef, m, providerModelId) => {
-        const lane = dispatchBrainLane(m?.provider, config.anthropic !== undefined);
+    const anthropicRouteBaseUrl = () => anthropicRouteRoot(config.anthropic ?? {});
+    const shapeFrom = (m, providerModelId = m.id) => {
+        const catalogRef = m.name;
+        const lane = brainLaneFor(m.provider, routeTableOf(config));
         switch (lane) {
             case "anthropic":
-                return { ok: true, catalogRef, providerModelId, baseUrl: m?.baseUrl || anthropicRouteBaseUrl(), api: "anthropic-messages" };
+                return { ok: true, catalogRef, providerModelId, baseUrl: m.baseUrl || anthropicRouteBaseUrl(), api: "anthropic-messages" };
             case "gateway": {
                 const endpoint = resolveOpenaiRouteEndpoint(catalogRef, m, config.gatewayBaseUrl, servedModelTableLeg(config));
-                return endpoint.ok ? { ok: true, catalogRef, providerModelId, baseUrl: endpoint.baseUrl, api: "openai-completions" } : { ok: false, error: endpoint.refusal };
+                return endpoint.ok ? { ok: true, catalogRef, providerModelId, baseUrl: endpoint.baseUrl, api: "openai-completions" } : unresolvedPick(endpoint.refusal);
             }
         }
     };
     const hookModelFor = (requested) => {
-        const shape = (ref) => shapeFrom(ref, config.models[ref], config.models[ref]?.id ?? ref);
+        const ownEntry = (ref) => (Object.hasOwn(config.models, ref) ? config.models[ref] : undefined);
         const unavailable = (field, ref) => {
-            if (config.models[ref] !== undefined)
+            if (ownEntry(ref) !== undefined)
                 return undefined;
             const hit = refusedCatalogEntry(ref, config.modelRefusals);
-            return hit === undefined ? undefined : { ok: false, error: modelUnavailableMessage(field, ref, hit.name, hit.refusal) };
+            return hit === undefined ? undefined : unresolvedPick(modelUnavailableMessage(field, ref, hit.name, hit.refusal));
         };
         if (requested === undefined) {
             const sum = config.roles.summarize;
             const roleModel = typeof sum === "string" ? sum : sum && typeof sum === "object" && "model" in sum && typeof sum.model === "string" ? sum.model : undefined;
-            if (roleModel !== undefined)
-                return unavailable("summarize role model", roleModel) ?? (config.models[roleModel] ? shape(roleModel) : shapeFrom(config.model.id, config.model, roleModel));
-            return shapeFrom(config.model.id, config.model, config.model.id);
+            if (roleModel !== undefined) {
+                const entry = ownEntry(roleModel);
+                return unavailable("summarize role model", roleModel) ?? (entry ? shapeFrom(entry) : shapeFrom(config.model, roleModel));
+            }
+            return shapeFrom(config.model);
         }
-        if (config.models[requested])
-            return shape(requested);
+        const matchedKey = matchCatalogModel(requested, config.models, config.modelRefusals);
+        if (matchedKey !== undefined)
+            return shapeFrom(config.models[matchedKey]);
         if (Object.hasOwn(config.modelRefusals ?? {}, requested))
             return unavailable("hook model", requested);
-        const byId = matchCatalogModel(requested, config.models, config.modelRefusals);
-        if (byId !== undefined)
-            return shape(byId);
         if (requested === config.model.id)
-            return shapeFrom(requested, config.model, requested);
-        return unavailable("hook model", requested) ?? { ok: false, error: `hook model "${requested}" is not in this deployment's catalog` };
+            return shapeFrom(config.model);
+        return unavailable("hook model", requested) ?? unresolvedPick(`hook model "${requested}" is not in this deployment's catalog`);
     };
     const judgeRoute = (pick, perModelKey, deploymentKey, declaredRoot) => {
         const credential = resolveRouteCredential({
             ...(perModelKey !== undefined ? { optionsApiKey: perModelKey } : {}),
             ...(deploymentKey !== undefined ? { configApiKey: deploymentKey } : {}),
         });
-        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 (${verdict.code}) — ` +
-                    buildDisplaySafeRefusal(routeRefusalText(verdict), [pick.baseUrl, declaredRoot ?? ""]),
-            };
+        let admission;
+        try {
+            admission = admitRouteRequest({ id: pick.catalogRef, baseUrl: pick.baseUrl }, credential, { ...(declaredRoot !== undefined ? { baseUrl: declaredRoot } : {}) });
         }
-        if (verdict.posture === "keyless" && routeKeyOf(pick.baseUrl) !== routeKeyOf(declaredRoot)) {
+        catch (e) {
+            return gateRefusal(pick, e, declaredRoot);
+        }
+        if (credential.source === "absent" && routeKeyOf(pick.baseUrl) !== routeKeyOf(declaredRoot)) {
             return {
                 ok: false,
+                code: "route_refused",
                 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)`,
             };
         }
-        return { ok: true, credential };
+        return { ok: true, credential, admission };
     };
     const fetchImpl = deps.fetchImpl ?? fetch;
     const callLlm = async ({ prompt, model, timeoutMs, system, maxOutputTokens }) => {
@@ -85,6 +104,7 @@ export function createHookLlm(deps) {
             return pick;
         const ac = new AbortController();
         const t = setTimeout(() => ac.abort(), timeoutMs);
+        let phase = "assemble";
         try {
             const keyResolver = deps.getKeyResolver();
             let perModelKey;
@@ -93,17 +113,21 @@ export function createHookLlm(deps) {
                     perModelKey = (await keyResolver({ name: pick.catalogRef }))?.apiKey;
                 }
                 catch (e) {
-                    return { ok: false, error: `per-model key resolution for "${pick.catalogRef}" failed — refusing to fall back to the shared route credential (${String(e)})` };
+                    return { ok: false, error: `per-model key resolution for "${pick.catalogRef}" failed — refusing to fall back to the shared route credential (${String(e)})`, code: "credential_custody_failed" };
                 }
             }
             let url;
             let headers;
             let body;
+            let admitted;
+            let declaredRoot;
             if (pick.api === "anthropic-messages") {
                 const routeBase = anthropicRouteBaseUrl();
+                declaredRoot = routeBase;
                 const routed = judgeRoute(pick, perModelKey, config.anthropic?.authToken ?? config.anthropic?.apiKey, routeBase);
                 if (!routed.ok)
                     return routed;
+                admitted = routed.admission;
                 url = joinRequestUrl(pick.baseUrl, "/v1/messages");
                 headers = {
                     "content-type": "application/json",
@@ -121,29 +145,47 @@ export function createHookLlm(deps) {
                 body = JSON.stringify({ model: pick.providerModelId, max_tokens: maxTokens, ...(system ? { system } : {}), messages: [{ role: "user", content: prompt }] });
             }
             else {
+                declaredRoot = config.gatewayBaseUrl;
                 const routed = judgeRoute(pick, perModelKey, config.gatewayApiKey, config.gatewayBaseUrl);
                 if (!routed.ok)
                     return routed;
+                admitted = routed.admission;
                 const hookKey = routed.credential.apiKey;
                 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 });
             }
+            try {
+                admitted();
+            }
+            catch (e) {
+                return gateRefusal(pick, e, declaredRoot);
+            }
+            phase = "transport";
             const r = await fetchImpl(url, { method: "POST", headers, body, signal: ac.signal, redirect: "manual" });
             const redirected = egressRedirectRefusal(r, "declare the final endpoint as this route's base URL");
             if (redirected !== undefined)
                 return { ok: false, error: `hook llm ${redirected}`, code: "redirect_refused" };
             if (!r.ok)
-                return { ok: false, error: `hook llm HTTP ${r.status}` };
+                return { ok: false, error: `hook llm HTTP ${r.status}`, code: "bad_response" };
+            let answered;
+            try {
+                answered = await r.json();
+            }
+            catch (e) {
+                if (ac.signal.aborted || e?.name !== "SyntaxError")
+                    throw e;
+                return { ok: false, error: "hook llm answered with a body that is not JSON", code: "bad_response" };
+            }
             let text;
             if (pick.api === "anthropic-messages") {
-                const j = (await r.json());
-                const parts = (Array.isArray(j.content) ? j.content : []).filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text);
+                const j = answered;
+                const parts = (Array.isArray(j?.content) ? j.content : []).filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text);
                 text = parts.length > 0 ? parts.join("") : undefined;
             }
             else {
-                const j = (await r.json());
-                text = j.choices?.[0]?.message?.content ?? undefined;
+                const j = answered;
+                text = j?.choices?.[0]?.message?.content ?? undefined;
             }
             metrics.inc("hook_llm_calls_total", { type: "prompt" });
             return typeof text === "string" ? { ok: true, text } : { ok: false, error: "hook llm returned no content", code: "no_content" };
@@ -153,6 +195,7 @@ export function createHookLlm(deps) {
             return {
                 ok: false,
                 error: ac.signal.aborted ? "hook llm timeout" : `hook llm request to ${pick.baseUrl} failed: ${String(e)}${cause ? ` (${String(cause)})` : ""}`,
+                code: ac.signal.aborted || phase === "transport" ? "unreachable" : "route_refused",
             };
         }
         finally {