@sema-agent/client-core 0.97.0 → 0.98.0

package/dist/model/modelsPolicy.d.ts

@@ -1,20 +1,15 @@
 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;
 }

package/dist/model/modelsPolicy.js

@@ -34,53 +34,23 @@ function atMentionOf(v) {
         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' };
-        }
+        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 };
         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'));
+            atMention = am === undefined ? { kind: 'unreadable' } : { kind: 'read', value: am };
         }
         return {
             ...(defaultModel !== undefined ? { defaultModel } : {}),
-            ...(defaultUnreadable ? { defaultUnreadable: true } : {}),
             ...(atMention !== undefined ? { atMention } : {}),
         };
     }

package/dist/model/subagentModelWord.d.ts

@@ -0,0 +1,31 @@
+import { type LiveModelCatalog } from '../liveModelCatalog.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
+export type SubagentModelWordKind = 'inherit' | 'catalog' | 'tier' | 'cc-alias' | 'best' | 'model-id' | 'passthrough' | 'catalog-unknown' | 'ambiguous' | 'unbound';
+export type SubagentModelWordProblem = 'tiers-inert' | 'chain-unbound' | 'binding-not-in-catalog';
+export interface SubagentModelLocalEngine {
+    readonly engine: 'started-by-this-process';
+    readonly tiers: Readonly<Record<string, string>> | undefined;
+    readonly pool?: readonly {
+        readonly name: string;
+        readonly id?: string;
+    }[];
+}
+export interface SubagentModelWordInput {
+    readonly word?: string | null | undefined;
+    readonly liveCatalog?: LiveModelCatalog | null | undefined;
+    readonly local?: SubagentModelLocalEngine | null | undefined;
+}
+export interface SubagentModelLanding {
+    readonly name: string;
+    readonly via: readonly string[];
+    readonly source: 'local-config';
+}
+export interface SubagentModelWordReading {
+    readonly kind: SubagentModelWordKind;
+    readonly model?: string;
+    readonly landing?: SubagentModelLanding;
+    readonly problem?: SubagentModelWordProblem;
+    readonly label?: string;
+}
+export declare function resolveSubagentModelWord(input: SubagentModelWordInput | null | undefined): SubagentModelWordReading;
+export declare function subagentModelWordProblemLine(word: string, reading: SubagentModelWordReading, lang?: UiLanguage): string | undefined;

package/dist/model/subagentModelWord.js

