@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/subagentContentStore.js

@@ -229,8 +229,40 @@ function dropTask(key) {
     totalBytes -= s.bytes;
     tasks.delete(key);
 }
+let subagentIdsReader;
+export function bindSubagentIdentityReader(fn) {
+    subagentIdsReader = fn;
+}
+function sameSubagentIds(id) {
+    let ids;
+    try {
+        ids = subagentIdsReader?.(id);
+    }
+    catch {
+        ids = undefined;
+    }
+    if (ids === undefined)
+        return [id];
+    return ids.includes(id) ? ids : [...ids, id];
+}
+function homeKeyOf(key) {
+    return sameSubagentIds(key).find((id) => tasks.has(id)) ?? key;
+}
+function contentKeyOf(taskId) {
+    const ids = sameSubagentIds(taskId);
+    const direct = ids.find((id) => tasks.has(id));
+    if (direct !== undefined)
+        return direct;
+    for (const id of ids) {
+        const parked = taskToParent.get(id)?.card;
+        if (parked !== undefined && tasks.has(parked))
+            return parked;
+    }
+    return '';
+}
 const parentToTask = new Map();
 const taskToParent = new Map();
+let parentStampSeq = 0;
 let notifyListener = null;
 const pendingNotify = new Set();
 let notifyTimer = null;
