@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/limitsWire.d.ts

@@ -16,12 +16,16 @@ export interface HeadlessLimits {
 export type LimitsParseResult = {
     ok: true;
     limits?: HeadlessLimits;
-    flaggedFlags: string[];
 } | {
     ok: false;
     error: string;
 };
 export declare function parseLimitsArgv(argv: string[]): LimitsParseResult;
+export declare function explicitLimitFlagNames(parsed: LimitsParseResult): string[];
+export declare function limitsSupportNotice(reading: {
+    observed: boolean;
+    version?: unknown;
+}, flags: readonly string[]): string | undefined;
 export type HeadlessEnvLimitsResult = {
     ok: true;
     limits: HeadlessLimits | undefined;

package/dist/limitsWire.js

@@ -1,5 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 import { lastFlagValue } from './argvFlagValue.js';
+import { engineVersionTier, SUPPORT_FLOOR } from './supportFloor.js';
+import { readThrownSlot } from './wireFailureShape.js';
 export const HEADLESS_DEADLINE_ENV = 'SEMA_HEADLESS_DEADLINE_SEC';
 export const HEADLESS_MAX_TURNS_ENV = 'SEMA_HEADLESS_MAX_TURNS';
 export const HEADLESS_MAX_TOKENS_ENV = 'SEMA_HEADLESS_MAX_TOKENS';
@@ -10,6 +12,11 @@ export const MAX_TURNS_MAX = Number.MAX_SAFE_INTEGER;
 export const MAX_TOKENS_MIN = 1;
 export const MAX_TOKENS_MAX = Number.MAX_SAFE_INTEGER;
 const SEC_TO_MS = 1_000;
+const LIMIT_FLAG_OF_KEY = {
+    maxWalltimeMs: '--deadline',
+    maxTurns: '--max-turns',
+    maxOutputTokens: '--max-tokens',
+};
 const DEADLINE_USAGE = `sema: --deadline expects a whole number of seconds between ${DEADLINE_SEC_MIN} and ${DEADLINE_SEC_MAX}.\n` +
     '  --deadline <sec>     wall-clock budget for this run (sema superset — no upstream equivalent):\n' +
     '                       reaching it ends the run LOUDLY (failed / limits.max_walltime_exceeded)\n' +
@@ -39,36 +46,67 @@ function hasAnyLimit(l) {
 }
 export function parseLimitsArgv(argv) {
     const limits = {};
-    const flaggedFlags = [];
-    const dl = lastFlagValue(argv, '--deadline');
+    const dl = lastFlagValue(argv, LIMIT_FLAG_OF_KEY.maxWalltimeMs);
     if (dl.present) {
         const n = dl.raw !== undefined ? parseIntInDomain(dl.raw, DEADLINE_SEC_MIN, DEADLINE_SEC_MAX) : null;
         if (n === null)
             return { ok: false, error: DEADLINE_USAGE };
         limits.maxWalltimeMs = n * SEC_TO_MS;
-        flaggedFlags.push('--deadline');
     }
-    const mt = lastFlagValue(argv, '--max-turns');
+    const mt = lastFlagValue(argv, LIMIT_FLAG_OF_KEY.maxTurns);
     if (mt.present) {
         const n = mt.raw !== undefined ? parseIntInDomain(mt.raw, MAX_TURNS_MIN, MAX_TURNS_MAX) : null;
         if (n === null)
             return { ok: false, error: MAX_TURNS_USAGE };
         limits.maxTurns = n;
-        flaggedFlags.push('--max-turns');
     }
-    const mk = lastFlagValue(argv, '--max-tokens');
+    const mk = lastFlagValue(argv, LIMIT_FLAG_OF_KEY.maxOutputTokens);
     if (mk.present) {
         const n = mk.raw !== undefined ? parseIntInDomain(mk.raw, MAX_TOKENS_MIN, MAX_TOKENS_MAX) : null;
         if (n === null)
             return { ok: false, error: MAX_TOKENS_USAGE };
         limits.maxOutputTokens = n;
-        flaggedFlags.push('--max-tokens');
     }
-    return {
-        ok: true,
-        ...(flaggedFlags.length > 0 ? { limits } : {}),
-        flaggedFlags,
-    };
+    return { ok: true, ...(hasAnyLimit(limits) ? { limits } : {}) };
+}
+export function explicitLimitFlagNames(parsed) {
+    if (typeof parsed !== 'object' || parsed === null || parsed.ok !== true)
+        return [];
+    const limits = parsed.limits;
+    if (typeof limits !== 'object' || limits === null)
+        return [];
+    return Object.keys(LIMIT_FLAG_OF_KEY).filter((k) => limits[k] !== undefined).map((k) => LIMIT_FLAG_OF_KEY[k]);
+}
+const LIMIT_FLAGS_READ_MAX = 64;
+function limitFlagWordsIn(flags) {
+    const all = Object.values(LIMIT_FLAG_OF_KEY);
+    if (typeof flags !== 'object' || flags === null)
+        return all;
+    const length = readThrownSlot(flags, 'length');
+    if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0)
+        return all;
+    const given = new Set();
+    for (let i = 0; i < Math.min(length, LIMIT_FLAGS_READ_MAX); i++)
+        given.add(readThrownSlot(flags, String(i)));
+    const shown = all.filter((w) => given.has(w));
+    return shown.length > 0 ? shown : all;
+}
+export function limitsSupportNotice(reading, flags) {
+    if (typeof reading !== 'object' || reading === null)
+        return undefined;
+    if (readThrownSlot(reading, 'observed') !== true)
+        return undefined;
+    const rawVersion = readThrownSlot(reading, 'version');
+    const version = typeof rawVersion === 'string' ? rawVersion : undefined;
+    const tier = engineVersionTier(version);
+    if (tier === 'engine')
+        return undefined;
+    const shown = limitFlagWordsIn(flags);
+    const text = shown.join(' / ');
+    if (tier === 'legacy') {
+        return `[sema] The engine reports version ${String(version)}, older than ${SUPPORT_FLOOR.server} (the oldest engine this client supports); it may ignore ${text}.`;
+    }
+    return `[sema] The engine did not report a version this client can read, so it cannot be confirmed that it honors ${text}; ${shown.length > 1 ? 'they were' : 'it was'} sent anyway.`;
 }
 export function headlessLimitsFromEnv(env = hostEnv()) {
     const out = {};
@@ -109,5 +147,5 @@ export function limitsForPrint(argv, env = hostEnv()) {
     if (!fromEnv.ok)
         return { ok: false, error: fromEnv.error };
     const merged = { ...(fromEnv.limits ?? {}), ...(parsed.limits ?? {}) };
-    return { ok: true, ...(hasAnyLimit(merged) ? { limits: merged } : {}), flaggedFlags: parsed.flaggedFlags };
+    return { ok: true, ...(hasAnyLimit(merged) ? { limits: merged } : {}) };
 }

package/dist/liveModelCatalog.d.ts

@@ -1,3 +1,4 @@
+import type { AgentClient } from '@sema-agent/sdk';
 export interface LiveModelInfo {
     name: string;
     id?: string;
@@ -5,11 +6,21 @@ export interface LiveModelInfo {
     reasoning?: boolean;
     vision?: boolean;
     routePairing?: string;
+    supportedEffortLevels?: string[];
+    contextWindow?: number;
+    maxOutputTokens?: number;
+    atMentionable?: boolean;
+    compat?: LiveModelCompat;
     [k: string]: unknown;
 }
 export interface LiveModelCatalog {
     models: LiveModelInfo[];
     default: string;
+    defaultModel?: {
+        readonly id: string;
+        readonly name?: string;
+    };
+    droppedEntries?: readonly LiveModelDroppedEntry[];
 }
 export declare function setLiveModelCatalog(next: LiveModelCatalog | null): void;
 export declare function setLiveModelCatalogRefresher(fn: (() => Promise<LiveModelCatalog | null>) | null): void;
@@ -18,9 +29,107 @@ export declare function getLiveModelCatalog(): LiveModelCatalog | null;
 export declare function normalizeLiveModelRef(ref: string): string;
 export type ImageVision = 'yes' | 'no' | 'unknown';
 export declare function imageVisionOf(model: string | undefined, catalog?: LiveModelCatalog | null): ImageVision;
+export type EffortLevelsReading = {
+    readonly kind: 'clamped';
+    readonly levels: readonly string[];
+} | {
+    readonly kind: 'not_clamped';
+} | {
+    readonly kind: 'not_applicable';
+} | {
+    readonly kind: 'unknown';
+    readonly why: 'no_catalog' | 'model_not_listed' | 'reasoning_unreported' | 'levels_malformed' | 'unreadable';
+};
+export declare function effortLevelsOf(model: string | undefined, catalog?: LiveModelCatalog | null): EffortLevelsReading;
+export declare function effortLevelHonored(reading: EffortLevelsReading, level: string): 'yes' | 'no' | 'unknown';
 export declare function liveDefaultModelName(): string | null;
+type SdkModelsListResult = Awaited<ReturnType<AgentClient['models']['list']>>;
+type SdkDroppedEntry = SdkModelsListResult extends {
+    droppedEntries?: ReadonlyArray<infer E>;
+} ? E : never;
+type SdkModelInfo = SdkModelsListResult extends {
+    models: ReadonlyArray<infer M>;
+} ? M : never;
+export type LiveModelCompat = NonNullable<SdkModelInfo extends {
+    compat?: infer C;
+} ? C : never>;
+export type LiveModelDroppedEntry = SdkDroppedEntry extends {
+    reasonCode: infer R;
+} ? Omit<SdkDroppedEntry, 'reasonCode'> & {
+    readonly reasonCode: R | (string & {});
+} : SdkDroppedEntry;
+export type ModelDroppedEntriesReading = {
+    readonly kind: 'reported';
+    readonly entries: readonly LiveModelDroppedEntry[];
+    readonly unreadable: number;
+} | {
+    readonly kind: 'not_reported';
+} | {
+    readonly kind: 'unknown';
+    readonly why: 'no_catalog' | 'malformed' | 'unreadable';
+};
+export declare function droppedModelEntriesOf(catalog?: LiveModelCatalog | null): ModelDroppedEntriesReading;
 export interface RoutePairingVerdict {
     verdict: 'ok' | 'broken' | 'unknown';
     posture?: string;
 }
 export declare function routePairingVerdict(v: unknown): RoutePairingVerdict;
+export type LiveModelCatalogReading = {
+    readonly kind: 'read';
+    readonly catalog: LiveModelCatalog;
+    readonly unreadableRows: number;
+    readonly defaultModelMalformed?: true;
+} | {
+    readonly kind: 'unreadable';
+    readonly why: 'not_an_object' | 'models_not_array' | 'default_missing' | 'unreadable';
+};
+export declare function readLiveModelCatalog(body: unknown): LiveModelCatalogReading;
+export type LiveDefaultModelReading = {
+    readonly kind: 'listed';
+    readonly name: string;
+    readonly from: 'defaultModel.name' | 'defaultModel.id';
+} | {
+    readonly kind: 'not_listed';
+    readonly id: string;
+} | {
+    readonly kind: 'unknown';
+    readonly why: 'no_catalog' | 'not_reported' | 'unreadable';
+};
+export declare function liveDefaultModelOf(catalog?: LiveModelCatalog | null): LiveDefaultModelReading;
+export type AtMentionReading = {
+    readonly kind: 'allowed';
+} | {
+    readonly kind: 'refused';
+} | {
+    readonly kind: 'not_governed';
+} | {
+    readonly kind: 'unknown';
+    readonly why: 'no_catalog' | 'model_not_listed' | 'malformed' | 'unreadable';
+};
+export declare function atMentionOf(model: string | undefined, catalog?: LiveModelCatalog | null): AtMentionReading;
+export type ModelCompatReading = {
+    readonly kind: 'declared';
+    readonly compat: Readonly<LiveModelCompat>;
+} | {
+    readonly kind: 'not_declared';
+} | {
+    readonly kind: 'unknown';
+    readonly why: 'no_catalog' | 'model_not_listed' | 'malformed' | 'unreadable';
+};
+export declare function modelCompatOf(model: string | undefined, catalog?: LiveModelCatalog | null): ModelCompatReading;
+export interface LiveModelRowView {
+    readonly name: string;
+    readonly id?: string;
+    readonly provider?: string;
+    readonly reasoning?: boolean;
+    readonly contextWindow?: number;
+    readonly maxOutputTokens?: number;
+    readonly isDefault: boolean;
+    readonly vision: ImageVision;
+    readonly effort: EffortLevelsReading;
+    readonly routePairing: RoutePairingVerdict;
+    readonly atMention: AtMentionReading;
+    readonly compat: ModelCompatReading;
+}
+export declare function liveModelRowsOf(catalog?: LiveModelCatalog | null): readonly LiveModelRowView[] | null;
+export {};

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,35 +61,172 @@ 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)
+        const target = targetRowOf(model, catalog);
+        if (target.kind !== 'row')
             return 'unknown';
-        const row = liveModelRowOf(catalog, target);
-        if (row === undefined)
-            return 'unknown';
-        const vision = ownDataOf(row, 'vision');
+        const vision = ownDataOf(target.row, 'vision');
         return vision === true ? 'yes' : vision === false ? 'no' : 'unknown';
     }
     catch {
         return 'unknown';
     }
 }
