@sema-agent/client-core 0.96.0 → 0.97.0

package/dist/engineCapsCache.js

@@ -1,5 +1,6 @@
 import { settleWithinDeadline } from './abortableSleep.js';
 import { ownDataField } from './ownKey.js';
+const NOT_LANDED = Object.freeze({ kind: 'not_landed' });
 const capsByBase = new Map();
 const inFlight = new Set();
 const settleByBase = new Map();
@@ -13,11 +14,16 @@ export function engineCapsGeneration(baseUrl) {
     return capsGeneration(baseUrl);
 }
 export function engineCapsLandingOf(baseUrl) {
-    return capsByBase.get(baseUrl);
+    if (typeof baseUrl !== 'string' || baseUrl === '')
+        return NOT_LANDED;
+    return capsByBase.get(baseUrl) ?? NOT_LANDED;
 }
 export function kickEngineCapsProbe(baseUrl, probe) {
+    startEngineCapsProbe(baseUrl, probe);
+}
+function startEngineCapsProbe(baseUrl, probe) {
     if (!baseUrl || capsByBase.has(baseUrl) || inFlight.has(baseUrl))
-        return;
+        return false;
     probeByBase.set(baseUrl, probe);
     const gen = capsGeneration(baseUrl);
     inFlight.add(baseUrl);
@@ -35,8 +41,7 @@ export function kickEngineCapsProbe(baseUrl, probe) {
             const caps = await probe();
             if (gen !== capsGeneration(baseUrl))
                 return;
-            if (caps && typeof caps === 'object')
-                landCapsSnapshot(baseUrl, gen, caps);
+            landCapsSnapshot(baseUrl, gen, caps);
         }
         catch {
         }
@@ -49,6 +54,7 @@ export function kickEngineCapsProbe(baseUrl, probe) {
             markSettled();
         }
     })();
+    return true;
 }
 const MAX_WITHIN_MS = 2_147_483_647;
 function waitBudgetOf(opts) {
@@ -118,9 +124,7 @@ export async function engineCapsSettled(baseUrl, opts) {
     }
 }
 export function engineCapState(baseUrl, key) {
-    if (!baseUrl)
-        return 'unprobed';
-    return capStateIn(capsByBase.get(baseUrl)?.caps, key);
+    return stateOfSlot(slotInLanding(engineCapsLandingOf(baseUrl), key));
 }
 const SNAPSHOT_MAX_DEPTH = 64;
 const SNAPSHOT_MAX_NODES = 100_000;
@@ -156,10 +160,16 @@ function throwingAccessor() {
     };
 }
 function landCapsSnapshot(baseUrl, gen, caps) {
+    if (!isPlainCapsBody(caps))
+        return 'not_a_record';
     const snapshot = snapshotCapsBody(caps);
     if (gen !== capsGeneration(baseUrl))
-        return;
-    capsByBase.set(baseUrl, Object.freeze({ caps: snapshot }));
+        return 'superseded';
+    const record = snapshot === UNREADABLE_NODE
+        ? Object.freeze({ kind: 'unreadable' })
+        : Object.freeze({ kind: 'landed', caps: snapshot });
+    capsByBase.set(baseUrl, record);
+    return 'landed';
 }
 function snapshotCapsBody(body) {
     if (body === null || typeof body !== 'object')
@@ -237,8 +247,20 @@ function capSlotIn(caps, key) {
         return SLOT_UNREADABLE;
     }
 }
