@sema-agent/client-core 0.94.0 → 0.96.0

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,35 @@ export function readOwnDataValue(v, key) {
     const d = Object.getOwnPropertyDescriptor(v, key);
     return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
 }
+export function guardedRead(read) {
+    try {
+        return read();
+    }
+    catch {
+        return 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 +64,37 @@ export function readFrameStringKey(frame, key) {
         return undefined;
     }
 }
+export function readFrameTrueMark(frame, key) {
+    try {
+        if (frame === null || frame === undefined || typeof frame !== 'object' || Array.isArray(frame))
+            return false;
+        return ownDataField(frame, key) === true;
+    }
+    catch {
+        return false;
+    }
+}
+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 {};