@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/wireErrorTriage.js

@@ -1,17 +1,18 @@
-import { PROTOCOL_ERROR_NAME, protocolErrorNameOf, readBlockedBy, readErrorNumber, readErrorString, readErrorStringList, readThrownSlot, readThrownStatusSlot, thrownIsInstanceOf, THROWN_SLOT_UNREADABLE, WIRE_FAILURE_UNRENDERABLE_TEXT, } from './wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, effectiveWireCodeReading, isSlotCarrier, protocolErrorNameOf, readErrorNumber, readErrorString, readErrorStringList, readThrownSlot, readThrownStatusSlot, 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 { CORRUPT_ROW_ERROR_CODE, 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';
+import { answerReadingOf, captureAnswer, captureUnanswered, causeSlotReadOf, effectiveCodeOf, noteTriageReading, ownReadingSlot } from './engineWireFor.js';
+import { CORRUPT_ROW_ERROR_CODE, DRAINING_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, 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) {
+function readTurnErrorSlots(err, status, topCause) {
     if (err === null || err === undefined)
         return { status: undefined, errorCode: undefined, message: undefined, cause: undefined, name: undefined };
     return {
-        status: readThrownSlot(err, 'status', 'data'),
+        status,
         errorCode: readThrownSlot(err, 'errorCode', 'data'),
         message: readThrownSlot(err, 'message'),
-        cause: readThrownSlot(err, 'cause'),
+        cause: topCause !== undefined ? topCause.value : undefined,
         name: typeof err === 'object' ? readThrownSlot(err, 'name') : undefined,
     };
 }
@@ -29,52 +30,108 @@ function wireErrorDetailOf(slots, err) {
         (typeof slots.message === 'string' && slots.message.length > 0 && slots.message) ||
         renderedText(err));
 }
