@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/liveModelCatalog.js

@@ -1,3 +1,4 @@
+import { frozenJsonCopyOf, liveDefaultModelCopy, liveModelRowCopy } from './model/liveCatalogShape.js';
 let catalog = null;
 let refresher = null;
 export function setLiveModelCatalog(next) {
@@ -42,6 +43,12 @@ function ownDataOf(o, key) {
     }
 }
 function liveModelRowOf(cat, ref) {
+    const rows = catalogRowsOf(cat);
+    if (rows === undefined)
+        return undefined;
+    return rows.find((row) => ownDataOf(row, 'name') === ref) ?? rows.find((row) => ownDataOf(row, 'id') === ref);
+}
+function catalogRowsOf(cat) {
     const models = ownDataOf(cat, 'models');
     if (!Array.isArray(models))
         return undefined;
@@ -54,25 +61,31 @@ function liveModelRowOf(cat, ref) {
         if (row !== null && typeof row === 'object')
             rows.push(row);
     }
-    return rows.find((row) => ownDataOf(row, 'name') === ref) ?? rows.find((row) => ownDataOf(row, 'id') === ref);
+    return rows;
+}
+function targetRowOf(model, cat) {
+    if (model !== undefined && typeof model !== 'string')
+        return { kind: 'none', why: 'unreadable' };
+    if (cat === null || typeof cat !== 'object' || Array.isArray(cat))
+        return { kind: 'none', why: 'no_catalog' };
+    let target = model !== undefined && model.length > 0 ? model : undefined;
+    if (target === undefined) {
+        const d = liveDefaultModelOf(cat);
+        if (d.kind === 'unknown' && d.why === 'unreadable')
+            return { kind: 'none', why: 'unreadable' };
+        if (d.kind !== 'listed')
+            return { kind: 'none', why: 'model_not_listed' };
+        target = d.name;
+    }
+    const row = liveModelRowOf(cat, target);
+    return row === undefined ? { kind: 'none', why: 'model_not_listed' } : { kind: 'row', row };
 }
 export function imageVisionOf(model, catalog = getLiveModelCatalog()) {
     try {
-        if (model !== undefined && typeof model !== 'string')
-            return 'unknown';
-        if (catalog === null || typeof catalog !== 'object' || Array.isArray(catalog))
-            return 'unknown';
-        let target = model !== undefined && model.length > 0 ? model : undefined;
-        if (target === undefined) {
-            const def = ownDataOf(catalog, 'default');
-            target = typeof def === 'string' && def.length > 0 ? def : undefined;
-        }
-        if (target === undefined)
-            return 'unknown';
-        const row = liveModelRowOf(catalog, target);
-        if (row === undefined)
+        const target = targetRowOf(model, catalog);
+        if (target.kind !== 'row')
             return 'unknown';
-        const vision = ownDataOf(row, 'vision');
+        const vision = ownDataOf(target.row, 'vision');
         return vision === true ? 'yes' : vision === false ? 'no' : 'unknown';
     }
     catch {
@@ -84,20 +97,10 @@ const NOT_APPLICABLE = Object.freeze({ kind: 'not_applicable' });
 const unknownEffort = (why) => Object.freeze({ kind: 'unknown', why });
 export function effortLevelsOf(model, catalog = getLiveModelCatalog()) {
     try {
-        if (model !== undefined && typeof model !== 'string')
-            return unknownEffort('unreadable');
-        if (catalog === null || typeof catalog !== 'object' || Array.isArray(catalog))
-            return unknownEffort('no_catalog');
-        let target = model !== undefined && model.length > 0 ? model : undefined;
-        if (target === undefined) {
-            const def = ownDataOf(catalog, 'default');
-            target = typeof def === 'string' && def.length > 0 ? def : undefined;
-        }
-        if (target === undefined)
-            return unknownEffort('model_not_listed');
-        const row = liveModelRowOf(catalog, target);
-        if (row === undefined)
-            return unknownEffort('model_not_listed');
+        const target = targetRowOf(model, catalog);
+        if (target.kind !== 'row')
+            return unknownEffort(target.why);
+        const row = target.row;
         const levels = ownDataOf(row, 'supportedEffortLevels');
         if (levels !== undefined) {
             if (!Array.isArray(levels))
@@ -141,9 +144,89 @@ export function effortLevelHonored(reading, level) {
     }
 }
 export function liveDefaultModelName() {
-    if (!catalog?.default)
-        return null;
-    return normalizeLiveModelRef(catalog.default);
+    const d = liveDefaultModelOf(catalog);
+    return d.kind === 'listed' ? d.name : d.kind === 'not_listed' ? d.id : null;
+}
+const notReportedDropped = () => Object.freeze({ kind: 'not_reported' });
+const unknownDropped = (why) => Object.freeze({ kind: 'unknown', why });
+function ownDataCopy(o) {
+    const out = {};
+    for (const k of Object.keys(o)) {
+        const d = Object.getOwnPropertyDescriptor(o, k);
+        if (d === undefined || !('value' in d))
+            return undefined;
+        Object.defineProperty(out, k, { value: d.value, enumerable: true, writable: true, configurable: true });
+    }
+    return out;
+}
+function isDroppedRow(r) {
+    const index = r.index;
+    if (typeof index !== 'number' || !Number.isSafeInteger(index) || index < 0)
+        return false;
+    if (typeof r.reasonCode !== 'string' || r.reasonCode.length === 0)
+        return false;
+    if (!Object.hasOwn(r, 'identity'))
+        return true;
+    const id = r.identity;
+    if (id === null || typeof id !== 'object' || Array.isArray(id) || !Object.isFrozen(id))
+        return false;
+    const idr = id;
+    for (const k of ['name', 'id'])
+        if (Object.hasOwn(idr, k) && (typeof idr[k] !== 'string' || idr[k] === ''))
+            return false;
+    return !Object.hasOwn(idr, 'enabled') || typeof idr.enabled === 'boolean';
+}
+function droppedRowOf(row) {
+    if (row === null || typeof row !== 'object' || Array.isArray(row))
+        return undefined;
+    const copy = ownDataCopy(row);
+    if (copy === undefined)
+        return undefined;
+    if (Object.hasOwn(copy, 'identity')) {
+        const id = copy.identity;
+        if (id === null || typeof id !== 'object' || Array.isArray(id))
+            return undefined;
+        const idCopy = ownDataCopy(id);
+        if (idCopy === undefined)
+            return undefined;
+        copy.identity = Object.freeze(idCopy);
+    }
+    if (!isDroppedRow(copy))
+        return undefined;
+    return Object.freeze(copy);
+}
+export function droppedModelEntriesOf(catalog = getLiveModelCatalog()) {
+    try {
+        if (catalog === null || typeof catalog !== 'object' || Array.isArray(catalog))
+            return unknownDropped('no_catalog');
+        if (!Object.hasOwn(catalog, 'droppedEntries'))
+            return notReportedDropped();
+        const d = Object.getOwnPropertyDescriptor(catalog, 'droppedEntries');
+        if (d === undefined || !('value' in d))
+            return unknownDropped('unreadable');
+        const raw = d.value;
+        if (raw === undefined)
+            return notReportedDropped();
+        if (!Array.isArray(raw))
+            return unknownDropped('malformed');
+        const n = ownDataOf(raw, 'length');
+        if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+            return unknownDropped('unreadable');
+        const entries = [];
+        let unreadable = 0;
+        for (let i = 0; i < n; i += 1) {
+            const rd = Object.getOwnPropertyDescriptor(raw, String(i));
+            const row = rd !== undefined && 'value' in rd ? droppedRowOf(rd.value) : undefined;
+            if (row === undefined)
+                unreadable += 1;
+            else
+                entries.push(row);
+        }
+        return Object.freeze({ kind: 'reported', entries: Object.freeze(entries), unreadable });
+    }
+    catch {
+        return unknownDropped('unreadable');
+    }
 }
 const ROUTE_PAIRING_OK = new Set(['ok:per-model', 'ok:paired', 'ok:unpinned', 'ok:keyless']);
 const ROUTE_PAIRING_BROKEN = new Set(['broken:credential_mismatch', 'broken:credential_missing']);
@@ -156,3 +239,185 @@ export function routePairingVerdict(v) {
         return { verdict: 'broken', posture: v };
     return { verdict: 'unknown', posture: v };
 }
+const unreadableCatalog = (why) => Object.freeze({ kind: 'unreadable', why });
+function envelopeKey(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    if (d === undefined)
+        return { present: false };
+    if (!('value' in d))
+        throw new Error('accessor');
+    return { present: true, value: d.value };
+}
+export function readLiveModelCatalog(body) {
+    try {
+        if (body === null || typeof body !== 'object' || Array.isArray(body))
+            return unreadableCatalog('not_an_object');
+        const modelsKey = envelopeKey(body, 'models');
+        const defaultKey = envelopeKey(body, 'default');
+        const defaultModelKey = envelopeKey(body, 'defaultModel');
+        const droppedKey = envelopeKey(body, 'droppedEntries');
+        const raw = modelsKey.present ? modelsKey.value : undefined;
+        if (!Array.isArray(raw))
+            return unreadableCatalog('models_not_array');
+        const def = defaultKey.present ? defaultKey.value : undefined;
+        if (typeof def !== 'string' || def.length === 0)
+            return unreadableCatalog('default_missing');
+        const n = envelopeKey(raw, 'length');
+        const len = n.present ? n.value : undefined;
+        if (typeof len !== 'number' || !Number.isSafeInteger(len) || len < 0)
+            return unreadableCatalog('unreadable');
+        const models = [];
+        const names = new Set();
+        let unreadableRows = 0;
+        for (let i = 0; i < len; i += 1) {
+            const d = Object.getOwnPropertyDescriptor(raw, String(i));
+            const row = d !== undefined && 'value' in d ? liveModelRowCopy(d.value) : undefined;
+            if (row === undefined || names.has(row.name)) {
+                unreadableRows += 1;
+                continue;
+            }
+            names.add(row.name);
+            models.push(row);
+        }
+        const out = { models: Object.freeze(models), default: def };
+        let defaultModelMalformed = false;
+        if (defaultModelKey.present && defaultModelKey.value !== undefined) {
+            const dm = liveDefaultModelCopy(defaultModelKey.value);
+            if (dm === undefined)
+                defaultModelMalformed = true;
+            else
+                out.defaultModel = dm;
+        }
+        if (droppedKey.present && droppedKey.value !== undefined) {
+            const dropped = droppedEntriesCopy(droppedKey.value);
+            out.droppedEntries = dropped;
+        }
+        return Object.freeze({ kind: 'read', catalog: Object.freeze(out), unreadableRows, ...(defaultModelMalformed ? { defaultModelMalformed: true } : {}) });
+    }
+    catch {
+        return unreadableCatalog('unreadable');
+    }
+}
+function droppedEntriesCopy(v) {
+    if (!Array.isArray(v))
+        return frozenJsonCopyOf(v) ?? null;
+    const n = Object.getOwnPropertyDescriptor(v, 'length')?.value;
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+        return null;
+    const out = [];
+    for (let i = 0; i < n; i += 1) {
+        const d = Object.getOwnPropertyDescriptor(v, String(i));
+        out.push((d !== undefined && 'value' in d ? frozenJsonCopyOf(d.value) : undefined) ?? null);
+    }
+    return Object.freeze(out);
+}
+const nonEmptyString = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+export function liveDefaultModelOf(catalog = getLiveModelCatalog()) {
+    try {
+        if (catalog === null || typeof catalog !== 'object' || Array.isArray(catalog))
+            return Object.freeze({ kind: 'unknown', why: 'no_catalog' });
+        const dm = liveDefaultModelCopy(ownDataOf(catalog, 'defaultModel'));
+        if (dm === undefined)
+            return Object.freeze({ kind: 'unknown', why: 'not_reported' });
+        const dmName = dm.name;
+        const dmId = dm.id;
+        if (dmName !== undefined && catalogRowsOf(catalog)?.some((row) => ownDataOf(row, 'name') === dmName) === true) {
+            return Object.freeze({ kind: 'listed', name: dmName, from: 'defaultModel.name' });
+        }
+        const row = catalogRowsOf(catalog)?.find((r) => ownDataOf(r, 'id') === dmId);
+        const name = row !== undefined ? nonEmptyString(ownDataOf(row, 'name')) : undefined;
+        return name !== undefined ? Object.freeze({ kind: 'listed', name, from: 'defaultModel.id' }) : Object.freeze({ kind: 'not_listed', id: dmId });
+    }
+    catch {
+        return Object.freeze({ kind: 'unknown', why: 'unreadable' });
+    }
+}
+export function atMentionOf(model, catalog = getLiveModelCatalog()) {
+    try {
+        const target = targetRowOf(model, catalog);
+        if (target.kind !== 'row')
+            return Object.freeze({ kind: 'unknown', why: target.why });
+        const d = Object.getOwnPropertyDescriptor(target.row, 'atMentionable');
+        if (d === undefined)
+            return Object.freeze({ kind: 'not_governed' });
+        if (!('value' in d))
+            return Object.freeze({ kind: 'unknown', why: 'unreadable' });
+        if (d.value === undefined)
+            return Object.freeze({ kind: 'not_governed' });
+        if (d.value === true)
+            return Object.freeze({ kind: 'allowed' });
+        if (d.value === false)
+            return Object.freeze({ kind: 'refused' });
+        return Object.freeze({ kind: 'unknown', why: 'malformed' });
+    }
+    catch {
+        return Object.freeze({ kind: 'unknown', why: 'unreadable' });
+    }
+}
+export function modelCompatOf(model, catalog = getLiveModelCatalog()) {
+    try {
+        const target = targetRowOf(model, catalog);
+        if (target.kind !== 'row')
+            return Object.freeze({ kind: 'unknown', why: target.why });
+        const d = Object.getOwnPropertyDescriptor(target.row, 'compat');
+        if (d === undefined)
+            return Object.freeze({ kind: 'not_declared' });
+        if (!('value' in d))
+            return Object.freeze({ kind: 'unknown', why: 'unreadable' });
+        if (d.value === undefined)
+            return Object.freeze({ kind: 'not_declared' });
+        if (d.value === null || typeof d.value !== 'object' || Array.isArray(d.value))
+            return Object.freeze({ kind: 'unknown', why: 'malformed' });
+        const copy = frozenJsonCopyOf(d.value);
+        if (copy === undefined || copy === null || typeof copy !== 'object')
+            return Object.freeze({ kind: 'unknown', why: 'unreadable' });
+        if (Object.keys(copy).length === 0)
+            return Object.freeze({ kind: 'unknown', why: 'malformed' });
+        return Object.freeze({ kind: 'declared', compat: copy });
+    }
+    catch {
+        return Object.freeze({ kind: 'unknown', why: 'unreadable' });
+    }
+}
+const positiveFinite = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : undefined);
+export function liveModelRowsOf(catalog = getLiveModelCatalog()) {
+    try {
+        if (catalog === null || typeof catalog !== 'object' || Array.isArray(catalog))
+            return null;
+        const rows = catalogRowsOf(catalog);
+        if (rows === undefined)
+            return null;
+        const def = liveDefaultModelOf(catalog);
+        const seen = new Set();
+        const out = [];
+        for (const row of rows) {
+            const name = nonEmptyString(ownDataOf(row, 'name'));
+            if (name === undefined || seen.has(name))
+                continue;
+            seen.add(name);
+            const id = nonEmptyString(ownDataOf(row, 'id'));
+            const provider = nonEmptyString(ownDataOf(row, 'provider'));
+            const reasoning = ownDataOf(row, 'reasoning');
+            const contextWindow = positiveFinite(ownDataOf(row, 'contextWindow'));
+            const maxOutputTokens = positiveFinite(ownDataOf(row, 'maxOutputTokens'));
+            out.push(Object.freeze({
+                name,
+                ...(id !== undefined ? { id } : {}),
+                ...(provider !== undefined ? { provider } : {}),
+                ...(typeof reasoning === 'boolean' ? { reasoning } : {}),
+                ...(contextWindow !== undefined ? { contextWindow } : {}),
+                ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
+                isDefault: def.kind === 'listed' && def.name === name,
+                vision: imageVisionOf(name, catalog),
+                effort: effortLevelsOf(name, catalog),
+                routePairing: Object.freeze(routePairingVerdict(ownDataOf(row, 'routePairing'))),
+                atMention: atMentionOf(name, catalog),
+                compat: modelCompatOf(name, catalog),
+            }));
+        }
+        return Object.freeze(out);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/mcpEngineLeg.d.ts

@@ -15,6 +15,31 @@ export type McpEngineLegLiveness = {
     state: string;
 };
 export declare function mcpEngineLegLivenessOf(serverName: string, rows: readonly WiringManifestMcpEntryView[] | null | undefined): McpEngineLegLiveness;
+export type McpEngineLegConnection = {
+    state: 'connected';
+    toolCount?: number;
+} | {
+    state: 'not_connected';
+    cause: 'failed';
+    errorCode?: string;
+    delivered?: string;
+    httpStatus?: number;
+} | {
+    state: 'not_connected';
+    cause: 'skipped' | 'not_listed';
+} | {
+    state: 'unknown';
+    cause: 'unobserved' | 'unreadable';
+} | {
+    state: 'unknown';
+    cause: 'ambiguous';
+    rows: number;
+} | {
+    state: 'unknown';
+    cause: 'unrecognized_status';
+    status: string;
+};
+export declare function mcpEngineLegConnectionOf(serverName: string, rows: readonly WiringManifestMcpEntryView[] | null | undefined): McpEngineLegConnection;
 export interface McpDetailLegNoteInput {
     localClientFailed: boolean;
     engineHostedToolCount: number | undefined;

package/dist/mcpEngineLeg.js

@@ -1,4 +1,5 @@
 import { isMcpLivenessState } from './mcpLiveness.js';
+import { mcpSectionDroppedNamedRowsOf } from './ownKey.js';
 void true;
 void true;
 void true;
@@ -18,6 +19,26 @@ const readKey = (o, k) => {
     }
 };
 export function mcpEngineLegLivenessOf(serverName, rows) {
+    const hit = findMcpLegRow(serverName, rows);
+    if (hit.kind === 'row-unreadable')
+        return { kind: 'unreadable' };
+    if (hit.kind !== 'row')
+        return hit;
+    const first = hit.row;
+    const flag = readKey(first, 'livenessUnreadable');
+    if (flag === UNREADABLE_CELL || flag === true)
+        return { kind: 'unreadable' };
+    const cell = readKey(first, 'liveness');
+    if (cell === ABSENT_CELL)
+        return { kind: 'absent' };
+    if (cell === UNREADABLE_CELL || cell === null || typeof cell !== 'object')
+        return { kind: 'unreadable' };
+    const state = readKey(cell, 'state');
+    if (typeof state !== 'string' || state === '')
+        return { kind: 'unreadable' };
+    return { kind: 'observed', state };
+}
+function findMcpLegRow(serverName, rows) {
     let isArray = false;
     try {
         isArray = Array.isArray(rows);
@@ -56,22 +77,57 @@ export function mcpEngineLegLivenessOf(serverName, rows) {
     }
     if (incomplete)
         return { kind: 'unobserved' };
-    if (matches >= 2)
-        return { kind: 'ambiguous', rows: matches };
-    if (matches === 0)
+    const dropped = mcpSectionDroppedNamedRowsOf(rows, serverName);
+    const total = matches + dropped;
+    if (total >= 2)
+        return { kind: 'ambiguous', rows: total };
+    if (total === 0)
         return { kind: 'not-listed' };
-    const flag = readKey(first, 'livenessUnreadable');
-    if (flag === UNREADABLE_CELL || flag === true)
-        return { kind: 'unreadable' };
-    const cell = readKey(first, 'liveness');
-    if (cell === ABSENT_CELL)
-        return { kind: 'absent' };
-    if (cell === UNREADABLE_CELL || cell === null || typeof cell !== 'object')
-        return { kind: 'unreadable' };
-    const state = readKey(cell, 'state');
-    if (typeof state !== 'string' || state === '')
-        return { kind: 'unreadable' };
-    return { kind: 'observed', state };
+    if (first === undefined)
+        return { kind: 'row-unreadable' };
+    return { kind: 'row', row: first };
+}
+const MCP_LEG_CONNECT_STATUS_ARMS = Object.freeze({
+    connected: 'connected',
+    failed: 'failed',
+    skipped: 'skipped',
+});
+void true;
+export function mcpEngineLegConnectionOf(serverName, rows) {
+    const hit = findMcpLegRow(serverName, rows);
+    if (hit.kind === 'unobserved')
+        return { state: 'unknown', cause: 'unobserved' };
+    if (hit.kind === 'ambiguous')
+        return { state: 'unknown', cause: 'ambiguous', rows: hit.rows };
+    if (hit.kind === 'not-listed')
+        return { state: 'not_connected', cause: 'not_listed' };
+    if (hit.kind === 'row-unreadable')
+        return { state: 'unknown', cause: 'unreadable' };
+    const row = hit.row;
+    const status = readKey(row, 'status');
+    if (typeof status !== 'string' || status === '')
+        return { state: 'unknown', cause: 'unreadable' };
+    const arm = Object.hasOwn(MCP_LEG_CONNECT_STATUS_ARMS, status)
+        ? MCP_LEG_CONNECT_STATUS_ARMS[status]
+        : undefined;
+    if (arm === undefined)
+        return { state: 'unknown', cause: 'unrecognized_status', status };
+    if (arm === 'skipped')
+        return { state: 'not_connected', cause: 'skipped' };
+    if (arm === 'connected') {
+        const n = readKey(row, 'toolCount');
+        return typeof n === 'number' && Number.isInteger(n) && n >= 0 ? { state: 'connected', toolCount: n } : { state: 'connected' };
+    }
+    const errorCode = readKey(row, 'errorCode');
+    const delivered = readKey(row, 'delivered');
+    const httpStatus = readKey(row, 'httpStatus');
+    return {
+        state: 'not_connected',
+        cause: 'failed',
+        ...(typeof errorCode === 'string' && errorCode !== '' ? { errorCode } : {}),
+        ...(typeof delivered === 'string' && delivered !== '' ? { delivered } : {}),
+        ...(typeof httpStatus === 'number' && Number.isFinite(httpStatus) ? { httpStatus } : {}),
+    };
 }
 const rosterReadingOf = (v) => {
     if (v === UNREADABLE_CELL)

package/dist/mcpPanel.js

@@ -1,4 +1,5 @@
 import { hostLog } from './host.js';
+import { isSessionIdPathSegment } from './sessionIdSegment.js';
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { mcpLivenessRollupOf } from './mcpLiveness.js';
@@ -62,7 +63,7 @@ export function projectMcpPanel(body) {
     return view;
 }
 export async function fetchMcpPanel(client, sessionId, opts) {
-    if (typeof sessionId !== 'string' || sessionId.length === 0)
+    if (!isSessionIdPathSegment(sessionId))
         return undefined;
     let body;
     try {

package/dist/mcpProbeCapability.d.ts

@@ -8,11 +8,6 @@ export type McpProbeReading = {
     kind: 'present';
 };
 export declare function projectMcpProbeCapability(caps: unknown): McpProbeReading | undefined;
-export declare function noteEngineCapsForMcpProbe(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 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 forgetMcpProbeReading(baseUrl: string | undefined): void;
-export declare function __resetMcpProbeReadingsForTests(): void;

package/dist/mcpProbeCapability.js

@@ -1,12 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectMcpProbeCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'mcpProbe'))
-            return { kind: 'not_reported' };
-        const v = caps.mcpProbe;
+        const v = ownDataField(caps, 'mcpProbe');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -22,9 +21,6 @@ const reader = createEngineCapReader({
     project: projectMcpProbeCapability,
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForMcpProbe(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedMcpProbe(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -52,9 +48,3 @@ export function mcpProbeDoctorDetail(reading) {
                 'and a probe of caller-supplied declarations answers with the very same body shape');
     }
 }
-export function forgetMcpProbeReading(baseUrl) {
-    reader.forget(baseUrl);
-}
-export function __resetMcpProbeReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/mcpReconnect.d.ts

@@ -62,9 +62,7 @@ export type McpReconnectVerdict = {
 };
 export interface McpReconnectClientLike {
     sessions: {
-        mcpReconnect?: (sessionId: string, body: {
-            server: string;
-        }, opts?: {
+        mcpReconnect?: (sessionId: string, server: string, opts?: {
             signal?: AbortSignal;
         }) => Promise<unknown>;
     };

package/dist/mcpReconnect.js

@@ -1,10 +1,14 @@
 import { capForDisplay } from './fleetTaskDesc.js';
+import { ownDataField } from './ownKey.js';
+import { isSessionIdPathSegment } from './sessionIdSegment.js';
 export const MCP_RECONNECT_OUTCOMES = Object.freeze(['accepted', 'refused', 'unsupported']);
 export const MCP_RECONNECT_TRANSACTION_NOTICE = 'Reconnecting closes the current connection before dialing again. On a healthy server this is a transaction, ' +
     'not a refresh: a failed re-dial leaves the server down and withdraws its tools from the model until a later re-dial succeeds.';
 export const MCP_RECONNECT_UNSETTLED_NOTICE = 'The MCP re-dial did not settle within the time this request waits, so there is no result yet: the re-dial was not cancelled and may still be running. ' +
     "Check the server's state before re-dialing it again — a second request that arrives after the dial has settled closes the connection and dials once more.";
 const UNSETTLED_CODE = 'state.mcp_reconnect_unsettled';
+const _sdkClientIsAnInjection = [true];
+void _sdkClientIsAnInjection;
 const RECONNECT_TEXT_MAX = 200;
 const RECONNECT_WORD_MAX = 40;
 const SERVER_NAME_MAX = 190;
@@ -137,7 +141,7 @@ export function classifyMcpReconnectFailure(e) {
     return { kind: 'failed', error: e };
 }
 export async function reconnectMcpServer(client, sessionId, server, opts) {
-    if (!nonEmpty(sessionId))
+    if (!isSessionIdPathSegment(sessionId))
         return { kind: 'invalid' };
     if (!nonEmpty(server) || server.length > SERVER_NAME_MAX)
         return { kind: 'invalid' };
@@ -148,7 +152,7 @@ export async function reconnectMcpServer(client, sessionId, server, opts) {
         if (opts?.signal?.aborted === true) {
             return { kind: 'failed', error: opts.signal.reason ?? new Error('mcpReconnect: aborted before the verb was called') };
         }
-        const raw = await client.sessions.mcpReconnect(sessionId, { server }, opts?.signal ? { signal: opts.signal } : undefined);
+        const raw = await client.sessions.mcpReconnect(sessionId, server, opts?.signal ? { signal: opts.signal } : undefined);
         if (isUnsettledBody(raw))
             return unsettledVerdict(raw);
         const view = projectMcpReconnectResult(raw);
@@ -166,11 +170,12 @@ export function projectMcpReconnectCapability(caps) {
     try {
         if (!isRecord(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'mcpReconnect') || caps.mcpReconnect === undefined)
+        const v = ownDataField(caps, 'mcpReconnect');
+        if (v === undefined)
             return 'not_reported';
-        if (caps.mcpReconnect === true)
+        if (v === true)
             return 'available';
-        if (caps.mcpReconnect === false)
+        if (v === false)
             return 'unavailable';
         return undefined;
     }

package/dist/memoryComplianceCapability.d.ts

@@ -9,11 +9,6 @@ export type MemoryComplianceReading = {
     kind: 'present';
 };
 export declare function projectMemoryComplianceCapability(caps: unknown): MemoryComplianceReading | undefined;
-export declare function noteEngineCapsForMemoryCompliance(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedMemoryCompliance(baseUrl?: string | undefined): MemoryComplianceReading;
 export declare function memoryComplianceVerbsAvailable(reading: MemoryComplianceReading): 'yes' | 'no' | 'unknown';
 export declare function memoryComplianceDoctorDetail(reading: MemoryComplianceReading): string;
-export declare function forgetMemoryComplianceReading(baseUrl: string | undefined): void;
-export declare function __resetMemoryComplianceReadingsForTests(): void;