@sema-agent/client-core 0.93.1 → 0.95.0

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

@@ -14,5 +14,4 @@ export declare function noteEngineCapsForMcpProbe(baseUrl: string, caps: unknown
 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,16 +1,20 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectMcpProbeCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'mcpProbe'))
-        return { kind: 'not_reported' };
-    const v = caps.mcpProbe;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'mcpProbe');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return v ? { kind: 'present' } : { kind: 'absent' };
+    }
+    catch {
         return undefined;
-    return v ? { kind: 'present' } : { kind: 'absent' };
+    }
 }
 const reader = createEngineCapReader({
     name: 'mcpProbe',
@@ -47,9 +51,6 @@ 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);
@@ -163,15 +167,21 @@ export async function reconnectMcpServer(client, sessionId, server, opts) {
     }
 }
 export function projectMcpReconnectCapability(caps) {
-    if (!isRecord(caps))
+    try {
+        if (!isRecord(caps))
+            return undefined;
+        const v = ownDataField(caps, 'mcpReconnect');
+        if (v === undefined)
+            return 'not_reported';
+        if (v === true)
+            return 'available';
+        if (v === false)
+            return 'unavailable';
+        return undefined;
+    }
+    catch {
         return undefined;
-    if (!Object.hasOwn(caps, 'mcpReconnect') || caps.mcpReconnect === undefined)
-        return 'not_reported';
-    if (caps.mcpReconnect === true)
-        return 'available';
-    if (caps.mcpReconnect === false)
-        return 'unavailable';
-    return undefined;
+    }
 }
 export function mcpReconnectOutcomeDetail(view) {
     const name = capForDisplay(view.server, RECONNECT_WORD_MAX);

package/dist/memoryComplianceCapability.d.ts

@@ -15,5 +15,4 @@ export declare function noteEngineCapsForMemoryCompliance(baseUrl: string, caps:
 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;

package/dist/memoryComplianceCapability.js

@@ -1,18 +1,22 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export const MEMORY_ENGINE_REQUIRED_CODE = 'capability.memory_engine_required';
 export function projectMemoryComplianceCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    const c = caps;
-    if (!Object.hasOwn(c, 'memoryCompliance'))
-        return { kind: 'not_reported' };
-    const v = c.memoryCompliance;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const c = caps;
+        const v = ownDataField(c, 'memoryCompliance');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return v ? { kind: 'present' } : { kind: 'absent' };
+    }
+    catch {
         return undefined;
-    return v ? { kind: 'present' } : { kind: 'absent' };
+    }
 }
 const reader = createEngineCapReader({
     name: 'memoryCompliance',
@@ -44,9 +48,6 @@ export function memoryComplianceDoctorDetail(reading) {
             return 'memory compliance face on — the entry-provenance and erasure endpoints are mounted and the operator roster is non-empty on this engine; this says the door opens, not that any one call succeeds (a damaged control-plane ledger is a runtime fact and arrives as a typed 500)';
     }
 }
-export function forgetMemoryComplianceReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetMemoryComplianceReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/memoryOriginCapability.d.ts

@@ -14,5 +14,4 @@ export declare function noteEngineCapsForMemoryOrigin(baseUrl: string, caps: unk
 export declare function observedMemoryOrigin(baseUrl?: string | undefined): MemoryOriginReading;
 export declare function memoryOriginVerbsAvailable(reading: MemoryOriginReading): 'yes' | 'no' | 'unknown';
 export declare function memoryOriginDoctorDetail(reading: MemoryOriginReading): string;
-export declare function forgetMemoryOriginReading(baseUrl: string | undefined): void;
 export declare function __resetMemoryOriginReadingsForTests(): void;

package/dist/memoryOriginCapability.js

@@ -1,18 +1,22 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 import { MEMORY_ENGINE_REQUIRED_CODE } from './memoryComplianceCapability.js';
 export function projectMemoryOriginCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    const c = caps;
-    if (!Object.hasOwn(c, 'memoryOrigin'))
-        return { kind: 'not_reported' };
-    const v = c.memoryOrigin;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const c = caps;
+        const v = ownDataField(c, 'memoryOrigin');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return v ? { kind: 'present' } : { kind: 'absent' };
+    }
+    catch {
         return undefined;
-    return v ? { kind: 'present' } : { kind: 'absent' };
+    }
 }
 const reader = createEngineCapReader({
     name: 'memoryOrigin',
@@ -44,9 +48,6 @@ export function memoryOriginDoctorDetail(reading) {
             return 'external-origin face on — the origin listing and clearance endpoints are mounted and the operator roster is non-empty on this engine; this says the door opens, not that any one call succeeds, and it says nothing about the listing being complete (the engine has no scope-enumeration read face, so an answer covers only the scopes the caller named and an empty one must never be read as a clean store)';
     }
 }
-export function forgetMemoryOriginReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetMemoryOriginReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/memoryVerbsWire.d.ts

@@ -21,7 +21,7 @@ export interface MemoryFacade {
 }
 export declare const MEMORY_VERB_REFUSAL_CAUSES: readonly ["face_absent", "client_too_old", "unreadable_request", "store_absent", "operator_only", "operators_unconfigured", "unauthorized", "service_token_required", "id_invalid", "request_id_required", "body_shape", "query_invalid", "selector_invalid", "evidence_unavailable", "selector_mismatch", "census_incomplete", "clear_unattributed", "clear_invalid", "clear_not_marked", "clear_challenged", "clear_conflict", "clear_pending"];
 export type MemoryVerbRefusalCause = (typeof MEMORY_VERB_REFUSAL_CAUSES)[number];
-export declare const MEMORY_VERB_UNKNOWN_WHYS: readonly ["no_verdict", "server_fault", "control_plane_corrupt", "clear_unknown", "clear_failed", "result_unreadable", "unsupported_version", "identity_mismatch", "unclassified"];
+export declare const MEMORY_VERB_UNKNOWN_WHYS: readonly ["no_verdict", "server_fault", "control_plane_corrupt", "clear_unknown", "clear_failed", "result_unreadable", "unsupported_version", "identity_mismatch", "store_form_refused", "unclassified"];
 export type MemoryVerbUnknownWhy = (typeof MEMORY_VERB_UNKNOWN_WHYS)[number];
 export type MemoryVerbRefused = {
     status: 'refused';

package/dist/memoryVerbsWire.js

@@ -35,6 +35,7 @@ export const MEMORY_VERB_UNKNOWN_WHYS = Object.freeze([
     'result_unreadable',
     'unsupported_version',
     'identity_mismatch',
+    'store_form_refused',
     'unclassified',
 ]);
 function refusedBy(cause, message) {
@@ -90,6 +91,9 @@ export function classifyMemoryFailure(e) {
             return unknownBy('clear_unknown', message);
         case 'memory.origin_clear_failed':
             return unknownBy('clear_failed', message);
+        case 'memory.target_outside_store':
+        case 'memory.scope_home_not_directory':
+            return unknownBy('store_form_refused', message);
         case 'internal.memory_control_plane_corrupt':
             return unknownBy('control_plane_corrupt', message);
         default:

package/dist/model/liveCatalogShape.d.ts

@@ -0,0 +1,14 @@
+export type FrozenJsonValue = string | number | boolean | null | readonly FrozenJsonValue[] | {
+    readonly [k: string]: FrozenJsonValue;
+};
+export declare function frozenJsonCopyOf(v: unknown): FrozenJsonValue | undefined;
+export declare function liveModelRowCopy(row: unknown): FrozenJsonRow | undefined;
+export type FrozenJsonRow = {
+    readonly [k: string]: FrozenJsonValue;
+} & {
+    readonly name: string;
+};
+export declare function liveDefaultModelCopy(v: unknown): {
+    readonly id: string;
+    readonly name?: string;
+} | undefined;

package/dist/model/liveCatalogShape.js

@@ -0,0 +1,71 @@
+const MAX_DEPTH = 16;
+class Unreadable extends Error {
+}
+function frozenJsonCopy(v, depth) {
+    if (depth > MAX_DEPTH)
+        throw new Unreadable();
+    if (v === null || typeof v === 'string' || typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number') {
+        if (!Number.isFinite(v))
+            throw new Unreadable();
+        return v;
+    }
+    if (typeof v !== 'object')
+        throw new Unreadable();
+    if (Array.isArray(v)) {
+        const n = Object.getOwnPropertyDescriptor(v, 'length')?.value;
+        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))
+                throw new Unreadable();
+            out.push(frozenJsonCopy(d.value, depth + 1));
+        }
+        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))
+            throw new Unreadable();
+        if (d.value === undefined)
+            continue;
+        Object.defineProperty(out, k, { value: frozenJsonCopy(d.value, depth + 1), enumerable: true, writable: true, configurable: true });
+    }
+    return Object.freeze(out);
+}
+export function frozenJsonCopyOf(v) {
+    try {
+        return frozenJsonCopy(v, 0);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function liveModelRowCopy(row) {
+    if (row === null || typeof row !== 'object' || Array.isArray(row))
+        return undefined;
+    const copy = frozenJsonCopyOf(row);
+    if (!isFrozenJsonObject(copy))
+        return undefined;
+    const name = copy.name;
+    return typeof name === 'string' && name.length > 0 ? copy : undefined;
+}
+const isFrozenJsonObject = (v) => v !== undefined && v !== null && typeof v === 'object' && !Array.isArray(v);
+export function liveDefaultModelCopy(v) {
+    if (v === null || typeof v !== 'object' || Array.isArray(v))
+        return undefined;
+    const c = frozenJsonCopyOf(v);
+    if (!isFrozenJsonObject(c))
+        return undefined;
+    const id = c.id;
+    const name = c.name;
+    if (typeof id !== 'string' || id.length === 0)
+        return undefined;
+    if (Object.hasOwn(c, 'name') && (typeof name !== 'string' || name.length === 0))
+        return undefined;
+    return c;
+}

package/dist/model/modelSupplyRules.d.ts

@@ -26,6 +26,7 @@ export interface DeleteWarningsInput {
     id: string;
     doc: {
         atModelAllowlist?: unknown;
+        atMention?: unknown;
         tierGroups?: unknown;
     } | null;
     tierGroups: TierGroupsView | null;

package/dist/model/modelSupplyRules.js

@@ -1,3 +1,5 @@
+import { SETTINGS_NARROW_AT_MENTION } from '../generated/settingsSchemaFns.js';
+import { modelsPolicyOf } from './modelsPolicy.js';
 import { inferFamily } from './providerPresets.js';
 function isPlainObject(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
@@ -13,15 +15,16 @@ export function resolveEntryVision(entry) {
 export function computeDeleteWarnings(input) {
     const { id, doc, tierGroups, survivingIds } = input;
     const out = [];
-    const allow = doc?.atModelAllowlist;
-    if (Array.isArray(allow)) {
-        const declared = allow.filter((x) => typeof x === 'string');
-        const effectiveBefore = declared.filter(n => n === id || survivingIds.includes(n));
-        const effectiveAfter = declared.filter(n => n !== id && survivingIds.includes(n));
-        if (effectiveBefore.length > 0 && effectiveAfter.length === 0) {
+    const am = modelsPolicyOf(doc).atMention;
+    if (am?.kind === 'read' && am.value.mode === 'only') {
+        const before = SETTINGS_NARROW_AT_MENTION(am.value, new Set([id, ...survivingIds]));
+        const after = SETTINGS_NARROW_AT_MENTION(am.value, new Set(survivingIds.filter((n) => n !== id)));
+        if (before.mode === 'only' && after.mode === 'none') {
             out.push({
                 kind: 'allowlist-empties',
-                consequence: 'it is the last usable model on your @-mention allowlist — deleting it empties the list, which means EVERY enabled model becomes @-mentionable',
+                consequence: am.from === 'atModelAllowlist'
+                    ? 'it is the last usable model on your @-mention allowlist — deleting it empties the list, which means EVERY enabled model becomes @-mentionable'
+                    : 'it is the last usable model on your @-mention allowlist — deleting it leaves no model that can be @-mentioned',
             });
         }
     }
@@ -47,15 +50,33 @@ export function computeDeleteWarnings(input) {
 export function computeDeleteBlockers(input) {
     const { id, doc, rosters } = input;
     const out = [];
-    if (doc && typeof doc.default === 'string' && doc.default === id) {
+    const policy = modelsPolicyOf(doc);
+    if (policy.unreadable) {
+        out.push({
+            kind: 'unreadable',
+            where: 'models.json (the document could not be read)',
+            fix: 'fix or re-save models.json so it can be read, then delete this model',
+        });
+    }
+    if (policy.defaultUnreadable) {
+        out.push({
+            kind: 'unreadable',
+            where: 'models.json `default` (the default model could not be read)',
+            fix: 'fix or re-save models.json so its default model can be read, then delete this model',
+        });
+    }
+    const dm = policy.defaultModel;
+    if (dm !== undefined && dm.name === id) {
         out.push({
             kind: 'default',
-            where: 'models.json `default`',
+            where: dm.from === 'default' ? 'models.json `default`' : 'models.json roles.default',
             fix: 'point another model at the default first (Model Hub: select it and press u), then delete this one',
         });
     }
     if (doc && isPlainObject(doc.roles)) {
         for (const [role, target] of Object.entries(doc.roles)) {
+            if (role === 'default' && dm?.from === 'roles.default')
+                continue;
             if (!isPlainObject(target) || typeof target.model !== 'string')
                 continue;
             if (target.model !== id)

package/dist/model/modelsPolicy.d.ts

@@ -0,0 +1,21 @@
+import { type SettingsAtMention } from '../generated/settingsSchemaFns.js';
+export interface CanonicalDefaultModel {
+    readonly name: string;
+    readonly from: 'default' | 'roles.default';
+}
+export type CanonicalAtMention = {
+    readonly kind: 'read';
+    readonly value: SettingsAtMention;
+    readonly from: 'atMention' | 'atModelAllowlist';
+    readonly unreadableEntries: number;
+} | {
+    readonly kind: 'unreadable';
+    readonly from: 'atMention' | 'atModelAllowlist';
+};
+export interface CanonicalModelsPolicy {
+    readonly defaultModel?: CanonicalDefaultModel;
+    readonly defaultUnreadable?: true;
+    readonly atMention?: CanonicalAtMention;
+    readonly unreadable?: true;
+}
+export declare function modelsPolicyOf(doc: unknown): CanonicalModelsPolicy;

package/dist/model/modelsPolicy.js

@@ -0,0 +1,90 @@
+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;
+    }
+    catch {
+        return undefined;
+    }
+}
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function atMentionOf(v) {
+    try {
+        if (!isRecord(v))
+            return undefined;
+        const mode = ownData(v, 'mode');
+        if (typeof mode !== 'string' || !SETTINGS_AT_MENTION_MODES.includes(mode))
+            return undefined;
+        if (mode !== 'only')
+            return { mode: mode };
+        const list = ownData(v, 'models');
+        if (!Array.isArray(list) || list.length === 0)
+            return undefined;
+        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)
+                return undefined;
+            out.push(d.value);
+        }
+        return { mode: 'only', models: out };
+    }
+    catch {
+        return undefined;
+    }
+}
+function atModelAllowlistOf(v) {
+    if (!Array.isArray(v))
+        return { kind: 'unreadable', from: 'atModelAllowlist' };
+    const names = [];
+    let bad = 0;
+    for (let i = 0; i < v.length; i += 1) {
+        const d = Object.getOwnPropertyDescriptor(v, i);
+        const x = d !== undefined && 'value' in d ? d.value : undefined;
+        if (typeof x === 'string' && x.length > 0)
+            names.push(x);
+        else
+            bad += 1;
+    }
+    const value = names.length > 0 ? { mode: 'only', models: names } : { mode: 'all' };
+    return { kind: 'read', value, from: 'atModelAllowlist', unreadableEntries: bad };
+}
+export function modelsPolicyOf(doc) {
+    try {
+        if (!isRecord(doc))
+            return {};
+        let defaultModel;
+        let defaultUnreadable = false;
+        if (Object.hasOwn(doc, 'default')) {
+            const d = ownData(doc, 'default');
+            if (typeof d === 'string' && d.length > 0)
+                defaultModel = { name: d, from: 'default' };
+            else
+                defaultUnreadable = true;
+        }
+        if (defaultModel === undefined && !defaultUnreadable) {
+            const roles = ownData(doc, 'roles');
+            const rd = isRecord(roles) ? ownData(roles, 'default') : undefined;
+            const model = isRecord(rd) ? ownData(rd, 'model') : undefined;
+            if (typeof model === 'string' && model.length > 0)
+                defaultModel = { name: model, from: 'roles.default' };
+        }
+        let atMention;
+        if (Object.hasOwn(doc, 'atMention')) {
+            const am = atMentionOf(ownData(doc, 'atMention'));
+            atMention = am === undefined ? { kind: 'unreadable', from: 'atMention' } : { kind: 'read', value: am, from: 'atMention', unreadableEntries: 0 };
+        }
+        else if (Object.hasOwn(doc, 'atModelAllowlist')) {
+            atMention = atModelAllowlistOf(ownData(doc, 'atModelAllowlist'));
+        }
+        return {
+            ...(defaultModel !== undefined ? { defaultModel } : {}),
+            ...(defaultUnreadable ? { defaultUnreadable: true } : {}),
+            ...(atMention !== undefined ? { atMention } : {}),
+        };
+    }
+    catch {
+        return { unreadable: true };
+    }
+}