@sema-agent/client-core 0.93.1 → 0.95.0

package/dist/modelIdentityResolvability.d.ts

@@ -16,17 +16,19 @@ export interface LocalEngineModelIdentityReading {
     lanes: ModelIdentityLanes;
     engineAnswer?: EngineAnswerObservation;
     engineAcceptsCatalogDefault?: boolean;
+    routeGap?: ModelRouteGapReading;
 }
+export type ModelRouteGapReading = 'endpoint_missing' | 'lane_credential_missing' | 'none';
 export interface RemoteEngineModelIdentityReading {
     engine: 'remote';
     engineAnswer: EngineAnswerObservation;
 }
 export type ModelIdentityReading = LocalEngineModelIdentityReading | RemoteEngineModelIdentityReading;
 export type ModelIdentityResolvability = 'resolvable' | 'not_resolvable' | 'unknown';
-export type ModelSetupDecision = 'offer_setup' | 'explain_unconfigured' | 'proceed';
+export type ModelSetupDecision = 'offer_setup' | 'explain_unconfigured' | 'explain_route_gap' | 'proceed';
 export declare function modelIdentityResolvability(reading: ModelIdentityReading): ModelIdentityResolvability;
 export declare function modelIdentityDetail(reading: ModelIdentityReading): string;
-export declare function modelSetupDecision(identity: ModelIdentityResolvability, hostCanConfigureModel: boolean): ModelSetupDecision;
+export declare function modelSetupDecision(reading: ModelIdentityReading, hostCanConfigureModel: boolean): ModelSetupDecision;
 export declare function modelSetupNotice(decision: ModelSetupDecision): string | null;
 export declare function observedEngineAnswer(baseUrl?: string | undefined): EngineAnswerObservation;
 export {};

package/dist/modelIdentityResolvability.js

@@ -26,6 +26,10 @@ function catalogDefaultEvidence(catalog, accepts) {
     void _evidencePin;
     return catalog === 'complete' && accepts === true ? { catalog, engineAccepts: accepts } : undefined;
 }
