@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/mcpWireCaps.js

@@ -1,87 +1,177 @@
-import { guardedRead } from './ownKey.js';
-import { readMcpToolAxes } from './coreValuePorts.js';
+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 { appendOwnElement, guardedRead } from './ownKey.js';
+import { readMcpToolAxes, readToolFaces } 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) {
+function transparentKeys(startupTimeoutMs, axes, faces, elicitation) {
     return {
-        ...(c.toolFaces !== undefined ? { toolFaces: c.toolFaces } : {}),
+        ...(faces !== undefined ? { toolFaces: faces } : {}),
         ...(axes !== undefined ? { toolAxes: axes } : {}),
         ...(elicitation !== undefined ? { elicitation } : {}),
+        ...(startupTimeoutMs !== undefined ? { 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 entryShapeOf(c) {
+    try {
+        return typeof c === 'object' && c !== null && !Array.isArray(c) ? 'object' : 'not_object';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+function readEntryOwnKeys(c) {
+    try {
+        const allowTools = c.allowTools;
+        return { toolAxes: c.toolAxes, elicitation: c.elicitation, allowTools, startupTimeoutMs: c.startupTimeoutMs };
+    }
+    catch {
+        return undefined;
+    }
+}
 function mcpConfigEntry(name, c) {
-    if (mcpNameFlaw(name) !== undefined)
+    if (!nameUsable(name))
         return { spec: null };
-    const declared = c.toolAxes;
+    const shape = entryShapeOf(c);
+    if (shape === 'not_object')
+        return { spec: null, entryNotObject: true };
+    if (shape === 'unreadable')
+        return { spec: null, entryUnreadable: true };
+    const own = readEntryOwnKeys(c);
+    if (own === undefined) {
+        const t = transportOf(c);
+        if (t.kind === 'skip')
+            return { spec: null };
+        if (t.kind === 'both_set')
+            return { spec: null, identityBothSet: true };
+        if (t.kind === 'bad')
+            return { spec: null, transportBad: t.issue };
+        return { spec: null, entryUnreadable: true };
+    }
+    const declared = own.toolAxes;
     const verdict = mcpToolAxesVerdict(declared);
-    const elDeclared = c.elicitation;
+    let facesDeclared;
+    let facesUnreadable = false;
+    try {
+        facesDeclared = c.toolFaces;
+    }
+    catch {
+        facesUnreadable = true;
+    }
+    const facesVerdict = facesUnreadable
+        ? Object.freeze({ kind: 'bad', problem: renderMessage(msg('config.mcp.toolFacesUnreadable')) })
+        : mcpToolFacesVerdict(facesDeclared);
+    const elDeclared = own.elicitation;
     const elVerdict = mcpElicitationVerdict(elDeclared);
-    if (verdict.kind === 'bad' || elVerdict.kind === 'bad') {
-        const rest = specOf(name, c, undefined, undefined);
-        if (rest === null)
+    const allowVerdict = mcpAllowToolsVerdict(() => own.allowTools, `mcpServers.${capForDisplay(name, DROP_NAME_SHOWN)}.`);
+    if (verdict.kind === 'bad' || facesVerdict.kind === 'bad' || elVerdict.kind === 'bad' || allowVerdict.kind === 'bad') {
+        const rest = specOf(name, c, own, undefined, undefined, undefined, undefined);
+        if (rest.kind === 'skip')
             return { spec: null };
-        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) };
-}
-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),
-        };
-    }
-    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),
-        };
-    }
-    return null;
+        if (rest.kind === 'both_set')
+            return { spec: null, identityBothSet: true };
+        if (rest.kind === 'bad')
+            return { spec: null, transportBad: rest.issue };
+        if (verdict.kind === 'bad')
+            return { spec: null, axesProblem: verdict.problem };
+        if (facesVerdict.kind === 'bad')
+            return { spec: null, facesProblem: facesVerdict.problem };
+        if (elVerdict.kind === 'bad')
+            return { spec: null, elicitationInvalid: true };
+        return allowVerdict.kind === 'bad' ? { spec: null, allowToolsInvalid: { path: allowVerdict.path, problem: allowVerdict.problem } } : { spec: null };
+    }
+    const read = specOf(name, c, own, verdict.kind === 'ok' ? verdict.toolAxes : declared, facesVerdict.kind === 'ok' ? facesVerdict.toolFaces : facesDeclared, elVerdict.elicitation, allowVerdict.allowTools);
+    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 transportOf(c) {
+    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' };
+        }
+    }
+    catch {
+        return transportUnreadableRead();
+    }
+    let read;
+    try {
+        read = SETTINGS_READ_REQUEST_MCP_TRANSPORT(candidate);
+    }
+    catch {
+        return transportUnreadableRead();
+    }
+    if (!read.ok)
+        return { kind: 'bad', issue: read.issue };
+    return { kind: 'ok', transport: wireTransportOf(read.transport), lost: read.lost };
+}
+function transportUnreadableRead() {
+    return { kind: 'bad', issue: { path: 'transport', reason: renderMessage(msg('config.mcp.transportUnreadable')) } };
+}
+function specOf(name, c, own, axes, faces, elicitation, allowTools) {
+    const t = transportOf(c);
+    if (t.kind !== 'ok')
+        return t;
+    const spec = {
+        name,
+        transport: t.transport,
+        ...(allowTools !== undefined ? { allowTools } : {}),
+        ...transparentKeys(own.startupTimeoutMs, axes, faces, elicitation),
+    };
+    return { kind: 'ok', spec, lost: t.lost };
+}
+export function mcpTransportVerdict(entry) {
+    const shape = entryShapeOf(entry);
+    if (shape !== 'object')
+        return transportBadVerdict('transport', renderMessage(msg(shape === 'not_object' ? 'config.mcp.entryNotObjectProblem' : 'config.mcp.transportUnreadable')));
+    const t = transportOf(entry);
+    if (t.kind === 'ok')
+        return Object.freeze({ kind: 'ok', transport: t.transport, lost: Object.freeze([...t.lost]) });
+    if (t.kind === 'bad')
+        return transportBadVerdict(t.issue.path, t.issue.reason);
+    if (t.kind === 'both_set')
+        return transportBadVerdict('transport', renderMessage(msg('config.mcp.transportIdentityBothSetProblem')));
+    return transportBadVerdict('transport.kind', renderMessage(msg('config.mcp.transportTypeUnsupported')));
+}
+function transportBadVerdict(key, detail) {
+    return Object.freeze({ kind: 'bad', key, detail });
 }
 export function mcpConfigsToSpecs(servers) {
     return projectMcpConfigs(servers).specs;
@@ -102,23 +192,121 @@ export function mcpToolAxesVerdict(declared) {
     }
     return Object.freeze({ kind: 'unavailable' });
 }
