@sema-agent/client-core 0.102.0 → 0.104.0

package/dist/wireFailureShape.d.ts

@@ -23,6 +23,11 @@ export type ThrownExtraReading = {
     readonly state: 'unreadable';
 };
 export declare function readThrownExtra(o: {} | null | undefined): ThrownExtraReading;
+export interface ThrownExtraSnapshot {
+    readonly sdkInstance: boolean;
+    readonly bag: ThrownExtraReading;
+}
+export declare function readThrownExtraSnapshot(o: {} | null | undefined): ThrownExtraSnapshot;
 export declare const PROTOCOL_ERROR_NAME: Readonly<{
     readonly ApprovalBindingMismatchError: "ApprovalBindingMismatchError";
     readonly ApprovalStaleError: "ApprovalStaleError";
@@ -53,7 +58,7 @@ export type ProtocolErrorNameReading = {
 } | {
     readonly state: 'unreadable';
 };
-export declare function protocolErrorNameReading(e: object): ProtocolErrorNameReading;
+export declare function protocolErrorNameReading(e: object, extra?: ThrownExtraSnapshot): ProtocolErrorNameReading;
 export declare function protocolErrorNameOf(e: object): ProtocolErrorName | undefined;
 export type ThrownStatusReading = number | undefined | typeof THROWN_SLOT_UNREADABLE;
 export declare function readThrownStatusSlot(o: object, notePresence?: (presence: SlotPresence) => void): ThrownStatusReading;
@@ -66,6 +71,7 @@ export declare function slotPresenceOf(o: object, key: string): SlotPresence;
 export declare function slotReadOf(o: object, key: string): OwnSlotRead;
 export declare function readErrorNumber(o: object, key: string): number | undefined;
 export declare function readErrorRecord(o: object, key: string): object | undefined;
+export declare function readErrorPresent(o: object, key: string): {} | null | undefined;
 export declare function readErrorString(o: object, key: string): string | undefined;
 export declare function readErrorStringList(o: object, key: string): readonly string[] | undefined;
 export declare function readErrorStrictStringList(o: object, key: string): readonly string[] | undefined;
@@ -106,6 +112,11 @@ export declare function ownFoldedCodeBitsOf(wire: {
     readonly blockedBy?: string;
 } | undefined): FoldedCodeBits;
 export declare function readRefusalField(o: object): string | undefined;
+export interface RefusalSlotReading {
+    readonly word: string | undefined;
+    readonly present: boolean;
+}
+export declare function readRefusalSlots<K extends string>(o: object, keys: readonly K[], bag?: ThrownExtraReading): Readonly<Record<K, RefusalSlotReading>>;
 export declare const REFUSAL_PROBLEMS_READ_MAX = 1000;
 export declare function readRefusalNamedFields(o: object): readonly string[];
 export declare function isDisplayableWireCode(s: string): boolean;

package/dist/wireFailureShape.js

@@ -87,28 +87,38 @@ function isBuiltinErrorPrototype(node) {
     return ['message', 'name', 'toString'].every((k) => Object.getOwnPropertyDescriptor(node, k) !== undefined);
 }
 export function readThrownExtra(o) {
+    return readThrownExtraSnapshot(o).bag;
+}
+export function readThrownExtraSnapshot(o) {
     if (o === null || o === undefined || (typeof o !== 'object' && typeof o !== 'function'))
-        return { state: 'absent' };
+        return { sdkInstance: false, bag: { state: 'absent' } };
+    let at;
+    try {
+        at = extraSlotOf(o);
+    }
+    catch {
+        return { sdkInstance: false, bag: { state: 'unreadable' } };
+    }
+    const sdkInstance = at.kind === 'sdk-class';
+    if (at.kind === 'own-accessor')
+        return { sdkInstance, bag: { state: 'unreadable' } };
+    if (at.kind === 'none')
+        return { sdkInstance, bag: { 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' };
+        return { sdkInstance, bag: { state: 'unreadable' } };
     }
     try {
         if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
-            return { state: 'absent' };
+            return { sdkInstance, bag: { state: 'absent' } };
     }
     catch {
-        return { state: 'unreadable' };
+        return { sdkInstance, bag: { state: 'unreadable' } };
     }
-    return { state: 'object', value: slot };
+    return { sdkInstance, bag: { state: 'object', value: slot } };
 }
 export const PROTOCOL_ERROR_NAME = Object.freeze({
     ApprovalBindingMismatchError: 'ApprovalBindingMismatchError',
@@ -137,11 +147,11 @@ export function isSdkErrorInstance(o) {
         return false;
     }
 }
-export function protocolErrorNameReading(e) {
+export function protocolErrorNameReading(e, extra) {
     if (typeof e !== 'object' || e === null)
         return { state: 'absent' };
     try {
-        if (isSdkErrorInstance(e))
+        if (extra !== undefined ? extra.sdkInstance : isSdkErrorInstance(e))
             return { state: 'sdk-instance' };
         const name = ownDataField(e, 'name');
         return typeof name === 'string' && PROTOCOL_ERROR_NAMES.has(name) ? { state: 'named', name: name } : { state: 'absent' };
@@ -221,6 +231,10 @@ export function readErrorRecord(o, key) {
     const v = readErrorSlot(o, key, (x) => typeof x === 'object' && x !== null && !Array.isArray(x));
     return typeof v === 'object' && v !== null && !Array.isArray(v) ? v : undefined;
 }
+export function readErrorPresent(o, key) {
+    const v = readErrorSlot(o, key, (x) => x !== undefined);
+    return v === undefined ? undefined : v;
+}
 export function readErrorString(o, key) {
     const v = readErrorSlot(o, key, (x) => typeof x === 'string');
     return typeof v === 'string' ? v : undefined;
@@ -396,18 +410,38 @@ export function ownFoldedCodeBitsOf(wire) {
     return Object.freeze({ errorCode: bit('errorCode'), blockedBy: bit('blockedBy') });
 }
 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;
-    }
-    const top = readThrownSlot(o, 'field', 'data');
-    return typeof top === 'string' && top !== '' ? top : undefined;
+    return readRefusalSlots(o, REFUSAL_FIELD_ONLY).field.word;
+}
+const REFUSAL_SLOT_ABSENT = Object.freeze({ word: undefined, present: false });
+const REFUSAL_SLOT_HELD_UNREADABLE = Object.freeze({ word: undefined, present: true });
+const REFUSAL_FIELD_ONLY = Object.freeze(['field']);
+function refusalSlotOf(container, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(container, key);
+        if (d === undefined)
+            return REFUSAL_SLOT_ABSENT;
+        if (!Object.hasOwn(d, 'value'))
+            return REFUSAL_SLOT_HELD_UNREADABLE;
+        const v = d.value;
+        if (v === undefined)
+            return REFUSAL_SLOT_ABSENT;
+        return typeof v === 'string' && v !== '' ? Object.freeze({ word: v, present: true }) : REFUSAL_SLOT_HELD_UNREADABLE;
+    }
+    catch {
+        return REFUSAL_SLOT_HELD_UNREADABLE;
+    }
+}
+export function readRefusalSlots(o, keys, bag = readThrownExtra(o)) {
+    const carrier = isSlotCarrier(o);
+    const out = Object.create(null);
+    for (const key of keys) {
+        const fromBag = bag.state === 'object' ? refusalSlotOf(bag.value, key) : REFUSAL_SLOT_ABSENT;
+        const top = carrier ? refusalSlotOf(o, key) : REFUSAL_SLOT_ABSENT;
+        const word = fromBag.word ?? top.word;
+        const present = bag.state === 'unreadable' || fromBag.present || top.present;
+        out[key] = word === undefined && !present ? REFUSAL_SLOT_ABSENT : Object.freeze({ word, present });
+    }
+    return Object.freeze(out);
 }
 export const REFUSAL_PROBLEMS_READ_MAX = 1000;
 export function readRefusalNamedFields(o) {

package/dist/wireRefusalCopy.d.ts

@@ -126,7 +126,6 @@ export type HookMatcherRefusal = {
     readonly totalMs?: number;
     readonly path?: readonly (string | number)[];
 };
-export declare function hookMatcherRefusalFromError(err: unknown): HookMatcherRefusal | undefined;
 export interface SettingsHooksRefusal {
     readonly reason: string;
     readonly path?: readonly (string | number)[];
@@ -159,11 +158,9 @@ export interface UserAttachmentRefusalDetail {
     readonly path?: string;
 }
 export declare function userAttachmentRefusalFromError(err: {} | null | undefined): UserAttachmentRefusalDetail | null;
-export declare function userAttachmentRefusalContent(detail?: Pick<UserAttachmentRefusalDetail, 'index'>): string;
 export interface UserInvokedSkillRefusalDetail {
     readonly code: typeof USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE;
     readonly retryable: false;
 }
 export declare function userInvokedSkillRefusalFromError(err: {} | null | undefined): UserInvokedSkillRefusalDetail | null;
-export declare function userInvokedSkillRefusalContent(): string;
 export {};

package/dist/wireRefusalCopy.js

@@ -4,7 +4,6 @@ import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_L
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
-import { prepareRefusalNoteOf } from './prepareRefusal.js';
 import { PERMISSION_RULE_ISSUE_CODES, permissionRuleIssueDetail } from './permissionRuleIssue.js';
 import { ruleRefusalListText } from './ruleRefusalSentence.js';
 import { msg, renderMessage } from './i18n/translate.js';
@@ -734,9 +733,6 @@ export function hostPostureRefusalContent(detail, lang) {
     }
 }
 const HOOK_MATCHER_REFUSAL_FIELD = 'settings.hooks';
-export function hookMatcherRefusalFromError(err) {
-    return settingsHooksRefusalFromError(err)?.matcher;
-}
 function hooksRefusalPathOf(detail) {
     try {
         const raw = readOwnDataValue(detail, 'path');
@@ -979,19 +975,6 @@ export function userAttachmentRefusalFromError(err) {
         return null;
     }
 }
-export function userAttachmentRefusalContent(detail) {
-    let index;
-    try {
-        index = detail === undefined || detail === null ? undefined : detail.index;
-    }
-    catch {
-        index = undefined;
-    }
-    return prepareRefusalNoteOf(USER_ATTACHMENT_INVALID_ERROR_CODE, typeof index === 'number' ? { index } : undefined);
-}
 export function userInvokedSkillRefusalFromError(err) {
     return effectiveWireErrorCode(err) === USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE ? { code: USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE, retryable: false } : null;
 }
-export function userInvokedSkillRefusalContent() {
-    return prepareRefusalNoteOf(USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE);
-}