-function isTransportShape(slots, detail) {
+function isTransportShape(slots, detail, chain) {
     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());
+    if (chain.reading === 'answered')
+        return false;
+    if (chain.reading === 'transient')
+        return true;
+    if (slots.cause !== undefined && slots.cause !== THROWN_SLOT_UNREADABLE && ownReadingSlot(chain, 'chainEnd') !== 'unreadable')
+        return true;
+    return WIRE_NETWORK_ERROR_PATTERN.test(detail()) || (typeof slots.message === 'string' && WIRE_NETWORK_ERROR_PATTERN.test(slots.message));
+}
+function topStatusOf(err, ans) {
+    if (ans.answer === THROWN_SLOT_UNREADABLE)
+        return ans.chain.reading === 'answered' ? undefined : THROWN_SLOT_UNREADABLE;
+    return ans.answer !== undefined && ans.answer.layer === err ? ans.answer.status : undefined;
+}
+function httpVerdictOf(captured, fallbackMessage, topLocal, topCause) {
+    const source = captured.layer;
+    const errorCode = captured.code.state === 'read' ? captured.code.wire : undefined;
+    const rawMessage = readThrownSlot(source, 'message');
+    const message = typeof rawMessage === 'string' && rawMessage.length > 0 ? rawMessage : fallbackMessage();
+    const effectiveCode = effectiveCodeOf(captured.code);
+    const storedRowWhere = isSlotCarrier(source) ? storedRowWhereOf(source, effectiveCode) : undefined;
+    const sessionUnreadable = isCorruptSessionCode(effectiveCode);
+    const leaseUnavailable = errorCode === FLEET_LEASE_UNAVAILABLE && fleetLeaseUnavailableFromError(source) !== null;
+    const verdict = {
+        kind: 'http',
+        status: captured.status,
+        ...(errorCode !== undefined ? { errorCode } : {}),
+        message,
+        ...(storedRowWhere !== undefined ? { storedRowWhere } : {}),
+        ...(sessionUnreadable ? { sessionUnreadable: true } : {}),
+        ...(leaseUnavailable ? { leaseUnavailable: true } : {}),
+    };
+    noteTriageReading(verdict, { answer: captured, ...(topLocal !== undefined ? { topLocalCode: topLocal } : {}), ...(topCause !== undefined ? { topCause } : {}), transport: false });
+    return verdict;
+}
+function noted(verdict, ans, captured, transport, err, topCode, topCauseRead) {
+    const a = ans.answer;
+    const topLocalCode = ownReadingSlot(ans, 'topLocalCode');
+    const unanswered = a === undefined && isSlotCarrier(err) ? { unanswered: captureUnanswered(err, topCode, topLocalCode, ownReadingSlot(ans, 'topStatusSlot')) } : {};
+    const topLocal = topLocalOf(err, a, topLocalCode);
+    const topCause = topCauseRecordOf(err, topCauseRead);
+    noteTriageReading(verdict, {
+        answer: a === THROWN_SLOT_UNREADABLE ? a : captured,
+        ...unanswered,
+        ...(topLocal !== undefined ? { topLocalCode: topLocal } : {}),
+        ...(topCause !== undefined ? { topCause } : {}),
+        transport,
+        ...(ownReadingSlot(ans.chain, 'chainEnd') === 'unreadable' ? { chainEnd: 'unreadable' } : {}),
+    });
+    return verdict;
+}
+function topCauseReadFor(err, ans) {
+    const walked = ownReadingSlot(ans, 'topCause');
+    if (walked !== undefined)
+        return walked;
+    return isSlotCarrier(err) ? causeSlotReadOf(err) : undefined;
+}
+function topCauseRecordOf(err, read) {
+    return read !== undefined && isSlotCarrier(err) ? Object.freeze({ layer: err, read }) : undefined;
+}
+function topLocalOf(err, a, topLocalCode) {
+    if (topLocalCode === undefined || a === undefined || (a !== THROWN_SLOT_UNREADABLE && a.layer === err) || !isSlotCarrier(err))
+        return undefined;
+    return Object.freeze({ layer: err, localCode: topLocalCode.value });
 }
 export function classifyTurnWireError(err) {
-    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: slots.status,
-            ...(errorCode !== undefined ? { errorCode } : {}),
-            message,
-            ...(storedRowWhere !== undefined ? { storedRowWhere } : {}),
-            ...(sessionUnreadable ? { sessionUnreadable: true } : {}),
-            ...(leaseUnavailable ? { leaseUnavailable: true } : {}),
-        };
-    }
+    const ans = answerReadingOf(err);
+    const a = ans.answer;
+    const captured = a !== undefined && a !== THROWN_SLOT_UNREADABLE ? captureAnswer(a, readThrownSlot(a.layer, 'errorCode', 'data')) : undefined;
+    const topCauseRead = topCauseReadFor(err, ans);
+    if (captured !== undefined && captured.layer === err)
+        return httpVerdictOf(captured, () => renderedText(err), undefined, topCauseRecordOf(err, topCauseRead));
+    const slots = readTurnErrorSlots(err, topStatusOf(err, ans), topCauseRead);
     if (slots.status !== THROWN_SLOT_UNREADABLE && slots.name === 'StreamEndedWithoutTerminalError') {
-        return { kind: 'stream-ended-without-terminal' };
+        return noted({ kind: 'stream-ended-without-terminal' }, ans, captured, transportShapeOf(slots, err, ans), err, slots.errorCode, topCauseRead);
+    }
+    if (captured !== undefined) {
+        const top = slots.message;
+        return httpVerdictOf(captured, () => (typeof top === 'string' && top.length > 0 ? top : renderedText(err)), topLocalOf(err, captured, ownReadingSlot(ans, 'topLocalCode')), topCauseRecordOf(err, topCauseRead));
     }
     const detail = wireErrorDetailOf(slots, err);
-    if (isTransportShape(slots, () => detail))
-        return { kind: 'transport', detail };
+    if (ans.answer === undefined && isTransportShape(slots, () => detail, ans.chain))
+        return noted({ kind: 'transport', detail }, ans, undefined, true, err, slots.errorCode, topCauseRead);
     const name = thrownIsInstanceOf(err, Error) && slots.name !== THROWN_SLOT_UNREADABLE ? slots.name : typeof err;
