@sema-agent/client-core 0.95.0 → 0.97.0

package/dist/wireFailureShape.js

@@ -1,6 +1,12 @@
+import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
 export const THROWN_SLOT_UNREADABLE = Symbol('thrown-slot-unreadable');
 export function readThrownSlot(o, key, own = false) {
     try {
+        if (own === 'data') {
+            if (o === null || o === undefined)
+                return THROWN_SLOT_UNREADABLE;
+            return typeof o === 'object' || typeof o === 'function' ? ownDataField(o, key) : undefined;
+        }
         if (own && !Object.hasOwn(o, key))
             return undefined;
         return o[key];
@@ -21,34 +27,95 @@ export function thrownIsInstanceOf(e, cls) {
         return false;
     }
 }
+const EXTRA_KEY = 'extra';
+const EXTRA_CHAIN_DEPTH_MAX = 64;
+function extraSlotOf(o) {
+    let node = o;
+    for (let depth = 0; node !== null; depth++) {
+        if (depth > EXTRA_CHAIN_DEPTH_MAX)
+            throw new RangeError('prototype chain too deep to read');
+        const d = Object.getOwnPropertyDescriptor(node, EXTRA_KEY);
+        if (d !== undefined) {
+            const isData = Object.hasOwn(d, 'value');
+            if (node === o)
+                return isData ? { kind: 'own-data', value: d.value } : { kind: 'own-accessor' };
+            return !isData && typeof d.get === 'function' && isSdkErrorClassPrototype(node) ? { kind: 'sdk-class' } : { kind: 'none' };
+        }
+        node = Object.getPrototypeOf(node);
+    }
+    return { kind: 'none' };
+}
+function isSdkErrorClassPrototype(holder) {
+    if (holder === Object.prototype || !isClassPrototype(holder))
+        return false;
+    let node = Object.getPrototypeOf(holder);
+    for (let depth = 0; node !== null; depth++) {
+        if (depth > EXTRA_CHAIN_DEPTH_MAX)
+            throw new RangeError('prototype chain too deep to read');
+        if (isBuiltinErrorPrototype(node))
+            return true;
+        node = Object.getPrototypeOf(node);
+    }
+    return false;
+}
+function classConstructorOf(node) {
+    const ctor = Object.getOwnPropertyDescriptor(node, 'constructor');
+    if (ctor === undefined || !Object.hasOwn(ctor, 'value') || typeof ctor.value !== 'function')
+        return undefined;
+    const fn = ctor.value;
+    const p = Object.getOwnPropertyDescriptor(fn, 'prototype');
+    return p !== undefined && Object.hasOwn(p, 'value') && p.value === node ? fn : undefined;
+}
+function isClassPrototype(node) {
+    return classConstructorOf(node) !== undefined;
+}
+const BUILTIN_ERROR_SOURCE = /^function Error\(\)\s*\{\s*\[native code\]\s*\}$/;
+function isBuiltinErrorPrototype(node) {
+    const fn = classConstructorOf(node);
+    if (fn === undefined)
+        return false;
+    const n = Object.getOwnPropertyDescriptor(fn, 'name');
+    if (n === undefined || !Object.hasOwn(n, 'value') || n.value !== 'Error')
+        return false;
+    if (!BUILTIN_ERROR_SOURCE.test(Function.prototype.toString.call(fn)))
+        return false;
+    return ['message', 'name', 'toString'].every((k) => Object.getOwnPropertyDescriptor(node, k) !== undefined);
+}
+export function readThrownExtra(o) {
+    if (o === null || o === undefined || (typeof o !== 'object' && typeof o !== 'function'))
+        return { state: 'absent' };
+    let slot;
+    try {
+        const at = extraSlotOf(o);
+        if (at.kind === 'own-accessor')
+            return { state: 'unreadable' };
+        if (at.kind === 'none')
+            return { state: 'absent' };
+        slot = at.kind === 'own-data' ? at.value : Reflect.get(o, EXTRA_KEY);
+    }
+    catch {
+        return { state: 'unreadable' };
+    }
+    try {
+        if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
+            return { state: 'absent' };
+    }
+    catch {
+        return { state: 'unreadable' };
+    }
+    return { state: 'object', value: slot };
+}
 function readErrorSlot(obj, key, accept) {
     try {
-        const o = obj;
-        let top;
-        try {
-            top = o[key];
-        }
-        catch {
-            top = undefined;
-        }
+        const topRaw = readThrownSlot(obj, key, 'data');
+        const top = topRaw === THROWN_SLOT_UNREADABLE ? undefined : topRaw;
         if (accept(top))
             return top;
-        let extra;
-        try {
-            extra = o['extra'];
-        }
-        catch {
-            extra = undefined;
-        }
-        if (typeof extra !== 'object' || extra === null || Array.isArray(extra))
+        const reading = readThrownExtra(obj);
+        if (reading.state !== 'object')
             return undefined;
-        let fromExtra;
-        try {
-            fromExtra = Object.hasOwn(extra, key) ? extra[key] : undefined;
-        }
-        catch {
-            fromExtra = undefined;
-        }
+        const extra = reading.value;
+        const fromExtra = guardedRead(() => readOwnDataValue(extra, key));
         return accept(fromExtra) ? fromExtra : undefined;
     }
     catch {
@@ -98,28 +165,25 @@ export function readErrorStrictStringList(o, key) {
         return undefined;
     }
 }
+export const WIRE_FAILURE_UNRENDERABLE_TEXT = 'the call failed with an error this client could not render';
+function userFacingReasonOf(e, ownMessage) {
+    if (ownMessage !== undefined)
+        return ownMessage;
+    if (typeof e === 'string')
+        return e !== '' ? e : WIRE_FAILURE_UNRENDERABLE_TEXT;
+    if (typeof e === 'number' || typeof e === 'boolean' || typeof e === 'bigint')
+        return String(e);
+    return WIRE_FAILURE_UNRENDERABLE_TEXT;
+}
 export function wireFailureShapeOf(e) {
     const o = e ?? {};
     const status = readGuarded(o, 'status');
     const errorCode = readGuarded(o, 'errorCode');
     const rawMessage = readGuarded(o, 'message');
     const retryAfterMs = readGuarded(o, 'retryAfterMs');
-    let extra;
-    let extraUnreadable = false;
-    try {
-        extra = o['extra'];
-    }
-    catch {
-        extraUnreadable = true;
-    }
-    let extraObj;
-    try {
-        extraObj = typeof extra === 'object' && extra !== null && !Array.isArray(extra) ? extra : undefined;
-    }
-    catch {
-        extraObj = undefined;
-        extraUnreadable = true;
-    }
+    const extraReading = readThrownExtra(e);
+    let extraUnreadable = extraReading.state === 'unreadable';
+    const extraObj = extraReading.state === 'object' ? extraReading.value : undefined;
     let committedPresent = false;
     let committedRaw;
     if (extraObj !== undefined) {
@@ -156,13 +220,7 @@ export function wireFailureShapeOf(e) {
     const bodyVerdict = ownString('verdict');
     const bodyCurrentName = ownString('currentName');
     const ownMessage = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : undefined;
-    let message;
-    try {
-        message = ownMessage !== undefined ? ownMessage : String(e);
-    }
-    catch {
-        message = WIRE_FAILURE_UNRENDERABLE_TEXT;
-    }
+    const message = userFacingReasonOf(e, ownMessage);
     const sec = typeof retryAfterMs === 'number' && Number.isFinite(retryAfterMs) && retryAfterMs >= 0
         ? Math.ceil(retryAfterMs / 1000)
         : undefined;
@@ -183,12 +241,10 @@ export function wireFailureShapeOf(e) {
         ...(bodyVerdict !== undefined ? { bodyVerdict } : {}),
         ...(bodyCurrentName !== undefined ? { bodyCurrentName } : {}),
         message,
-        ...(ownMessage !== undefined ? { ownMessage } : {}),
     };
 }
-export const WIRE_FAILURE_UNRENDERABLE_TEXT = 'the call failed with an error this client could not render';
 export function wireFailureTextsOf(e) {
-    const { ownMessage } = wireFailureShapeOf(e);
+    const { message } = wireFailureShapeOf(e);
     let log;
     try {
         log = String(e).slice(0, 300);
@@ -196,34 +252,34 @@ export function wireFailureTextsOf(e) {
     catch {
         log = '<unprintable thrown value>';
     }
-    if (ownMessage !== undefined)
-        return { reason: ownMessage, log };
-    if (typeof e === 'string')
-        return { reason: e !== '' ? e : WIRE_FAILURE_UNRENDERABLE_TEXT, log };
-    if (typeof e === 'number' || typeof e === 'boolean' || typeof e === 'bigint')
-        return { reason: String(e), log };
-    return { reason: WIRE_FAILURE_UNRENDERABLE_TEXT, log };
+    return { reason: message, log };
 }
-export function readRefusalField(o) {
-    const str = (rec) => {
-        let v;
-        try {
-            v = rec.field;
-        }
-        catch {
-            return undefined;
-        }
-        return typeof v === 'string' && v !== '' ? v : undefined;
-    };
-    let extra;
+export function readBlockedBy(o) {
+    const judge = (v) => (typeof v === 'string' && v.length > 0 ? { kind: 'named', code: v } : { kind: 'unreadable' });
     try {
-        extra = o.extra;
+        const top = o['blockedBy'];
+        if (top !== undefined)
+            return judge(top);
+        const reading = readThrownExtra(o);
+        if (reading.state === 'unreadable')
+            return { kind: 'unreadable' };
+        if (reading.state === 'object' && Object.hasOwn(reading.value, 'blockedBy')) {
+            return judge(reading.value['blockedBy']);
+        }
+        return { kind: 'absent' };
     }
     catch {
-        extra = undefined;
+        return { kind: 'unreadable' };
     }
-    if (typeof extra === 'object' && extra !== null && !Array.isArray(extra)) {
-        const fromExtra = str(extra);
+}
+export function readRefusalField(o) {
+    const str = (rec) => {
+        const v = guardedRead(() => readOwnDataValue(rec, 'field'));
+        return typeof v === 'string' && v !== '' ? v : undefined;
+    };
+    const reading = readThrownExtra(o);
+    if (reading.state === 'object') {
+        const fromExtra = str(reading.value);
         if (fromExtra !== undefined)
             return fromExtra;
     }

package/dist/workflowsJournalCapability.d.ts

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

package/dist/workflowsJournalCapability.js

@@ -1,5 +1,5 @@
 import { engineWireTarget } from './engineWireTarget.js';
-import { createEngineCapReader } from './engineCapReader.js';
+import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectWorkflowsJournalCapability(caps) {
     try {
@@ -19,7 +19,6 @@ export function projectWorkflowsJournalCapability(caps) {
 const reader = createEngineCapReader({
     name: 'workflowsJournal',
     project: projectWorkflowsJournalCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForWorkflowsJournal(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -36,6 +35,8 @@ export function workflowsJournalAvailable(reading) {
 }
 export function workflowsJournalDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('workflow journal');
         case 'unobserved':
             return 'workflow journal not observed — the engine reports it on /v1/capabilities (workflowsJournal); 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)';
         case 'not_reported':

package/dist/writeProtectionCapability.d.ts

@@ -3,6 +3,8 @@ export interface WriteProtectionCapabilityView extends Pick<WriteProtectionCapab
 }
 export type WriteProtectionReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/writeProtectionCapability.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 projectWriteProtectionCapability(caps) {
     try {
@@ -65,7 +65,6 @@ export function projectWriteProtectionPosture(wiring) {
 const reader = createEngineCapReader({
     name: 'writeProtection',
     project: projectWriteProtectionCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForWriteProtection(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -76,6 +75,8 @@ export function observedWriteProtection(baseUrl = engineWireTarget()?.baseUrl) {
 const WP_DETAIL_MAX = 40;
 export function writeProtectionDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail();
         case 'unobserved':
             return ('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)');