@@ -0,0 +1,261 @@
+import { CC_TIER_ALIASES, TIER_ORDER } from './tierVocabulary.js';
+import { liveModelRowsOf } from '../liveModelCatalog.js';
+import { quoteUntrustedForSentence } from '../displayUntrusted.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+const STARTED_BY_THIS_PROCESS = 'started-by-this-process';
+function ownData(v, key) {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const nonEmpty = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+function listOf(v) {
+    try {
+        if (!Array.isArray(v))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const n = ownData(v, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < n; i += 1)
+        out.push(ownData(v, String(i)));
+    return out;
+}
+function catalogFrom(rows) {
+    const names = [];
+    const idToName = new Map();
+    for (const r of rows) {
+        if (!names.includes(r.name))
+            names.push(r.name);
+        if (r.id !== undefined && !idToName.has(r.id))
+            idToName.set(r.id, r.name);
+    }
+    return { names, nameSet: new Set(names), idToName };
+}
+function localOf(input) {
+    const local = ownData(input, 'local');
+    if (local === null || typeof local !== 'object')
+        return undefined;
+    return ownData(local, 'engine') === STARTED_BY_THIS_PROCESS ? local : undefined;
+}
+function catalogOf(input, local) {
+    const live = ownData(input, 'liveCatalog');
+    if (live !== undefined && live !== null) {
+        const rows = typeof live === 'object' ? liveModelRowsOf(live) : null;
+        return rows === null ? undefined : catalogFrom(rows.map((r) => ({ name: r.name, id: r.id })));
+    }
+    if (local === undefined)
+        return undefined;
+    const pool = listOf(ownData(local, 'pool'));
+    if (pool === undefined)
+        return undefined;
+    const rows = [];
+    for (const e of pool) {
+        const name = nonEmpty(ownData(e, 'name'));
+        if (name === undefined)
+            continue;
+        const id = nonEmpty(ownData(e, 'id'));
+        rows.push(id === undefined ? { name } : { name, id });
+    }
+    return catalogFrom(rows);
+}
+function ownSlot(v, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        if (d === undefined)
+            return { kind: 'absent' };
+        return 'value' in d ? { kind: 'value', value: d.value } : { kind: 'unreadable' };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
+function tiersOf(local) {
+    if (local === undefined)
+        return undefined;
+    const slot = ownSlot(local, 'tiers');
+    if (slot.kind !== 'value')
+        return undefined;
+    const raw = slot.value;
+    if (raw === undefined || raw === null)
+        return new Map();
+    if (typeof raw !== 'object')
+        return undefined;
+    try {
+        if (Array.isArray(raw))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const out = new Map();
+    let keys;
+    try {
+        keys = Object.keys(raw);
+    }
+    catch {
+        return undefined;
+    }
+    for (const k of keys) {
+        const b = ownSlot(raw, k);
+        if (b.kind !== 'value' || typeof b.value !== 'string')
+            return undefined;
+        if (b.value.length > 0)
+            out.set(k, b.value);
+    }
+    return out;
+}
+const BUILTIN_VOCAB = [...TIER_ORDER, ...Object.keys(CC_TIER_ALIASES), 'best'];
+function builtinKindOf(w) {
+    if (TIER_ORDER.includes(w))
+        return 'tier';
+    if (Object.hasOwn(CC_TIER_ALIASES, w))
+        return 'cc-alias';
+    return w === 'best' ? 'best' : undefined;
+}
+class BrokenBinding {
+}
+function landingOf(word, kind, tiers, cat) {
+    const ownKey = (k) => cat.nameSet.has(k);
+    const bound = (t) => {
+        const b = tiers.get(t);
+        if (b === undefined)
+            return undefined;
+        if (!cat.nameSet.has(b))
+            throw new BrokenBinding();
+        return b;
+    };
+    const landing = (t, self) => {
+        const b = bound(t);
+        if (b === undefined)
+            return undefined;
+        return { name: b, via: [...(t !== self && !ownKey(t) ? [t] : []), b] };
+    };
+    const resolveTier = (name, self = name) => {
+        const direct = landing(name, self);
+        if (direct !== undefined)
+            return direct;
+        const at = TIER_ORDER.indexOf(name);
+        if (at === -1)
+            return undefined;
+        for (let i = at + 1; i < TIER_ORDER.length; i++) {
+            const next = landing(TIER_ORDER[i], self);
+            if (next !== undefined)
+                return { name: next.name, via: [...(name !== self && !ownKey(name) ? [name] : []), ...next.via] };
+        }
+        return undefined;
+    };
+    if (tiers.has(word) || kind === 'tier')
+        return resolveTier(word);
+    if (kind === 'cc-alias')
+        return resolveTier(CC_TIER_ALIASES[word], word);
+    for (const name of TIER_ORDER) {
+        const r = landing(name, 'best');
+        if (r !== undefined)
+            return r;
+    }
+    return undefined;
+}
+const tierLabelOf = (word, kind) => (kind === 'cc-alias' ? CC_TIER_ALIASES[word] ?? word : word);
+function freezeReading(r) {
+    if (r.landing !== undefined) {
+        Object.freeze(r.landing.via);
+        Object.freeze(r.landing);
+    }
+    return Object.freeze(r);
+}
+function resolveIn(input) {
+    const rawWord = ownData(input, 'word');
+    const word = typeof rawWord === 'string' ? rawWord.trim() : '';
+    if (word === '' || word.toLowerCase() === 'inherit')
+        return freezeReading({ kind: 'inherit' });
+    const local = localOf(input);
+    const cat = catalogOf(input, local);
+    const tiers = tiersOf(local);
+    const customTierKeys = tiers === undefined ? [] : [...tiers.keys()];
+    const tierClass = (w, kind) => {
+        const label = tierLabelOf(w, kind);
+        if (tiers === undefined || cat === undefined)
+            return { kind, model: w, label };
+        if (tiers.size === 0)
+            return { kind: 'unbound', problem: 'tiers-inert', label };
+        let l;
+        try {
+            l = landingOf(w, kind, tiers, cat);
+        }
+        catch (e) {
+            if (e instanceof BrokenBinding)
+                return { kind: 'unbound', problem: 'binding-not-in-catalog', label };
+            throw e;
+        }
+        if (l === undefined)
+            return { kind: 'unbound', problem: 'chain-unbound', label };
+        return { kind, model: w, landing: { name: l.name, via: l.via, source: 'local-config' }, label: `${l.name} (${label})` };
+    };
+    const asCatalog = (name) => ({ kind: 'catalog', model: name, label: name });
+    const classify = (k) => {
+        if (cat?.nameSet.has(k))
+            return asCatalog(k);
+        const b = builtinKindOf(k);
+        return tierClass(k, b ?? 'tier');
+    };
+    if (cat?.nameSet.has(word))
+        return freezeReading(asCatalog(word));
+    const exact = builtinKindOf(word);
+    if (exact !== undefined)
+        return freezeReading(tierClass(word, exact));
+    if (tiers?.has(word))
+        return freezeReading(tierClass(word, 'tier'));
+    const lower = word.toLowerCase();
+    const space = new Set([...(cat?.names ?? []), ...BUILTIN_VOCAB, ...customTierKeys]);
+    const ciMatches = [...space].filter((k) => k.toLowerCase() === lower);
+    if (builtinKindOf(lower) !== undefined) {
+        return freezeReading(ciMatches.length === 1 ? classify(ciMatches[0]) : { kind: 'ambiguous' });
+    }
+    const byId = cat?.idToName.get(word);
+    if (byId !== undefined)
+        return freezeReading({ kind: 'model-id', model: byId, label: byId });
+    if (ciMatches.length === 1)
+        return freezeReading(classify(ciMatches[0]));
+    if (ciMatches.length > 1)
+        return freezeReading({ kind: 'ambiguous' });
+    return freezeReading({ kind: cat === undefined ? 'catalog-unknown' : 'passthrough', model: word, label: word });
+}
+export function resolveSubagentModelWord(input) {
+    try {
+        return resolveIn(input);
+    }
+    catch {
+        const w = ownData(input, 'word');
+        const word = typeof w === 'string' ? w.trim() : '';
+        return freezeReading(word === '' ? { kind: 'inherit' } : { kind: 'catalog-unknown', model: word, label: word });
+    }
+}
+export function subagentModelWordProblemLine(word, reading, lang) {
+    const ref = problemRefOf(word, reading);
+    return ref === undefined ? undefined : renderMessage(ref, lang);
+}
+function problemRefOf(word, reading) {
+    const kind = ownData(reading, 'kind');
+    if (kind !== 'unbound' && kind !== 'ambiguous')
+        return undefined;
+    const quoted = quoteUntrustedForSentence(typeof word === 'string' ? word.trim() : '', 80) ?? '""';
+    if (kind === 'ambiguous')
+        return msg('model.subagent.ambiguous', { word: quoted });
+    const problem = ownData(reading, 'problem');
+    if (problem === 'tiers-inert')
+        return msg('model.subagent.tiersInert', { word: quoted });
+    if (problem === 'binding-not-in-catalog')
+        return msg('model.subagent.bindingNotInCatalog', { word: quoted });
+    return msg('model.subagent.chainUnbound', { word: quoted });
+}

package/dist/notifications.d.ts

@@ -32,6 +32,12 @@ export interface TranscriptNotificationSeeds {
     seeded: number;
 }
 export declare function parseTranscriptNotificationSeeds(messages: ReadonlyArray<unknown>): TranscriptNotificationSeeds;
+export interface TaskNotificationXmlRead {
+    readonly taskId?: string;
+    readonly status?: string;
+    readonly external: boolean;
+}
+export declare function readTaskNotificationXml(xml: string): TaskNotificationXmlRead | undefined;
 export interface QueuedCommandLike {
     mode?: unknown;
     agentId?: unknown;

package/dist/notifications.js

@@ -91,12 +91,6 @@ export function taskNotificationDedupKeyFromWire(n) {
     });
 }
 export function parseTranscriptNotificationSeeds(messages) {
-    const unescape = (s) => s
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/&amp;/g, '&');
     const renderedKeys = [];
     const notifiedKeys = [];
     let seeded = 0;
@@ -116,24 +110,13 @@ export function parseTranscriptNotificationSeeds(messages) {
             }
         }
         for (const text of texts) {
-            if (!text.includes(`<${TASK_NOTIFICATION_TAG}`))
-                continue;
-            const blockRe = new RegExp(`<${TASK_NOTIFICATION_TAG}(\\s[^>]*)?>([\\s\\S]*?)</${TASK_NOTIFICATION_TAG}>`, 'g');
-            for (const bm of text.matchAll(blockRe)) {
-                const attrs = bm[1] ?? '';
-                const body = bm[2] ?? '';
-                const idM = body.match(new RegExp(`<${TASK_ID_TAG}>([\\s\\S]*?)</${TASK_ID_TAG}>`));
-                const stM = body.match(new RegExp(`<${STATUS_TAG}>([\\s\\S]*?)</${STATUS_TAG}>`));
-                if (!idM || !stM)
-                    continue;
-                const taskId = unescape(idM[1] ?? '');
-                const status = unescape(stM[1] ?? '');
-                if (taskId.length === 0 || status.length === 0)
+            for (const block of scanTaskNotificationBlocks(text)) {
+                const read = readTaskNotificationBlock(block);
+                if (read.taskId === undefined || read.status === undefined)
                     continue;
-                const external = /\btype="external"/.test(attrs);
-                renderedKeys.push(`${external ? 'external:' : ''}${taskId}:${status}`);
-                if (!external && isCoreTaskNotificationTerminal(status)) {
-                    notifiedKeys.push(taskId);
+                renderedKeys.push(`${read.external ? 'external:' : ''}${read.taskId}:${read.status}`);
+                if (!read.external && isCoreTaskNotificationTerminal(read.status)) {
+                    notifiedKeys.push(read.taskId);
                 }
                 seeded++;
             }
@@ -141,6 +124,71 @@ export function parseTranscriptNotificationSeeds(messages) {
     }
     return { renderedKeys, notifiedKeys, seeded };
 }
+export function readTaskNotificationXml(xml) {
+    if (typeof xml !== 'string')
+        return undefined;
+    for (const block of scanTaskNotificationBlocks(xml))
+        return readTaskNotificationBlock(block);
+    return undefined;
+}
+function unescapeNotificationXml(s) {
+    return s
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+function* scanTaskNotificationBlocks(text) {
+    const open = `<${TASK_NOTIFICATION_TAG}`;
+    const close = `</${TASK_NOTIFICATION_TAG}>`;
+    let from = 0;
+    for (;;) {
+        const i = text.indexOf(open, from);
+        if (i < 0)
+            return;
+        const after = i + open.length;
+        const c = text.charAt(after);
+        let gt;
+        if (c === '>') {
+            gt = after;
+        }
+        else if (c !== '' && /\s/.test(c)) {
+            gt = text.indexOf('>', after + 1);
+            if (gt < 0)
+                return;
+        }
+        else {
+            from = i + 1;
+            continue;
+        }
+        const end = text.indexOf(close, gt + 1);
+        if (end < 0)
+            return;
+        yield { attrs: c === '>' ? '' : text.slice(after, gt), body: text.slice(gt + 1, end) };
+        from = end + close.length;
+    }
+}
+function firstTagBodyOf(body, tag) {
+    const open = `<${tag}>`;
+    const i = body.indexOf(open);
+    if (i < 0)
+        return undefined;
+    const start = i + open.length;
+    const end = body.indexOf(`</${tag}>`, start);
+    return end < 0 ? undefined : body.slice(start, end);
+}
+function readTaskNotificationBlock(block) {
+    const idRaw = firstTagBodyOf(block.body, TASK_ID_TAG);
+    const statusRaw = firstTagBodyOf(block.body, STATUS_TAG);
+    const taskId = idRaw === undefined ? '' : unescapeNotificationXml(idRaw);
+    const status = statusRaw === undefined ? '' : unescapeNotificationXml(statusRaw);
+    return {
+        ...(taskId.length > 0 ? { taskId } : {}),
+        ...(status.length > 0 ? { status } : {}),
+        external: /\btype="external"/.test(block.attrs),
+    };
+}
 const TASK_NOTIFICATION_TAG = 'task-notification';
 const TASK_ID_TAG = 'task-id';
 const STATUS_TAG = 'status';

package/dist/outputStyleSeatCapability.d.ts

@@ -9,8 +9,5 @@ export type OutputStyleSeatReading = {
     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;

package/dist/outputStyleSeatCapability.js

@@ -18,9 +18,6 @@ const reader = createEngineCapReader({
     name: 'outputStyleSeat',
     project: projectOutputStyleSeatCapability,
 });
-export function noteEngineCapsForOutputStyleSeat(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedOutputStyleSeat(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }

package/dist/ownKey.d.ts

@@ -2,6 +2,7 @@ export declare function putOwnKey<T>(table: Record<string, T>, key: string, valu
 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 readOwnDataFiniteNumber(v: object | null | undefined, key: string): number | undefined;
 export declare function readOwnDataValue<T>(v: object | null | undefined, key: string): T | undefined;
 export declare function guardedRead<T>(read: () => T | undefined): T | undefined;
 export declare function ownDataField(v: object, key: string): unknown;
@@ -9,5 +10,19 @@ 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 readFrameTrueMark(frame: object | null | undefined, key: string): boolean;
+export type FrameTrueMarkReading = 'marked' | 'absent' | 'unreadable';
+export declare function readFrameTrueMarkReading(frame: object | null | undefined, key: string): FrameTrueMarkReading;
+export interface ContextUsageSectionRow {
+    id: string;
+    tokens: number;
+    kind?: string;
+}
+export interface ContextUsageReading {
+    usedTokens?: number;
+    windowTokens?: number;
+    compactAtTokens?: number;
+    sections?: readonly ContextUsageSectionRow[];
+}
+export declare function contextUsageReadingOf(payload: {} | null | undefined): ContextUsageReading | 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

@@ -19,6 +19,15 @@ export function readOwnDataNonEmptyString(v, key) {
     const raw = d.value;
     return typeof raw === 'string' && raw !== '' ? raw : undefined;
 }
+export function readOwnDataFiniteNumber(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    const d = Object.getOwnPropertyDescriptor(v, key);
+    if (d === undefined || !Object.hasOwn(d, 'value'))
+        return undefined;
+    const raw = d.value;
+    return typeof raw === 'number' && Number.isFinite(raw) ? raw : undefined;
+}
 export function readOwnDataValue(v, key) {
     if (typeof v !== 'object' || v === null)
         return undefined;
@@ -65,13 +74,61 @@ export function readFrameStringKey(frame, key) {
     }
 }
 export function readFrameTrueMark(frame, key) {
+    return readFrameTrueMarkReading(frame, key) === 'marked';
+}
+export function readFrameTrueMarkReading(frame, key) {
     try {
         if (frame === null || frame === undefined || typeof frame !== 'object' || Array.isArray(frame))
-            return false;
-        return ownDataField(frame, key) === true;
+            return 'absent';
+        return ownDataField(frame, key) === true ? 'marked' : 'absent';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+const CONTEXT_USAGE_SECTION_ROWS_MAX = 1024;
+function contextUsageSectionRowOf(raw, i) {
+    const row = readOwnDataValue(raw, String(i));
+    if (typeof row !== 'object' || row === null || Array.isArray(row))
+        return undefined;
+    const id = readOwnDataNonEmptyString(row, 'id');
+    const tokens = readOwnDataFiniteNumber(row, 'tokens');
+    if (id === undefined || tokens === undefined)
+        return undefined;
+    const kind = readOwnDataNonEmptyString(row, 'kind');
+    return { id, tokens, ...(kind !== undefined ? { kind } : {}) };
+}
+function contextUsageSectionRowsOf(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const n = Math.min(raw.length, CONTEXT_USAGE_SECTION_ROWS_MAX);
+    const rows = [];
+    for (let i = 0; i < n; i++) {
+        const row = guardedRead(() => contextUsageSectionRowOf(raw, i));
+        if (row !== undefined)
+            rows.push(row);
+    }
+    return rows.length > 0 ? rows : undefined;
+}
+export function contextUsageReadingOf(payload) {
+    try {
+        if (typeof payload !== 'object' || payload === null || Array.isArray(payload))
+            return undefined;
+        const usedTokens = guardedRead(() => readOwnDataFiniteNumber(payload, 'usedTokens'));
+        const windowTokens = guardedRead(() => readOwnDataFiniteNumber(payload, 'windowTokens'));
+        const compactAtTokens = guardedRead(() => readOwnDataFiniteNumber(payload, 'compactAtTokens'));
+        const sections = guardedRead(() => contextUsageSectionRowsOf(readOwnDataValue(payload, 'sections')));
+        if (usedTokens === undefined && windowTokens === undefined && compactAtTokens === undefined && sections === undefined)
+            return undefined;
+        return {
+            ...(usedTokens !== undefined ? { usedTokens } : {}),
+            ...(windowTokens !== undefined ? { windowTokens } : {}),
+            ...(compactAtTokens !== undefined ? { compactAtTokens } : {}),
+            ...(sections !== undefined ? { sections } : {}),
+        };
     }
     catch {
-        return false;
+        return undefined;
     }
 }
 const DROPPED_NAMED_ROWS = Symbol.for('@sema-agent/client-core/mcpSectionDroppedNamedRows');