@sema-agent/client-core 0.99.0 → 0.100.0

package/dist/mcpToolToggles.js

@@ -0,0 +1,46 @@
+import { checkMcpToolToggleKey } from './seatContract.js';
+function keyOf(key, index) {
+    const refuse = (why) => new TypeError(`mcpToolTogglesToExcludeTools: keys[${index}] 不是逐工具开关键 { server, tool }(${why})—— 值不回显。` +
+        '宿主存档读坏了请在读档处用 checkMcpToolToggleKey 判,不要交进来让它在每一回合被静默丢掉。');
+    const shape = checkMcpToolToggleKey(key);
+    if (shape !== true)
+        throw refuse(`${shape.reason}${shape.field !== undefined ? ` @ ${shape.field}` : ''}`);
+    let snap;
+    try {
+        snap = { server: Object.getOwnPropertyDescriptor(key, 'server')?.value, tool: Object.getOwnPropertyDescriptor(key, 'tool')?.value };
+    }
+    catch {
+        throw refuse('读不出');
+    }
+    const again = checkMcpToolToggleKey(snap);
+    if (again !== true)
+        throw refuse(`${again.reason}${again.field !== undefined ? ` @ ${again.field}` : ''};判形之后读到的值与判过的不一致`);
+    return Object.freeze({ server: snap.server, tool: snap.tool });
+}
+function mountedSetOf(mountedServers) {
+    if (mountedServers === 'unknown')
+        return 'unknown';
+    if (!Array.isArray(mountedServers) || !mountedServers.every((s) => typeof s === 'string')) {
+        throw new TypeError("mcpToolTogglesToExcludeTools: mountedServers 只接受服务器名(串)数组,或宿主判不出时交 'unknown' —— 收到别的形(值不回显)。" +
+            "不知道本回合挂了哪些时请交 'unknown'(全部出),不要交 [](那会把用户关掉的工具静默放回)。");
+    }
+    return new Set(mountedServers);
+}
+export function mcpToolTogglesToExcludeTools(keys, mountedServers) {
+    if (!Array.isArray(keys)) {
+        throw new TypeError('mcpToolTogglesToExcludeTools: keys 必须是逐工具开关键数组(值不回显)。');
+    }
+    const mounted = mountedSetOf(mountedServers);
+    const parts = keys.map((k, i) => keyOf(k, i));
+    const out = [];
+    const seen = new Set();
+    for (const { server, tool } of parts) {
+        if (mounted !== 'unknown' && !mounted.has(server))
+            continue;
+        if (seen.has(tool))
+            continue;
+        seen.add(tool);
+        out.push(tool);
+    }
+    return out;
+}

package/dist/mcpWireCaps.d.ts

@@ -1,9 +1,7 @@
 import type { McpServerSpec } from '@sema-agent/sdk';
+import type { McpEntryKeyIssue } from './generated/settingsSchemaTypes.js';
 import type { UiLanguage } from './env/uiLanguage.js';
 export type { McpServerSpec };
