@sema-agent/client-core 0.84.0 → 0.85.0

package/dist/wireRefusalCopy.d.ts

@@ -23,3 +23,13 @@ export interface DenyAttributionRefusalDetail {
 }
 export declare function denyAttributionRefusalFromError(err: unknown, sentSettledBy: boolean): DenyAttributionRefusalDetail | null;
 export declare function denyAttributionRefusalContent(detail: Pick<DenyAttributionRefusalDetail, 'kind' | 'field'>): string;
+export declare const CONFLICT_SESSION_CHILDREN_ALIVE = "conflict.session_children_alive";
+export type SessionDeleteConflictKind = 'children_alive' | 'active_run' | 'unrecognized';
+export interface SessionDeleteConflictDetail {
+    kind: SessionDeleteConflictKind;
+    code?: string;
+    remaining?: readonly string[];
+    activeTaskId?: string;
+}
+export declare function sessionDeleteConflictFromError(err: unknown): SessionDeleteConflictDetail | null;
+export declare function sessionDeleteConflictContent(detail: Pick<SessionDeleteConflictDetail, 'kind' | 'remaining' | 'activeTaskId'>): string;

package/dist/wireRefusalCopy.js

@@ -1,5 +1,6 @@
-import { readErrorNumber } from './wireFailureShape.js';
-import { USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { capForDisplay } from './fleetTaskDesc.js';
 export const CONFLICT_APPROVAL_SETTLED = 'conflict.approval_settled';
 export const CONFLICT_RUN_NOT_RUNNING = 'conflict.run_not_running';
 function readStringField(o, key) {
@@ -151,3 +152,62 @@ export function denyAttributionRefusalContent(detail) {
         }
     }
 }
+export const CONFLICT_SESSION_CHILDREN_ALIVE = 'conflict.session_children_alive';
+export function sessionDeleteConflictFromError(err) {
+    try {
+        if (err === null || typeof err !== 'object')
+            return null;
+        const o = err;
+        const rawStatus = o.status ?? o.statusCode;
+        const is409 = rawStatus === 409 || (rawStatus === undefined && o.name === 'ConflictError');
+        if (!is409)
+            return null;
+        const code = readStringField(o, 'errorCode');
+        if (code === CONFLICT_SESSION_CHILDREN_ALIVE) {
+            const remaining = readErrorStringList(err, 'remaining')?.filter((id) => id.length > 0);
+            return { kind: 'children_alive', code, ...(remaining !== undefined && remaining.length > 0 ? { remaining: Object.freeze(remaining) } : {}) };
+        }
+        if (code === ACTIVE_RUN_BUSY_ERROR_CODE) {
+            const activeTaskId = readErrorString(err, 'activeTaskId');
+            return { kind: 'active_run', code, ...(activeTaskId !== undefined && activeTaskId.length > 0 ? { activeTaskId } : {}) };
+        }
+        return { kind: 'unrecognized', ...(code !== undefined ? { code } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
+const DELETE_CONFLICT_IDS_SHOWN = 3;
+const DELETE_CONFLICT_ID_MAX = 64;
+function sessionDeleteConflictUnrecognizedContent() {
+    return ('The engine refused to delete this session with a conflict it did not explain · ' +
+        'Check whether the session is still listed and whether anything of it is still running, then try the delete again');
+}
+export function sessionDeleteConflictContent(detail) {
+    try {
+        if (detail === null || typeof detail !== 'object')
+            return sessionDeleteConflictUnrecognizedContent();
+        switch (detail.kind) {
+            case 'children_alive': {
+                const raw = detail.remaining;
+                const ids = Array.isArray(raw) ? raw.filter((id) => typeof id === 'string' && id.length > 0) : [];
+                const shown = ids.slice(0, DELETE_CONFLICT_IDS_SHOWN).map((id) => capForDisplay(id, DELETE_CONFLICT_ID_MAX));
+                const more = ids.length > shown.length ? ` and ${ids.length - shown.length} more` : '';
+                const which = shown.length > 0 ? ` (${shown.join(', ')}${more})` : '';
+                return (`This session was not deleted: background agents it started are still running where this engine cannot stop them${which} · ` +
+                    'Nothing was deleted — delete it again once they finish, or stop them where they run first');
+            }
+            case 'active_run': {
+                const active = detail.activeTaskId;
+                const run = typeof active === 'string' && active.length > 0 ? ` (run ${capForDisplay(active, DELETE_CONFLICT_ID_MAX)})` : '';
+                return (`This session was not deleted: it still has a run in progress${run} · ` +
+                    'Nothing was deleted — cancel that run or let it finish, then delete the session again');
+            }
+            default:
+                return sessionDeleteConflictUnrecognizedContent();
+        }
+    }
+    catch {
+        return sessionDeleteConflictUnrecognizedContent();
+    }
+}