@sema-agent/client-core 0.94.0 → 0.96.0

package/dist/usageAnalytics.js

@@ -0,0 +1,335 @@
+export const USAGE_SENTENCES = Object.freeze({
+    analyticsUnavailable: 'Usage analytics aren’t available on this backend.',
+    analyticsUnread: 'Usage analytics couldn’t be read just now.',
+    modelsUnavailable: "Per-model usage breakdown isn't available on this backend.",
+    modelsUnread: 'Per-model usage breakdown couldn’t be read just now.',
+});
+const _sdkClientIsAnInjection = [true];
+void _sdkClientIsAnInjection;
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const nonNeg = (v) => typeof v === 'number' && Number.isFinite(v) && v >= 0;
+const nonEmpty = (v) => typeof v === 'string' && v.length > 0;
+export function classifyUsageFailure(e) {
+    let code;
+    let status;
+    try {
+        const o = e;
+        const rawCode = o?.errorCode;
+        const rawStatus = o?.status;
+        code = typeof rawCode === 'string' ? rawCode : undefined;
+        status = typeof rawStatus === 'number' ? rawStatus : undefined;
+    }
+    catch {
+        return { kind: 'failed', error: e };
+    }
+    if (code !== undefined) {
+        if (code.startsWith('capability.'))
+            return { kind: 'unavailable', why: 'capability' };
+        if (code.startsWith('feature.'))
+            return { kind: 'unavailable', why: 'feature' };
+        if (code === 'not_found.route')
+            return { kind: 'unavailable', why: 'route' };
+        return { kind: 'failed', error: e };
+    }
+    if (status === 501)
+        return { kind: 'unavailable', why: 'capability' };
+    return { kind: 'failed', error: e };
+}
+function windowOf(o) {
+    const w = { truncated: o.truncated === true };
+    if (nonEmpty(o.from))
+        w.from = o.from;
+    if (nonEmpty(o.to))
+        w.to = o.to;
+    return w;
+}
+const precisionOf = (estimated) => (estimated === false ? 'exact' : 'estimated');
+const TOTAL_FIELDS = ['tasks', 'tokensIn', 'tokensOut', 'cost'];
+const TOTAL_WIRE_KEYS = Object.freeze({ tasks: 'tasks', tokensIn: 'tokensIn', tokensOut: 'tokensOut', cost: 'costUsd' });
+function totalsOf(o) {
+    const t = { precision: precisionOf(o.estimated) };
+    for (const field of TOTAL_FIELDS) {
+        const v = o[TOTAL_WIRE_KEYS[field]];
+        if (nonNeg(v))
+            t[field] = v;
+    }
+    return t;
+}
+export function projectUsageSummary(body) {
+    try {
+        if (!isRecord(body))
+            return undefined;
+        return { ...windowOf(body), ...totalsOf(body) };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function projectUsageSeries(body) {
+    try {
+        if (!isRecord(body))
+            return undefined;
+        const series = body.series;
+        if (!Array.isArray(series))
+            return undefined;
+        const points = [];
+        let unreadable = 0;
+        for (const raw of series) {
+            if (!isRecord(raw) || typeof raw.t !== 'string' || usageInstantOf(raw.t) === undefined || !nonNeg(raw.v)) {
+                unreadable++;
+                continue;
+            }
+            const p = { t: raw.t, v: raw.v };
+            if (typeof raw.estimated === 'boolean')
+                p.estimated = raw.estimated;
+            points.push(p);
+        }
+        return { ...windowOf(body), points, unreadable };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function projectUsageBreakdown(body) {
+    try {
+        if (!isRecord(body))
+            return undefined;
+        const breakdown = body.breakdown;
+        if (!Array.isArray(breakdown))
+            return undefined;
+        const rows = [];
+        let unreadable = 0;
+        for (const raw of breakdown) {
+            if (!isRecord(raw) || !nonEmpty(raw.key)) {
+                unreadable++;
+                continue;
+            }
+            rows.push({ key: raw.key, ...totalsOf(raw) });
+        }
+        return { ...windowOf(body), rows, unreadable };
+    }
+    catch {
+        return undefined;
+    }
+}
+function windowBag(opts) {
+    const bag = {};
+    if (opts.from !== undefined)
+        bag.from = opts.from;
+    if (opts.to !== undefined)
+        bag.to = opts.to;
+    if (opts.principal !== undefined)
+        bag.principal = opts.principal;
+    if (opts.signal !== undefined)
+        bag.signal = opts.signal;
+    return bag;
+}
+async function readOne(call, project, what) {
+    try {
+        const pending = call();
+        if (pending === undefined)
+            return { kind: 'unavailable', why: 'route' };
+        const view = project(await pending);
+        if (view === undefined)
+            return { kind: 'failed', error: new Error(`usage ${what}: malformed body`) };
+        return { kind: 'ok', value: view };
+    }
+    catch (e) {
+        return classifyUsageFailure(e);
+    }
+}
+export function readUsageSummary(client, opts = {}) {
+    return readOne(() => (typeof client?.usage?.summary === 'function' ? client.usage.summary(windowBag(opts)) : undefined), projectUsageSummary, 'summary');
+}
+export function readUsageSeries(client, opts = {}) {
+    return readOne(() => {
+        if (typeof client?.usage?.series !== 'function')
+            return undefined;
+        const bag = windowBag(opts);
+        if (opts.metric !== undefined)
+            bag.metric = opts.metric;
+        if (opts.granularity !== undefined)
+            bag.granularity = opts.granularity;
+        return client.usage.series(bag);
+    }, projectUsageSeries, 'series');
+}
+export function readUsageBreakdown(client, opts = {}) {
+    return readOne(() => {
+        if (typeof client?.usage?.breakdown !== 'function')
+            return undefined;
+        const bag = windowBag(opts);
+        if (opts.dimension !== undefined)
+            bag.dimension = opts.dimension;
+        return client.usage.breakdown(bag);
+    }, projectUsageBreakdown, 'breakdown');
+}
+export function usageBoundPrefix(bound) {
+    return bound === 'lower' ? '≥' : bound === 'approximate' ? '≈' : '';
+}
+const DAY_MS = 86_400_000;
+export const USAGE_HEATMAP_MAX_DAYS = 70;
+export function usageWindowOfRange(range, now) {
+    if (range === 'all')
+        return { from: 0, to: now };
+    const days = range === '30d' ? 30 : 7;
+    return { from: now - days * DAY_MS, to: now };
+}
+function unavailableCauseOf(v) {
+    return v.kind === 'unavailable' ? 'no_backend_face' : 'read_failed';
+}
+function modelsUnavailable(cause) {
+    return { state: 'unavailable', cause, sentence: cause === 'no_backend_face' ? USAGE_SENTENCES.modelsUnavailable : USAGE_SENTENCES.modelsUnread };
+}
+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 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 peakHourOf(points) {
+    if (points.length === 0)
+        return undefined;
+    const perHour = new Array(24).fill(0);
+    for (const p of points) {
+        const at = usageInstantOf(p.t);
+        if (at === undefined)
+            return undefined;
+        perHour[at.hourUtc] = (perHour[at.hourUtc] ?? 0) + p.v;
+    }
+    let peakHour = -1;
+    let peakValue = -1;
+    perHour.forEach((value, h) => {
+        if (value > peakValue) {
+            peakValue = value;
+            peakHour = h;
+        }
+    });
+    return peakHour >= 0 && peakValue > 0 ? peakHour : undefined;
+}
+function heatmapOf(window, dayValues) {
+    if (!Number.isFinite(window.from) || !Number.isFinite(window.to))
+        return null;
+    const windowDays = Math.max(1, Math.round((window.to - window.from) / DAY_MS) + 1);
+    const days = Math.min(windowDays, USAGE_HEATMAP_MAX_DAYS);
+    const cells = [];
+    for (let i = days - 1; i >= 0; i--) {
+        const at = new Date(window.to - i * DAY_MS);
+        if (Number.isNaN(at.getTime()))
+            return null;
+        const key = at.toISOString().slice(0, 10);
+        cells.push({ date: key, tasks: dayValues.get(key) ?? 0 });
+    }
+    return cells;
+}
+export function projectUsageAnalytics(inputs, window) {
+    const s = inputs.summary;
+    if (s.kind !== 'ok') {
+        const cause = unavailableCauseOf(s);
+        return {
+            state: 'unavailable',
+            cause,
+            sentence: cause === 'no_backend_face' ? USAGE_SENTENCES.analyticsUnavailable : USAGE_SENTENCES.analyticsUnread,
+            models: modelsUnavailable(cause),
+        };
+    }
+    const sv = s.value;
+    const readings = {
+        state: sv.precision === 'estimated' ? 'estimated' : 'available',
+        truncated: sv.truncated,
+        heatmap: null,
+        models: modelsUnavailable('read_failed'),
+    };
+    if (sv.tasks !== undefined)
+        readings.runs = sv.tasks;
+    const exact = sv.precision === 'exact';
+    if (sv.tokensIn !== undefined && sv.tokensOut !== undefined) {
+        readings.tokens = { value: sv.tokensIn + sv.tokensOut, bound: !exact ? 'approximate' : sv.truncated ? 'lower' : 'exact' };
+    }
+    if (sv.cost !== undefined)
+        readings.cost = { value: sv.cost, bound: exact && !sv.truncated ? 'exact' : 'lower' };
+    const day = inputs.daySeries;
+    if (day.kind === 'ok' && isWhole(day.value)) {
+        const dayValues = new Map();
+        let allKeysReadable = true;
+        for (const p of day.value.points) {
+            const at = usageInstantOf(p.t);
+            if (at === undefined)
+                allKeysReadable = false;
+            else
+                dayValues.set(at.dayKey, (dayValues.get(at.dayKey) ?? 0) + p.v);
+        }
+        if (allKeysReadable) {
+            readings.activeDays = [...dayValues.values()].filter((v) => v > 0).length;
+            readings.heatmap = heatmapOf(window, dayValues);
+        }
+    }
+    const hour = inputs.hourSeries;
+    if (hour.kind === 'ok' && isWhole(hour.value)) {
+        const peak = peakHourOf(hour.value.points);
+        if (peak !== undefined)
+            readings.peakHourUtc = peak;
+    }
+    const br = inputs.modelBreakdown;
+    if (br.kind === 'ok') {
+        readings.models = { state: 'available', rows: br.value.rows, unreadable: br.value.unreadable };
+        if (isWhole(br.value)) {
+            let favorite;
+            for (const row of br.value.rows) {
+                if (row.tasks === undefined)
+                    continue;
+                if (favorite === undefined || row.tasks > (favorite.tasks ?? -1))
+                    favorite = row;
+            }
+            if (favorite !== undefined)
+                readings.favoriteModel = favorite.key;
+        }
+    }
+    else {
+        readings.models = modelsUnavailable(unavailableCauseOf(br));
+    }
+    return readings;
+}
+export async function readUsageAnalytics(client, window, opts = {}) {
+    const base = { from: window.from, to: window.to, ...(opts.signal ? { signal: opts.signal } : {}) };
+    const [summary, daySeries, hourSeries, modelBreakdown] = await Promise.all([
+        readUsageSummary(client, base),
+        readUsageSeries(client, { ...base, metric: 'tasks', granularity: 'day' }),
+        readUsageSeries(client, { ...base, metric: 'tasks', granularity: 'hour' }),
+        readUsageBreakdown(client, { ...base, dimension: 'model' }),
+    ]);
+    return projectUsageAnalytics({ summary, daySeries, hourSeries, modelBreakdown }, window);
+}

package/dist/userInvokedSkillsCapability.d.ts

@@ -14,5 +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 forgetUserInvokedSkillsReading(baseUrl: string | undefined): void;
-export declare function __resetUserInvokedSkillsReadingsForTests(): void;

package/dist/userInvokedSkillsCapability.js

@@ -1,12 +1,11 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export function projectUserInvokedSkillsCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'userInvokedSkills'))
-            return { kind: 'not_reported' };
-        const v = caps.userInvokedSkills;
+        const v = ownDataField(caps, 'userInvokedSkills');
         if (v === undefined)
             return { kind: 'not_reported' };
         if (typeof v !== 'boolean')
@@ -47,9 +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 forgetUserInvokedSkillsReading(baseUrl) {
-    reader.forget(baseUrl);
-}
-export function __resetUserInvokedSkillsReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/webSearchBackendCapability.d.ts

@@ -18,5 +18,4 @@ export declare function noteEngineCapsForWebSearchBackend(baseUrl: string, caps:
 }): void;
 export declare function observedWebSearchBackend(baseUrl?: string | undefined): WebSearchBackendReading;
 export declare function webSearchBackendDoctorDetail(reading: WebSearchBackendReading): string;
-export declare function forgetWebSearchBackendReading(baseUrl: string | undefined): void;
 export declare function __resetWebSearchBackendReadingsForTests(): void;

package/dist/webSearchBackendCapability.js

@@ -1,6 +1,7 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { ownDataField } from './ownKey.js';
 export const WEB_SEARCH_BACKEND_NONE = 'none';
 export function projectWebSearchBackendCapability(caps) {
     try {
@@ -8,14 +9,12 @@ export function projectWebSearchBackendCapability(caps) {
             return undefined;
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
             return undefined;
-        if (!Object.hasOwn(caps, 'webSearch'))
-            return { kind: 'not_reported' };
-        const ws = caps.webSearch;
+        const ws = ownDataField(caps, 'webSearch');
         if (ws === undefined)
             return { kind: 'not_reported' };
         if (ws === null || typeof ws !== 'object' || Array.isArray(ws))
             return undefined;
-        const backend = ws.backend;
+        const backend = ownDataField(ws, 'backend');
         if (typeof backend !== 'string' || backend === '')
             return undefined;
         if (backend === WEB_SEARCH_BACKEND_NONE)
@@ -56,9 +55,6 @@ export function webSearchBackendDoctorDetail(reading) {
                 '(per-request overrides are not echoed here)');
     }
 }
-export function forgetWebSearchBackendReading(baseUrl) {
-    reader.forget(baseUrl);
-}
 export function __resetWebSearchBackendReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/webSearchWireCaps.js

@@ -1,3 +1,4 @@
+import { SETTINGS_IS_HIERARCHICAL_URL } from './generated/settingsSchemaFns.js';
 import { hostEnv } from './hostEnv.js';
 export const WEBSEARCH_ENV = {
     provider: 'SEMA_WEBSEARCH_PROVIDER',
@@ -6,15 +7,6 @@ export const WEBSEARCH_ENV = {
     maxResults: 'SEMA_WEBSEARCH_MAX_RESULTS',
 };
 const isBlankText = (v) => v.trim() === '';
-function isHierarchicalUrl(raw) {
-    try {
-        const u = new URL(raw);
-        return u.href.startsWith(u.protocol + '//');
-    }
-    catch {
-        return false;
-    }
-}
 function judgeProvider(raw) {
     const word = typeof raw === 'string' ? raw.trim().toLowerCase() : undefined;
     if (word === 'brave' || word === 'tavily' || word === 'searxng')
@@ -71,7 +63,7 @@ function judgeEndpoint(raw) {
         return { ok: false, issue: ENDPOINT_ISSUE };
     if (isBlankText(raw))
         return { ok: true, value: undefined };
-    if (!isHierarchicalUrl(raw))
+    if (!SETTINGS_IS_HIERARCHICAL_URL(raw))
         return { ok: false, issue: ENDPOINT_ISSUE };
     const u = new URL(raw);
     return u.username !== '' || u.password !== ''
@@ -236,7 +228,7 @@ export function webSearchVerdictMessage(verdict, context = 'submit') {
         : `Web search is misconfigured: ${where} ${verdict.issue}. Requests will be refused until you ${fix}.`;
 }
 export function webSearchEndpointForDisplay(raw) {
-    if (typeof raw !== 'string' || !isHierarchicalUrl(raw))
+    if (typeof raw !== 'string' || !SETTINGS_IS_HIERARCHICAL_URL(raw))
         return undefined;
     try {
         const u = new URL(raw);

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,17 +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 {};