@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/mcpPanel.js

@@ -3,6 +3,7 @@ import { isSessionIdPathSegment } from './sessionIdSegment.js';
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { mcpLivenessRollupOf } from './mcpLiveness.js';
+import { scenarioRefusalOf } from './scenarioRefusal.js';
 const MCP_PANEL_ERROR_MAX = 200;
 const MCP_PANEL_WORD_MAX = 40;
 const MCP_PANEL_NAMES_MAX = 8;
@@ -40,19 +41,29 @@ export function projectMcpPanel(body) {
         return undefined;
     if (!nonEmpty(body.asOf))
         return undefined;
-    if (!Array.isArray(body.servers))
+    const refusal = scenarioRefusalOf(body);
+    if (refusal === null)
         return undefined;
-    const servers = [];
-    for (const r of body.servers) {
-        const row = projectServerRow(r);
-        if (row !== undefined)
-            servers.push(row);
+    let view;
+    if (refusal !== undefined) {
+        view = { asOf: body.asOf, scenarioRefusal: refusal };
+    }
+    else {
+        if (!Array.isArray(body.servers))
+            return undefined;
+        const servers = [];
+        for (const r of body.servers) {
+            const row = projectServerRow(r);
+            if (row !== undefined)
+                servers.push(row);
+        }
+        if (body.servers.length > 0 && servers.length === 0)
+            return undefined;
+        const sv = { asOf: body.asOf, servers };
+        if (body.degraded === true)
+            sv.degraded = true;
+        view = sv;
     }
-    if (body.servers.length > 0 && servers.length === 0)
-        return undefined;
-    const view = { asOf: body.asOf, servers };
-    if (body.degraded === true)
-        view.degraded = true;
     if ('lastLegMcp' in body) {
         const leg = projectLastLeg(body.lastLegMcp);
         if (leg !== undefined)
@@ -62,6 +73,20 @@ export function projectMcpPanel(body) {
     }
     return view;
 }
+export function mcpPanelRefusalOf(view) {
+    try {
+        if (view === null || typeof view !== 'object')
+            return undefined;
+        const d = Object.getOwnPropertyDescriptor(view, 'scenarioRefusal');
+        if (d === undefined || !('value' in d))
+            return undefined;
+        const r = d.value;
+        return r !== null && typeof r === 'object' && !Array.isArray(r) ? r : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function fetchMcpPanel(client, sessionId, opts) {
     if (!isSessionIdPathSegment(sessionId))
         return undefined;
@@ -95,15 +120,19 @@ export function mcpPanelLastLegDetail(view, opts) {
 }
 const _mcpPanelShapePin = (p) => p;
 void _mcpPanelShapePin;
+const _mcpPanelRefusalPin = (p) => p;
+void _mcpPanelRefusalPin;
 export function mcpEngineLegPresence(view) {
     if (view === undefined)
         return 'unknown';
-    if (view.servers.length > 0)
-        return 'present';
     if (view.lastLegMcp !== undefined)
         return 'present';
     if (view.lastLegMcpUnreadable === true)
         return 'present';
+    if (!('servers' in view))
+        return 'unknown';
+    if (view.servers.length > 0)
+        return 'present';
     if (view.degraded === true)
         return 'present';
     return 'absent';

package/dist/mcpProbeCapability.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type McpProbeReading = {
     kind: 'unobserved';
 } | {
@@ -12,4 +13,4 @@ export type McpProbeReading = {
 export declare function projectMcpProbeCapability(caps: unknown): McpProbeReading | undefined;
 export declare function observedMcpProbe(baseUrl?: string | undefined): McpProbeReading;
 export declare function mcpProbeAvailable(reading: McpProbeReading): 'yes' | 'no' | 'unknown';
-export declare function mcpProbeDoctorDetail(reading: McpProbeReading): string;
+export declare function mcpProbeDoctorDetail(reading: McpProbeReading, lang?: UiLanguage): string;

package/dist/mcpProbeCapability.js

@@ -1,5 +1,6 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
 export function projectMcpProbeCapability(caps) {
     try {
@@ -30,22 +31,17 @@ export function mcpProbeAvailable(reading) {
         return 'no';
     return 'unknown';
 }
-export function mcpProbeDoctorDetail(reading) {
+export function mcpProbeDoctorDetail(reading, lang) {
     switch (reading.kind) {
         case 'unreadable':
-            return unreadableReadingDetail('per-server MCP status face');
+            return unreadableReadingDetail(renderMessage(msg('notice.capability.subject.mcpProbe'), lang), lang);
         case 'unobserved':
-            return ('per-server MCP status face not observed — the engine reports whether it has one on /v1/capabilities; ' +
-                'this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');
+            return renderMessage(msg('notice.capability.mcpProbe.unobserved'), lang);
         case 'not_reported':
-            return ('per-server MCP status face not reported by this engine — this binary predates the face, so that path is not expected to exist here ' +
-                '(asking it usually answers with a machine-readable route-not-found, though a timeout or an uncoded gateway answer still says nothing either way); ' +
-                'prefer the session panel last-leg roster where that panel carries one, and otherwise show this reason rather than an entry that cannot answer');
+            return renderMessage(msg('notice.capability.mcpProbe.notReported'), lang);
         case 'absent':
-            return ('per-server MCP status face reported off on this deployment — this engine answers no readings there; ' +
-                'this client does not guess why, and whether caller-supplied declarations are honored is a separate position with its own answer');
+            return renderMessage(msg('notice.capability.mcpProbe.absent'), lang);
         case 'present':
-            return ('per-server MCP status face on — this engine dials its own declared MCP servers on request, with no run, ' +
-                'and a probe of caller-supplied declarations answers with the very same body shape');
+            return renderMessage(msg('notice.capability.mcpProbe.present'), lang);
     }
 }

package/dist/mcpProbeWire.d.ts

@@ -1,6 +1,7 @@
 import type { McpProbeFace, McpServerSpec } from '@sema-agent/sdk';
 import { type WiringManifestMcpEntryView } from './adapter/downstream/eventToSdkMessage.js';
 import { type McpProbeReading } from './mcpProbeCapability.js';
+import { type ScenarioRefusalReading } from './scenarioRefusal.js';
 export interface McpProbeFacade {
     mcpCapabilities(opts?: {
         signal?: AbortSignal;
@@ -9,7 +10,7 @@ export interface McpProbeFacade {
         signal?: AbortSignal;
     }): Promise<McpProbeFace>;
 }
-export declare const MCP_PROBE_REFUSAL_CAUSES: readonly ["face_absent", "client_too_old", "unreadable_request", "injection_not_honored", "body_shape", "field_invalid", "body_unparseable", "payload_too_large", "rate_limited", "unauthorized", "principal_required", "principal_unverified"];
+export declare const MCP_PROBE_REFUSAL_CAUSES: readonly ["face_absent", "client_too_old", "unreadable_request", "injection_not_honored", "body_shape", "field_invalid", "body_unparseable", "payload_too_large", "rate_limited", "unauthorized", "principal_required", "principal_unverified", "scenario_refused"];
 export type McpProbeRefusalCause = (typeof MCP_PROBE_REFUSAL_CAUSES)[number];
 export declare const MCP_PROBE_UNKNOWN_WHYS: readonly ["no_verdict", "probe_incomplete", "server_fault", "result_unreadable", "index_misaligned", "unclassified"];
 export type McpProbeUnknownWhy = (typeof MCP_PROBE_UNKNOWN_WHYS)[number];
@@ -18,6 +19,7 @@ export type McpProbeRefused = {
     cause: McpProbeRefusalCause;
     message: string;
     retryAfterSec?: number;
+    scenarioRefusal?: ScenarioRefusalReading;
 };
 export type McpProbeUnknown = {
     status: 'unknown';

package/dist/mcpProbeWire.js

@@ -1,6 +1,7 @@
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { wireFailureShapeOf } from './wireFailureShape.js';
 import { mcpProbeAvailable } from './mcpProbeCapability.js';
+import { scenarioRefusalFromError } from './scenarioRefusal.js';
 export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
     'face_absent',
     'client_too_old',
@@ -14,6 +15,7 @@ export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
     'unauthorized',
     'principal_required',
     'principal_unverified',
+    'scenario_refused',
 ]);
 export const MCP_PROBE_UNKNOWN_WHYS = Object.freeze([
     'no_verdict',
@@ -168,6 +170,9 @@ export async function readMcpCapabilities(facade, call, opts) {
         res = await facade.mcpCapabilities(opts);
     }
     catch (e) {
+        const refusal = scenarioRefusalFromError(e);
+        if (refusal !== null)
+            return { ...refusedBy('scenario_refused', wireFailureShapeOf(e).message), scenarioRefusal: refusal };
         return classifyMcpProbeFailure(e);
     }
     const narrowed = narrowProbeFace(res);

package/dist/mcpReconnect.js

@@ -187,14 +187,14 @@ export function mcpReconnectOutcomeDetail(view) {
     const name = capForDisplay(view.server, RECONNECT_WORD_MAX);
     switch (view.outcome) {
         case 'accepted':
-            return `MCP server ${name} was re-dialed: ${view.toolCount} tool${view.toolCount === 1 ? '' : 's'} mounted (${view.added.length} added, ${view.removed.length} removed)`;
+            return `MCP server ${name} was re-dialed: ${view.toolCount} tool${view.toolCount === 1 ? '' : 's'} mounted for this run (${view.added.length} added, ${view.removed.length} removed)`;
         case 'refused': {
             const why = view.reason !== undefined ? ` — ${view.reason}` : '';
             if (view.toolNames === undefined) {
                 return `MCP server ${name} was NOT re-dialed; its connection and tools were left untouched${why}`;
             }
             if (view.toolNames.length === 0) {
-                return `MCP server ${name} was NOT re-dialed and its tools were withdrawn from the model until a later re-dial succeeds${why}`;
+                return `MCP server ${name} was NOT re-dialed; this run's tool list has no tools from it right now (the dial failed, or this run's tool settings let none of its tools through)${why}`;
             }
             return `MCP server ${name} was NOT re-dialed; the engine reports ${view.toolNames.length} tool${view.toolNames.length === 1 ? '' : 's'} for it after this attempt${why}`;
         }

package/dist/mcpToolToggles.d.ts

@@ -0,0 +1,6 @@
+export interface McpToolToggleKey {
+    readonly server: string;
+    readonly tool: string;
+}
+export type McpMountedServers = readonly string[] | 'unknown';
+export declare function mcpToolTogglesToExcludeTools(keys: readonly McpToolToggleKey[], mountedServers: McpMountedServers): string[];

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,8 +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;
@@ -13,8 +12,10 @@ export interface McpConfigLike {
     principalHeader?: string;
     assertionHeader?: string;
     allowTools?: string[];
+    elicitation?: {} | null | undefined;
     toolFaces?: unknown;
     toolAxes?: unknown;
+    startupTimeoutMs?: number;
 }
 export type McpHttpIdentityHeaders = {
     readonly kind: 'ok';
@@ -26,4 +27,43 @@ export type McpHttpIdentityHeaders = {
 export declare function readMcpHttpIdentityHeaders(transport: object): McpHttpIdentityHeaders;
 export declare function mcpConfigToSpec(name: string, c: McpConfigLike): McpServerSpec | null;
 export declare function mcpConfigsToSpecs(servers: Record<string, McpConfigLike> | undefined): McpServerSpec[];
+export type McpToolAxesVerdict = {
+    readonly kind: 'ok';
+    readonly toolAxes?: Readonly<Record<string, object>>;
+} | {
+    readonly kind: 'bad';
+    readonly problem: string;
+} | {
+    readonly kind: 'unavailable';
+};
+export declare function mcpToolAxesVerdict(declared: {} | null | undefined): McpToolAxesVerdict;
+export declare function mcpElicitationVerdict(declared: {} | null | undefined): {
+    readonly kind: 'ok';
+    readonly elicitation?: boolean;
+} | {
+    readonly kind: 'bad';
+};
+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;
+    readonly lang?: UiLanguage;
+}
+export declare function projectMcpConfigs(servers: Record<string, McpConfigLike> | undefined, opts?: ProjectMcpConfigsOptions): McpConfigProjection;
 export declare function mcpAssertionHeaderNotSentNotice(specs: readonly McpServerSpec[]): string | undefined;

package/dist/mcpWireCaps.js

@@ -1,79 +1,214 @@
+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) {
+function transparentKeys(c, axes, elicitation) {
     return {
         ...(c.toolFaces !== undefined ? { toolFaces: c.toolFaces } : {}),
-        ...(c.toolAxes !== undefined ? { toolAxes: c.toolAxes } : {}),
+        ...(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) {
-    const n = (name ?? '').trim();
-    if (!n)
-        return null;
-    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 } : {}),
-            },
-            ...(c.allowTools && c.allowTools.length > 0 ? { allowTools: c.allowTools } : {}),
-            ...transparentKeys(c),
-        };
+    return mcpConfigEntry(name, c).spec;
+}
+function mcpConfigEntry(name, c) {
+    if (!nameUsable(name))
+        return { spec: null };
+    const declared = c.toolAxes;
+    const verdict = mcpToolAxesVerdict(declared);
+    const elDeclared = c.elicitation;
+    const elVerdict = mcpElicitationVerdict(elDeclared);
+    if (verdict.kind === 'bad' || elVerdict.kind === 'bad') {
+        const rest = specOf(name, c, undefined, undefined);
+        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 };
+    }
+    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(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 } : {}),
-            },
-            ...(c.allowTools && c.allowTools.length > 0 ? { allowTools: c.allowTools } : {}),
-            ...transparentKeys(c),
-        };
+    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) {
-    const out = [];
-    for (const [name, c] of Object.entries(servers ?? {})) {
-        if (out.length >= MCP_CAPS.items)
-            break;
-        const spec = mcpConfigToSpec(name, c);
-        if (spec)
-            out.push(spec);
+    return projectMcpConfigs(servers).specs;
+}
+export function mcpToolAxesVerdict(declared) {
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    const read = readMcpToolAxes(declared);
+    if (read === undefined || read === null || typeof read !== 'object')
+        return Object.freeze({ kind: 'unavailable' });
+    if (read.ok === true) {
+        const copy = read.toolAxes;
+        return Object.freeze(typeof copy === 'object' && copy !== null ? { kind: 'ok', toolAxes: copy } : { kind: 'ok' });
+    }
+    if (read.ok === false) {
+        const problem = read.problem;
+        return Object.freeze({ kind: 'bad', problem: typeof problem === 'string' && problem.length > 0 ? problem : renderMessage(msg('config.mcp.toolAxesFallbackProblem')) });
+    }
+    return Object.freeze({ kind: 'unavailable' });
+}
+export function mcpElicitationVerdict(declared) {
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    return typeof declared === 'boolean' ? Object.freeze({ kind: 'ok', elicitation: declared }) : Object.freeze({ kind: 'bad' });
+}
+const nameUsable = (name) => SETTINGS_IS_USABLE_WIRE_NAME(name);
+function mcpNameDropReasonOf(name) {
+    if (typeof name !== 'string' || name.trim().length === 0)
+        return 'name_blank';
+    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;
+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);
+    }
+    catch {
+        label = undefined;
+    }
+    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 === '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) {
+        if (nameUsable(name))
+            exactNames.add(name);
+        else if (mcpNameDropReasonOf(name) === 'name_edge_whitespace')
+            trimmedCount.set(name.trim(), (trimmedCount.get(name.trim()) ?? 0) + 1);
+    }
+    for (const [name, c] of entries) {
+        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;
+        }
+        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.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 out;
+    return { specs, dropped: Object.freeze(dropped), degraded: Object.freeze(degraded) };
 }
 function assertionDeclaringServerName(spec) {
     const t = spec?.transport;
@@ -97,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.129.1 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;
+}