+export function mcpToolFacesVerdict(declared) {
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    const read = readToolFaces(declared);
+    if (read === undefined || read === null || typeof read !== 'object')
+        return Object.freeze({ kind: 'unavailable' });
+    if (read.ok === true) {
+        const copy = read.faces;
+        return Object.freeze(typeof copy === 'object' && copy !== null ? { kind: 'ok', toolFaces: 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.toolFacesFallbackProblem')) });
+    }
+    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' });
 }
-function mcpNameFlaw(name) {
-    if (typeof name !== 'string')
-        return 'name_blank';
-    const t = name.trim();
-    if (t.length === 0)
+const ALLOW_TOOLS_READ_BUDGET = 100_000;
+export function mcpAllowToolsVerdict(read, keyPrefix = '') {
+    const bad = (path, key, got) => Object.freeze({ kind: 'bad', path, problem: renderMessage(msg(key, { path: `${keyPrefix}${path}`, got: got ?? '' })) });
+    let declared;
+    try {
+        declared = read();
+    }
+    catch {
+        return bad('allowTools', 'config.mcp.allowToolsUnreadable');
+    }
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    try {
+        if (!Array.isArray(declared))
+            return bad('allowTools', 'config.mcp.allowToolsNotArray', declared === null ? 'null' : typeof declared);
+        const lengthDesc = Object.getOwnPropertyDescriptor(declared, 'length');
+        const length = lengthDesc !== undefined && Object.hasOwn(lengthDesc, 'value') ? lengthDesc.value : undefined;
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0)
+            return bad('allowTools', 'config.mcp.allowToolsUnreadable');
+        if (length > ALLOW_TOOLS_READ_BUDGET)
+            return bad('allowTools', 'config.mcp.allowToolsTooMany', String(ALLOW_TOOLS_READ_BUDGET));
+        const copy = [];
+        for (let i = 0; i < length; i++) {
+            const d = Object.getOwnPropertyDescriptor(declared, String(i));
+            if (d === undefined)
+                return bad(`allowTools[${i}]`, 'config.mcp.allowToolsHole');
+            if (!Object.hasOwn(d, 'value'))
+                return bad(`allowTools[${i}]`, 'config.mcp.allowToolsUnreadable');
+            const el = d.value;
+            if (typeof el !== 'string')
+                return bad(`allowTools[${i}]`, 'config.mcp.allowToolsElementNotString', el === null ? 'null' : Array.isArray(el) ? 'array' : typeof el);
+            appendOwnElement(copy, el);
+        }
+        return Object.freeze({ kind: 'ok', allowTools: copy });
+    }
+    catch {
+        return bad('allowTools', 'config.mcp.allowToolsUnreadable');
+    }
+}
+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 _nameReasonsPin = true;
+void _nameReasonsPin;
+function nameSiblingsOf(siblings) {
+    if (siblings === undefined || siblings === null)
+        return undefined;
+    if (typeof siblings[Symbol.iterator] !== 'function') {
+        throw new TypeError('mcpServerNameVerdict: siblings must be an iterable of server names (or absent)');
+    }
+    const usable = new Set();
+    const variants = new Map();
+    for (const entry of siblings) {
+        const sibling = entry;
+        if (typeof sibling !== 'string')
+            continue;
+        if (nameUsable(sibling))
+            usable.add(sibling);
+        else if (mcpNameDropReasonOf(sibling) === 'name_edge_whitespace') {
+            const trimmed = sibling.trim();
+            const set = variants.get(trimmed);
+            if (set === undefined)
+                variants.set(trimmed, new Set([sibling]));
+            else
+                set.add(sibling);
+        }
+    }
+    return { usable, variants };
+}
+function nameVerdictAmong(name, among) {
+    if (nameUsable(name))
+        return Object.freeze({ usable: true });
+    const reason = mcpNameDropReasonOf(name);
+    if (reason === 'name_edge_whitespace' && among !== undefined && typeof name === 'string') {
+        const trimmed = name.trim();
+        const others = among.variants.get(trimmed);
+        if (among.usable.has(trimmed) || (others !== undefined && (others.size > 1 || !others.has(name)))) {
+            return Object.freeze({ usable: false, reason: 'name_collides_after_trim' });
+        }
+    }
+    return Object.freeze({ usable: false, reason });
+}
+export function mcpServerNameVerdict(name, siblings) {
+    return nameVerdictAmong(name, nameSiblingsOf(siblings));
 }
 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,52 +316,103 @@ 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 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 });
