@sema-agent/client-core 0.95.0 → 0.96.0

package/dist/supportFloor.js

@@ -11,7 +11,8 @@ function releaseTriple(v) {
     const m = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(v);
     if (m === null)
         return undefined;
-    return [Number(m[1]), Number(m[2]), Number(m[3])];
+    const t = [Number(m[1]), Number(m[2]), Number(m[3])];
+    return t.every(Number.isSafeInteger) ? t : undefined;
 }
 function compareTriple(a, b) {
     for (let i = 0; i < 3; i++) {
@@ -22,28 +23,31 @@ function compareTriple(a, b) {
     }
     return 0;
 }
-function versionTierAgainst(version, base, floor, caller) {
+function judgeAgainst(version, base, floor, caller) {
     const baseTriple = releaseTriple(base);
     if (baseTriple === undefined) {
         throw new TypeError(`${caller}: 门槛只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)—— 收到 typeof=${base === null ? 'null' : typeof base}。错误文本只报形状,不回显值。`);
     }
-    let need = baseTriple;
+    let need = { triple: baseTriple, text: base };
     if (floor !== undefined) {
         const own = releaseTriple(floor);
         if (own === undefined) {
             throw new TypeError(`${caller}: floor 只接受纯 x.y.z 版本串(整串、无前导零、无前后缀)或缺席 —— 收到 typeof=${floor === null ? 'null' : typeof floor}。错误文本只报形状,不回显值。`);
         }
-        if (compareTriple(own, need) > 0)
-            need = own;
+        if (compareTriple(own, need.triple) > 0)
+            need = { triple: own, text: floor };
     }
     const got = releaseTriple(version);
     if (got === undefined)
-        return 'unknown';
-    return compareTriple(got, need) >= 0 ? 'engine' : 'legacy';
+        return { need: need.text, tier: 'unknown' };
+    return { need: need.text, tier: compareTriple(got, need.triple) >= 0 ? 'engine' : 'legacy' };
 }
 export function engineVersionTier(version, floor) {
-    return versionTierAgainst(version, SUPPORT_FLOOR.server, floor, 'engineVersionTier');
+    return judgeAgainst(version, SUPPORT_FLOOR.server, floor, 'engineVersionTier').tier;
+}
+export function engineSupportFloorEffective(floor) {
+    return judgeAgainst(undefined, SUPPORT_FLOOR.server, floor, 'engineSupportFloorEffective').need;
 }
 export function coreVersionTier(version, floor) {
-    return versionTierAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier');
+    return judgeAgainst(version, SUPPORT_FLOOR.core, floor, 'coreVersionTier').tier;
 }

package/dist/systemReminderTag.d.ts

@@ -5,3 +5,4 @@ export interface SystemReminderOpenTagSpan {
 export declare function findSystemReminderOpenTag(text: string, from?: number): SystemReminderOpenTagSpan | null;
 export declare function unwrapSystemReminder(text: string): string;
 export declare function stripSystemReminderBlocks(text: string): string;
+export declare function stripSystemReminderTagTokens(text: string): string;

package/dist/systemReminderTag.js

@@ -39,3 +39,11 @@ export function stripSystemReminderBlocks(text) {
     }
     return pos === 0 ? text : out + text.slice(pos);
 }
+const SYSTEM_REMINDER_TAG_TOKEN = /<[^A-Za-z0-9>]{0,12}system-reminder(?:[^>]{0,200}>)?/gi;
+const SYSTEM_REMINDER_TAG_HEAD = /<[^A-Za-z0-9>]{0,12}system-reminder/i;
+export function stripSystemReminderTagTokens(text) {
+    if (typeof text !== 'string')
+        return text;
+    const once = text.replace(SYSTEM_REMINDER_TAG_TOKEN, ' ');
+    return SYSTEM_REMINDER_TAG_HEAD.test(once) ? once.replace(/</g, '&lt;') : once;
+}

package/dist/toolHistoryMismatch.d.ts

@@ -18,8 +18,6 @@ export declare const TOOL_HISTORY_MISMATCH_ANCHORS: readonly ToolHistoryMismatch
 export declare function classifyToolHistoryMismatch(err: ToolHistoryErrorCarrier | null | undefined): ToolHistoryMismatch | null;
 export declare const TOOL_HISTORY_REWIND_SENTENCE = "Run /rewind to recover the conversation.";
 export declare function toolHistoryRepeatSentence(n: number): string;
-type ConversationRewindVerdict = 'available' | 'unavailable' | 'unknown';
-export declare function _wireConversationRewindJudge(judge: (engineBaseUrl: string) => ConversationRewindVerdict): void;
 export declare function toolHistoryRewindOffered(declared: boolean | {
     readonly engineBaseUrl: string;
 } | undefined): boolean;
@@ -61,4 +59,3 @@ export type ToolHistoryRewindResolution<R> = {
     undecidable: ToolHistoryUndecidableReason;
 };
 export declare function resolveToolHistoryRewindTarget<R extends ToolHistoryRow>(rows: readonly (R | null | undefined)[] | null | undefined, mismatch: ToolHistoryMismatch | null | undefined): ToolHistoryRewindResolution<R>;
-export {};

package/dist/toolHistoryMismatch.js

@@ -1,3 +1,4 @@
+import { rewindArchiveReadingAt, rewindConversationAvailability } from './rewindArchiveReading.js';
 export const TOOL_HISTORY_MISMATCH_KINDS = Object.freeze([
     'tool_use_without_result',
     'orphan_tool_result',
@@ -224,10 +225,6 @@ export const TOOL_HISTORY_REWIND_SENTENCE = 'Run /rewind to recover the conversa
 export function toolHistoryRepeatSentence(n) {
     return `The same error has now happened ${n} times in a row; /rewind is the only way to recover this conversation.`;
 }
-let conversationRewindJudge;
-export function _wireConversationRewindJudge(judge) {
-    conversationRewindJudge = judge;
-}
 export function toolHistoryRewindOffered(declared) {
     const decl = declared;
     if (decl === true)
@@ -238,10 +235,9 @@ export function toolHistoryRewindOffered(declared) {
         if (Array.isArray(decl))
             return false;
         const base = decl.engineBaseUrl;
-        const judge = conversationRewindJudge;
-        if (typeof base !== 'string' || base.length === 0 || judge === undefined)
+        if (typeof base !== 'string' || base.length === 0)
             return true;
-        return judge(base) !== 'unavailable';
+        return rewindConversationAvailability(rewindArchiveReadingAt(base)) !== 'unavailable';
     }
     catch {
         return true;

package/dist/toolResult.d.ts

@@ -86,7 +86,7 @@ export declare function _resetBackgroundReceiptParseCountForTest(): void;
 export type FlattenWireOutput = (output: unknown) => string;
 export declare const TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT: "wire_carried_no_output";
 export interface ToolResultBody {
-    content: unknown;
+    content: string | unknown[];
     isError: boolean;
     toolUseResult?: unknown;
     degraded?: typeof TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT;

package/dist/toolResult.js

@@ -355,8 +355,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

@@ -14,4 +14,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

@@ -46,6 +46,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/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,9 +1,9 @@
-import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
-import { capForDisplay } from './fleetTaskDesc.js';
+import { readBlockedBy, readErrorNumber, readErrorString, readErrorStringList } 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;
+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 wireErrorDetail(err) {
     const e = err;
     const cause = e?.cause;
@@ -64,8 +64,8 @@ export function effectiveWireErrorCode(err) {
     const outer = typeof outerRaw === 'string' && outerRaw.length > 0 ? outerRaw : undefined;
     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')
@@ -151,6 +151,35 @@ 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;

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 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 {};

package/dist/wireFailureShape.js

@@ -21,6 +21,21 @@ export function thrownIsInstanceOf(e, cls) {
         return false;
     }
 }
+export function readThrownExtra(o) {
+    if (o === null || o === undefined)
+        return { state: 'absent' };
+    const slot = readThrownSlot(o, 'extra');
+    if (slot === THROWN_SLOT_UNREADABLE)
+        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;
@@ -33,15 +48,10 @@ function readErrorSlot(obj, key, accept) {
         }
         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;
+        const extra = reading.value;
         let fromExtra;
         try {
             fromExtra = Object.hasOwn(extra, key) ? extra[key] : undefined;
@@ -98,28 +108,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 +163,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 +184,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,13 +195,25 @@ 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 readBlockedBy(o) {
+    const judge = (v) => (typeof v === 'string' && v.length > 0 ? { kind: 'named', code: v } : { kind: 'unreadable' });
+    try {
+        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 {
+        return { kind: 'unreadable' };
+    }
 }
 export function readRefusalField(o) {
     const str = (rec) => {
@@ -215,15 +226,9 @@ export function readRefusalField(o) {
         }
         return typeof v === 'string' && v !== '' ? v : undefined;
     };
-    let extra;
-    try {
-        extra = o.extra;
-    }
-    catch {
-        extra = undefined;
-    }
-    if (typeof extra === 'object' && extra !== null && !Array.isArray(extra)) {
-        const fromExtra = str(extra);
+    const reading = readThrownExtra(o);
+    if (reading.state === 'object') {
+        const fromExtra = str(reading.value);
         if (fromExtra !== undefined)
             return fromExtra;
     }