+function routeGapOf(reading) {
+    const v = own(reading, 'routeGap')?.v;
+    return v === 'endpoint_missing' || v === 'lane_credential_missing' || v === 'none' ? v : undefined;
+}
 function analyse(reading) {
     try {
         if (!isPlainObject(reading))
@@ -69,7 +73,10 @@ function analyse(reading) {
                 }
             }
             else if (s === 'complete') {
-                return { verdict: 'resolvable', why: 'lane', lane };
+                const route = routeGapOf(reading);
+                if (route === 'endpoint_missing' || route === 'lane_credential_missing')
+                    return { verdict: 'not_resolvable', why: 'route_gap', lane, gap: route };
+                return { verdict: 'resolvable', why: 'lane', lane, route: route === 'none' ? 'none' : 'unreported' };
             }
             if (s === 'partial')
                 partial.push(lane);
@@ -83,7 +90,7 @@ function analyse(reading) {
         if (unreadable.length > 0 || unreported.length > 0 || unusable.length > 0 || catalogUnconfirmed !== null) {
             return { verdict: 'unknown', why: 'lanes', unreadable, unreported, unusable, catalogUnconfirmed, catalogRefused };
         }
-        return { verdict: 'not_resolvable', partial, catalogRefused };
+        return { verdict: 'not_resolvable', why: 'lanes', partial, catalogRefused };
     }
     catch {
         return malformed();
@@ -121,8 +128,16 @@ export function modelIdentityDetail(reading) {
             if (a.why === 'catalog_default') {
                 return `${laneLabel('modelCatalogFile')} supplies a model name as its default, and the local engine accepts a catalog default in place of a startup model name, so it can start with it — whether its gateway accepts that name is a separate check`;
             }
-            return `${laneLabel(a.lane)} supplies a model name, so the local engine can start with it — whether its gateway accepts that name is a separate check`;
+            if (a.route === 'none') {
+                return `${laneLabel(a.lane)} supplies a model name and the local engine has a route to reach it, so it can start with it — whether its gateway accepts that name is a separate check`;
+            }
+            return `${laneLabel(a.lane)} supplies a model name for the local engine — whether the engine also has a route to reach that model (an endpoint, or credentials for the channel it names) and whether its gateway accepts the name are separate checks`;
         case 'not_resolvable': {
+            if (a.why === 'route_gap') {
+                return a.gap === 'endpoint_missing'
+                    ? `${laneLabel(a.lane)} supplies a model name, but the local engine has no route to reach it — the model rides the OpenAI-compatible route and no gateway address (MODEL_GATEWAY_BASEURL) is set, and the engine refuses to start without one`
+                    : `${laneLabel(a.lane)} supplies a model name, but the local engine has no route to reach it — the anthropic channel is selected (MODEL_PROVIDER=anthropic), neither ANTHROPIC_API_KEY nor ANTHROPIC_AUTH_TOKEN is set, and there is no gateway address (MODEL_GATEWAY_BASEURL) to fall back to, so the engine cannot start on any route`;
+            }
             const others = a.catalogRefused ? a.partial.filter((l) => l !== 'modelCatalogFile') : a.partial;
             const partialClause = others.length > 0
                 ? `${joinPhrases(others.map(laneLabel))} ${others.length > 1 ? 'carry' : 'carries'} part of a model configuration (such as a gateway address or a credential) but no model name`
@@ -163,8 +178,11 @@ 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) {
-    if (identity !== 'not_resolvable')
+export function modelSetupDecision(reading, hostCanConfigureModel) {
+    const a = analyse(reading);
+    if (a.verdict === 'not_resolvable' && a.why === 'route_gap')
+        return 'explain_route_gap';
+    if (a.verdict !== 'not_resolvable')
         return 'proceed';
     if (hostCanConfigureModel === true)
         return 'offer_setup';
@@ -178,6 +196,8 @@ 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 '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';
         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;

package/dist/modelSwitchFallback.js

@@ -0,0 +1,206 @@
+import { resultErrorCodeOf, resultSelectedModelOf } from './resultFrameKeys.js';
+import { readFrameStringKey, readOwnDataValue } from './ownKey.js';
+const trimmed = (v) => (typeof v === 'string' ? v.trim() : '');
+const reasonOf = (v) => {
+    const t = trimmed(v);
+    return t.length > 0 ? t : undefined;
+};
+function thrownReason(e) {
+    try {
+        if (e instanceof Error)
+            return reasonOf(e.message);
+        return reasonOf(e);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function modelSwitchProbeOutcomeOf(input) {
+    let model = '';
+    let lane;
+    let absent;
+    let probe;
+    try {
+        model = trimmed(input?.model);
+        lane = input?.lane;
+        absent = reasonOf(input?.engineAbsentReason);
+        probe = input?.probe;
+    }
+    catch {
+        return { ok: false, kind: 'unavailable', cause: 'probe_missing', model };
+    }
+    if (model.length === 0)
+        return { ok: true, probed: false };
+    if (lane === 'unwired')
+        return { ok: false, kind: 'unavailable', cause: 'unwired', model };
+    if (lane === 'mock' || (lane === 'engine_absent' && absent === undefined))
+        return { ok: true, probed: false };
+    if (lane !== 'live' && lane !== 'engine_absent')
+        return { ok: false, kind: 'unavailable', cause: 'unwired', model };
+    let kind;
+    let verdict;
+    let error;
+    try {
+        kind = probe?.kind;
+        verdict = kind === 'verdict' ? probe.verdict : undefined;
+        error = kind === 'threw' ? probe.error : undefined;
+    }
+    catch {
+        kind = undefined;
+    }
+    if (kind === 'threw') {
+        const reason = thrownReason(error);
+        return { ok: false, kind: 'unavailable', cause: 'probe_threw', model, ...(reason !== undefined ? { reason } : {}) };
+    }
+    if (kind !== 'verdict' || verdict === null || typeof verdict !== 'object')
+        return { ok: false, kind: 'unavailable', cause: 'probe_missing', model };
+    let valid;
+    let unchecked;
+    let why;
+    try {
+        valid = verdict.valid;
+        unchecked = verdict.unchecked;
+        why = reasonOf(verdict.error);
+    }
+    catch {
+        return { ok: false, kind: 'unavailable', cause: 'probe_missing', model };
+    }
+    if (valid === true)
+        return { ok: true, probed: lane === 'live' };
+    if (unchecked === true) {
+        const reason = why ?? absent;
+        return { ok: false, kind: 'unavailable', cause: 'unchecked', model, ...(reason !== undefined ? { reason } : {}) };
+    }
+    return { ok: false, kind: 'rejected', model, ...(why !== undefined ? { reason: why } : {}) };
+}
+export async function runModelSwitchProbe(model, ports) {
+    let laneReading;
+    try {
+        const got = await ports.lane();
+        const lane = got?.lane;
+        const why = got?.engineAbsentReason;
+        laneReading = {
+            lane: lane === 'live' || lane === 'mock' || lane === 'engine_absent' || lane === 'unwired' ? lane : 'unwired',
+            ...(typeof why === 'string' ? { engineAbsentReason: why } : {}),
+        };
+    }
+    catch {
+        laneReading = { lane: 'unwired' };
+    }
+    const base = { model, ...laneReading };
+    const pre = modelSwitchProbeOutcomeOf(base);
+    if (pre.ok || (pre.kind === 'unavailable' && pre.cause !== 'probe_missing'))
+        return pre;
+    try {
+        const verdict = await ports.validate(trimmed(model));
+        return modelSwitchProbeOutcomeOf({ ...base, probe: { kind: 'verdict', verdict } });
+    }
+    catch (error) {
+        return modelSwitchProbeOutcomeOf({ ...base, probe: { kind: 'threw', error } });
+    }
+}
+const EMPTY_STREAM_ERROR_CODE = 'stream_torn';
+const LEDGER_SESSION_CAP = 1024;
+function isEmptyStreamFailureFrame(frame) {
+    try {
+        if (frame === null || typeof frame !== 'object' || Array.isArray(frame))
+            return false;
+        if (readFrameStringKey(frame, 'type') !== 'result')
+            return false;
+        if (readOwnDataValue(frame, 'is_error') !== true)
+            return false;
+        return resultErrorCodeOf(frame) === EMPTY_STREAM_ERROR_CODE;
+    }
+    catch {
+        return false;
+    }
+}
+export function createModelSwitchFallbackLedger() {
+    const bySession = new Map();
+    let lastSeq = 0;
+    const drop = (sid) => {
+        if (sid.length > 0)
+            bySession.delete(sid);
+    };
+    return {
+        noteSwitch(input) {
+            let sid = '';
+            let current = '';
+            let previous = '';
+            try {
+                sid = trimmed(input?.sessionId);
+                current = trimmed(input?.to);
+                previous = trimmed(input?.lastServed);
+            }
+            catch {
+                return undefined;
+            }
+            if (sid.length === 0)
+                return undefined;
+            if (current.length === 0 || previous.length === 0 || previous === current) {
+                drop(sid);
+                return undefined;
+            }
+            lastSeq += 1;
+            const rec = Object.freeze({ previous, current, seq: lastSeq });
+            bySession.delete(sid);
+            bySession.set(sid, rec);
+            while (bySession.size > LEDGER_SESSION_CAP) {
+                const oldest = bySession.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                bySession.delete(oldest);
+            }
+            return rec;
+        },
+        peek(sessionId) {
+            const sid = trimmed(sessionId);
+            return sid.length > 0 ? bySession.get(sid) : undefined;
+        },
+        advisoryFor(input) {
+            let frame;
+            let sid = '';
+            let streamModel = '';
+            let served = '';
+            try {
+                frame = input?.frame;
+                sid = trimmed(input?.sessionId);
+                streamModel = trimmed(input?.streamModel);
+                served = trimmed(input?.lastServed);
+            }
+            catch {
+                return undefined;
+            }
+            if (!isEmptyStreamFailureFrame(frame))
+                return undefined;
+            if (sid.length === 0)
+                return undefined;
+            const rec = bySession.get(sid);
+            if (rec === undefined)
+                return undefined;
+            const frameModel = trimmed(resultSelectedModelOf(frame));
+            const candidates = frameModel.length > 0 && frameModel !== streamModel ? [streamModel, frameModel] : [streamModel];
+            for (const c of candidates) {
+                if (c.length === 0 || rec.current !== c)
+                    continue;
+                if (served === c)
+                    return undefined;
+                return rec;
+            }
+            return undefined;
+        },
+        release(sessionId, seq) {
+            const sid = trimmed(sessionId);
+            if (sid.length === 0)
+                return false;
+            const rec = bySession.get(sid);
+            if (rec === undefined || typeof seq !== 'number' || rec.seq !== seq)
+                return false;
+            bySession.delete(sid);
+            return true;
+        },
+        clear(sessionId) {
+            drop(trimmed(sessionId));
+        },
+    };
+}

package/dist/notifications.js

@@ -1,7 +1,9 @@
 import { hostEnv } from './hostEnv.js';
 import { unrefTimer } from './unrefTimer.js';
 import { clearEnginePanelTaskResidentByWire, publishEngineAgentPanelEvent, } from './engineAgentPanelStore.js';
-import { isTaskNotificationTerminalStatus, isTerminalNotSuccess, isTerminalStatus } from './runTerminal.js';
+import { panelEndFact } from './panelReduce.js';
+import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess } from './terminalStatuses.js';
+import { cycleSeqValue } from './cycleOrder.js';
 function escapeXml(v) {
     return v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -130,7 +132,7 @@ export function parseTranscriptNotificationSeeds(messages) {
                     continue;
                 const external = /\btype="external"/.test(attrs);
                 renderedKeys.push(`${external ? 'external:' : ''}${taskId}:${status}`);
-                if (!external && (isTerminalStatus(status) || isTaskNotificationTerminalStatus(status))) {
+                if (!external && isCoreTaskNotificationTerminal(status)) {
                     notifiedKeys.push(taskId);
                 }
                 seeded++;
@@ -316,6 +318,10 @@ const BG_FIRST_SEQ = 1;
 function normalizeBgSeq(seq) {
     return typeof seq === 'number' && Number.isFinite(seq) && seq >= BG_FIRST_SEQ ? Math.floor(seq) : BG_FIRST_SEQ;
 }
+function notificationCycleOf(n) {
+    const cycleSeq = cycleSeqValue(n.seq);
+    return cycleSeq !== undefined ? { cycleSeq } : undefined;
+}
 function bgOutstandingKey(taskId, seq) {
     return `${taskId}:${seq}`;
 }
@@ -570,20 +576,15 @@ export function enqueueBgChildNotification(n) {
         return;
     }
     bgNotifiedKeys.add(key);
-    const terminal = isTaskNotificationTerminalStatus(n.status);
+    const terminal = isCoreTaskNotificationTerminal(n.status);
     if (terminal) {
         markRunNotified(n.taskId, cycle);
         cardEnqueuedRunIds.add(n.taskId);
     }
     if (terminal) {
         try {
-            clearEnginePanelTaskResidentByWire(n.taskId, typeof n.seq === 'number' && Number.isInteger(n.seq) && n.seq >= BG_FIRST_SEQ ? { cycleSeq: n.seq } : undefined);
-            publishEngineAgentPanelEvent({
-                kind: 'end',
-                taskId: n.taskId,
-                isError: isTerminalNotSuccess(n.status),
-                ...(typeof n.seq === 'number' && Number.isInteger(n.seq) && n.seq >= BG_FIRST_SEQ ? { cycleSeq: n.seq } : {}),
-            });
+            clearEnginePanelTaskResidentByWire(n.taskId, notificationCycleOf(n));
+            publishEngineAgentPanelEvent(panelEndFact(n.taskId, isCoreTaskNotificationTerminalNotSuccess(n.status), notificationCycleOf(n)));
         }
         catch {
         }
@@ -667,7 +668,7 @@ export function taskNotificationDeliverySupplement(objective) {
         return `${SUPPLEMENT_LINE_PREFIX}completed — only this notification delivery failed. Check /tasks for the result.`;
     }
     const statusNote = status && status.length > 0 ? ` (status: ${status})` : '';
-    if (isTaskNotificationTerminalStatus(status)) {
+    if (isCoreTaskNotificationTerminal(status)) {
         return `${SUPPLEMENT_LINE_PREFIX}already finished${statusNote} — only this notification delivery failed. Check /tasks for the result.`;
     }
     return `${SUPPLEMENT_LINE_PREFIX}is in a state this client cannot confirm${statusNote} — this notification delivery failed and the task's outcome is unknown here. Check /tasks for its current state.`;

package/dist/outputStyleSeatCapability.d.ts

@@ -0,0 +1,15 @@
+export type OutputStyleSeatReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    value: true;
+};
+export declare function projectOutputStyleSeatCapability(caps: unknown): OutputStyleSeatReading | undefined;
+export declare function noteEngineCapsForOutputStyleSeat(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedOutputStyleSeat(baseUrl?: string | undefined): OutputStyleSeatReading;
+export declare function outputStyleSeatAdmitted(reading: OutputStyleSeatReading | undefined): boolean;
+export declare function __resetOutputStyleSeatReadingsForTests(): void;

package/dist/outputStyleSeatCapability.js

@@ -0,0 +1,42 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
+export function projectOutputStyleSeatCapability(caps) {
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const v = ownDataField(caps, 'outputStyle');
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        return v === true ? { kind: 'present', value: true } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const reader = createEngineCapReader({
+    name: 'outputStyleSeat',
+    project: projectOutputStyleSeatCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForOutputStyleSeat(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedOutputStyleSeat(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function outputStyleSeatAdmitted(reading) {
+    try {
+        if (reading === null || reading === undefined || typeof reading !== 'object' || Array.isArray(reading))
+            return false;
+        if (readOwnDataValue(reading, 'kind') !== 'present')
+            return false;
+        return readOwnDataValue(reading, 'value') === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function __resetOutputStyleSeatReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/ownKey.d.ts

@@ -1,4 +1,11 @@
 export declare function putOwnKey<T>(table: Record<string, T>, key: string, value: T): void;
 export declare function readOwnNonEmptyString(v: object | null | undefined, key: string): string | undefined;
+export declare function readAskOrigin(carrier: object | null | undefined): string | undefined;
 export declare function readOwnDataNonEmptyString(v: object | null | undefined, key: string): string | undefined;
 export declare function readOwnDataValue<T>(v: object | null | undefined, key: string): T | undefined;
+export declare function ownDataField(v: object, key: string): unknown;
+export declare function ownSendableField(v: object, key: string): unknown;
+export declare function ownDataRefusalKeyOf(e: unknown): string | undefined;
+export declare function readFrameStringKey(frame: unknown, key: string): string | undefined;
+export declare function markMcpSectionDroppedNamedRows(rows: object, dropped: ReadonlyMap<string, number>): void;
+export declare function mcpSectionDroppedNamedRowsOf(rows: object | null | undefined, name: string): number;

package/dist/ownKey.js

@@ -7,6 +7,9 @@ export function readOwnNonEmptyString(v, key) {
     const raw = v[key];
     return typeof raw === 'string' && raw !== '' ? raw : undefined;
 }
+export function readAskOrigin(carrier) {
+    return readOwnNonEmptyString(carrier, 'origin');
+}
 export function readOwnDataNonEmptyString(v, key) {
     if (typeof v !== 'object' || v === null)
         return undefined;
@@ -22,3 +25,58 @@ export function readOwnDataValue(v, key) {
     const d = Object.getOwnPropertyDescriptor(v, key);
     return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
 }
+export function ownDataField(v, key) {
+    return ownField(v, key, false);
+}
+export function ownSendableField(v, key) {
+    return ownField(v, key, true);
+}
+export function ownDataRefusalKeyOf(e) {
+    return typeof e === 'object' && e !== null ? REFUSAL_KEYS.get(e) : undefined;
+}
+const REFUSAL_KEYS = new WeakMap();
+function ownField(v, key, sendable) {
+    const d = Object.getOwnPropertyDescriptor(v, key);
+    if (d === undefined)
+        return undefined;
+    if (!Object.hasOwn(d, 'value') || (sendable && d.enumerable !== true)) {
+        const e = new TypeError(`own property "${key}" is not a plain${sendable ? ' enumerable' : ''} data property (accessors are not executed)`);
+        REFUSAL_KEYS.set(e, key);
+        throw e;
+    }
+    return d.value;
+}
+export function readFrameStringKey(frame, key) {
+    try {
+        if (frame === null || typeof frame !== 'object' || Array.isArray(frame))
+            return undefined;
+        return readOwnDataNonEmptyString(frame, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+const DROPPED_NAMED_ROWS = Symbol.for('@sema-agent/client-core/mcpSectionDroppedNamedRows');
+export function markMcpSectionDroppedNamedRows(rows, dropped) {
+    if (dropped.size === 0)
+        return;
+    try {
+        Object.defineProperty(rows, DROPPED_NAMED_ROWS, { value: Object.freeze(new Map(dropped)), enumerable: false, writable: false, configurable: false });
+    }
+    catch {
+    }
+}
+export function mcpSectionDroppedNamedRowsOf(rows, name) {
+    try {
+        if (rows === null || typeof rows !== 'object')
+            return 0;
+        const d = Object.getOwnPropertyDescriptor(rows, DROPPED_NAMED_ROWS);
+        if (d === undefined || !Object.hasOwn(d, 'value') || !(d.value instanceof Map))
+            return 0;
+        const n = d.value.get(name);
+        return typeof n === 'number' && Number.isInteger(n) && n > 0 ? n : 0;
+    }
+    catch {
+        return 0;
+    }
+}