+const NOT_CLAMPED = Object.freeze({ kind: 'not_clamped' });
+const NOT_APPLICABLE = Object.freeze({ kind: 'not_applicable' });
+const unknownEffort = (why) => Object.freeze({ kind: 'unknown', why });
+export function effortLevelsOf(model, catalog = getLiveModelCatalog()) {
+    try {
+        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))
+                return unknownEffort('levels_malformed');
+            const n = ownDataOf(levels, 'length');
+            if (typeof n !== 'number' || !Number.isSafeInteger(n) || n <= 0)
+                return unknownEffort('levels_malformed');
+            const out = [];
+            for (let i = 0; i < n; i += 1) {
+                const w = ownDataOf(levels, String(i));
+                if (typeof w !== 'string' || w.length === 0)
+                    return unknownEffort('levels_malformed');
+                if (!out.includes(w))
+                    out.push(w);
+            }
+            return Object.freeze({ kind: 'clamped', levels: Object.freeze(out) });
+        }
+        const reasoning = ownDataOf(row, 'reasoning');
+        if (reasoning === true)
+            return NOT_CLAMPED;
+        if (reasoning === false)
+            return NOT_APPLICABLE;
+        return unknownEffort('reasoning_unreported');
+    }
+    catch {
+        return unknownEffort('unreadable');
+    }
+}
+export function effortLevelHonored(reading, level) {
+    if (typeof level !== 'string' || level.length === 0)
+        return 'unknown';
+    switch (reading?.kind) {
+        case 'clamped':
+            return Array.isArray(reading.levels) && reading.levels.includes(level) ? 'yes' : 'no';
+        case 'not_clamped':
+            return 'yes';
+        case 'not_applicable':
+            return 'no';
+        default:
+            return 'unknown';
+    }
+}
 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']);
@@ -95,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;