@sema-agent/client-core 0.94.0 → 0.95.0

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

@@ -12,5 +12,4 @@ export declare function noteEngineCapsForOutputStyleSeat(baseUrl: string, caps:
 }): void;
 export declare function observedOutputStyleSeat(baseUrl?: string | undefined): OutputStyleSeatReading;
 export declare function outputStyleSeatAdmitted(reading: OutputStyleSeatReading | undefined): boolean;
-export declare function forgetOutputStyleSeatReading(baseUrl: string | undefined): void;
 export declare function __resetOutputStyleSeatReadingsForTests(): void;

package/dist/outputStyleSeatCapability.js

@@ -1,13 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-import { readOwnDataValue } from './ownKey.js';
+import { ownDataField, readOwnDataValue } from './ownKey.js';
 export function projectOutputStyleSeatCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'outputStyle'))
-            return { kind: 'not_reported' };
-        const v = caps.outputStyle;
+        const v = ownDataField(caps, 'outputStyle');
         if (v === undefined)
             return { kind: 'not_reported' };
         return v === true ? { kind: 'present', value: true } : undefined;
@@ -39,9 +37,6 @@ export function outputStyleSeatAdmitted(reading) {
         return false;
     }
 }
-export function forgetOutputStyleSeatReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetOutputStyleSeatReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/ownKey.d.ts

@@ -1,5 +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,6 +25,27 @@ 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))
@@ -32,3 +56,27 @@ export function readFrameStringKey(frame, key) {
         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;
+    }
+}

package/dist/panelReduce.d.ts

@@ -0,0 +1,114 @@
+import type { EngineAgentPanelAbsence, EngineAgentPanelEvent } from './engineAgentPanelStore.js';
+import type { FleetAgentRowLike } from './fleetAgentRowLike.js';
+import { type EngineAgentPanelCycleIdentity } from './cycleOrder.js';
+export declare function isStaleEngineAgentPanelEnd(end: EngineAgentPanelCycleIdentity | null | undefined, current: EngineAgentPanelCycleIdentity | null | undefined): boolean;
+export declare function isNewEngineAgentPanelCycle(prev: EngineAgentPanelCycleIdentity | null | undefined, next: EngineAgentPanelCycleIdentity | null | undefined): boolean;
+type EndArm = Extract<EngineAgentPanelEvent, {
+    kind: 'end';
+}>;
+export declare const ABSENT_SETTLE_MS = 30000;
+export declare const MAX_HELD_WIRE_TICK_BEATS = 16;
+export type PanelFrame = EngineAgentPanelEvent | {
+    kind: 'fleet-rows';
+    sessionKey: string;
+    rows: readonly FleetAgentRowLike[];
+    nowMs: number;
+} | {
+    kind: 'fleet-rows-reset';
+    sessionKey?: string;
+} | {
+    kind: 'absence';
+    absence: EngineAgentPanelAbsence;
+} | {
+    kind: 'resident';
+    taskId: string;
+    resident: boolean;
+} | {
+    kind: 'resident-clear-wire';
+    taskId: string;
+    cycle?: EngineAgentPanelCycleIdentity;
+} | {
+    kind: 'anchor';
+    taskId: string;
+    transcriptId: string;
+};
+export interface PanelRowFields {
+    name?: string;
+    description?: string;
+    prompt?: string;
+    currentAction?: string;
+    spawnName?: string;
+    currentTool?: {
+        toolName: string;
+        target?: string;
+    };
+    transcriptId?: string;
+    parentToolCallId?: string;
+    startedAt?: number;
+    cycleSeq?: number;
+    wireTaskId?: string;
+    taskIdOrigin?: 'fleet-row' | 'wire';
+    absence?: {
+        lastSeenAtMs: number;
+        absentForMs: number;
+    } | null;
+}
+export type PanelDelta = {
+    op: 'upsert';
+    canonicalId: string;
+    created?: true;
+    revived?: true;
+    fields: PanelRowFields;
+} | {
+    op: 'usage_delta';
+    canonicalId: string;
+    totalTokens?: number;
+    toolUses?: number;
+} | {
+    op: 'terminal';
+    canonicalId: string;
+    isError: boolean;
+    report?: string;
+    cause: 'end' | 'sweep';
+} | {
+    op: 'remove';
+    canonicalId: 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 function createPanelReduceState(): PanelReduceState;
+export interface PanelStep {
+    readonly state: PanelReduceState;
+    readonly deltas: PanelDelta[];
+    readonly facts: Array<{
+        readonly ch: 'event';
+        readonly ev: EngineAgentPanelEvent;
+    } | {
+        readonly ch: 'absence';
+        readonly absence: EngineAgentPanelAbsence;
+    }>;
+}
+export declare function panelEndFact(taskId: string, isError: boolean, extra?: Pick<EndArm, 'report' | 'cycleSeq' | 'startedAt'>): EndArm;
+export interface EnginePanelTaskIdentity {
+    readonly taskId: string;
+    readonly origin: 'fleet-row' | 'wire';
+    readonly cycleSeq?: number;
+    readonly startedAt?: number;
+}
+export declare function stepPanelFrame(state: PanelReduceState, frame: PanelFrame): PanelStep;
+export declare function reducePanelFrame(state: PanelReduceState, frame: PanelFrame): {
+    state: PanelReduceState;
+    deltas: PanelDelta[];
+};
+export declare function panelRowSnapshot(state: PanelReduceState): PanelDelta[];
+export declare function panelResolveTaskId(state: PanelReduceState, wireTaskId: string, parentToolCallId?: 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;
+export declare function panelClearIdentity(state: PanelReduceState): PanelReduceState;
+export declare function panelClearAnchors(state: PanelReduceState): PanelReduceState;
+export declare function panelClearRows(state: PanelReduceState): PanelReduceState;
+export {};