-    return { kind: 'internal', name, detail };
+    return noted({ kind: 'internal', name, detail }, ans, undefined, false, err, slots.errorCode, topCauseRead);
+}
+function transportShapeOf(slots, err, ans) {
+    return ans.answer === undefined && isTransportShape(slots, () => wireErrorDetailOf(slots, err), ans.chain);
 }
 export function isWireTransportError(err) {
-    const slots = readTurnErrorSlots(err);
-    return isTransportShape(slots, () => wireErrorDetailOf(slots, err));
+    const ans = answerReadingOf(err);
+    return transportShapeOf(readTurnErrorSlots(err, topStatusOf(err, ans), topCauseReadFor(err, ans)), err, ans);
 }
 export function isPreStreamDrainingReject(err) {
     return readThrownSlot(err, 'status', 'data') === 503 && readThrownSlot(err, 'errorCode', 'data') === DRAINING_ERROR_CODE;
 }
 export function effectiveWireErrorCode(err) {
-    if (typeof err !== 'object' || err === null)
+    if (!isSlotCarrier(err))
         return undefined;
-    const outerRaw = readThrownSlot(err, 'errorCode', 'data');
-    const outer = typeof outerRaw === 'string' && outerRaw.length > 0 ? outerRaw : undefined;
-    return foldedWireErrorCode(err, outer);
+    return effectiveWireCodeReading(err).code;
 }
 export function isNotFoundFailure(e) {
     try {
@@ -98,15 +155,9 @@ export function isNotFoundFailure(e) {
     }
 }
 const NOT_FOUND_CODE_PREFIX = 'not_found.';
-function foldedWireErrorCode(err, outer) {
-    if (outer !== RESUME_POLICY_FOLD_CODE)
-        return outer;
-    const inner = readBlockedBy(err);
-    return inner.kind === 'named' ? inner.code : outer;
-}
 export function corruptStoredRowWhere(err) {
     const code = effectiveWireErrorCode(err);
-    return typeof err === 'object' && err !== null ? storedRowWhereOf(err, code) : undefined;
+    return isSlotCarrier(err) ? storedRowWhereOf(err, code) : undefined;
 }
 function storedRowWhereOf(err, effectiveCode) {
     if (effectiveCode !== CORRUPT_ROW_ERROR_CODE)
@@ -164,17 +215,15 @@ export function streamDrainingDecision(frame, attempt, opts) {
     return { reconnectAfterMs: drainingRetryDelayMs(null, attempt, opts?.ladder !== undefined ? { ladder: opts.ladder } : undefined) };
 }
 export function scenarioDenyFromError(err) {
-    if (typeof err !== 'object' || err === null)
+    if (!isSlotCarrier(err))
         return null;
     const status = readThrownSlot(err, 'status', 'data');
     if (status !== 400 && status !== 409)
         return null;
-    if (status === 409) {
-        const outer = readThrownSlot(err, 'errorCode', 'data');
-        if (outer !== RESUME_POLICY_FOLD_CODE)
-            return null;
-    }
-    if (effectiveWireErrorCode(err) !== SCENARIO_NOT_ALLOWED_ERROR_CODE)
+    const coded = effectiveWireCodeReading(err);
+    if (status === 409 && !coded.folded)
+        return null;
+    if (coded.code !== SCENARIO_NOT_ALLOWED_ERROR_CODE)
         return null;
     const allowlist = (readErrorStringList(err, 'allowlist') ?? []).filter((x) => x.length > 0);
     return { allowlist };
@@ -209,7 +258,7 @@ export function scenarioNotAllowedContent(detail, requestedScenario, surface) {
     return parts.join(' · ');
 }
 export function resumeRetryLaterFromError(err) {
-    if (typeof err !== 'object' || err === null)
+    if (!isSlotCarrier(err))
         return null;
     const code = readThrownSlot(err, 'errorCode', 'data');
     if (typeof code !== 'string' || !RESUME_RETRY_LATER_CODES.includes(code))

package/dist/wireFailureShape.d.ts

@@ -11,6 +11,7 @@ interface WireFailureShape {
     message: string;
 }
 export declare const THROWN_SLOT_UNREADABLE: unique symbol;
+export declare function isSlotCarrier(x: {} | null | undefined): x is object;
 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 = {
@@ -55,7 +56,14 @@ export type ProtocolErrorNameReading = {
 export declare function protocolErrorNameReading(e: object): ProtocolErrorNameReading;
 export declare function protocolErrorNameOf(e: object): ProtocolErrorName | undefined;
 export type ThrownStatusReading = number | undefined | typeof THROWN_SLOT_UNREADABLE;
-export declare function readThrownStatusSlot(o: object): ThrownStatusReading;
+export declare function readThrownStatusSlot(o: object, notePresence?: (presence: SlotPresence) => void): ThrownStatusReading;
+export type SlotPresence = 'absent' | 'present' | 'unreadable';
+export interface OwnSlotRead {
+    readonly value: {} | null | undefined;
+    readonly presence: SlotPresence;
+}
+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 readErrorString(o: object, key: string): string | undefined;
@@ -83,7 +91,23 @@ export type BlockedByReading = {
     kind: 'unreadable';
 };
 export declare function readBlockedBy(o: object): BlockedByReading;
+export interface FoldedCodeReading {
+    readonly code: string | undefined;
+    readonly folded: boolean;
+}
+export declare function foldedWireCodeReading(o: object, outer: string | undefined): FoldedCodeReading;
+export declare function effectiveWireCodeReading(o: object): FoldedCodeReading;
+export interface FoldedCodeBits {
+    readonly errorCode: string | undefined;
+    readonly blockedBy: string | undefined;
+}
+export declare function ownFoldedCodeBitsOf(wire: {
+    readonly errorCode?: string;
+    readonly blockedBy?: string;
+} | undefined): FoldedCodeBits;
 export declare function readRefusalField(o: object): string | undefined;
+export declare const REFUSAL_PROBLEMS_READ_MAX = 1000;
+export declare function readRefusalNamedFields(o: object): readonly string[];
 export declare function isDisplayableWireCode(s: string): boolean;
 export declare const ASSEMBLY_REFUSAL_CAUSES: readonly ["ports_missing", "judge_unanswerable", "input_malformed", "agents_projection_failed", "agents_not_ready"];
 export interface AssemblyRefusal {

package/dist/wireFailureShape.js

@@ -1,12 +1,16 @@
 import { msg, renderMessage } from './i18n/translate.js';
 import { guardedRead, ownDataField, readOwnDataValue } from './ownKey.js';
+import { RESUME_POLICY_FOLD_CODE } from './engineErrorCodes.js';
 export const THROWN_SLOT_UNREADABLE = Symbol('thrown-slot-unreadable');
+export function isSlotCarrier(x) {
+    return (typeof x === 'object' && x !== null) || typeof x === 'function';
+}
 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;
+            return isSlotCarrier(o) ? ownDataField(o, key) : undefined;
         }
         if (own && !Object.hasOwn(o, key))
             return undefined;
@@ -150,13 +154,48 @@ export function protocolErrorNameOf(e) {
     const r = protocolErrorNameReading(e);
     return r.state === 'named' ? r.name : undefined;
 }
-export function readThrownStatusSlot(o) {
-    const st = readThrownSlot(o, 'status', 'data');
-    const raw = st !== THROWN_SLOT_UNREADABLE && (st === undefined || st === null) ? readThrownSlot(o, 'statusCode', 'data') : st;
+export function readThrownStatusSlot(o, notePresence) {
+    const withPresence = notePresence !== undefined;
+    const offCarrier = { value: o === null || o === undefined ? THROWN_SLOT_UNREADABLE : undefined, presence: 'unreadable' };
+    const st = isSlotCarrier(o) ? readOwnSlot(o, 'status', withPresence) : offCarrier;
+    let raw = st.value;
+    let presence = st.presence;
+    if (raw !== THROWN_SLOT_UNREADABLE && (raw === undefined || raw === null)) {
+        const sc = isSlotCarrier(o) ? readOwnSlot(o, 'statusCode', withPresence) : offCarrier;
+        raw = sc.value;
+        if (presence === 'absent')
+            presence = sc.presence;
+    }
+    notePresence?.(presence);
     if (raw === undefined)
         return undefined;
     return typeof raw === 'number' ? raw : THROWN_SLOT_UNREADABLE;
 }
+function readOwnSlot(o, key, withPresence) {
+    let d;
+    try {
+        d = Object.getOwnPropertyDescriptor(o, key);
+    }
+    catch {
+        return { value: THROWN_SLOT_UNREADABLE, presence: 'unreadable' };
+    }
+    if (d !== undefined)
+        return Object.hasOwn(d, 'value') ? { value: d.value, presence: 'present' } : { value: THROWN_SLOT_UNREADABLE, presence: 'unreadable' };
+    if (!withPresence)
+        return { value: undefined, presence: 'unreadable' };
+    try {
+        return { value: undefined, presence: key in o ? 'unreadable' : 'absent' };
+    }
+    catch {
+        return { value: undefined, presence: 'unreadable' };
+    }
+}
+export function slotPresenceOf(o, key) {
+    return slotReadOf(o, key).presence;
+}
+export function slotReadOf(o, key) {
+    return readOwnSlot(o, key, true);
+}
 function readErrorSlot(obj, key, accept) {
     try {
         const topRaw = readThrownSlot(obj, key, 'data');
@@ -338,6 +377,24 @@ export function readBlockedBy(o) {
         return { kind: 'unreadable' };
     }
 }
+export function foldedWireCodeReading(o, outer) {
+    if (outer !== RESUME_POLICY_FOLD_CODE)
+        return { code: outer, folded: false };
+    const inner = readBlockedBy(o);
+    return inner.kind === 'named' ? { code: inner.code, folded: true } : { code: outer, folded: false };
+}
+export function effectiveWireCodeReading(o) {
+    const outerRaw = readThrownSlot(o, 'errorCode', 'data');
+    const outer = typeof outerRaw === 'string' && outerRaw.length > 0 ? outerRaw : undefined;
+    return foldedWireCodeReading(o, outer);
+}
+export function ownFoldedCodeBitsOf(wire) {
+    const bit = (key) => {
+        const v = readThrownSlot(wire, key, 'data');
+        return typeof v === 'string' ? v : undefined;
+    };
+    return Object.freeze({ errorCode: bit('errorCode'), blockedBy: bit('blockedBy') });
+}
 export function readRefusalField(o) {
     const str = (rec) => {
         const v = guardedRead(() => readOwnDataValue(rec, 'field'));
@@ -349,7 +406,37 @@ export function readRefusalField(o) {
         if (fromExtra !== undefined)
             return fromExtra;
     }
-    return str(o);
+    const top = readThrownSlot(o, 'field', 'data');
+    return typeof top === 'string' && top !== '' ? top : undefined;
+}
+export const REFUSAL_PROBLEMS_READ_MAX = 1000;
+export function readRefusalNamedFields(o) {
+    const out = [];
+    const add = (v) => {
+        if (typeof v === 'string' && v !== '' && !out.includes(v))
+            out.push(v);
+    };
+    add(guardedRead(() => readRefusalField(o)));
+    const detail = guardedRead(() => readErrorRecord(o, 'detail'));
+    if (detail !== undefined) {
+        add(guardedRead(() => readOwnDataValue(detail, 'field')));
+        try {
+            const list = readOwnDataValue(detail, 'problems');
+            if (Array.isArray(list)) {
+                const n = list.length;
+                const len = typeof n === 'number' && Number.isSafeInteger(n) && n > 0 ? Math.min(n, REFUSAL_PROBLEMS_READ_MAX) : 0;
+                for (let i = 0; i < len; i += 1) {
+                    const item = guardedRead(() => readOwnDataValue(list, String(i)));
+                    if (typeof item !== 'object' || item === null)
+                        continue;
+                    add(guardedRead(() => readOwnDataValue(item, 'field')));
+                }
+            }
+        }
+        catch {
+        }
+    }
+    return Object.freeze(out);
 }
 const DISPLAYABLE_WIRE_CODE = /^[A-Za-z0-9._:-]{1,64}$/;
 export function isDisplayableWireCode(s) {

package/dist/wireRefusalCopy.d.ts

@@ -16,6 +16,17 @@ export interface UsageWindowExhaustedDetail {
 }
 export declare function usageWindowExhaustedFromError(err: unknown): UsageWindowExhaustedDetail | null;
 export declare function usageWindowExhaustedContent(detail: UsageWindowExhaustedDetail, lang?: UiLanguage): string;
+export interface QuotaExhaustedView {
+    readonly windowType?: 'fiveHour' | 'weekly' | 'budget';
+    readonly remaining?: number;
+    readonly resetAt?: string | null;
+    readonly isEstimate?: boolean;
+    readonly pool?: string;
+    readonly retryAfterSec?: number;
+}
+export declare function quotaExhaustedFromError(err: {} | null | undefined): QuotaExhaustedView | null;
+export declare function quotaResetInstantText(resetAtIso: string, nowMs: number, lang?: UiLanguage): string | undefined;
+export declare function quotaExhaustedContent(detail: QuotaExhaustedView, nowMs: number, lang?: UiLanguage): string;
 export interface FleetLeaseUnavailableDetail {
     code: typeof FLEET_LEASE_UNAVAILABLE;
     reason?: string;
@@ -52,7 +63,6 @@ export interface SettingsPermissionBucketRefusalDetail {
     readonly index?: number;
     readonly folded?: true;
 }
-export declare function settingsPermissionBucketRefusalFromError(err: unknown): SettingsPermissionBucketRefusalDetail | null;
 export type FieldLimitRefusalReason = 'over_cap' | 'too_long' | 'bad_entry';
 export interface FieldLimitRefusalDetail {
     readonly field: string;
@@ -63,6 +73,7 @@ export interface FieldLimitRefusalDetail {
     readonly folded?: true;
 }
 export declare function fieldLimitRefusalFromError(err: {} | null | undefined): FieldLimitRefusalDetail | null;
+export declare function fieldLimitRefusalOfSettingsHooks(refusal: SettingsHooksRefusal | null | undefined): FieldLimitRefusalDetail | null;
 export declare function fieldLimitRefusalContent(detail: FieldLimitRefusalDetail, lang?: UiLanguage): string;
 export declare function settingsPermissionBucketRefusalContent(detail: SettingsPermissionBucketRefusalDetail, lang?: UiLanguage): string;
 declare const PAYLOAD_TOO_LARGE = "request.payload_too_large";
@@ -129,6 +140,18 @@ export interface AutonomyLaneRefusalDetail {
 }
 export declare function autonomyLaneRefusalFromError(err: unknown): AutonomyLaneRefusalDetail | null;
 export declare function autonomyLaneRefusalContent(lang?: UiLanguage): string;
+export interface UnsupportedRuleRefusalProblem {
+    readonly code: string;
+    readonly field?: string;
+    readonly entry?: string;
+}
+export interface UnsupportedRuleRefusalDetail {
+    readonly code: string;
+    readonly problems?: readonly UnsupportedRuleRefusalProblem[];
+    readonly folded?: true;
+}
+export declare function unsupportedRuleRefusalFromError(err: {} | null | undefined): UnsupportedRuleRefusalDetail | null;
+export declare function unsupportedRuleRefusalContent(detail: UnsupportedRuleRefusalDetail, lang?: UiLanguage): string;
 export interface UserAttachmentRefusalDetail {
     readonly code: typeof USER_ATTACHMENT_INVALID_ERROR_CODE;
     readonly retryable: false;