@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/mcpWireCaps.js

@@ -448,6 +448,6 @@ export function mcpAssertionHeaderNotSentNotice(specs) {
     const parts = distinct.slice(0, ASSERTION_NOTICE_NAMES_SHOWN).map((x) => `"${x}"`);
     if (distinct.length > ASSERTION_NOTICE_NAMES_SHOWN)
         parts.push(`+${distinct.length - ASSERTION_NOTICE_NAMES_SHOWN} more`);
-    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.147.0 accept this setting but do not send the header, ` +
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.149.0 accept this setting but do not send the header, ` +
         'and this client cannot tell whether the engine it uses sends it; a connector that requires the header will refuse requests from these servers');
 }

package/dist/memoryVerbsWire.js

@@ -1,4 +1,5 @@
 import { wireFailureShapeOf } from './wireFailureShape.js';
+import { CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED, MEMORY_CONTROL_PLANE_CORRUPT } from './engineErrorCodes.js';
 import { memoryComplianceVerbsAvailable } from './memoryComplianceCapability.js';
 import { memoryOriginVerbsAvailable } from './memoryOriginCapability.js';
 import { readMemoryEraseReceipt, readMemoryOriginClearanceReceipt } from './memoryEntriesWire.js';
@@ -53,7 +54,7 @@ export function classifyMemoryFailure(e) {
             return refusedBy('unauthorized', message);
         case 'auth.operator_only':
             return refusedBy('operator_only', message);
-        case 'capability.operator_principals_required':
+        case CAPABILITY_OPERATOR_PRINCIPALS_REQUIRED:
             return refusedBy('operators_unconfigured', message);
         case 'auth.service_token_required':
             return refusedBy('service_token_required', message);
@@ -94,7 +95,7 @@ export function classifyMemoryFailure(e) {
         case 'memory.target_outside_store':
         case 'memory.scope_home_not_directory':
             return unknownBy('store_form_refused', message);
-        case 'internal.memory_control_plane_corrupt':
+        case MEMORY_CONTROL_PLANE_CORRUPT:
             return unknownBy('control_plane_corrupt', message);
         default:
             break;

package/dist/model/engineModelWords.d.ts

@@ -0,0 +1,3 @@
+export type EngineModelWordKind = 'tier' | 'cc-alias' | 'best' | 'default';
+export declare const ENGINE_MODEL_WORDS: readonly string[];
+export declare function engineModelWordKindOf(word: string): EngineModelWordKind | undefined;

package/dist/model/engineModelWords.js

@@ -0,0 +1,13 @@
+import { CC_TIER_ALIASES, TIER_ORDER } from './tierVocabulary.js';
+export const ENGINE_MODEL_WORDS = Object.freeze([...TIER_ORDER, ...Object.keys(CC_TIER_ALIASES), 'best', 'default']);
+export function engineModelWordKindOf(word) {
+    if (typeof word !== 'string')
+        return undefined;
+    if (TIER_ORDER.includes(word))
+        return 'tier';
+    if (Object.hasOwn(CC_TIER_ALIASES, word))
+        return 'cc-alias';
+    if (word === 'best')
+        return 'best';
+    return word === 'default' ? 'default' : undefined;
+}

package/dist/model/onboardJudgement.d.ts

@@ -1,7 +1,10 @@
-import type { ModelApiWord } from './providerPresets.js';
-import type { OnboardCatalogIssue, OnboardProbeResult, OnboardProbeVerdict, OnboardRefusal } from '../seatContract.js';
+import { type ModelApiWord } from './providerPresets.js';
+import type { ModelDiscoveryResult, OnboardCatalogIssue, OnboardProbeResult, OnboardProbeVerdict, OnboardRefusal } from '../seatContract.js';
+import type { SettingsDocument } from '../host.js';
 import { type ModelProbeResult } from '../modelCapabilityProbe.js';
 import type { UiLanguage } from '../env/uiLanguage.js';
+export declare function onboardKeyCarriedBy(text: string, key: string | undefined): boolean;
+export declare function onboardRedactKey(text: string, key: string | undefined): string;
 export declare function onboardBaseUrlProblem(url: string, lang?: UiLanguage): string | undefined;
 export interface OnboardProbeTarget {
     readonly baseUrl: string;
@@ -42,6 +45,13 @@ export interface OnboardProbeDeps {
     readonly firstTokenMs?: number | undefined;
 }
 export declare function probeModelEndpoint(target: OnboardProbeTarget, deps?: OnboardProbeDeps): Promise<OnboardProbeResult>;
+export interface OnboardDiscoveryTarget {
+    readonly baseUrl: string;
+    readonly api: ModelApiWord;
+    readonly apiKey?: string | undefined;
+    readonly auth?: 'bearer' | 'x-api-key' | undefined;
+}
+export declare function discoverEndpointModels(target: OnboardDiscoveryTarget, deps?: OnboardProbeDeps): Promise<ModelDiscoveryResult>;
 export type OnboardWriteVerdict = {
     readonly write: true;
     readonly unverified: boolean;
@@ -49,10 +59,11 @@ export type OnboardWriteVerdict = {
     readonly write: false;
     readonly refusal: 'probe_failed' | 'probe_unverified';
 };
-export declare function onboardWriteVerdict(verdict: OnboardProbeVerdict, acceptUnverified?: boolean): OnboardWriteVerdict;
+export declare function onboardWriteVerdict(verdict: OnboardProbeVerdict | undefined, acceptUnverified?: boolean): OnboardWriteVerdict;
 export declare const KEY_SLOT_PREFIX = "SEMA_MODEL_KEY_";
 export declare function keyEnvNameForEntry(entryName: string): string;
 export declare function poolEntryNameOf(modelId: string, channel: string, taken: ReadonlySet<string>): string;
+export declare function onboardEntryCredentialIssue(m: SettingsDocument, env: Readonly<Record<string, string | undefined>>): string | undefined;
 export interface OnboardPlanEntry {
     readonly modelId: string;
     readonly api: ModelApiWord;
@@ -90,5 +101,4 @@ export type OnboardWritePlan = {
     readonly refusal: Extract<OnboardRefusal, 'input' | 'catalog_unreadable' | 'credential_unpaired' | 'engine_is_remote' | 'env_catalog_present'>;
     readonly detail: string;
 };
-export declare function onboardWritePlan(input: OnboardWritePlanInput): OnboardWritePlan;
 export declare function onboardRefusalText(refusal: OnboardRefusal, lang?: UiLanguage): string;

package/dist/model/onboardJudgement.js

@@ -1,6 +1,8 @@
+import { inferFamily } from './providerPresets.js';
 import { ONBOARD_REFUSALS } from '../seatContract.js';
-import { joinRequestUrl, routeKeyOf } from '../coreValuePorts.js';
-import { applyProbeToEntry, probeModelLiveness, probeVerdictNotice } from '../modelCapabilityProbe.js';
+import { adjudicateModelRoute, joinRequestUrl, routeKeyOf } from '../coreValuePorts.js';
+import { settleWithinDeadline } from '../abortableSleep.js';
+import { probeModelLiveness, probeVerdictNotice } from '../modelCapabilityProbe.js';
 import { ownDataField } from '../ownKey.js';
 import { msg, renderMessage } from '../i18n/translate.js';
 const field = (v, key) => {
@@ -57,6 +59,9 @@ function safeDecode(t) {
         return t;
     }
 }
+export function onboardKeyCarriedBy(text, key) {
+    return carriesKey(text, key);
+}
 function carriesKey(text, key) {
     if (key === undefined || key === '')
         return false;
@@ -69,6 +74,9 @@ function carriesKey(text, key) {
 function looksLikeSecret(val) {
     return /^(sk|ak|pk|rk)[-_]/i.test(val) || (val.length >= 20 && /[A-Za-z]/.test(val) && /[0-9]/.test(val) && /^[A-Za-z0-9._~+/=-]+$/.test(val));
 }
+export function onboardRedactKey(text, key) {
+    return redact(text, key);
+}
 function redact(text, key) {
     if (key === undefined || key === '')
         return text;
@@ -197,7 +205,71 @@ export async function probeModelEndpoint(target, deps) {
     });
     if (v.verdict === 'unreachable' && seen.redirected !== undefined)
         return out('unreachable', seen.redirected);
-    return out(v.verdict, probeDetailOf(v));
+    const firstOutputMs = v.verdict === 'ok' && typeof v.waitedMs === 'number' && Number.isFinite(v.waitedMs) && v.waitedMs >= 0 ? Math.round(v.waitedMs) : undefined;
+    const r = out(v.verdict, probeDetailOf(v));
+    return firstOutputMs === undefined ? r : Object.freeze({ ...r, firstOutputMs });
+}
+const DISCOVERY_MAX = 512;
+export async function discoverEndpointModels(target, deps) {
+    const apiKey = field(target, 'apiKey');
+    const key = typeof apiKey === 'string' && apiKey !== '' ? apiKey : undefined;
+    const fail = (verdict, detail) => Object.freeze({ ok: false, verdict, detail: capText(redact(detail, key?.trim() || undefined)) });
+    const baseUrl = field(target, 'baseUrl');
+    const api = field(target, 'api');
+    const auth = field(target, 'auth');
+    if (typeof baseUrl !== 'string' || (api !== 'anthropic-messages' && api !== 'openai-completions'))
+        return fail('other', en('onboard.probe.incomplete'));
+    const f = (field(deps, 'fetchImpl') ?? globalThis.fetch);
+    if (typeof f !== 'function')
+        return fail('unreachable', en('onboard.probe.noFetch'));
+    const root = baseUrl.trim();
+    let url;
+    try {
+        url = joinRequestUrl(root, 'models');
+    }
+    catch {
+        return fail('other', en('onboard.baseUrl.invalid'));
+    }
+    if (url === undefined)
+        return fail('other', en('onboard.probe.judgeAbsent'));
+    const t = field(deps, 'timeoutMs');
+    const budget = typeof t === 'number' && Number.isFinite(t) && t > 0 ? t : 10_000;
+    const headers = { ...(api === 'anthropic-messages' ? { 'anthropic-version': '2023-06-01' } : {}), ...keyHeaders(api, key, auth === 'bearer' || auth === 'x-api-key' ? auth : undefined) };
+    const settled = await settleWithinDeadline(budget, async (signal) => {
+        const res = await f(url, { method: 'GET', headers, redirect: 'manual', signal });
+        const redirected = redirectRefusal(res, url, key);
+        if (redirected !== undefined)
+            return fail('unreachable', redirected);
+        if (res.status === 401 || res.status === 403)
+            return fail('auth', en('model.pool.discover.status', { status: res.status }));
+        if (res.status < 200 || res.status >= 300)
+            return fail('other', en('model.pool.discover.status', { status: res.status }));
+        let body;
+        try {
+            body = JSON.parse(await res.text());
+        }
+        catch {
+            return fail('shape', en('model.pool.discover.notList'));
+        }
+        const data = field(body, 'data');
+        if (!Array.isArray(data))
+            return fail('shape', en('model.pool.discover.notList'));
+        const out = [];
+        for (let i = 0; i < data.length && out.length < DISCOVERY_MAX; i++) {
+            const id = field(field(data, String(i)), 'id');
+            if (typeof id !== 'string' || id.trim() === '' || id.length > 512 || carriesKey(id, key) || out.some((c) => c.id === id))
+                continue;
+            const fam = inferFamily(id);
+            const exact = fam !== undefined && fam.perModelCap !== undefined;
+            out.push(Object.freeze({ id, ...(exact ? { contextWindow: fam.contextWindow, maxTokens: fam.maxTokens } : {}) }));
+        }
+        return Object.freeze({ ok: true, candidates: Object.freeze(out) });
+    });
+    if (settled.kind === 'deadline')
+        return fail('unreachable', en('model.pool.discover.timeout'));
+    if (settled.kind === 'error')
+        return fail('unreachable', en('model.pool.discover.unreachable', { cause: settled.detail }));
+    return settled.value;
 }
 export function onboardWriteVerdict(verdict, acceptUnverified) {
     if (verdict === 'ok')
@@ -224,6 +296,9 @@ export function poolEntryNameOf(modelId, channel, taken) {
         candidate = `${name}-${channel}-${i}`;
     return candidate;
 }
+export function onboardEntryCredentialIssue(m, env) {
+    return entryCredentialIssue(m, env);
+}
 function entryCredentialIssue(m, env) {
     const name = typeof m['name'] === 'string' ? m['name'] : '?';
     if (m['sealedApiKey'] !== undefined && m['sealedApiKey'] !== null)
@@ -239,6 +314,19 @@ function entryCredentialIssue(m, env) {
     const api = typeof m['api'] === 'string' ? m['api'] : 'openai-completions';
     const rootKey = api === 'anthropic-messages' ? 'ANTHROPIC_BASE_URL' : 'MODEL_GATEWAY_BASEURL';
     const root = env[rootKey];
+    if (api !== 'anthropic-messages' && (typeof root !== 'string' || root.trim() === '')) {
+        let keyless;
+        try {
+            keyless = adjudicateModelRoute({ id: typeof m['id'] === 'string' ? m['id'] : name, baseUrl: base }, { source: 'absent' }, {});
+        }
+        catch {
+            keyless = undefined;
+        }
+        if (keyless === undefined)
+            return en('onboard.catalog.judgeAbsent', { name });
+        if (keyless.ok)
+            return undefined;
+    }
     let paired;
     try {
         const a = routeKeyOf(base);
@@ -262,142 +350,6 @@ function entryCredentialIssue(m, env) {
     const rootText = typeof root === 'string' && root !== '' ? `${rootKey} (${hostOf(root)})` : en('onboard.catalog.noRoot', { rootKey });
     return en('onboard.catalog.unpaired', { name, host: hostOf(base), root: rootText });
 }
-function migrateLegacyDefaultKey(doc) {
-    const legacy = doc['default'];
-    if (typeof legacy !== 'string' || legacy.length === 0)
-        return doc;
-    const { default: _legacy, ...rest } = doc;
-    void _legacy;
-    const prevRoles = rest['roles'];
-    const roles = prevRoles !== null && typeof prevRoles === 'object' && !Array.isArray(prevRoles) ? { ...prevRoles } : {};
-    roles['default'] = { model: legacy };
-    return { ...rest, roles };
-}
-export function onboardWritePlan(input) {
-    const rawKey = field(field(input, 'entry'), 'apiKey');
-    const planKey = typeof rawKey === 'string' && rawKey !== '' ? rawKey : undefined;
-    const say = (text) => redact(text, planKey);
-    const refuse = (refusal, detail) => Object.freeze({ ok: false, refusal, detail: say(detail) });
-    try {
-        if (input.engineMode === 'cloud')
-            return refuse('engine_is_remote', en('onboard.refusal.engineIsRemote'));
-        const rawDoc = input.modelsDoc;
-        if (rawDoc !== undefined && (rawDoc === null || typeof rawDoc !== 'object' || Array.isArray(rawDoc)))
-            return refuse('catalog_unreadable', en('onboard.plan.notObject'));
-        const doc = migrateLegacyDefaultKey(rawDoc === undefined ? {} : { ...rawDoc });
-        const rawModels = doc['models'];
-        if (rawModels !== undefined && !Array.isArray(rawModels))
-            return refuse('catalog_unreadable', en('onboard.plan.modelsNotList'));
-        const list = Array.isArray(rawModels) ? rawModels : [];
-        if (list.some((m) => m === null || typeof m !== 'object' || Array.isArray(m)))
-            return refuse('catalog_unreadable', en('onboard.plan.modelsItemNotObject'));
-        const models = list.map((m) => ({ ...m }));
-        const envModel = [input.effectiveEnv?.['MODEL_ID'], input.effectiveEnv?.['MODEL_CHEAP_ID']].find((v) => typeof v === 'string' && v.trim() !== '');
-        if (envModel !== undefined && !models.some((m) => m['enabled'] !== false)) {
-            return refuse('env_catalog_present', en('onboard.plan.envCatalogPresent', { model: envModel }));
-        }
-        const rawEnv = input.settingsEnv;
-        if (rawEnv !== undefined && (rawEnv === null || typeof rawEnv !== 'object' || Array.isArray(rawEnv)))
-            return refuse('catalog_unreadable', en('onboard.plan.envNotObject'));
-        const prevEnv = rawEnv === undefined ? {} : { ...rawEnv };
-        const e = input.entry;
-        const isShellSlot = (ref) => typeof ref === 'string' && ref.startsWith(KEY_SLOT_PREFIX) && typeof prevEnv[ref] === 'string';
-        const targetKey = routeKeyOf(e.baseUrl);
-        if (targetKey === undefined)
-            return refuse('credential_unpaired', en('onboard.catalog.judgeAbsent', { name: e.modelId }));
-        const sameTarget = (m) => m['id'] === e.modelId && m['api'] === e.api && typeof m['baseUrl'] === 'string' && routeKeyOf(m['baseUrl']) === targetKey;
-        const existingIdx = models.findIndex((m) => sameTarget(m) && m['enabled'] !== false && m['sealedApiKey'] === undefined && (m['apiKeyEnv'] === undefined || isShellSlot(m['apiKeyEnv'])));
-        const taken = new Set(models.map((m) => (typeof m['name'] === 'string' ? m['name'] : '')).filter((n) => n !== ''));
-        const name = existingIdx >= 0 ? String(models[existingIdx]['name']) : poolEntryNameOf(e.modelId, e.channel, taken);
-        const existingRef = existingIdx >= 0 ? models[existingIdx]['apiKeyEnv'] : undefined;
-        const sharedByOther = typeof existingRef === 'string' &&
-            models.some((m, i) => i !== existingIdx && typeof m['apiKeyEnv'] === 'string' && m['apiKeyEnv'].toUpperCase() === existingRef.toUpperCase());
-        let keyEnv;
-        if (isShellSlot(existingRef) && !sharedByOther) {
-            keyEnv = existingRef;
-        }
-        else {
-            const used = new Set();
-            for (const m of models)
-                if (typeof m['apiKeyEnv'] === 'string')
-                    used.add(m['apiKeyEnv'].toUpperCase());
-            for (const k of Object.keys(prevEnv))
-                used.add(k.toUpperCase());
-            for (const [k, v] of Object.entries(input.effectiveEnv ?? {}))
-                if (typeof v === 'string')
-                    used.add(k.toUpperCase());
-            const baseSlot = keyEnvNameForEntry(name);
-            keyEnv = baseSlot;
-            for (let i = 2; used.has(keyEnv.toUpperCase()); i++)
-                keyEnv = `${baseSlot}_${i}`;
-        }
-        if (carriesKey(name, e.apiKey) || carriesKey(keyEnv, e.apiKey))
-            return refuse('input', en('onboard.input.keyInFields'));
-        const base = existingIdx >= 0 ? models[existingIdx] : {};
-        let entry = {
-            ...base,
-            name,
-            id: e.modelId,
-            provider: e.api === 'anthropic-messages' ? 'anthropic' : 'gateway',
-            api: e.api,
-            baseUrl: e.baseUrl,
-            contextWindow: typeof base['contextWindow'] === 'number' ? base['contextWindow'] : e.contextWindow,
-            maxTokens: typeof base['maxTokens'] === 'number' ? base['maxTokens'] : e.maxTokens,
-            apiKeyEnv: keyEnv,
-            semaChannel: typeof base['semaChannel'] === 'string' ? base['semaChannel'] : e.channel,
-            semaLabel: typeof base['semaLabel'] === 'string' ? base['semaLabel'] : e.providerName,
-            semaProbe: input.probe.verdict,
-            semaProbeAt: input.now,
-        };
-        if (input.thinking !== undefined) {
-            const probed = applyProbeToEntry({ ...(typeof entry['reasoning'] === 'boolean' ? { reasoning: entry['reasoning'] } : {}), ...(entry['compat'] !== undefined ? { compat: entry['compat'] } : {}) }, input.thinking);
-            const next = { ...entry };
-            if (typeof probed.reasoning === 'boolean')
-                next['reasoning'] = probed.reasoning;
-            if (probed.compat !== undefined)
-                next['compat'] = probed.compat;
-            else
-                delete next['compat'];
-            entry = next;
-        }
-        const envView = { ...input.effectiveEnv, [keyEnv]: e.apiKey };
-        const issue = entryCredentialIssue(entry, envView);
-        if (issue !== undefined)
-            return refuse('credential_unpaired', issue);
-        if (existingIdx >= 0)
-            models[existingIdx] = entry;
-        else
-            models.push(entry);
-        const nextDoc = { ...doc, models };
-        if (input.makeDefault) {
-            const prevRoles = doc['roles'];
-            const roles = prevRoles !== null && typeof prevRoles === 'object' && !Array.isArray(prevRoles) ? { ...prevRoles } : {};
-            roles['default'] = { model: name };
-            nextDoc['roles'] = roles;
-        }
-        const otherIssues = [];
-        for (const m of models) {
-            if (m['enabled'] === false || m['name'] === name)
-                continue;
-            const other = entryCredentialIssue(m, envView);
-            if (other !== undefined) {
-                otherIssues.push(Object.freeze({ name: typeof m['name'] === 'string' ? m['name'] : '?', modelId: typeof m['id'] === 'string' ? m['id'] : '?', issue: say(other) }));
-            }
-        }
-        return Object.freeze({
-            ok: true,
-            entryName: name,
-            keyEnv,
-            updatedExisting: existingIdx >= 0,
-            nextModelsDoc: nextDoc,
-            nextSettingsEnv: { ...prevEnv, [keyEnv]: e.apiKey },
-            otherIssues: Object.freeze(otherIssues),
-        });
-    }
-    catch {
-        return refuse('input', en('onboard.refusal.input'));
-    }
-}
 const REFUSAL_KEYS = {
     input: 'onboard.refusal.input',
     probe_failed: 'onboard.refusal.probeFailed',

package/dist/model/subagentModelWord.d.ts

@@ -1,9 +1,9 @@
 import { type LiveModelCatalog } from '../liveModelCatalog.js';
 import type { UiLanguage } from '../env/uiLanguage.js';
-export type SubagentModelWordKind = 'inherit' | 'catalog' | 'tier' | 'cc-alias' | 'best' | 'model-id' | 'passthrough' | 'catalog-unknown' | 'ambiguous' | 'unbound';
+export type SubagentModelWordKind = 'inherit' | 'catalog' | 'tier' | 'cc-alias' | 'best' | 'default' | 'model-id' | 'passthrough' | 'catalog-unknown' | 'ambiguous' | 'unbound';
 export type SubagentModelWordProblem = 'tiers-inert' | 'chain-unbound' | 'binding-not-in-catalog';
 export interface SubagentModelLocalEngine {
-    readonly engine: 'started-by-this-process';
+    readonly engine: 'reads-this-config' | 'started-by-this-process';
     readonly tiers: Readonly<Record<string, string>> | undefined;
     readonly pool?: readonly {
         readonly name: string;
@@ -29,3 +29,22 @@ export interface SubagentModelWordReading {
 }
 export declare function resolveSubagentModelWord(input: SubagentModelWordInput | null | undefined): SubagentModelWordReading;
 export declare function subagentModelWordProblemLine(word: string, reading: SubagentModelWordReading, lang?: UiLanguage): string | undefined;
+export declare function subagentModelCallRefusalReason(word: string, reading: SubagentModelWordReading, lang?: UiLanguage): string | undefined;
+export type SubagentModelAdmission = {
+    readonly verdict: 'accepted';
+    readonly why: 'not_sent';
+} | {
+    readonly verdict: 'accepted';
+    readonly why: 'served';
+    readonly model: string;
+} | {
+    readonly verdict: 'refused';
+    readonly why: 'not_listed' | 'not_served' | 'disabled';
+    readonly model: string;
+} | {
+    readonly verdict: 'unknown';
+    readonly why: 'catalog_absent' | 'catalog_unreadable' | 'catalog_incomplete' | 'reserved_word';
+    readonly model: string;
+};
+export declare function subagentModelAdmissionOf(input: SubagentModelWordInput | null | undefined): SubagentModelAdmission;
+export declare function subagentModelAdmissionLine(word: string, admission: SubagentModelAdmission, lang?: UiLanguage): string | undefined;

package/dist/model/subagentModelWord.js

@@ -1,8 +1,10 @@
 import { CC_TIER_ALIASES, TIER_ORDER } from './tierVocabulary.js';
-import { liveModelRowsOf } from '../liveModelCatalog.js';
+import { ENGINE_MODEL_WORDS, engineModelWordKindOf } from './engineModelWords.js';
+import { liveModelRowsOf, modelAcceptanceOf } from '../liveModelCatalog.js';
 import { quoteUntrustedForSentence } from '../displayUntrusted.js';
 import { msg, renderMessage } from '../i18n/translate.js';
-const STARTED_BY_THIS_PROCESS = 'started-by-this-process';
+const READS_THIS_CONFIG = 'reads-this-config';
+const LEGACY_LOCAL_ENGINE_WORD = 'started-by-this-process';
 function ownData(v, key) {
     if (v === null || typeof v !== 'object')
         return undefined;
@@ -46,7 +48,8 @@ function localOf(input) {
     const local = ownData(input, 'local');
     if (local === null || typeof local !== 'object')
         return undefined;
-    return ownData(local, 'engine') === STARTED_BY_THIS_PROCESS ? local : undefined;
+    const engine = ownData(local, 'engine');
+    return engine === READS_THIS_CONFIG || engine === LEGACY_LOCAL_ENGINE_WORD ? local : undefined;
 }
 function catalogOf(input, local) {
     const live = ownData(input, 'liveCatalog');
@@ -115,14 +118,7 @@ function tiersOf(local) {
     }
     return out;
 }
-const BUILTIN_VOCAB = [...TIER_ORDER, ...Object.keys(CC_TIER_ALIASES), 'best'];
-function builtinKindOf(w) {
-    if (TIER_ORDER.includes(w))
-        return 'tier';
-    if (Object.hasOwn(CC_TIER_ALIASES, w))
-        return 'cc-alias';
-    return w === 'best' ? 'best' : undefined;
-}
+const builtinKindOf = engineModelWordKindOf;
 class BrokenBinding {
 }
 function landingOf(word, kind, tiers, cat) {
@@ -203,21 +199,22 @@ function resolveIn(input) {
         return { kind, model: w, landing: { name: l.name, via: l.via, source: 'local-config' }, label: `${l.name} (${label})` };
     };
     const asCatalog = (name) => ({ kind: 'catalog', model: name, label: name });
+    const asDefault = (w) => ({ kind: 'default', model: w, label: w });
+    const vocab = (w, b) => (b === 'default' ? asDefault(w) : tierClass(w, b));
     const classify = (k) => {
         if (cat?.nameSet.has(k))
             return asCatalog(k);
-        const b = builtinKindOf(k);
-        return tierClass(k, b ?? 'tier');
+        return vocab(k, builtinKindOf(k) ?? 'tier');
     };
     if (cat?.nameSet.has(word))
         return freezeReading(asCatalog(word));
     const exact = builtinKindOf(word);
     if (exact !== undefined)
-        return freezeReading(tierClass(word, exact));
+        return freezeReading(vocab(word, exact));
     if (tiers?.has(word))
         return freezeReading(tierClass(word, 'tier'));
     const lower = word.toLowerCase();
-    const space = new Set([...(cat?.names ?? []), ...BUILTIN_VOCAB, ...customTierKeys]);
+    const space = new Set([...(cat?.names ?? []), ...ENGINE_MODEL_WORDS, ...customTierKeys]);
     const ciMatches = [...space].filter((k) => k.toLowerCase() === lower);
     if (builtinKindOf(lower) !== undefined) {
         return freezeReading(ciMatches.length === 1 ? classify(ciMatches[0]) : { kind: 'ambiguous' });
@@ -241,21 +238,95 @@ export function resolveSubagentModelWord(input) {
         return freezeReading(word === '' ? { kind: 'inherit' } : { kind: 'catalog-unknown', model: word, label: word });
     }
 }
-export function subagentModelWordProblemLine(word, reading, lang) {
-    const ref = problemRefOf(word, reading);
-    return ref === undefined ? undefined : renderMessage(ref, lang);
-}
-function problemRefOf(word, reading) {
+function wordCauseOf(reading) {
     const kind = ownData(reading, 'kind');
-    if (kind !== 'unbound' && kind !== 'ambiguous')
-        return undefined;
-    const quoted = quoteUntrustedForSentence(typeof word === 'string' ? word.trim() : '', 80) ?? '""';
     if (kind === 'ambiguous')
-        return msg('model.subagent.ambiguous', { word: quoted });
+        return 'ambiguous';
+    if (kind !== 'unbound')
+        return undefined;
     const problem = ownData(reading, 'problem');
-    if (problem === 'tiers-inert')
-        return msg('model.subagent.tiersInert', { word: quoted });
-    if (problem === 'binding-not-in-catalog')
-        return msg('model.subagent.bindingNotInCatalog', { word: quoted });
-    return msg('model.subagent.chainUnbound', { word: quoted });
+    return problem === 'tiers-inert' || problem === 'binding-not-in-catalog' ? problem : 'chain-unbound';
+}
+const PROBLEM_LINE_KEYS = Object.freeze({
+    ambiguous: 'model.subagent.ambiguous',
+    'tiers-inert': 'model.subagent.tiersInert',
+    'chain-unbound': 'model.subagent.chainUnbound',
+    'binding-not-in-catalog': 'model.subagent.bindingNotInCatalog',
+});
+const CALL_REFUSAL_KEYS = Object.freeze({
+    ambiguous: 'model.subagent.call.ambiguous',
+    'tiers-inert': 'model.subagent.call.tiersInert',
+    'chain-unbound': 'model.subagent.call.chainUnbound',
+    'binding-not-in-catalog': 'model.subagent.call.bindingNotInCatalog',
+});
+const WORD_SHOWN_MAX = 80;
+function quotedWord(word) {
+    return quoteUntrustedForSentence(typeof word === 'string' ? word.trim() : '', WORD_SHOWN_MAX) ?? '""';
+}
+export function subagentModelWordProblemLine(word, reading, lang) {
+    const cause = wordCauseOf(reading);
+    return cause === undefined ? undefined : renderMessage(msg(PROBLEM_LINE_KEYS[cause], { word: quotedWord(word) }), lang);
+}
+export function subagentModelCallRefusalReason(word, reading, lang) {
+    try {
+        const cause = wordCauseOf(reading);
+        if (cause === undefined)
+            return undefined;
+        const label = ownData(reading, 'label');
+        const tier = typeof label === 'string' && label.trim() !== '' ? label : word;
+        return renderMessage(msg(CALL_REFUSAL_KEYS[cause], { word: quotedWord(word), tier: quotedWord(tier) }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+const notSent = () => Object.freeze({ verdict: 'accepted', why: 'not_sent' });
+const isVocabKind = (k) => k === 'tier' || k === 'cc-alias' || k === 'best' || k === 'default';
+function admissionIn(input) {
+    const reading = resolveIn(input);
+    const model = reading.model;
+    if (model === undefined)
+        return notSent();
+    const live = ownData(input, 'liveCatalog');
+    if (live === undefined || live === null)
+        return Object.freeze({ verdict: 'unknown', why: 'catalog_absent', model });
+    const a = modelAcceptanceOf(model, live);
+    if (a.verdict === 'accepted')
+        return Object.freeze({ verdict: 'accepted', why: 'served', model });
+    if (a.verdict === 'refused') {
+        if (a.why === 'not_at_mentionable')
+            return Object.freeze({ verdict: 'accepted', why: 'served', model });
+        if (a.why === 'disabled')
+            return Object.freeze({ verdict: 'refused', why: 'disabled', model });
+        return Object.freeze({ verdict: 'refused', why: isVocabKind(reading.kind) ? 'not_served' : 'not_listed', model });
+    }
+    return Object.freeze({ verdict: 'unknown', why: a.why === 'model_absent' ? 'catalog_unreadable' : a.why, model });
+}
+export function subagentModelAdmissionOf(input) {
+    try {
+        return admissionIn(input);
+    }
+    catch {
+        const w = ownData(input, 'word');
+        const word = typeof w === 'string' ? w.trim() : '';
+        return word === '' ? notSent() : Object.freeze({ verdict: 'unknown', why: 'catalog_unreadable', model: word });
+    }
+}
+const ADMISSION_LINE_KEYS = Object.freeze({
+    not_listed: 'model.subagent.refused.notListed',
+    not_served: 'model.subagent.refused.notServed',
+    disabled: 'model.subagent.refused.disabled',
+});
+export function subagentModelAdmissionLine(word, admission, lang) {
+    try {
+        if (ownData(admission, 'verdict') !== 'refused')
+            return undefined;
+        const why = ownData(admission, 'why');
+        if (why !== 'not_listed' && why !== 'not_served' && why !== 'disabled')
+            return undefined;
+        return renderMessage(msg(ADMISSION_LINE_KEYS[why], { word: quotedWord(word) }), lang);
+    }
+    catch {
+        return undefined;
+    }
 }

package/dist/modelCapabilityProbe.js

@@ -1,5 +1,5 @@
 import { displayUntrusted } from './displayUntrusted.js';
-import { abortableSleep } from './abortableSleep.js';
+import { requestDeadline } from './abortableSleep.js';
 import { causeSlotProtected, walkCauseChain } from './engineWireFor.js';
 import { readThrownSlot } from './wireFailureShape.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
@@ -522,45 +522,8 @@ function shownCause(e, redact) {
     const shown = displayUntrusted(masked, { max: 160 });
     return shown.trim() === '' ? undefined : shown;
 }
-const MAX_TIMER_MS = 2_147_483_647;
-function probeDeadline(ms, cancel) {
-    const ctl = new AbortController();
-    const stop = new AbortController();
-    let expired = false;
-    const gone = new Promise((_resolve, reject) => {
-        const fire = () => reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
-        if (ctl.signal.aborted)
-            fire();
-        else
-            ctl.signal.addEventListener('abort', fire, { once: true });
-    });
-    gone.catch(() => undefined);
-    void abortableSleep(Math.min(ms, MAX_TIMER_MS), stop.signal).then(() => {
-        if (stop.signal.aborted)
-            return;
-        expired = true;
-        ctl.abort();
-    });
-    const onCancel = () => ctl.abort();
-    if (cancel !== undefined) {
-        if (cancel.aborted)
-            ctl.abort();
-        else
-            cancel.addEventListener('abort', onCancel, { once: true });
-    }
-    return {
-        signal: ctl.signal,
-        expired: () => expired,
-        abort: () => {
-            stop.abort();
-            cancel?.removeEventListener('abort', onCancel);
-            ctl.abort();
-        },
-        race: (p) => Promise.race([p, gone]),
-    };
-}
 async function getCatalogText(fetchIt, url, headers, timeoutMs, cancel) {
-    const d = probeDeadline(timeoutMs, cancel);
+    const d = requestDeadline(timeoutMs, cancel);
     try {
         const res = await d.race(fetchIt(url, { method: 'GET', headers, signal: d.signal }));
         let text = '';
@@ -577,7 +540,7 @@ async function getCatalogText(fetchIt, url, headers, timeoutMs, cancel) {
     }
 }
 async function postForFirstToken(fetchIt, api, url, path, headers, body, deadlineMs, cancel, now, redact) {
-    const d = probeDeadline(deadlineMs, cancel);
+    const d = requestDeadline(deadlineMs, cancel);
     const startedAt = now();
     try {
         const res = await d.race(fetchIt(url, { method: 'POST', headers, body, signal: d.signal }));