+    const badName = () => capForDisplay(SETTINGS_DESCRIBE_BAD_WIRE_NAME(name), DROP_BAD_NAME_SHOWN);
+    const ref = reason === 'entry_not_object'
+        ? msg('config.mcp.entryNotObject', { name: quoted, where })
+        : reason === 'entry_unreadable'
+            ? msg('config.mcp.entryUnreadable', { name: quoted, where })
+            : reason === 'tool_axes_invalid'
+                ? msg('config.mcp.toolAxesInvalid', { name: quoted, where, problem: capForDisplay(problem ?? renderMessage(msg('config.mcp.toolAxesFallbackProblem')), DROP_PROBLEM_SHOWN) })
+                : reason === 'tool_faces_invalid'
+                    ? msg('config.mcp.toolFacesInvalid', { name: quoted, where, problem: capForDisplay(problem ?? renderMessage(msg('config.mcp.toolFacesFallbackProblem')), DROP_PROBLEM_SHOWN) })
+                    : reason === 'elicitation_invalid'
+                        ? msg('config.mcp.elicitationInvalid', { name: quoted, where })
+                        : reason === 'allow_tools_invalid'
+                            ? msg('config.mcp.allowToolsInvalid', { name: quoted, where, problem: capForDisplay(problem ?? '', DROP_PROBLEM_SHOWN) })
+                            : 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);
+}
+function entriesOf(servers) {
+    const table = servers ?? {};
+    return Object.keys(table).map((name) => {
+        try {
+            return [name, table[name], false];
+        }
+        catch {
+            return [name, undefined, true];
+        }
+    });
+}
 export function projectMcpConfigs(servers, opts) {
     const specs = [];
     const dropped = [];
-    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)
-            exactNames.add(name);
-        else if (flaw === '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) {
-            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) });
+    const degraded = [];
+    const entries = entriesOf(servers);
+    const among = nameSiblingsOf(entries.map(([name]) => name));
+    for (const [name, c, slotUnreadable] of entries) {
+        const nameVerdict = nameVerdictAmong(name, among);
+        if (!nameVerdict.usable) {
+            dropped.push({ name, reason: nameVerdict.reason, notice: dropNotice(name, nameVerdict.reason, undefined, opts) });
             continue;
         }
-        const out = mcpConfigEntry(name, c);
+        const out = slotUnreadable ? { spec: null, entryUnreadable: true } : 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.entryNotObject === true) {
+            dropped.push({ name, reason: 'entry_not_object', notice: dropNotice(name, 'entry_not_object', undefined, opts) });
+        }
+        else if (out.entryUnreadable === true) {
+            dropped.push({ name, reason: 'entry_unreadable', notice: dropNotice(name, 'entry_unreadable', undefined, opts) });
+        }
+        else 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.facesProblem !== undefined) {
+            dropped.push({ name, reason: 'tool_faces_invalid', problem: out.facesProblem, notice: dropNotice(name, 'tool_faces_invalid', out.facesProblem, opts) });
+        }
         else if (out.elicitationInvalid === true) {
             dropped.push({ name, reason: 'elicitation_invalid', notice: dropNotice(name, 'elicitation_invalid', undefined, opts) });
         }