+function slotInLanding(landing, key) {
+    switch (landing.kind) {
+        case 'not_landed':
+            return SLOT_UNOBSERVED;
+        case 'unreadable':
+            return SLOT_UNREADABLE;
+        case 'landed':
+            return capSlotIn(landing.caps, key);
+    }
+}
 function capStateIn(caps, key) {
-    const slot = capSlotIn(caps, key);
+    return stateOfSlot(capSlotIn(caps, key));
+}
+function stateOfSlot(slot) {
     switch (slot.kind) {
         case 'unobserved':
             return 'unprobed';
@@ -276,7 +298,8 @@ export async function engineCapStateVia(baseUrl, key, probe, opts) {
         try {
             if (signal?.aborted)
                 return 'unprobed';
-            return capStateIn(await probe(signal), key);
+            const body = await probe(signal);
+            return isPlainCapsBody(body) ? capStateIn(body, key) : 'unprobed';
         }
         catch {
             return 'unprobed';
@@ -297,9 +320,7 @@ export function engineCapNestedTrue(baseUrl, parentKey, key) {
     return state.kind === 'value' && state.value === true;
 }
 export function engineCapNestedValue(baseUrl, parentKey, key) {
-    if (!baseUrl)
-        return { kind: 'unobserved' };
-    const parent = capSlotIn(capsByBase.get(baseUrl)?.caps, parentKey);
+    const parent = slotInLanding(engineCapsLandingOf(baseUrl), parentKey);
     if (parent.kind !== 'present')
         return valueStateOfSlot(parent);
     const group = parent.value;
@@ -308,9 +329,7 @@ export function engineCapNestedValue(baseUrl, parentKey, key) {
     return valueStateOfSlot(capSlotIn(group, key));
 }
 export function engineCapValue(baseUrl, key) {
-    if (!baseUrl)
-        return { kind: 'unobserved' };
-    return valueStateOfSlot(capSlotIn(capsByBase.get(baseUrl)?.caps, key));
+    return valueStateOfSlot(slotInLanding(engineCapsLandingOf(baseUrl), key));
 }
 function valueStateOfSlot(slot) {
     switch (slot.kind) {
@@ -325,9 +344,7 @@ function valueStateOfSlot(slot) {
     }
 }
 export function engineCapString(baseUrl, key) {
-    if (!baseUrl)
-        return undefined;
-    const slot = capSlotIn(capsByBase.get(baseUrl)?.caps, key);
+    const slot = slotInLanding(engineCapsLandingOf(baseUrl), key);
     return slot.kind === 'present' && typeof slot.value === 'string' && slot.value.length > 0 ? slot.value : undefined;
 }
 export function invalidateEngineCaps(baseUrl, probe) {
@@ -348,6 +365,19 @@ export function invalidateEngineCaps(baseUrl, probe) {
     if (probe !== undefined)
         kickEngineCapsProbe(baseUrl, probe);
 }
+export function rotateEngineCapsProbe(baseUrl, probe) {
+    try {
+        if (typeof baseUrl !== 'string' || baseUrl === '' || typeof probe !== 'function')
+            return 'ignored';
+        if (startEngineCapsProbe(baseUrl, probe))
+            return 'started';
+        probeByBase.set(baseUrl, probe);
+        return 'registered';
+    }
+    catch {
+        return 'ignored';
+    }
+}
 export async function refreshEngineCapsOnce(baseUrl, opts) {
     try {
         if (typeof baseUrl !== 'string' || baseUrl === '')
@@ -370,10 +400,9 @@ export async function refreshEngineCapsOnce(baseUrl, opts) {
         void (async () => {
             try {
                 const caps = await probe();
-                if (gen !== capsGeneration(baseUrl) || !capsByBase.has(baseUrl) || !isPlainCapsBody(caps))
+                if (gen !== capsGeneration(baseUrl) || !capsByBase.has(baseUrl))
                     return false;
-                landCapsSnapshot(baseUrl, gen, caps);
-                return gen === capsGeneration(baseUrl);
+                return landCapsSnapshot(baseUrl, gen, caps) === 'landed';
             }
             catch {
                 return false;
@@ -393,6 +422,8 @@ function isPlainCapsBody(caps) {
     try {
         if (typeof caps !== 'object' || caps === null)
             return false;
+        if (Array.isArray(caps))
+            return false;
         const proto = Object.getPrototypeOf(caps);
         if (proto !== null && Object.getPrototypeOf(proto) !== null)
             return false;

package/dist/engineErrorCodes.d.ts

@@ -35,6 +35,9 @@ export declare const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = "capability.self_o
 export declare const CAPABILITY_IMAGE_INDEX_REQUIRED = "capability.image_index_required";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
+export declare const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = "conflict.idempotency_payload_mismatch";
+export declare function isIdempotencyPayloadMismatchCode(code: string | null | undefined): boolean;
+export declare function idempotencyPayloadMismatchContent(): string;
 export interface BusyClassification {
     readonly busy: boolean;
     readonly handle: string | null;

package/dist/engineErrorCodes.js

@@ -1,4 +1,5 @@
 import { frozenSet } from './frozenSet.js';
+import { ownDataField } from './ownKey.js';
 import { SDK_DENY_REASON_ROUTING_FAILURE, SDK_RUN_DEATH_VERDICT_CODES, SDK_STATUS_DERIVED_COARSE_CODES } from './generated/sdkFactTables.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
@@ -65,6 +66,13 @@ export const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = 'capability.self_orchestra
 export const CAPABILITY_IMAGE_INDEX_REQUIRED = 'capability.image_index_required';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
+export const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = 'conflict.idempotency_payload_mismatch';
+export function isIdempotencyPayloadMismatchCode(code) {
+    return code === CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH;
+}
+export function idempotencyPayloadMismatchContent() {
+    return 'This request reused an idempotency key that is already bound to a different request body, so the engine refused it and nothing ran · To retry, send exactly the same request again; to send a different request, use a new idempotency key';
+}
 export function classifyActiveRunBusy(input) {
     const handle = typeof input.activeTaskId === 'string' && input.activeTaskId.length > 0 ? input.activeTaskId : null;
     if (input.errorCode === ACTIVE_RUN_BUSY_ERROR_CODE)
@@ -139,7 +147,7 @@ export function refusalSaysStillPending(err) {
 }
 export function refusalRetriableReading(err) {
     try {
-        return Object.hasOwn(err, 'retriable') && err.retriable === true;
+        return ownDataField(err, 'retriable') === true;
     }
     catch {
         return undefined;

package/dist/engineNoticeCodes.js

@@ -1,6 +1,5 @@
 import { AUTO_MODE_UNAVAILABLE_CAUSES } from './autoModeUnavailable.js';
 import { displayUntrusted } from './displayUntrusted.js';
-import { currentEngineWord } from './engineWordRenames.js';
 import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE, CORE_USER_INPUT_UNDRAINED_FAMILIES, } from './generated/engineNoticeTables.js';
 import { CORE_ASK_UNRESOLVABLE_CAUSES, CORE_DURABLE_MANDATE_SOURCES, CORE_PERMISSION_MODE_FOLD_REASONS, } from './generated/engineFactTables.js';
 export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
@@ -9,13 +8,13 @@ function audienceRow(table, code) {
     return Object.hasOwn(table, code) ? table[code] : undefined;
 }
 export function engineNoticeInCatalog(code) {
-    return typeof code === 'string' && (CATALOG.has(code) || CATALOG.has(currentEngineWord(code)));
+    return typeof code === 'string' && CATALOG.has(code);
 }
 export const ENGINE_NOTICE_AUDIENCE = CORE_NOTICE_AUDIENCE;
 export function noticeAudienceOf(code) {
     if (typeof code !== 'string')
         return 'operator';
-    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? audienceRow(ENGINE_NOTICE_AUDIENCE, currentEngineWord(code)) ?? 'operator';
+    return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? 'operator';
 }
 export const MCP_INJECTION_DROP_REASONS = CORE_MCP_INJECTION_DROP_REASONS;
 const DROP_REASONS = new Set(MCP_INJECTION_DROP_REASONS);

package/dist/executionLaneCapability.d.ts

@@ -7,6 +7,8 @@ export interface ExecutionLaneCapabilityView {
 }
 export type ExecutionLaneReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/executionLaneCapability.js

@@ -1,6 +1,6 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectExecutionLaneCapability(caps) {
     try {
@@ -55,7 +55,6 @@ export function projectExecutionLaneWiring(wiring) {
 const reader = createEngineCapReader({
     name: 'executionLane',
     project: projectExecutionLaneCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForExecutionLane(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -98,6 +97,8 @@ export function noOsSandboxContent() {
 const LANE_DETAIL_MAX = 40;
 export function executionLaneDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('execution lane');
         case 'unobserved':
             return ('execution lane not observed — the engine reports it on /v1/capabilities; ' +
                 'this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');

package/dist/fileHistoryCaptureCapability.d.ts

@@ -1,5 +1,7 @@
 export type FileHistoryCaptureReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/fileHistoryCaptureCapability.js

@@ -1,6 +1,6 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { refreshEngineCapsOnce } from './engineCapsCache.js';
 import { ownDataField } from './ownKey.js';
 import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
@@ -22,7 +22,6 @@ export function projectFileHistoryCaptureCapability(caps) {
 const reader = createEngineCapReader({
     name: 'fileHistoryCapture',
     project: projectFileHistoryCaptureCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForFileHistoryCapture(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -64,11 +63,36 @@ export function fileHistoryTightenVerdict(reading, captureOffByUser) {
         return 'already_off';
     return 'unjudged';
 }
-const FILE_HISTORY_UNJUDGED_REFUSAL = 'Nothing was sent: file checkpointing is turned off in your settings, but this engine did not report whether it can ' +
-    'stop recording file history for a session, so sending now could record it anyway. Try again in a moment; to send ' +
-    'regardless and let file history be recorded this time, turn file checkpointing back on in your settings.';
+const FILE_HISTORY_REFUSAL_NOT_YET = "Nothing was sent: file checkpointing is turned off in your settings, but this engine's capabilities have not been read " +
+    'yet, so whether it can stop recording file history for a session is unknown and sending now could record it anyway. ' +
+    'Try again in a moment; to send regardless and let file history be recorded this time, turn file checkpointing back on in your settings.';
+const FILE_HISTORY_REFUSAL_NOT_SAID = 'Nothing was sent: file checkpointing is turned off in your settings, but this engine did not report whether it can ' +
+    'stop recording file history for a session, so sending now could record it anyway. Trying again will not change that ' +
+    'while this engine reports the same; to send and let file history be recorded this time, turn file checkpointing back on in your settings.';
+const FILE_HISTORY_REFUSAL_UNREADABLE = "Nothing was sent: file checkpointing is turned off in your settings, but this engine's report on whether it can stop " +
+    'recording file history for a session could not be read by this client, so sending now could record it anyway. Trying ' +
+    'again will not change that while this engine reports the same; to send and let file history be recorded this time, ' +
+    'turn file checkpointing back on in your settings.';
+function unjudgedRefusalOf(reading) {
+    let kind;
+    let word;
+    try {
+        kind = typeof reading === 'object' && reading !== null ? reading.kind : undefined;
+        word = kind === 'present' ? reading.word : undefined;
+    }
+    catch {
+        return FILE_HISTORY_REFUSAL_NOT_YET;
+    }
+    if (kind === 'unreadable')
+        return FILE_HISTORY_REFUSAL_UNREADABLE;
+    if (kind === 'not_reported')
+        return FILE_HISTORY_REFUSAL_NOT_SAID;
+    if (kind === 'present' && typeof word === 'string' && word.length > 0)
+        return FILE_HISTORY_REFUSAL_NOT_SAID;
+    return FILE_HISTORY_REFUSAL_NOT_YET;
+}
 export function fileHistoryUnjudgedRefusal(reading, captureOffByUser) {
-    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? FILE_HISTORY_UNJUDGED_REFUSAL : undefined;
+    return fileHistoryTightenVerdict(reading, captureOffByUser) === 'unjudged' ? unjudgedRefusalOf(reading) : undefined;
 }
 const FILE_HISTORY_REFRESH_WITHIN_MS = 3000;
 export async function judgeFileHistoryTighten(captureOffByUser, opts) {
@@ -76,7 +100,7 @@ export async function judgeFileHistoryTighten(captureOffByUser, opts) {
     const failClosed = () => {
         const reading = { kind: 'unobserved' };
         return closed
-            ? { verdict: 'unjudged', reading, refreshed: false, refusal: FILE_HISTORY_UNJUDGED_REFUSAL }
+            ? { verdict: 'unjudged', reading, refreshed: false, refusal: FILE_HISTORY_REFUSAL_NOT_YET }
             : { verdict: 'not_requested', reading, refreshed: false, refusal: undefined };
     };
     try {
@@ -115,7 +139,7 @@ export async function judgeFileHistoryTighten(captureOffByUser, opts) {
             verdict: v2,
             reading: second,
             refreshed: outcome !== 'no_probe',
-            refusal: v2 === 'unjudged' ? FILE_HISTORY_UNJUDGED_REFUSAL : undefined,
+            refusal: v2 === 'unjudged' ? unjudgedRefusalOf(second) : undefined,
         };
     }
     catch {
@@ -137,6 +161,8 @@ export function fileHistoryCaptureDoctorDetail(reading) {
         return unobserved;
     }
     switch (kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('file history capture');
         case 'not_reported':
             return 'file history capture not reported by this engine; this does not say whether file history is captured here';
         case 'present':

package/dist/fileHistoryLegNotice.js

@@ -89,6 +89,8 @@ function canonReading(r) {
         const kind = r.kind;
         if (kind === 'not_reported')
             return 'not_reported';
+        if (kind === 'unreadable')
+            return 'unreadable';
         if (kind === 'present') {
             const word = r.word;
             return typeof word === 'string' && word.length > 0 ? `present:${word}` : 'unobserved';
@@ -102,6 +104,8 @@ function canonReading(r) {
 function readingOfCanon(c) {
     if (c === 'not_reported')
         return { kind: 'not_reported' };
+    if (c === 'unreadable')
+        return { kind: 'unreadable' };
     if (c.startsWith('present:'))
         return { kind: 'present', word: c.slice('present:'.length) };
     return { kind: 'unobserved' };