@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/memoryComplianceCapability.js

@@ -1,14 +1,13 @@
 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) {
     try {
         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;
+        const v = ownDataField(c, 'memoryCompliance');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -24,9 +23,6 @@ const reader = createEngineCapReader({
     project: projectMemoryComplianceCapability,
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForMemoryCompliance(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedMemoryCompliance(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -49,9 +45,3 @@ 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

@@ -8,11 +8,6 @@ export type MemoryOriginReading = {
     kind: 'present';
 };
 export declare function projectMemoryOriginCapability(caps: unknown): MemoryOriginReading | undefined;
-export declare function noteEngineCapsForMemoryOrigin(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 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,14 +1,13 @@
 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) {
     try {
         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;
+        const v = ownDataField(c, 'memoryOrigin');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -24,9 +23,6 @@ const reader = createEngineCapReader({
     project: projectMemoryOriginCapability,
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-export function noteEngineCapsForMemoryOrigin(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedMemoryOrigin(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -49,9 +45,3 @@ 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/memorySpecWire.js

@@ -1,5 +1,5 @@
 import { CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH } from './engineErrorCodes.js';
-import { capForDisplay } from './fleetTaskDesc.js';
+import { escapeDisplayControlChars } from './fleetTaskDesc.js';
 export const KNOWN_AGENT_MEMORY_SPEC_KEYS = Object.freeze([
     'enabled',
     'scopeContract',
@@ -128,7 +128,7 @@ function quotedKeyForDisplay(key) {
     let out = '';
     let truncated = false;
     for (const ch of key) {
-        const tok = ch === '\\' ? '\\\\' : ch === '"' ? '\\"' : capForDisplay(ch, 8);
+        const tok = ch === '\\' ? '\\\\' : ch === '"' ? '\\"' : escapeDisplayControlChars(ch);
         if (out.length + tok.length > MEMORY_SPEC_KEY_DISPLAY_MAX) {
             truncated = true;
             break;

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 };
+    }
+}

package/dist/modelIdentityResolvability.d.ts

@@ -25,10 +25,10 @@ export interface RemoteEngineModelIdentityReading {
 }
 export type ModelIdentityReading = LocalEngineModelIdentityReading | RemoteEngineModelIdentityReading;
 export type ModelIdentityResolvability = 'resolvable' | 'not_resolvable' | 'unknown';
-export type ModelSetupDecision = 'offer_setup' | 'explain_unconfigured' | 'explain_route_gap' | 'proceed';
+export type ModelSetupDecision = 'offer_setup' | 'offer_route_setup' | 'explain_unconfigured' | 'explain_route_gap' | 'explain_route_unconfigurable' | 'proceed';
 export declare function modelIdentityResolvability(reading: ModelIdentityReading): ModelIdentityResolvability;
 export declare function modelIdentityDetail(reading: ModelIdentityReading): string;
-export declare function modelSetupDecision(identity: ModelIdentityResolvability | ModelIdentityReading, hostCanConfigureModel: boolean): ModelSetupDecision;
+export declare function modelSetupDecision(reading: ModelIdentityReading, hostCanConfigureModel: boolean, hostCanConfigureRoute?: boolean): ModelSetupDecision;
 export declare function modelSetupNotice(decision: ModelSetupDecision): string | null;
 export declare function observedEngineAnswer(baseUrl?: string | undefined): EngineAnswerObservation;
 export {};

package/dist/modelIdentityResolvability.js

@@ -178,18 +178,16 @@ export function modelIdentityDetail(reading) {
             return "this reading of the engine's model configuration could not be interpreted, so whether the engine has a model name is unknown";
     }
 }
-export function modelSetupDecision(identity, hostCanConfigureModel) {
-    let verdict;
-    if (typeof identity === 'string') {
-        verdict = identity;
-    }
-    else {
-        const a = analyse(identity);
-        if (a.verdict === 'not_resolvable' && a.why === 'route_gap')
-            return 'explain_route_gap';
-        verdict = a.verdict;
+export function modelSetupDecision(reading, hostCanConfigureModel, hostCanConfigureRoute) {
+    const a = analyse(reading);
+    if (a.verdict === 'not_resolvable' && a.why === 'route_gap') {
+        if (hostCanConfigureRoute === true)
+            return 'offer_route_setup';
+        if (hostCanConfigureRoute === false)
+            return 'explain_route_unconfigurable';
+        return 'explain_route_gap';
     }
-    if (verdict !== 'not_resolvable')
+    if (a.verdict !== 'not_resolvable')
         return 'proceed';
     if (hostCanConfigureModel === true)
         return 'offer_setup';
@@ -203,8 +201,12 @@ export function modelSetupNotice(decision) {
             return 'no model name is configured for the engine, and it does not start without one — opening model setup';
         case 'explain_unconfigured':
             return 'this engine has no model configured, and it cannot be configured from this client — ask whoever runs the engine to set one up';
+        case 'offer_route_setup':
+            return 'a model name is configured, but the engine has no route to reach that model (a gateway address, or credentials for the channel it names), so it does not start — opening setup so the route can be set';
         case 'explain_route_gap':
-            return 'a model name is configured, but the engine has no route to reach that model (a gateway address, or credentials for the channel it names), so it does not start — fix the route; model setup will not help';
+            return 'a model name is configured, but the engine has no route to reach that model (a gateway address, or credentials for the channel it names), so it does not start — the route has to be set before the engine can run';
+        case 'explain_route_unconfigurable':
+            return 'a model name is configured, but the engine has no route to reach that model (a gateway address, or credentials for the channel it names), so it does not start — the route cannot be set from this client; ask whoever runs the engine to set it';
         default:
             return null;
     }

package/dist/modelSwitchFallback.d.ts

@@ -0,0 +1,69 @@
+export type ModelSwitchProbeLane = 'live' | 'mock' | 'engine_absent' | 'unwired';
+export interface ModelSwitchProbeVerdict {
+    readonly valid: boolean;
+    readonly error?: string;
+    readonly unchecked?: true;
+}
+export interface ModelSwitchProbeInput {
+    readonly model: string;
+    readonly lane: ModelSwitchProbeLane;
+    readonly engineAbsentReason?: string;
+    readonly probe?: {
+        readonly kind: 'verdict';
+        readonly verdict: ModelSwitchProbeVerdict;
+    } | {
+        readonly kind: 'threw';
+        readonly error: unknown;
+    };
+}
+export type ModelSwitchProbeOutcome = {
+    readonly ok: true;
+    readonly probed: boolean;
+} | {
+    readonly ok: false;
+    readonly kind: 'rejected';
+    readonly model: string;
+    readonly reason?: string;
+} | {
+    readonly ok: false;
+    readonly kind: 'unavailable';
+    readonly cause: 'unwired' | 'probe_missing' | 'probe_threw' | 'unchecked';
+    readonly model: string;
+    readonly reason?: string;
+};
+export declare function modelSwitchProbeOutcomeOf(input: ModelSwitchProbeInput): ModelSwitchProbeOutcome;
+export interface ModelSwitchProbePorts {
+    readonly lane: () => {
+        readonly lane: ModelSwitchProbeLane;
+        readonly engineAbsentReason?: string;
+    } | Promise<{
+        readonly lane: ModelSwitchProbeLane;
+        readonly engineAbsentReason?: string;
+    }>;
+    readonly validate: (model: string) => Promise<ModelSwitchProbeVerdict>;
+}
+export declare function runModelSwitchProbe(model: string, ports: ModelSwitchProbePorts): Promise<ModelSwitchProbeOutcome>;
+export interface ModelSwitchFallbackRecord {
+    readonly previous: string;
+    readonly current: string;
+    readonly seq: number;
+}
+export interface ModelSwitchNote {
+    readonly sessionId: string;
+    readonly to: string | null | undefined;
+    readonly lastServed: string | null | undefined;
+}
+export interface ModelSwitchAdvisoryInput {
+    readonly frame: unknown;
+    readonly sessionId: string;
+    readonly streamModel: string | null | undefined;
+    readonly lastServed: string | null | undefined;
+}
+export interface ModelSwitchFallbackLedger {
+    noteSwitch(input: ModelSwitchNote): ModelSwitchFallbackRecord | undefined;
+    peek(sessionId: string): ModelSwitchFallbackRecord | undefined;
+    advisoryFor(input: ModelSwitchAdvisoryInput): ModelSwitchFallbackRecord | undefined;
+    release(sessionId: string, seq: number): boolean;
+    clear(sessionId: string): void;
+}
+export declare function createModelSwitchFallbackLedger(): ModelSwitchFallbackLedger;