@sema-agent/client-core 0.95.0 → 0.97.0

package/dist/toolResult.js

@@ -4,6 +4,7 @@ import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
 import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
+import { readFrameTrueMark } from './ownKey.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
@@ -276,6 +277,58 @@ export const TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT = 'wire_carried_no_output';
 export function degradedToolResultBody(isError) {
     return { content: '', isError, degraded: TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT };
 }
+const TOOL_CARD_DEGRADED_TEXT = {
+    'not-executed': 'This tool call did not run: the engine closed it without executing it.',
+    'error-without-detail': 'This tool call reported an error but returned no details.',
+    'no-result': 'No result was reported for this tool call, so whether it ran and what it did is not shown here — check before running it again.',
+    unrecognised: 'This tool call carries a result marker this client does not recognise, so no result is shown for it.',
+};
+const cardDegraded = (cause) => ({ kind: 'degraded', cause, text: TOOL_CARD_DEGRADED_TEXT[cause] });
+function cardOwnData(o, key) {
+    const d = Object.getOwnPropertyDescriptor(o, key);
+    if (d === undefined)
+        return undefined;
+    if (!Object.hasOwn(d, 'value'))
+        throw new TypeError(`own property "${key}" is an accessor`);
+    return d.value;
+}
+const isCardRecordObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function toolResultBlockOf(record) {
+    const message = cardOwnData(record, 'message');
+    if (!isCardRecordObject(message))
+        return undefined;
+    const content = cardOwnData(message, 'content');
+    if (!Array.isArray(content))
+        return undefined;
+    for (let i = 0; i < content.length; i++) {
+        const block = cardOwnData(content, String(i));
+        if (isCardRecordObject(block) && cardOwnData(block, 'type') === 'tool_result')
+            return block;
+    }
+    return undefined;
+}
+export function readToolCardOutcome(record) {
+    try {
+        if (!isCardRecordObject(record))
+            return { kind: 'unreadable' };
+        const block = toolResultBlockOf(record);
+        if (block === undefined)
+            return { kind: 'unreadable' };
+        if (readFrameTrueMark(record, '_sema_not_executed'))
+            return cardDegraded('not-executed');
+        const markerDesc = Object.getOwnPropertyDescriptor(record, '_sema_degraded');
+        if (markerDesc === undefined)
+            return { kind: 'normal' };
+        if (!Object.hasOwn(markerDesc, 'value'))
+            return { kind: 'unreadable' };
+        if (markerDesc.value !== TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT)
+            return cardDegraded('unrecognised');
+        return cardDegraded(cardOwnData(block, 'is_error') === true ? 'error-without-detail' : 'no-result');
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+}
 export function wireOutputToBody(toolName, output, isError, truncated, flatten, structured, leaderLedger = true) {
     const text = flatten(output);
     const name = (toolName || '').toLowerCase();
@@ -355,8 +408,9 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
         const body = truncated ? `${text}\n…(truncated)` : text;
         const parsed = parseModelFacingTaskOutput(text);
         const wrap = (task) => ({
-            content: { retrieval_status: 'success', task },
+            content: body,
             isError,
+            toolUseResult: { retrieval_status: 'success', task },
         });
         if (parsed.kind === 'agent') {
             return wrap({

package/dist/toolResultContent.d.ts

@@ -0,0 +1,2 @@
+export declare function toolResultBlocksOf(output: unknown, truncated: boolean): unknown[] | undefined;
+export declare function toolEndOutputText(output: unknown): string | undefined;

package/dist/toolResultContent.js

@@ -0,0 +1,63 @@
+const IMAGE_MEDIA_TYPES = Object.freeze(['image/jpeg', 'image/png', 'image/gif', 'image/webp']);
+const OMITTED_CONTENT_NOTE = '[unsupported content omitted]';
+const IMAGE_TEXT_PLACEHOLDER = '[image]';
+function blockOf(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const b = raw;
+    if (b.type === 'text')
+        return typeof b.text === 'string' ? { type: 'text', text: b.text } : null;
+    if (b.type !== 'image')
+        return null;
+    const data = b.data;
+    const mediaType = b.mimeType;
+    if (typeof data !== 'string')
+        return null;
+    if (typeof mediaType !== 'string' || !IMAGE_MEDIA_TYPES.includes(mediaType))
+        return null;
+    return { type: 'image', source: { type: 'base64', media_type: mediaType, data } };
+}
+const TRUNCATED_NOTE = '…(truncated)';
+function toolResultContentOf(output) {
+    if (typeof output === 'string')
+        return output;
+    if (!Array.isArray(output))
+        return undefined;
+    const blocks = [];
+    let omitted = 0;
+    let images = 0;
+    for (const raw of output) {
+        const block = blockOf(raw);
+        if (block === null)
+            omitted++;
+        else {
+            if (block.type === 'image')
+                images++;
+            blocks.push(block);
+        }
+    }
+    if (images === 0 && omitted === 0)
+        return blocks.map((b) => b.text).join('');
+    if (omitted > 0)
+        blocks.push({ type: 'text', text: OMITTED_CONTENT_NOTE });
+    return blocks;
+}
+export function toolResultBlocksOf(output, truncated) {
+    const content = toolResultContentOf(output);
+    if (!Array.isArray(content))
+        return undefined;
+    if (truncated)
+        content.push({ type: 'text', text: TRUNCATED_NOTE });
+    return content;
+}
+export function toolEndOutputText(output) {
+    const content = toolResultContentOf(output);
+    if (content === undefined || typeof content === 'string')
+        return content;
+    return content
+        .map((b) => {
+        const block = b;
+        return block.type === 'image' ? IMAGE_TEXT_PLACEHOLDER : (block.text ?? '');
+    })
+        .join('');
+}

package/dist/usageAnalytics.js

@@ -75,7 +75,7 @@ export function projectUsageSeries(body) {
         const points = [];
         let unreadable = 0;
         for (const raw of series) {
-            if (!isRecord(raw) || !nonEmpty(raw.t) || !nonNeg(raw.v)) {
+            if (!isRecord(raw) || typeof raw.t !== 'string' || usageInstantOf(raw.t) === undefined || !nonNeg(raw.v)) {
                 unreadable++;
                 continue;
             }
@@ -180,31 +180,55 @@ function unavailableCauseOf(v) {
 function modelsUnavailable(cause) {
     return { state: 'unavailable', cause, sentence: cause === 'no_backend_face' ? USAGE_SENTENCES.modelsUnavailable : USAGE_SENTENCES.modelsUnread };
 }
-const DAY_KEY_RE = /^(\d{4})-(\d{2})-(\d{2})(?:[T ]|$)/;
-function dayKeyOf(iso) {
-    const m = DAY_KEY_RE.exec(iso);
+const USAGE_TS_RE = /^(\d{4})-(\d{2})-(\d{2})(?:[Tt ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?([Zz]|[+-]\d{2}:?\d{2}))?$/;
+const OFFSET_RE = /^([+-])(\d{2}):?(\d{2})$/;
+function usageInstantOf(t) {
+    if (typeof t !== 'string')
+        return undefined;
+    const m = USAGE_TS_RE.exec(t);
     if (m === null)
         return undefined;
     const y = Number(m[1]);
     const mo = Number(m[2]);
     const d = Number(m[3]);
-    const at = new Date(Date.UTC(y, mo - 1, d));
-    return at.getUTCFullYear() === y && at.getUTCMonth() === mo - 1 && at.getUTCDate() === d ? iso.slice(0, 10) : undefined;
+    const date = new Date(Date.UTC(y, mo - 1, d));
+    if (date.getUTCFullYear() !== y || date.getUTCMonth() !== mo - 1 || date.getUTCDate() !== d)
+        return undefined;
+    if (m[4] === undefined)
+        return { dayKey: t.slice(0, 10), hourUtc: 0 };
+    const hh = Number(m[4]);
+    const mi = Number(m[5]);
+    const ss = m[6] === undefined ? 0 : Number(m[6]);
+    if (hh > 23 || mi > 59 || ss > 59)
+        return undefined;
+    let offsetMin = 0;
+    const zone = m[7];
+    if (zone !== 'Z' && zone !== 'z') {
+        const o = OFFSET_RE.exec(zone);
+        if (o === null)
+            return undefined;
+        const oh = Number(o[2]);
+        const om = Number(o[3]);
+        if (oh > 23 || om > 59)
+            return undefined;
+        offsetMin = (o[1] === '-' ? -1 : 1) * (oh * 60 + om);
+    }
+    const at = new Date(date.getTime() + ((hh * 60 + mi - offsetMin) * 60 + ss) * 1000);
+    const iso = at.toISOString();
+    if (!/^\d{4}-/.test(iso))
+        return undefined;
+    return { dayKey: iso.slice(0, 10), hourUtc: at.getUTCHours() };
 }
 const isWhole = (v) => v.unreadable === 0 && !v.truncated;
-function hourOfDayUtc(iso) {
-    const d = new Date(iso);
-    return Number.isNaN(d.getTime()) ? undefined : d.getUTCHours();
-}
 function peakHourOf(points) {
     if (points.length === 0)
         return undefined;
     const perHour = new Array(24).fill(0);
     for (const p of points) {
-        const h = hourOfDayUtc(p.t);
-        if (h === undefined)
+        const at = usageInstantOf(p.t);
+        if (at === undefined)
             return undefined;
-        perHour[h] = (perHour[h] ?? 0) + p.v;
+        perHour[at.hourUtc] = (perHour[at.hourUtc] ?? 0) + p.v;
     }
     let peakHour = -1;
     let peakValue = -1;
@@ -262,11 +286,11 @@ export function projectUsageAnalytics(inputs, window) {
         const dayValues = new Map();
         let allKeysReadable = true;
         for (const p of day.value.points) {
-            const key = dayKeyOf(p.t);
-            if (key === undefined)
+            const at = usageInstantOf(p.t);
+            if (at === undefined)
                 allKeysReadable = false;
             else
-                dayValues.set(key, (dayValues.get(key) ?? 0) + p.v);
+                dayValues.set(at.dayKey, (dayValues.get(at.dayKey) ?? 0) + p.v);
         }
         if (allKeysReadable) {
             readings.activeDays = [...dayValues.values()].filter((v) => v > 0).length;

package/dist/userInvokedSkillsCapability.d.ts

@@ -1,5 +1,7 @@
 export type UserInvokedSkillsReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {
@@ -14,4 +16,3 @@ export declare function noteEngineCapsForUserInvokedSkills(baseUrl: string, caps
 export declare function observedUserInvokedSkills(baseUrl?: string | undefined): UserInvokedSkillsReading;
 export declare function userInvokedSkillsAvailable(reading: UserInvokedSkillsReading): 'yes' | 'no' | 'unknown';
 export declare function userInvokedSkillsDoctorDetail(reading: UserInvokedSkillsReading): string;
-export declare function __resetUserInvokedSkillsReadingsForTests(): void;

package/dist/userInvokedSkillsCapability.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 projectUserInvokedSkillsCapability(caps) {
     try {
@@ -19,7 +19,6 @@ export function projectUserInvokedSkillsCapability(caps) {
 const reader = createEngineCapReader({
     name: 'userInvokedSkills',
     project: projectUserInvokedSkillsCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForUserInvokedSkills(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -36,6 +35,8 @@ export function userInvokedSkillsAvailable(reading) {
 }
 export function userInvokedSkillsDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('user-invoked skills');
         case 'unobserved':
             return 'user-invoked skills not observed — the engine reports it on /v1/capabilities (userInvokedSkills); 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':
@@ -46,6 +47,3 @@ export function userInvokedSkillsDoctorDetail(reading) {
             return 'user-invoked skills on — skills the user names on a request take effect when the run starts';
     }
 }
-export function __resetUserInvokedSkillsReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/webSearchBackendCapability.d.ts

@@ -4,6 +4,8 @@ export interface WebSearchBackendCapabilityView {
 }
 export type WebSearchBackendReading = {
     kind: 'unobserved';
+} | {
+    kind: 'unreadable';
 } | {
     kind: 'not_reported';
 } | {

package/dist/webSearchBackendCapability.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 const WEB_SEARCH_BACKEND_NONE = 'none';
 export function projectWebSearchBackendCapability(caps) {
@@ -28,7 +28,6 @@ export function projectWebSearchBackendCapability(caps) {
 const reader = createEngineCapReader({
     name: 'webSearch.backend',
     project: projectWebSearchBackendCapability,
-    makeUnobserved: () => ({ kind: 'unobserved' }),
 });
 export function noteEngineCapsForWebSearchBackend(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
@@ -40,6 +39,8 @@ const WS_DETAIL_MAX = 40;
 const DEPLOY_ENV = 'WEB_SEARCH_PROVIDER';
 export function webSearchBackendDoctorDetail(reading) {
     switch (reading.kind) {
+        case 'unreadable':
+            return unreadableReadingDetail('deployment default backend');
         case 'unobserved':
             return ('deployment default backend 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/wireErrorTriage.d.ts

@@ -43,6 +43,8 @@ export interface ScenarioDenyDetail {
     allowlist: string[];
 }
 export declare function scenarioDenyFromError(err: unknown): ScenarioDenyDetail | null;
+export type ScenarioDenySurface = 'request' | 'resumed_work';
+export declare function scenarioNotAllowedContent(detail: ScenarioDenyDetail, requestedScenario?: string, surface?: ScenarioDenySurface): string;
 export interface ResumeRetryLaterDetail {
     code: string;
     retryAfterSec?: number;

package/dist/wireErrorTriage.js

@@ -1,27 +1,51 @@
-import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
-import { capForDisplay } from './fleetTaskDesc.js';
+import { readBlockedBy, readErrorNumber, readErrorString, readErrorStringList, readThrownSlot, thrownIsInstanceOf, THROWN_SLOT_UNREADABLE, WIRE_FAILURE_UNRENDERABLE_TEXT, } from './wireFailureShape.js';
+import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
 import { readOwnDataValue } from './ownKey.js';
 import { fleetLeaseUnavailableFromError } from './wireRefusalCopy.js';
-import { DRAINING_ERROR_CODE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
-export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|terminated|other side closed/i;
-function wireErrorDetail(err) {
-    const e = err;
-    const cause = e?.cause;
-    return ((typeof cause?.message === 'string' && cause.message.length > 0 && cause.message) ||
-        (typeof e?.message === 'string' && e.message.length > 0 && e.message) ||
-        String(err));
+import { DRAINING_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
+export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|\bterminated\b|\bother side closed\b/i;
+function readTurnErrorSlots(err) {
+    if (err === null || err === undefined)
+        return { status: undefined, errorCode: undefined, message: undefined, cause: undefined, name: undefined };
+    return {
+        status: readThrownSlot(err, 'status', 'data'),
+        errorCode: readThrownSlot(err, 'errorCode', 'data'),
+        message: readThrownSlot(err, 'message'),
+        cause: readThrownSlot(err, 'cause'),
+        name: typeof err === 'object' ? readThrownSlot(err, 'name') : undefined,
+    };
+}
+function renderedText(err) {
+    try {
+        return String(err);
+    }
+    catch {
+        return WIRE_FAILURE_UNRENDERABLE_TEXT;
+    }
+}
+function wireErrorDetailOf(slots, err) {
+    const causeMessage = slots.cause === undefined || slots.cause === THROWN_SLOT_UNREADABLE ? undefined : readThrownSlot(slots.cause, 'message');
+    return ((typeof causeMessage === 'string' && causeMessage.length > 0 && causeMessage) ||
+        (typeof slots.message === 'string' && slots.message.length > 0 && slots.message) ||
+        renderedText(err));
+}
+function isTransportShape(slots, detail) {
+    if (typeof slots.status === 'number' || slots.status === THROWN_SLOT_UNREADABLE)
+        return false;
+    return (slots.cause !== undefined && slots.cause !== THROWN_SLOT_UNREADABLE) || WIRE_NETWORK_ERROR_PATTERN.test(detail());
 }
 export function classifyTurnWireError(err) {
-    const e = err;
-    if (typeof e?.status === 'number') {
-        const errorCode = typeof e.errorCode === 'string' && e.errorCode.length > 0 ? e.errorCode : undefined;
-        const message = typeof e.message === 'string' && e.message.length > 0 ? e.message : String(err);
-        const storedRowWhere = corruptStoredRowWhere(err);
-        const sessionUnreadable = isCorruptSessionCode(effectiveWireErrorCode(err));
-        const leaseUnavailable = fleetLeaseUnavailableFromError(err) !== null;
+    const slots = readTurnErrorSlots(err);
+    if (typeof slots.status === 'number') {
+        const errorCode = typeof slots.errorCode === 'string' && slots.errorCode.length > 0 ? slots.errorCode : undefined;
+        const message = typeof slots.message === 'string' && slots.message.length > 0 ? slots.message : renderedText(err);
+        const effectiveCode = typeof err === 'object' && err !== null ? foldedWireErrorCode(err, errorCode) : undefined;
+        const storedRowWhere = typeof err === 'object' && err !== null ? storedRowWhereOf(err, effectiveCode) : undefined;
+        const sessionUnreadable = isCorruptSessionCode(effectiveCode);
+        const leaseUnavailable = slots.errorCode === FLEET_LEASE_UNAVAILABLE && fleetLeaseUnavailableFromError(err) !== null;
         return {
             kind: 'http',
-            status: e.status,
+            status: slots.status,
             ...(errorCode !== undefined ? { errorCode } : {}),
             message,
             ...(storedRowWhere !== undefined ? { storedRowWhere } : {}),
@@ -29,27 +53,21 @@ export function classifyTurnWireError(err) {
             ...(leaseUnavailable ? { leaseUnavailable: true } : {}),
         };
     }
-    const errName = typeof err === 'object' && err !== null && typeof err.name === 'string'
-        ? err.name
-        : undefined;
-    if (errName === 'StreamEndedWithoutTerminalError') {
+    if (slots.status !== THROWN_SLOT_UNREADABLE && slots.name === 'StreamEndedWithoutTerminalError') {
         return { kind: 'stream-ended-without-terminal' };
     }
-    const detail = wireErrorDetail(err);
-    const isNetwork = e?.cause !== undefined || WIRE_NETWORK_ERROR_PATTERN.test(detail);
-    if (isNetwork)
+    const detail = wireErrorDetailOf(slots, err);
+    if (isTransportShape(slots, () => detail))
         return { kind: 'transport', detail };
-    return { kind: 'internal', name: err instanceof Error ? err.name : typeof err, detail };
+    const name = thrownIsInstanceOf(err, Error) && slots.name !== THROWN_SLOT_UNREADABLE ? slots.name : typeof err;
+    return { kind: 'internal', name, detail };
 }
 export function isWireTransportError(err) {
-    const e = err;
-    if (typeof e?.status === 'number')
-        return false;
-    return e?.cause !== undefined || WIRE_NETWORK_ERROR_PATTERN.test(wireErrorDetail(err));
+    const slots = readTurnErrorSlots(err);
+    return isTransportShape(slots, () => wireErrorDetailOf(slots, err));
 }
 export function isPreStreamDrainingReject(err) {
-    const e = err;
-    return typeof e?.status === 'number' && e.status === 503 && e.errorCode === DRAINING_ERROR_CODE;
+    return readThrownSlot(err, 'status', 'data') === 503 && readThrownSlot(err, 'errorCode', 'data') === DRAINING_ERROR_CODE;
 }
 export function effectiveWireErrorCode(err) {
     if (typeof err !== 'object' || err === null)
@@ -62,13 +80,20 @@ export function effectiveWireErrorCode(err) {
         outerRaw = undefined;
     }
     const outer = typeof outerRaw === 'string' && outerRaw.length > 0 ? outerRaw : undefined;
+    return foldedWireErrorCode(err, outer);
+}
+function foldedWireErrorCode(err, outer) {
     if (outer !== RESUME_POLICY_FOLD_CODE)
         return outer;
-    const inner = readErrorString(err, 'blockedBy');
-    return inner !== undefined && inner.length > 0 ? inner : outer;
+    const inner = readBlockedBy(err);
+    return inner.kind === 'named' ? inner.code : outer;
 }
 export function corruptStoredRowWhere(err) {
-    if (effectiveWireErrorCode(err) !== 'corrupt')
+    const code = effectiveWireErrorCode(err);
+    return typeof err === 'object' && err !== null ? storedRowWhereOf(err, code) : undefined;
+}
+function storedRowWhereOf(err, effectiveCode) {
+    if (effectiveCode !== 'corrupt')
         return undefined;
     const where = readErrorString(err, 'where');
     return where !== undefined && where.trim().length > 0 ? where : undefined;
@@ -81,7 +106,7 @@ export function isResumeAtRejection(err) {
     return code !== undefined && code.startsWith(RESUME_AT_ERROR_CODE_PREFIX);
 }
 export function drainingRetryDelayMs(err, attempt, opts) {
-    const ra = err?.retryAfterMs;
+    const ra = readThrownSlot(err, 'retryAfterMs', 'data');
     if (typeof ra === 'number' && Number.isFinite(ra) && ra >= 0) {
         return Math.min(ra, opts?.retryAfterCapMs ?? 15_000);
     }
@@ -151,11 +176,39 @@ export function scenarioDenyFromError(err) {
     const allowlist = (readErrorStringList(err, 'allowlist') ?? []).filter((x) => x.length > 0);
     return { allowlist };
 }
+export function scenarioNotAllowedContent(detail, requestedScenario, surface) {
+    const resumed = surface === 'resumed_work';
+    const names = [];
+    try {
+        const raw = detail?.allowlist;
+        if (Array.isArray(raw)) {
+            const n = raw.length;
+            for (let i = 0; i < n; i++) {
+                const item = raw[i];
+                if (typeof item === 'string' && item.length > 0)
+                    names.push(escapeDisplayControlChars(item));
+            }
+        }
+    }
+    catch {
+        names.length = 0;
+    }
+    const subject = typeof requestedScenario === 'string' && requestedScenario.length > 0
+        ? `Scenario "${escapeDisplayControlChars(requestedScenario)}" is not in your allowed list`
+        : resumed
+            ? 'The scenario this work resumes under is not in your allowed list'
+            : 'The requested scenario is not in your allowed list';
+    const parts = [subject];
+    if (names.length > 0)
+        parts.push(`Available: ${names.join(', ')}`);
+    if (!resumed)
+        parts.push('You can also omit the scenario to run on your default assignment');
+    return parts.join(' · ');
+}
 export function resumeRetryLaterFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;
-    const e = err;
-    const code = e.errorCode;
+    const code = readThrownSlot(err, 'errorCode', 'data');
     if (typeof code !== 'string' || !RESUME_RETRY_LATER_CODES.includes(code))
         return null;
     const sec = readErrorNumber(err, 'retryAfterSec');

package/dist/wireFailureShape.d.ts

@@ -8,21 +8,38 @@ interface WireFailureShape {
     bodyVerdict?: string;
     bodyCurrentName?: string;
     message: string;
-    ownMessage?: string;
 }
 export declare const THROWN_SLOT_UNREADABLE: unique symbol;
-export declare function readThrownSlot(o: unknown, key: string, own?: boolean): unknown;
+export declare function readThrownSlot(o: unknown, key: string, own?: boolean | 'data'): unknown;
 export declare function thrownIsInstanceOf<C extends abstract new (...args: never[]) => unknown>(e: unknown, cls: C): e is InstanceType<C>;
+export type ThrownExtraReading = {
+    readonly state: 'object';
+    readonly value: object;
+} | {
+    readonly state: 'absent';
+} | {
+    readonly state: 'unreadable';
+};
+export declare function readThrownExtra(o: {} | null | undefined): ThrownExtraReading;
 export declare function readErrorNumber(o: object, key: string): number | undefined;
 export declare function readErrorRecord(o: object, key: string): object | 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;
-export declare function wireFailureShapeOf(e: unknown): WireFailureShape;
 export declare const WIRE_FAILURE_UNRENDERABLE_TEXT = "the call failed with an error this client could not render";
+export declare function wireFailureShapeOf(e: unknown): WireFailureShape;
 export declare function wireFailureTextsOf(e: unknown): {
     reason: string;
     log: string;
 };
+export type BlockedByReading = {
+    kind: 'named';
+    code: string;
+} | {
+    kind: 'absent';
+} | {
+    kind: 'unreadable';
+};
+export declare function readBlockedBy(o: object): BlockedByReading;
 export declare function readRefusalField(o: object): string | undefined;
 export {};