-export declare const MCP_CAPS: {
-    readonly items: 32;
-};
 export interface McpConfigLike {
     type?: string;
     command?: string;
@@ -17,6 +15,7 @@ export interface McpConfigLike {
     elicitation?: {} | null | undefined;
     toolFaces?: unknown;
     toolAxes?: unknown;
+    startupTimeoutMs?: number;
 }
 export type McpHttpIdentityHeaders = {
     readonly kind: 'ok';
@@ -44,16 +43,23 @@ export declare function mcpElicitationVerdict(declared: {} | null | undefined):
 } | {
     readonly kind: 'bad';
 };
-export type McpConfigDropReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'tool_axes_invalid' | 'elicitation_invalid';
+export type McpConfigDropReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'transport_invalid' | 'identity_headers_both_set' | 'tool_axes_invalid' | 'elicitation_invalid';
 export interface McpConfigDropped {
     readonly name: string;
     readonly reason: McpConfigDropReason;
     readonly problem?: string;
+    readonly path?: string;
+    readonly notice: string;
+}
+export interface McpConfigDegraded {
+    readonly name: string;
+    readonly lost: readonly McpEntryKeyIssue[];
     readonly notice: string;
 }
 export interface McpConfigProjection {
     readonly specs: McpServerSpec[];
     readonly dropped: readonly McpConfigDropped[];
+    readonly degraded: readonly McpConfigDegraded[];
 }
 export interface ProjectMcpConfigsOptions {
     readonly sourceLabel?: (serverName: string) => string | undefined;

package/dist/mcpWireCaps.js

@@ -1,37 +1,32 @@
+import { SETTINGS_DESCRIBE_BAD_WIRE_NAME, SETTINGS_IS_USABLE_WIRE_NAME, SETTINGS_READ_MCP_IDENTITY_HEADERS, SETTINGS_READ_REQUEST_MCP_TRANSPORT, } from './generated/settingsSchemaFns.js';
+import { snapshotArgs, wireTransportOf } from './mcpWireTransport.js';
 import { guardedRead } from './ownKey.js';
 import { readMcpToolAxes } from './coreValuePorts.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { msg, renderMessage } from './i18n/translate.js';
 const _mcpServerSpecPin = true;
 void _mcpServerSpecPin;
-export const MCP_CAPS = { items: 32 };
 function transparentKeys(c, axes, elicitation) {
     return {
         ...(c.toolFaces !== undefined ? { toolFaces: c.toolFaces } : {}),
         ...(axes !== undefined ? { toolAxes: axes } : {}),
         ...(elicitation !== undefined ? { elicitation } : {}),
+        ...(c.startupTimeoutMs !== undefined ? { startupTimeoutMs: c.startupTimeoutMs } : {}),
     };
 }
-function presentHeaderName(v) {
-    return typeof v === 'string' && v.length > 0 ? v : undefined;
-}
 export function readMcpHttpIdentityHeaders(transport) {
     const t = transport;
-    const principalHeader = presentHeaderName(t.principalHeader);
-    const assertionHeader = presentHeaderName(t.assertionHeader);
+    const principalHeader = t.principalHeader;
+    const assertionHeader = t.assertionHeader;
     if (principalHeader !== undefined && assertionHeader !== undefined)
         return { kind: 'both_set' };
-    return {
-        kind: 'ok',
-        ...(principalHeader !== undefined ? { principalHeader } : {}),
-        ...(assertionHeader !== undefined ? { assertionHeader } : {}),
-    };
+    return { kind: 'ok', ...SETTINGS_READ_MCP_IDENTITY_HEADERS({ principalHeader, assertionHeader }) };
 }
 export function mcpConfigToSpec(name, c) {
     return mcpConfigEntry(name, c).spec;
 }
 function mcpConfigEntry(name, c) {
-    if (mcpNameFlaw(name) !== undefined)
+    if (!nameUsable(name))
         return { spec: null };
     const declared = c.toolAxes;
     const verdict = mcpToolAxesVerdict(declared);
@@ -39,49 +34,62 @@ function mcpConfigEntry(name, c) {
     const elVerdict = mcpElicitationVerdict(elDeclared);
     if (verdict.kind === 'bad' || elVerdict.kind === 'bad') {
         const rest = specOf(name, c, undefined, undefined);
-        if (rest === null)
+        if (rest.kind === 'skip')
             return { spec: null };
+        if (rest.kind === 'both_set')
+            return { spec: null, identityBothSet: true };
+        if (rest.kind === 'bad')
+            return { spec: null, transportBad: rest.issue };
         return verdict.kind === 'bad' ? { spec: null, axesProblem: verdict.problem } : { spec: null, elicitationInvalid: true };
     }
-    return { spec: specOf(name, c, verdict.kind === 'ok' ? verdict.toolAxes : declared, elVerdict.elicitation) };
+    const read = specOf(name, c, verdict.kind === 'ok' ? verdict.toolAxes : declared, elVerdict.elicitation);
+    if (read.kind === 'skip')
+        return { spec: null };
+    if (read.kind === 'both_set')
+        return { spec: null, identityBothSet: true };
+    if (read.kind === 'bad')
+        return { spec: null, transportBad: read.issue };
+    return { spec: read.spec, ...(read.lost.length > 0 ? { transportLost: read.lost } : {}) };
 }
-function specOf(n, c, axes, elicitation) {
-    const kind = c.type ?? 'stdio';
-    if (kind === 'stdio') {
-        if (!c.command)
-            return null;
-        return {
-            name: n,
-            transport: {
-                kind: 'stdio',
-                command: c.command,
-                ...(c.args && c.args.length > 0 ? { args: c.args } : {}),
-                ...(c.env ? { env: c.env } : {}),
-            },
-            ...(Array.isArray(c.allowTools) ? { allowTools: c.allowTools } : {}),
-            ...transparentKeys(c, axes, elicitation),
-        };
+function specOf(name, c, axes, elicitation) {
+    let candidate;
+    try {
+        const kind = c.type ?? 'stdio';
+        if (kind === 'stdio') {
+            const command = c.command;
+            const head = SETTINGS_READ_REQUEST_MCP_TRANSPORT({ kind: 'stdio', command });
+            if (!head.ok)
+                return { kind: 'bad', issue: head.issue };
+            candidate = { kind: 'stdio', command, args: snapshotArgs(c.args), env: c.env };
+        }
+        else if (kind === 'http') {
+            const url = c.url;
+            const head = SETTINGS_READ_REQUEST_MCP_TRANSPORT({ kind: 'http', url });
+            if (!head.ok)
+                return { kind: 'bad', issue: head.issue };
+            const principalHeader = c.principalHeader;
+            const assertionHeader = c.assertionHeader;
+            if (readMcpHttpIdentityHeaders({ principalHeader, assertionHeader }).kind === 'both_set')
+                return { kind: 'both_set' };
+            candidate = { kind: 'http', url, headers: c.headers, principalHeader, assertionHeader };
+        }
+        else {
+            return { kind: 'skip' };
+        }
     }
-    if (kind === 'http') {
-        if (!c.url)
-            return null;
-        const id = readMcpHttpIdentityHeaders(c);
-        if (id.kind === 'both_set')
-            return null;
-        return {
-            name: n,
-            transport: {
-                kind: 'http',
-                url: c.url,
-                ...(c.headers ? { headers: c.headers } : {}),
-                ...(id.principalHeader !== undefined ? { principalHeader: id.principalHeader } : {}),
-                ...(id.assertionHeader !== undefined ? { assertionHeader: id.assertionHeader } : {}),
-            },
-            ...(Array.isArray(c.allowTools) ? { allowTools: c.allowTools } : {}),
-            ...transparentKeys(c, axes, elicitation),
-        };
+    catch {
+        return { kind: 'bad', issue: { path: 'transport', reason: renderMessage(msg('config.mcp.transportUnreadable')) } };
     }
-    return null;
+    const read = SETTINGS_READ_REQUEST_MCP_TRANSPORT(candidate);
+    if (!read.ok)
+        return { kind: 'bad', issue: read.issue };
+    const spec = {
+        name,
+        transport: wireTransportOf(read.transport),
+        ...(Array.isArray(c.allowTools) ? { allowTools: c.allowTools } : {}),
+        ...transparentKeys(c, axes, elicitation),
+    };
+    return { kind: 'ok', spec, lost: read.lost };
 }
 export function mcpConfigsToSpecs(servers) {
     return projectMcpConfigs(servers).specs;
@@ -107,18 +115,18 @@ export function mcpElicitationVerdict(declared) {
         return Object.freeze({ kind: 'ok' });
     return typeof declared === 'boolean' ? Object.freeze({ kind: 'ok', elicitation: declared }) : Object.freeze({ kind: 'bad' });
 }
-function mcpNameFlaw(name) {
-    if (typeof name !== 'string')
-        return 'name_blank';
-    const t = name.trim();
-    if (t.length === 0)
+const nameUsable = (name) => SETTINGS_IS_USABLE_WIRE_NAME(name);
+function mcpNameDropReasonOf(name) {
+    if (typeof name !== 'string' || name.trim().length === 0)
         return 'name_blank';
-    return t === name ? undefined : 'name_edge_whitespace';
+    return name.trim() !== name ? 'name_edge_whitespace' : 'name_too_long';
 }
 const DROP_NAME_SHOWN = 80;
 const DROP_LABEL_SHOWN = 140;
 const DROP_PROBLEM_SHOWN = 300;
-function dropNotice(name, reason, problem, opts) {
+const DROP_BAD_NAME_SHOWN = 160;
+const DEGRADED_LOST_SHOWN = 400;
+function dropNotice(name, reason, problem, opts, path) {
     let label;
     try {
         label = opts?.sourceLabel?.(name);
@@ -128,35 +136,53 @@ function dropNotice(name, reason, problem, opts) {
     }
     const where = typeof label === 'string' && label.length > 0 ? ` (${capForDisplay(label, DROP_LABEL_SHOWN)})` : '';
     const quoted = `"${capForDisplay(name, DROP_NAME_SHOWN)}"`;
+    const badName = () => capForDisplay(SETTINGS_DESCRIBE_BAD_WIRE_NAME(name), DROP_BAD_NAME_SHOWN);
     const ref = reason === 'tool_axes_invalid'
         ? msg('config.mcp.toolAxesInvalid', { name: quoted, where, problem: capForDisplay(problem ?? renderMessage(msg('config.mcp.toolAxesFallbackProblem')), DROP_PROBLEM_SHOWN) })
         : reason === 'elicitation_invalid'
             ? msg('config.mcp.elicitationInvalid', { name: quoted, where })
-            : reason === 'name_blank'
-                ? msg('config.mcp.nameBlank', { name: quoted, where })
-                : reason === 'name_collides_after_trim'
-                    ? msg('config.mcp.nameCollides', { name: quoted, where })
-                    : msg('config.mcp.nameEdgeWhitespace', { name: quoted, where });
+            : reason === 'identity_headers_both_set'
+                ? msg('config.mcp.identityHeadersBothSet', { name: quoted, where })
+                : reason === 'transport_invalid'
+                    ? msg('config.mcp.transportInvalid', { name: quoted, where, path: capForDisplay(path ?? 'transport', DROP_NAME_SHOWN), problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
+                    : reason === 'name_blank'
+                        ? msg('config.mcp.nameBlank', { name: badName(), where })
+                        : reason === 'name_collides_after_trim'
+                            ? msg('config.mcp.nameCollides', { name: badName(), where })
+                            : reason === 'name_too_long'
+                                ? msg('config.mcp.nameTooLong', { name: badName(), where })
+                                : msg('config.mcp.nameEdgeWhitespace', { name: badName(), where });
     return renderMessage(ref, opts?.lang);
 }
+function degradedNotice(name, lost, opts) {
+    let label;
+    try {
+        label = opts?.sourceLabel?.(name);
+    }
+    catch {
+        label = undefined;
+    }
+    const where = typeof label === 'string' && label.length > 0 ? ` (${capForDisplay(label, DROP_LABEL_SHOWN)})` : '';
+    const quoted = `"${capForDisplay(name, DROP_NAME_SHOWN)}"`;
+    const what = capForDisplay(lost.map((l) => `${l.path}: ${l.reason}`).join('; '), DEGRADED_LOST_SHOWN);
+    return renderMessage(msg('config.mcp.transportDegraded', { name: quoted, where, lost: what }), opts?.lang);
+}
 export function projectMcpConfigs(servers, opts) {
     const specs = [];
     const dropped = [];
+    const degraded = [];
     const entries = Object.entries(servers ?? {});
     const exactNames = new Set();
     const trimmedCount = new Map();
     for (const [name] of entries) {
-        const flaw = mcpNameFlaw(name);
-        if (flaw === undefined)
+        if (nameUsable(name))
             exactNames.add(name);
-        else if (flaw === 'name_edge_whitespace')
+        else if (mcpNameDropReasonOf(name) === 'name_edge_whitespace')
             trimmedCount.set(name.trim(), (trimmedCount.get(name.trim()) ?? 0) + 1);
     }
     for (const [name, c] of entries) {
-        if (specs.length >= MCP_CAPS.items)
-            break;
-        const flaw = mcpNameFlaw(name);
-        if (flaw !== undefined) {
+        if (!nameUsable(name)) {
+            const flaw = mcpNameDropReasonOf(name);
             const reason = flaw === 'name_edge_whitespace' && (exactNames.has(name.trim()) || (trimmedCount.get(name.trim()) ?? 0) > 1) ? 'name_collides_after_trim' : flaw;
             dropped.push({ name, reason, notice: dropNotice(name, reason, undefined, opts) });
             continue;
@@ -164,16 +190,25 @@ export function projectMcpConfigs(servers, opts) {
         const out = mcpConfigEntry(name, c);
         if (out.spec !== null) {
             specs.push(out.spec);
+            if (out.transportLost !== undefined)
+                degraded.push({ name, lost: Object.freeze([...out.transportLost]), notice: degradedNotice(name, out.transportLost, opts) });
             continue;
         }
-        if (out.axesProblem !== undefined) {
+        if (out.identityBothSet === true) {
+            dropped.push({ name, reason: 'identity_headers_both_set', notice: dropNotice(name, 'identity_headers_both_set', undefined, opts) });
+        }
+        else if (out.transportBad !== undefined) {
+            const { path, reason: problem } = out.transportBad;
+            dropped.push({ name, reason: 'transport_invalid', problem, path, notice: dropNotice(name, 'transport_invalid', problem, opts, path) });
+        }
+        else if (out.axesProblem !== undefined) {
             dropped.push({ name, reason: 'tool_axes_invalid', problem: out.axesProblem, notice: dropNotice(name, 'tool_axes_invalid', out.axesProblem, opts) });
         }
         else if (out.elicitationInvalid === true) {
             dropped.push({ name, reason: 'elicitation_invalid', notice: dropNotice(name, 'elicitation_invalid', undefined, opts) });
         }
     }
-    return { specs, dropped: Object.freeze(dropped) };
+    return { specs, dropped: Object.freeze(dropped), degraded: Object.freeze(degraded) };
 }
 function assertionDeclaringServerName(spec) {
     const t = spec?.transport;
@@ -197,6 +232,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.131.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.132.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/mcpWireTransport.d.ts

@@ -0,0 +1,4 @@
+import type { McpServerSpec } from '@sema-agent/sdk';
+import type { RequestMcpTransport } from './generated/settingsSchemaTypes.js';
+export declare function snapshotArgs(v: {} | null | undefined): {} | null | undefined;
+export declare function wireTransportOf(t: RequestMcpTransport): McpServerSpec['transport'];

package/dist/mcpWireTransport.js

@@ -0,0 +1,18 @@
+const ARGS_SNAPSHOT_MAX = 65_536;
+export function snapshotArgs(v) {
+    if (!Array.isArray(v))
+        return v;
+    const n = v.length;
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0 || n > ARGS_SNAPSHOT_MAX)
+        return {};
+    const out = [];
+    for (let i = 0; i < n; i++)
+        out.push(v[i]);
+    return out;
+}
+export function wireTransportOf(t) {
+    if (t.kind === 'stdio') {
+        return { kind: 'stdio', command: t.command, ...(t.args !== undefined && t.args.length > 0 ? { args: t.args } : {}), ...(t.env !== undefined ? { env: t.env } : {}) };
+    }
+    return t;
+}

package/dist/modelCapabilityProbe.d.ts

@@ -1,4 +1,5 @@
 import type { ModelApiWord } from './model/providerPresets.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface OpenAICompletionsProbeBody {
     model: string;
     messages: ReadonlyArray<{
@@ -129,5 +130,5 @@ export interface ProbeVerdictFacts {
 }
 export declare function probeVerdictNotice(facts: ProbeVerdictFacts | null | undefined, ctx?: {
     readonly modelName?: string;
-}): ProbeVerdictNotice;
+}, lang?: UiLanguage): ProbeVerdictNotice;
 export {};

package/dist/modelCapabilityProbe.js

@@ -2,6 +2,7 @@ import { displayUntrusted } from './displayUntrusted.js';
 import { abortableSleep } from './abortableSleep.js';
 import { readThrownSlot } from './wireFailureShape.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const THINKING_FORMATS = Object.freeze([
     'openai',
     'openrouter',
@@ -698,7 +699,7 @@ function probeSeconds(ms) {
     return `${Number.isInteger(sec) ? sec : sec.toFixed(1)}s`;
 }
 const readFacts = (o, key) => guardedRead(() => readOwnDataValue(o, key));
-export function probeVerdictNotice(facts, ctx) {
+export function probeVerdictNotice(facts, ctx, lang) {
     const rawWord = readFacts(facts, 'verdict');
     const word = typeof rawWord === 'string' && PROBE_VERDICTS.includes(rawWord) ? rawWord : 'other';
     const rawStatus = readFacts(facts, 'httpStatus');
@@ -713,31 +714,31 @@ export function probeVerdictNotice(facts, ctx) {
     let recourse;
     switch (word) {
         case 'ok':
-            line = `The model answered${waited === undefined ? '' : ` — first token after ${probeSeconds(waited)}`}`;
+            line = renderMessage(waited === undefined ? msg('model.probe.verdict.ok') : msg('model.probe.verdict.okWaited', { time: probeSeconds(waited) }), lang);
             break;
         case 'auth':
-            line = `The model service rejected the API key${http}`;
+            line = renderMessage(msg('model.probe.verdict.auth', { http }), lang);
             recourse = 'check_credentials';
             break;
         case 'unreachable':
-            line = `Could not reach the model service${waited === undefined ? '' : ` — no response within ${probeSeconds(waited)}`}`;
+            line = renderMessage(waited === undefined ? msg('model.probe.verdict.unreachable') : msg('model.probe.verdict.unreachableWaited', { time: probeSeconds(waited) }), lang);
             break;
         case 'model':
-            line = `The model service does not recognise this model id${http}`;
+            line = renderMessage(msg('model.probe.verdict.model', { http }), lang);
             break;
         case 'shape':
-            line = `This address does not offer the expected interface${http} — check the API shape`;
+            line = renderMessage(msg('model.probe.verdict.shape', { http }), lang);
             break;
         case 'busy':
-            line = `The model service is busy right now${http} — retry later or switch model`;
+            line = renderMessage(msg('model.probe.verdict.busy', { http }), lang);
             recourse = 'switch_model';
             break;
         case 'no_token':
-            line = `The model service answered but sent no token${waited === undefined ? '' : ` within ${probeSeconds(waited)}`} — it may be overloaded`;
+            line = renderMessage(waited === undefined ? msg('model.probe.verdict.noToken') : msg('model.probe.verdict.noTokenWaited', { time: probeSeconds(waited) }), lang);
             recourse = 'switch_model';
             break;
         case 'other':
-            line = `The model service gave an unexpected answer${http}`;
+            line = renderMessage(msg('model.probe.verdict.other', { http }), lang);
             break;
     }
     return Object.freeze(recourse === undefined ? { line: `${prefix}${line}` } : { line: `${prefix}${line}`, recourse });

package/dist/modelIdentityResolvability.d.ts

@@ -12,11 +12,13 @@ export type ModelIdentityLanes = {
     [L in ModelIdentityLane]: ModelIdentityLaneReading;
 };
 export type EngineAnswerObservation = 'answered' | 'not_observed' | 'unreachable';
+export type EngineCatalogAdoptionReading = 'absent' | 'refused' | 'undetermined';
 export interface LocalEngineModelIdentityReading {
     engine: 'local';
     lanes: ModelIdentityLanes;
     engineAnswer?: EngineAnswerObservation;
     engineAcceptsCatalogDefault?: boolean;
+    catalogAdoption?: EngineCatalogAdoptionReading;
     routeGap?: ModelRouteGapReading;
 }
 export type ModelRouteGapReading = 'endpoint_missing' | 'lane_credential_missing' | 'none';

package/dist/modelIdentityResolvability.js

@@ -31,6 +31,10 @@ function routeGapOf(reading) {
     const v = own(reading, 'routeGap')?.v;
     return v === 'endpoint_missing' || v === 'lane_credential_missing' || v === 'none' ? v : undefined;
 }
+function catalogAdoptionOf(reading) {
+    const v = own(reading, 'catalogAdoption')?.v;
+    return v === 'absent' || v === 'refused' || v === 'undetermined' ? v : undefined;
+}
 function analyse(reading) {
     try {
         if (!isPlainObject(reading))
@@ -47,25 +51,30 @@ function analyse(reading) {
         const lanesHit = own(reading, 'lanes')?.v;
         const order = laneOrder();
         if (!isPlainObject(lanesHit)) {
-            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [], catalogUnconfirmed: null, catalogRefused: false };
+            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [], catalogUnconfirmed: null, catalogRefused: null };
         }
         const partial = [];
         const unreadable = [];
         const unreported = [];
         const unusable = [];
-        let catalogRefused = false;
+        let catalogRefused = null;
         let catalogUnconfirmed = null;
         for (const lane of order) {
             const s = laneState(lanesHit, lane);
             if (lane === 'modelCatalogFile') {
                 if (s === 'complete') {
+                    if (catalogAdoptionOf(reading) === 'refused') {
+                        partial.push(lane);
+                        catalogRefused = 'adoption';
+                        continue;
+                    }
                     const bit = own(reading, 'engineAcceptsCatalogDefault');
                     const evidence = catalogDefaultEvidence(s, bit?.v);
                     if (evidence !== undefined)
                         return { verdict: 'resolvable', why: 'catalog_default', evidence };
                     if (bit !== undefined && bit.v === false) {
                         partial.push(lane);
-                        catalogRefused = true;
+                        catalogRefused = 'engine';
                     }
                     else {
                         catalogUnconfirmed = bit === undefined || bit.v === undefined ? 'not_reported' : 'unusable';
@@ -151,7 +160,13 @@ export function modelIdentityDetail(reading) {
             const partialClause = others.length > 0
                 ? `${joinPhrases(others.map(laneLabel))} ${others.length > 1 ? 'carry' : 'carries'} part of a model configuration (such as a gateway address or a credential) but no model name`
                 : '';
-            if (a.catalogRefused) {
+            if (a.catalogRefused === 'adoption') {
+                const clause = msg('model.identity.catalogAdoption.refused', { lane: msg(LANE_LABEL_KEYS.modelCatalogFile) });
+                return partialClause !== ''
+                    ? renderMessage(msg('model.identity.catalogAdoption.notResolvableWithPartial', { clause, partial: partialClause }))
+                    : renderMessage(msg('model.identity.catalogAdoption.notResolvable', { clause }));
+            }
+            if (a.catalogRefused === 'engine') {
                 return (`no model name is configured for the local engine to start with — ${laneLabel('modelCatalogFile')} names a default model, but the local engine is reported not to accept a catalog default in place of a startup model name` +
                     (partialClause !== '' ? `, and ${partialClause}` : '') +
                     ', and the engine does not start without one');
@@ -179,7 +194,10 @@ export function modelIdentityDetail(reading) {
                 else if (a.catalogUnconfirmed === 'unusable') {
                     parts.push(`${laneLabel('modelCatalogFile')} names a default model, but the report of whether the local engine accepts a catalog default in place of a startup model name gave no usable reading`);
                 }
-                else if (a.catalogRefused) {
+                else if (a.catalogRefused === 'adoption') {
+                    parts.push(renderMessage(msg('model.identity.catalogAdoption.refused', { lane: msg(LANE_LABEL_KEYS.modelCatalogFile) })));
+                }
+                else if (a.catalogRefused === 'engine') {
                     parts.push(`${laneLabel('modelCatalogFile')} names a default model, but the local engine is reported not to accept a catalog default in place of a startup model name`);
                 }
                 return `whether the local engine has a model name is unknown — ${joinPhrases(parts)}, and no other place this client reads provides one`;

package/dist/ownKey.d.ts

@@ -33,3 +33,29 @@ export interface HumanInputAttachmentView {
 export declare function humanInputAttachmentsOf(frame: {} | null | undefined): HumanInputAttachmentView[] | undefined;
 export declare function markMcpSectionDroppedNamedRows(rows: object, dropped: ReadonlyMap<string, number>): void;
 export declare function mcpSectionDroppedNamedRowsOf(rows: object | null | undefined, name: string): number;
+export interface PromptManifestSectionRow {
+    id: string;
+    chars: number;
+    band?: string;
+    locale?: string;
+    variant?: string;
+    contentHash?: string;
+    slot?: string;
+}
+export interface PromptManifestIdentityRow {
+    readonly artifact: string;
+    readonly layers: PromptIdentityLayersRow;
+    readonly epoch: number;
+    readonly activatedBy: string;
+}
+export interface PromptIdentityLayersRow {
+    readonly catalog: string;
+    readonly renderers: Readonly<Record<string, number>>;
+    readonly center?: string;
+    readonly deploy?: string;
+    readonly task?: string;
+    readonly binding: string;
+}
+export declare function promptManifestSectionViewOf(row: object): PromptManifestSectionRow | undefined;
+export declare function promptManifestIdentityOfFrame(frame: object): PromptManifestIdentityRow | undefined;
+export declare function promptManifestIdentityOf(raw: {} | null | undefined): PromptManifestIdentityRow | undefined;