+        else if (out.allowToolsInvalid !== undefined) {
+            const { path, problem } = out.allowToolsInvalid;
+            dropped.push({ name, reason: 'allow_tools_invalid', problem, path, notice: dropNotice(name, 'allow_tools_invalid', problem, opts, path) });
+        }
     }
-    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 +436,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.134.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/memoryComplianceCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export const MEMORY_ENGINE_REQUIRED_CODE = 'capability.memory_engine_required';
@@ -22,7 +22,7 @@ const reader = createEngineCapReader({
     name: 'memoryCompliance',
     project: projectMemoryComplianceCapability,
 });
-export function observedMemoryCompliance(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedMemoryCompliance(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function memoryComplianceVerbsAvailable(reading) {

package/dist/memoryOriginCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 import { MEMORY_ENGINE_REQUIRED_CODE } from './memoryComplianceCapability.js';
@@ -22,7 +22,7 @@ const reader = createEngineCapReader({
     name: 'memoryOrigin',
     project: projectMemoryOriginCapability,
 });
-export function observedMemoryOrigin(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedMemoryOrigin(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function memoryOriginVerbsAvailable(reading) {

package/dist/model/catalogDefault.d.ts

@@ -0,0 +1,24 @@
+import { SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL, type SETTINGS_DEFAULT_ROLE_TIER_LADDER } from '../generated/settingsSchemaFns.js';
+export type CatalogDefaultModelsInput = Parameters<typeof SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL>[0];
+export type CatalogDefaultSource = 'roles.default' | 'fallback' | `tierGroup.${(typeof SETTINGS_DEFAULT_ROLE_TIER_LADDER)[number]}`;
+export interface CatalogDefaultDangling {
+    readonly source: Exclude<CatalogDefaultSource, 'fallback'>;
+    readonly name: string;
+}
+export interface CatalogDefaultSelectCriteria {
+    readonly tier?: string | undefined;
+    readonly needs?: readonly string[] | undefined;
+    readonly prefer?: string | undefined;
+}
+export interface CatalogDefaultNamed {
+    readonly kind: 'named';
+    readonly name: string;
+    readonly source: CatalogDefaultSource;
+    readonly dangling: readonly CatalogDefaultDangling[];
+}
+export interface CatalogDefaultSelect {
+    readonly kind: 'select';
+    readonly select: CatalogDefaultSelectCriteria;
+}
+export type CatalogDefaultModel = CatalogDefaultNamed | CatalogDefaultSelect;
+export declare function resolveCatalogDefaultModel(models: CatalogDefaultModelsInput, has: (name: string) => boolean, fallback: string): CatalogDefaultModel;

package/dist/model/catalogDefault.js

@@ -0,0 +1,4 @@
+import { SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL } from '../generated/settingsSchemaFns.js';
+export function resolveCatalogDefaultModel(models, has, fallback) {
+    return SETTINGS_RESOLVE_CATALOG_DEFAULT_MODEL(models, has, fallback);
+}

package/dist/model/liveCatalogShape.js

@@ -14,22 +14,23 @@ function frozenJsonCopy(v, depth) {
     if (typeof v !== 'object')
         throw new Unreadable();
     if (Array.isArray(v)) {
-        const n = Object.getOwnPropertyDescriptor(v, 'length')?.value;
+        const ld = Object.getOwnPropertyDescriptor(v, 'length');
+        const n = ld !== undefined && Object.hasOwn(ld, 'value') ? ld.value : undefined;
         if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
             throw new Unreadable();
         const out = [];
         for (let i = 0; i < n; i += 1) {
             const d = Object.getOwnPropertyDescriptor(v, String(i));
-            if (d === undefined || !('value' in d))
+            if (d === undefined || !Object.hasOwn(d, 'value'))
                 throw new Unreadable();
-            out.push(frozenJsonCopy(d.value, depth + 1));
+            Object.defineProperty(out, out.length, { value: frozenJsonCopy(d.value, depth + 1), writable: true, enumerable: true, configurable: true });
         }
         return Object.freeze(out);
     }
     const out = {};
     for (const k of Object.keys(v)) {
         const d = Object.getOwnPropertyDescriptor(v, k);
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !Object.hasOwn(d, 'value'))
             throw new Unreadable();
         if (d.value === undefined)
             continue;

package/dist/model/modelsPolicy.js

@@ -1,8 +1,9 @@
+import { appendOwnElement } from '../ownKey.js';
 import { SETTINGS_AT_MENTION_MODES } from '../generated/settingsSchemaFns.js';
 function ownData(o, key) {
     try {
         const d = Object.getOwnPropertyDescriptor(o, key);
-        return d !== undefined && 'value' in d ? d.value : undefined;
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return undefined;
@@ -24,9 +25,9 @@ function atMentionOf(v) {
         const out = [];
         for (let i = 0; i < list.length; i += 1) {
             const d = Object.getOwnPropertyDescriptor(list, i);
-            if (d === undefined || !('value' in d) || typeof d.value !== 'string' || d.value.length === 0)
+            if (d === undefined || !Object.hasOwn(d, 'value') || typeof d.value !== 'string' || d.value.length === 0)
                 return undefined;
-            out.push(d.value);
+            appendOwnElement(out, d.value);
         }
         return { mode: 'only', models: out };
     }