@sema-agent/client-core 0.97.1 → 0.99.0

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,26 @@ 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 interface HumanInputAttachmentView {
+    ordinal: number;
+    kind?: string;
+    outcome: string;
+    label?: string;
+}
+export declare function humanInputAttachmentsOf(frame: {} | null | undefined): HumanInputAttachmentView[] | 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,95 @@ 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 false;
+        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 undefined;
+    }
+}
+const HUMAN_INPUT_ATTACHMENT_ROWS_MAX = 256;
+export function humanInputAttachmentsOf(frame) {
+    try {
+        if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
+            return undefined;
+        const raw = guardedRead(() => readOwnDataValue(frame, 'attachments'));
+        if (!Array.isArray(raw))
+            return undefined;
+        const n = guardedRead(() => readOwnDataFiniteNumber(raw, 'length'));
+        if (n === undefined)
+            return undefined;
+        const rows = [];
+        for (let i = 0; i < Math.min(n, HUMAN_INPUT_ATTACHMENT_ROWS_MAX); i++) {
+            const row = guardedRead(() => {
+                const r = readOwnDataValue(raw, String(i));
+                if (typeof r !== 'object' || r === null || Array.isArray(r))
+                    return undefined;
+                const ordinal = readOwnDataValue(r, 'ordinal');
+                const outcome = readOwnDataNonEmptyString(r, 'outcome');
+                if (typeof ordinal !== 'number' || !Number.isSafeInteger(ordinal) || ordinal < 1 || outcome === undefined)
+                    return undefined;
+                const kind = readOwnDataNonEmptyString(r, 'kind');
+                const label = readOwnDataNonEmptyString(r, 'label');
+                return { ordinal, ...(kind !== undefined ? { kind } : {}), outcome, ...(label !== undefined ? { label } : {}) };
+            });
+            if (row !== undefined)
+                rows.push(row);
+        }
+        return rows.length > 0 ? rows : undefined;
+    }
+    catch {
+        return undefined;
     }
 }
 const DROPPED_NAMED_ROWS = Symbol.for('@sema-agent/client-core/mcpSectionDroppedNamedRows');

package/dist/panelReduce.d.ts

@@ -31,6 +31,11 @@ export type PanelFrame = EngineAgentPanelEvent | {
     kind: 'anchor';
     taskId: string;
     transcriptId: string;
+} | {
+    kind: 'start';
+    taskId: string;
+    startedAt?: number;
+    workflowRunId?: string;
 };
 export interface PanelRowFields {
     name?: string;
@@ -64,6 +69,10 @@ export type PanelDelta = {
     canonicalId: string;
     totalTokens?: number;
     toolUses?: number;
+    final?: {
+        readonly totalTokens?: true;
+        readonly toolUses?: true;
+    };
 } | {
     op: 'terminal';
     canonicalId: string;
@@ -73,25 +82,27 @@ export type PanelDelta = {
 } | {
     op: 'remove';
     canonicalId: string;
+    supersededBy?: string;
 };
 export declare const PANEL_DELTA_OPS: readonly ["upsert", "usage_delta", "terminal", "remove"];
 export interface PanelReduceState {
     readonly __panelReduceState: true;
 }
-export declare const PANEL_REDUCE_STATE_KEYS: readonly ["__panelReduceState", "records", "alias", "pending", "sessions", "overflowed", "counts"];
+export declare const PANEL_REDUCE_STATE_KEYS: readonly ["__panelReduceState", "records", "index", "cards", "pending", "sessions", "overflowed", "counts"];
 export declare function createPanelReduceState(): PanelReduceState;
+export type PanelFact = {
+    readonly ch: 'event';
+    readonly ev: EngineAgentPanelEvent;
+} | {
+    readonly ch: 'absence';
+    readonly absence: EngineAgentPanelAbsence;
+};
 export interface PanelStep {
     readonly state: PanelReduceState;
     readonly deltas: PanelDelta[];
-    readonly facts: Array<{
-        readonly ch: 'event';
-        readonly ev: EngineAgentPanelEvent;
-    } | {
-        readonly ch: 'absence';
-        readonly absence: EngineAgentPanelAbsence;
-    }>;
+    readonly facts: PanelFact[];
 }
-export declare function panelEndFact(taskId: string, isError: boolean, extra?: Pick<EndArm, 'report' | 'cycleSeq' | 'startedAt'>): EndArm;
+export declare function panelEndFact(taskId: string, isError: boolean, extra?: Pick<EndArm, 'report' | 'cycleSeq' | 'startedAt' | 'sessionId'>): EndArm;
 export interface EnginePanelTaskIdentity {
     readonly taskId: string;
     readonly origin: 'fleet-row' | 'wire';
@@ -104,7 +115,7 @@ export declare function reducePanelFrame(state: PanelReduceState, frame: PanelFr
     deltas: PanelDelta[];
 };
 export declare function panelRowSnapshot(state: PanelReduceState): PanelDelta[];
-export declare function panelResolveTaskId(state: PanelReduceState, wireTaskId: string, parentToolCallId?: string): EnginePanelTaskIdentity;
+export declare function panelResolveTaskId(state: PanelReduceState, wireTaskId: string): EnginePanelTaskIdentity;
 export declare function panelIsResident(state: PanelReduceState, taskId: string): boolean;
 export declare function panelAnchorOf(state: PanelReduceState, taskId: string): string | undefined;
 export declare function panelPresenceSize(state: PanelReduceState, sessionKey: string): number;