@@ -383,7 +415,8 @@ function aliasContentKey(parentToolCallId, taskId) {
 export function registerSubagentAlias(parentToolCallId, taskId) {
     if (!aliasContentKey(parentToolCallId, taskId))
         return;
-    taskToParent.set(taskId, parentToolCallId);
+    if (taskToParent.get(taskId)?.card !== parentToolCallId)
+        taskToParent.set(taskId, { card: parentToolCallId, stamp: ++parentStampSeq });
 }
 function replaySeen(s, ev) {
     const id = ev.eventId;
@@ -459,7 +492,7 @@ function canonicalKey(ev) {
     return parentToTask.get(ev.parentToolCallId) ?? ev.parentToolCallId;
 }
 export function publishSubagentContentEvent(ev) {
-    const key = canonicalKey(ev);
+    const key = homeKeyOf(canonicalKey(ev));
     const s = stateFor(key, ev.parentToolCallId);
     switch (ev.type) {
         case 'text_delta':
@@ -561,15 +594,17 @@ export function publishSubagentContentEvent(ev) {
     scheduleNotify(key);
 }
 export function pushSubagentLocalEcho(taskId, text) {
-    const s = stateFor(taskId, tasks.get(taskId)?.parentToolCallId ?? '');
+    const known = contentKeyOf(taskId);
+    const key = known !== '' ? known : taskId;
+    const s = stateFor(key, tasks.get(key)?.parentToolCallId ?? '');
     flushBuffers(s);
     pushItem(s, { kind: 'echo', text });
     enforceTaskCap(s);
-    enforceTotalCap(taskId);
-    scheduleNotify(taskId);
+    enforceTotalCap(key);
+    scheduleNotify(key);
 }
 export function getSubagentContentSnapshot(taskId) {
-    const key = tasks.has(taskId) ? taskId : (taskToParent.get(taskId) ?? '');
+    const key = contentKeyOf(taskId);
     const s = tasks.get(key);
     if (!s)
         return null;
@@ -615,17 +650,42 @@ export function planSubagentViewSlots(taskId) {
     return out;
 }
 export function parentToolCallIdOf(taskId) {
-    return taskToParent.get(taskId) ?? tasks.get(taskId)?.parentToolCallId;
+    const ids = sameSubagentIds(taskId);
+    let stated;
+    let statedStamp = -1;
+    for (const id of ids) {
+        const hit = taskToParent.get(id);
+        if (hit === undefined)
+            continue;
+        if (stated === undefined || hit.stamp > statedStamp) {
+            stated = hit.card;
+            statedStamp = hit.stamp;
+        }
+    }
+    if (stated !== undefined)
+        return stated;
+    for (const id of ids) {
+        const fromContent = tasks.get(id)?.parentToolCallId;
+        if (fromContent !== undefined)
+            return fromContent;
+    }
+    return undefined;
 }
 export function settleSubagentContent(taskId) {
-    const s = tasks.get(taskId);
+    const key = contentKeyOf(taskId);
+    const s = tasks.get(key);
     if (!s)
         return;
     flushBuffers(s);
-    scheduleNotify(taskId);
+    scheduleNotify(key);
 }
 export function clearSubagentContent(taskId) {
-    dropTask(taskId);
+    for (;;) {
+        const key = contentKeyOf(taskId);
+        if (key === '')
+            return;
+        dropTask(key);
+    }
 }
 const bgFacts = new Map();
 export function recordBgTerminalFacts(taskId, facts) {
@@ -641,10 +701,12 @@ export function recordBgTerminalFacts(taskId, facts) {
     scheduleNotify(taskId);
 }
 export function clearBgTerminalFacts(taskId) {
-    bgFacts.delete(taskId);
+    for (const id of sameSubagentIds(taskId))
+        bgFacts.delete(id);
 }
 export function getBgTerminalFacts(taskId) {
-    const key = bgFacts.has(taskId) ? taskId : (taskToParent.get(taskId) ?? '');
+    const ids = sameSubagentIds(taskId);
+    const key = ids.find((id) => bgFacts.has(id)) ?? ids.map((id) => taskToParent.get(id)?.card).find((c) => c !== undefined) ?? '';
     touchLru(bgFacts, key);
     return bgFacts.get(key);
 }
@@ -665,15 +727,35 @@ export function recordBgParentRun(taskId, runId, sessionId, sessionKey) {
 export function recordSubagentOwner(taskId, runId, sessionId, sessionKey) {
     if (!taskId || typeof runId !== 'string' || runId === '' || taskId === runId)
         return;
-    if (bgParentRun.size >= MAX_BG_PARENT_RUNS && !bgParentRun.has(taskId)) {
+    const ids = sameSubagentIds(taskId);
+    const heldKeys = ids.filter((k) => bgParentRun.has(k));
+    const heldRecs = [];
+    for (const k of heldKeys) {
+        const rec = bgParentRun.get(k);
+        if (rec !== undefined)
+            heldRecs.push(rec);
+    }
+    if (bgParentRun.size >= MAX_BG_PARENT_RUNS && heldKeys.length === 0) {
         const oldest = bgParentRun.keys().next().value;
         if (oldest !== undefined)
             bgParentRun.delete(oldest);
     }
-    const quarantinedRun = conflictQuarantine.get(taskId);
-    if (quarantinedRun !== undefined && quarantinedRun === runId)
+    const quarantinedHere = ids.some((k) => conflictQuarantine.get(k) === runId);
+    if (quarantinedHere)
+        return;
+    const sameRunHeld = heldRecs.filter((r) => r.runId === runId);
+    const heldSlots = new Set(sameRunHeld.map((r) => r.sessionKey ?? DEFAULT_SESSION_KEY));
+    if (sameRunHeld.length > 1 && heldSlots.size > 1) {
+        ownerSessionConflictCount++;
+        const pairOf = (r) => ({
+            ...(r.sessionId !== undefined ? { sessionId: r.sessionId } : {}),
+            ...(r.sessionKey !== undefined ? { sessionKey: r.sessionKey } : {}),
+        });
+        lastOwnerSessionConflict = { taskId, runId, prior: pairOf(sameRunHeld[0]), next: pairOf(sameRunHeld[1]) };
+        quarantineRun(ids, runId);
         return;
-    const prior = bgParentRun.get(taskId);
+    }
+    const prior = heldRecs.find((r) => r.runId === runId) ?? heldRecs[0];
     const sameRun = prior?.runId === runId;
     const incoming = typeof sessionId === 'string' && sessionId !== '' ? sessionId : undefined;
     const incomingKey = typeof sessionKey === 'string' && sessionKey !== '' ? sessionKey : undefined;
@@ -707,16 +789,13 @@ export function recordSubagentOwner(taskId, runId, sessionId, sessionKey) {
         const priorSlot = prior?.sessionKey ?? DEFAULT_SESSION_KEY;
         const nextSlot = nextPair.sessionKey ?? DEFAULT_SESSION_KEY;
         if (priorSlot !== nextSlot) {
-            bgParentRun.delete(taskId);
-            if (conflictQuarantine.size >= MAX_BG_PARENT_RUNS && !conflictQuarantine.has(taskId)) {
-                const oldestQ = conflictQuarantine.keys().next().value;
-                if (oldestQ !== undefined)
-                    conflictQuarantine.delete(oldestQ);
-            }
-            conflictQuarantine.set(taskId, runId);
+            quarantineRun(ids, runId);
             return;
         }
     }
+    for (const k of ids)
+        if (k !== taskId)
+            bgParentRun.delete(k);
     bgParentRun.delete(taskId);
     bgParentRun.set(taskId, { runId, ...nextPair });
 }
@@ -733,14 +812,43 @@ export function recordSubagentOwnerFromProgress(ev, ownerRunId, ownerSessionId,
     recordSubagentOwner(o.taskId, ownerRunId, ownerSessionId, ownerSessionKey);
 }
 export function getBgParentRun(taskId) {
-    touchLru(bgParentRun, taskId);
-    return bgParentRun.get(taskId)?.runId;
+    return getBgParentRunOwner(taskId)?.runId;
 }
 export function getBgParentRunOwner(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return undefined;
-    touchLru(bgParentRun, taskId);
-    return bgParentRun.get(taskId);
+    const live = liveOwnerEntries(sameSubagentIds(taskId));
+    const first = live[0];
+    if (first === undefined)
+        return undefined;
+    if (!live.every(([, rec]) => sameOwnerRecord(rec, first[1])))
+        return undefined;
+    touchLru(bgParentRun, first[0]);
+    return first[1];
+}
+function liveOwnerEntries(ids) {
+    const out = [];
+    for (const k of ids) {
+        const rec = bgParentRun.get(k);
+        if (rec === undefined)
+            continue;
+        if (ids.some((q) => conflictQuarantine.get(q) === rec.runId))
+            continue;
+        out.push([k, rec]);
+    }
+    return out;
+}
+const sameOwnerRecord = (a, b) => a.runId === b.runId && a.sessionId === b.sessionId && a.sessionKey === b.sessionKey;
+function quarantineRun(ids, runId) {
+    for (const k of ids) {
+        bgParentRun.delete(k);
+        if (conflictQuarantine.size >= MAX_BG_PARENT_RUNS && !conflictQuarantine.has(k)) {
+            const oldestQ = conflictQuarantine.keys().next().value;
+            if (oldestQ !== undefined)
+                conflictQuarantine.delete(oldestQ);
+        }
+        conflictQuarantine.set(k, runId);
+    }
 }
 export function __resetSubagentOwnerLedgerForTests() {
     bgParentRun.clear();

package/dist/submitFailure.d.ts

@@ -0,0 +1,8 @@
+import type { SDKAssistantMessageError } from '@sema-agent/agent-types';
+import type { SemaRowKind } from './rowKind.js';
+export interface SubmitFailureClass {
+    readonly kind: Extract<SemaRowKind, 'api_error' | 'model_output_error'>;
+    readonly errorCode?: string;
+    readonly ccError?: SDKAssistantMessageError;
+}
+export declare function classifySubmitFailure(err: {} | null | undefined): SubmitFailureClass;

package/dist/submitFailure.js

@@ -0,0 +1,17 @@
+import { isModelOutputErrorText } from './adapter/runStream.js';
+import { ccErrorOfProviderStatus } from './providerRejection.js';
+import { classifyTurnWireError } from './wireErrorTriage.js';
+export function classifySubmitFailure(err) {
+    const verdict = classifyTurnWireError(err);
+    const status = verdict.kind === 'http' ? verdict.status : undefined;
+    const errorCode = verdict.kind === 'http' && verdict.errorCode !== undefined && verdict.errorCode.length > 0 ? verdict.errorCode : undefined;
+    const text = verdict.kind === 'http' ? verdict.message : verdict.kind === 'transport' || verdict.kind === 'internal' ? verdict.detail : '';
+    const kind = isModelOutputErrorText(text) ? 'model_output_error' : 'api_error';
+    const mapped = status === undefined ? undefined : ccErrorOfProviderStatus(status);
+    const ccError = mapped === 'model_not_found' && errorCode !== undefined ? undefined : mapped;
+    return {
+        kind,
+        ...(errorCode !== undefined ? { errorCode } : {}),
+        ...(ccError !== undefined ? { ccError } : {}),
+    };
+}

package/dist/supportFloor.d.ts

@@ -10,3 +10,4 @@ export type EngineVersionTier = 'engine' | 'legacy' | 'unknown';
 export declare function engineVersionTier(version: unknown, floor?: string): EngineVersionTier;
 export declare function engineSupportFloorEffective(floor?: string): string;
 export declare function coreVersionTier(version: unknown, floor?: string): EngineVersionTier;
+export declare function compareReleaseVersions(a: string, b: string): -1 | 0 | 1 | undefined;

package/dist/supportFloor.js

@@ -51,3 +51,10 @@ export function engineSupportFloorEffective(floor) {
 export function coreVersionTier(version, floor) {
     return judgeAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier').tier;
 }
+export function compareReleaseVersions(a, b) {
+    const ta = releaseTriple(a);
+    const tb = releaseTriple(b);
+    if (ta === undefined || tb === undefined)
+        return undefined;
+    return compareTriple(ta, tb);
+}

package/dist/terminationIntent.d.ts

@@ -0,0 +1,55 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const TERMINATION_INTENT_TTL_MS = 60000;
+export declare const TERMINATION_INTENT_WEAK_SOURCE = "esc-abort";
+export declare const INTERRUPTED_SETTLE_BUDGET_MS = 10000;
+export declare const INTERRUPTED_SETTLE_POLL_MS = 1000;
+export type TerminationIntentSource = string;
+export interface TerminationIntentSnapshot {
+    readonly source: TerminationIntentSource;
+    readonly at: number;
+    readonly abortAt: number | null;
+}
+export interface TerminationIntentLedgerOptions {
+    readonly now: () => number;
+    readonly ttlMs?: number;
+    readonly exemptAbortReasons?: readonly string[];
+}
+export interface TerminationIntentLedger {
+    record(taskId: string | null | undefined, source: TerminationIntentSource): number;
+    snapshot(taskId: string | null | undefined): TerminationIntentSnapshot | null;
+    restoreIf(taskId: string | null | undefined, version: number, snapshot: TerminationIntentSnapshot | null): boolean;
+    rollbackIf(taskId: string | null | undefined, version: number, prior: TerminationIntentSource | null): boolean;
+    rollback(taskId: string | null | undefined, prior: TerminationIntentSource | null): void;
+    wasRecentlyTerminatedByUs(taskId: string | null | undefined): boolean;
+    sourceOf(taskId: string | null | undefined): TerminationIntentSource | null;
+    armOnAbort(signal: AbortSignal | undefined, taskId: string): void;
+    forget(taskId: string | null | undefined): void;
+    size(): number;
+}
+export declare function createTerminationIntentLedger(options: TerminationIntentLedgerOptions): TerminationIntentLedger;
+export type InterruptedRunSettleVerdict = {
+    readonly kind: 'settled';
+    readonly status: string;
+} | {
+    readonly kind: 'still-running';
+    readonly waitedMs: number;
+} | {
+    readonly kind: 'parked';
+    readonly status: string;
+} | {
+    readonly kind: 'unknown';
+};
+export interface InterruptedRunRow {
+    readonly status?: string | null;
+}
+export interface InterruptedRunSettleDeps {
+    readonly getRun?: (taskId: string, opts?: {
+        signal?: AbortSignal;
+    }) => Promise<InterruptedRunRow | null>;
+    readonly signal?: AbortSignal;
+    readonly budgetMs?: number;
+    readonly intervalMs?: number;
+    readonly now?: () => number;
+}
+export declare function awaitInterruptedRunSettle(taskId: string, deps: InterruptedRunSettleDeps): Promise<InterruptedRunSettleVerdict>;
+export declare function interruptedRunSettleRow(taskId: string, verdict: InterruptedRunSettleVerdict, lang?: UiLanguage): string | null;