@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/wireFailureShape.d.ts

@@ -24,7 +24,6 @@ export type ThrownExtraReading = {
 };
 export declare function readThrownExtra(o: {} | null | undefined): ThrownExtraReading;
 export interface ThrownExtraSnapshot {
-    readonly sdkInstance: boolean;
     readonly bag: ThrownExtraReading;
 }
 export declare function readThrownExtraSnapshot(o: {} | null | undefined): ThrownExtraSnapshot;
@@ -32,6 +31,7 @@ export declare const PROTOCOL_ERROR_NAME: Readonly<{
     readonly ApprovalBindingMismatchError: "ApprovalBindingMismatchError";
     readonly ApprovalStaleError: "ApprovalStaleError";
     readonly AskDecidedError: "AskDecidedError";
+    readonly CheckpointInvalidOutcomeError: "CheckpointInvalidOutcomeError";
     readonly ConflictError: "ConflictError";
     readonly NotFoundError: "NotFoundError";
     readonly ParkedResumeStartupError: "ParkedResumeStartupError";
@@ -47,18 +47,15 @@ export declare const PROTOCOL_ERROR_NAME: Readonly<{
     readonly UsageWindowExhaustedError: "UsageWindowExhaustedError";
 }>;
 export type ProtocolErrorName = (typeof PROTOCOL_ERROR_NAME)[keyof typeof PROTOCOL_ERROR_NAME];
-export declare function isSdkErrorInstance(o: object): boolean;
 export type ProtocolErrorNameReading = {
     readonly state: 'named';
     readonly name: ProtocolErrorName;
 } | {
     readonly state: 'absent';
-} | {
-    readonly state: 'sdk-instance';
 } | {
     readonly state: 'unreadable';
 };
-export declare function protocolErrorNameReading(e: object, extra?: ThrownExtraSnapshot): 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, notePresence?: (presence: SlotPresence) => void): ThrownStatusReading;
@@ -69,6 +66,26 @@ export interface OwnSlotRead {
 }
 export declare function slotPresenceOf(o: object, key: string): SlotPresence;
 export declare function slotReadOf(o: object, key: string): OwnSlotRead;
+export type InSlotRead = {
+    readonly state: 'absent';
+} | {
+    readonly state: 'present';
+    readonly value: {} | null | undefined;
+} | {
+    readonly state: 'present_unreadable';
+} | {
+    readonly state: 'unproven';
+};
+export declare function inSlotReadOf(o: object, key: string): InSlotRead;
+export type InValueRead = {
+    readonly state: 'absent';
+} | {
+    readonly state: 'present';
+    readonly value: {} | null | undefined;
+} | {
+    readonly state: 'unproven';
+};
+export declare function inValueOf(o: object, key: string): InValueRead;
 export declare function readErrorNumber(o: object, key: string): number | undefined;
 export declare function readErrorRecord(o: object, key: string): object | undefined;
 export declare function readErrorPresent(o: object, key: string): {} | null | undefined;

package/dist/wireFailureShape.js

@@ -91,39 +91,39 @@ export function readThrownExtra(o) {
 }
 export function readThrownExtraSnapshot(o) {
     if (o === null || o === undefined || (typeof o !== 'object' && typeof o !== 'function'))
-        return { sdkInstance: false, bag: { state: 'absent' } };
+        return { bag: { state: 'absent' } };
     let at;
     try {
         at = extraSlotOf(o);
     }
     catch {
-        return { sdkInstance: false, bag: { state: 'unreadable' } };
+        return { bag: { state: 'unreadable' } };
     }
-    const sdkInstance = at.kind === 'sdk-class';
     if (at.kind === 'own-accessor')
-        return { sdkInstance, bag: { state: 'unreadable' } };
+        return { bag: { state: 'unreadable' } };
     if (at.kind === 'none')
-        return { sdkInstance, bag: { state: 'absent' } };
+        return { bag: { state: 'absent' } };
     let slot;
     try {
         slot = at.kind === 'own-data' ? at.value : Reflect.get(o, EXTRA_KEY);
     }
     catch {
-        return { sdkInstance, bag: { state: 'unreadable' } };
+        return { bag: { state: 'unreadable' } };
     }
     try {
         if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
-            return { sdkInstance, bag: { state: 'absent' } };
+            return { bag: { state: 'absent' } };
     }
     catch {
-        return { sdkInstance, bag: { state: 'unreadable' } };
+        return { bag: { state: 'unreadable' } };
     }
-    return { sdkInstance, bag: { state: 'object', value: slot } };
+    return { bag: { state: 'object', value: slot } };
 }
 export const PROTOCOL_ERROR_NAME = Object.freeze({
     ApprovalBindingMismatchError: 'ApprovalBindingMismatchError',
     ApprovalStaleError: 'ApprovalStaleError',
     AskDecidedError: 'AskDecidedError',
+    CheckpointInvalidOutcomeError: 'CheckpointInvalidOutcomeError',
     ConflictError: 'ConflictError',
     NotFoundError: 'NotFoundError',
     ParkedResumeStartupError: 'ParkedResumeStartupError',
@@ -139,20 +139,10 @@ export const PROTOCOL_ERROR_NAME = Object.freeze({
     UsageWindowExhaustedError: 'UsageWindowExhaustedError',
 });
 const PROTOCOL_ERROR_NAMES = new Set(Object.values(PROTOCOL_ERROR_NAME));
-export function isSdkErrorInstance(o) {
-    try {
-        return extraSlotOf(o).kind === 'sdk-class';
-    }
-    catch {
-        return false;
-    }
-}
-export function protocolErrorNameReading(e, extra) {
+export function protocolErrorNameReading(e) {
     if (typeof e !== 'object' || e === null)
         return { state: 'absent' };
     try {
-        if (extra !== undefined ? extra.sdkInstance : isSdkErrorInstance(e))
-            return { state: 'sdk-instance' };
         const name = ownDataField(e, 'name');
         return typeof name === 'string' && PROTOCOL_ERROR_NAMES.has(name) ? { state: 'named', name: name } : { state: 'absent' };
     }
@@ -181,31 +171,62 @@ export function readThrownStatusSlot(o, notePresence) {
         return undefined;
     return typeof raw === 'number' ? raw : THROWN_SLOT_UNREADABLE;
 }
-function readOwnSlot(o, key, withPresence) {
+function observeOwnSlot(o, key, withPresence) {
     let d;
     try {
         d = Object.getOwnPropertyDescriptor(o, key);
     }
     catch {
-        return { value: THROWN_SLOT_UNREADABLE, presence: 'unreadable' };
+        return { kind: 'thrown' };
     }
     if (d !== undefined)
-        return Object.hasOwn(d, 'value') ? { value: d.value, presence: 'present' } : { value: THROWN_SLOT_UNREADABLE, presence: 'unreadable' };
+        return Object.hasOwn(d, 'value') ? { kind: 'data', value: d.value } : { kind: 'accessor' };
     if (!withPresence)
-        return { value: undefined, presence: 'unreadable' };
+        return { kind: 'not-own', inChain: 'unasked' };
     try {
-        return { value: undefined, presence: key in o ? 'unreadable' : 'absent' };
+        return { kind: 'not-own', inChain: key in o ? 'inherited' : 'none' };
     }
     catch {
-        return { value: undefined, presence: 'unreadable' };
+        return { kind: 'not-own', inChain: 'in-thrown' };
     }
 }
+function readOwnSlot(o, key, withPresence) {
+    const ob = observeOwnSlot(o, key, withPresence);
+    if (ob.kind === 'data')
+        return { value: ob.value, presence: 'present' };
+    if (ob.kind === 'thrown' || ob.kind === 'accessor')
+        return { value: THROWN_SLOT_UNREADABLE, presence: 'unreadable' };
+    return { value: undefined, presence: ob.inChain === 'none' ? 'absent' : 'unreadable' };
+}
 export function slotPresenceOf(o, key) {
     return slotReadOf(o, key).presence;
 }
 export function slotReadOf(o, key) {
     return readOwnSlot(o, key, true);
 }
+export function inSlotReadOf(o, key) {
+    const claimed = key in o;
+    const ob = observeOwnSlot(o, key, true);
+    if (ob.kind === 'thrown')
+        return { state: 'unproven' };
+    if (ob.kind === 'data' || ob.kind === 'accessor') {
+        if (!claimed)
+            return { state: 'unproven' };
+        return ob.kind === 'data' ? { state: 'present', value: ob.value } : { state: 'present_unreadable' };
+    }
+    if (ob.inChain === 'in-thrown' || ob.inChain === 'unasked')
+        return { state: 'unproven' };
+    const again = ob.inChain === 'inherited';
+    if (!claimed)
+        return again ? { state: 'unproven' } : { state: 'absent' };
+    return again ? { state: 'present_unreadable' } : { state: 'unproven' };
+}
+export function inValueOf(o, key) {
+    const s = inSlotReadOf(o, key);
+    if (s.state === 'present_unreadable')
+        return { state: 'present', value: o[key] };
+    return s;
+}
 function readErrorSlot(obj, key, accept) {
     try {
         const topRaw = readThrownSlot(obj, key, 'data');

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { CONFLICT_SESSION_ARCHIVE_STAMPED, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { CONFLICT_SESSION_ARCHIVE_STAMPED, CONFLICT_SESSION_ID_RETIRED, FLEET_LEASE_UNAVAILABLE, LIMIT_RATE_EXCEEDED, RATE_EXCEEDED_RUN_CONCURRENCY_CAP, REQUEST_ENV_CREDENTIAL_REFUSED, REQUEST_AUTONOMY_LANE_REFUSED, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 import type { UiLanguage } from './env/uiLanguage.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
@@ -53,6 +53,7 @@ export interface SessionDeleteConflictDetail {
 }
 export declare function sessionDeleteConflictFromError(err: unknown): SessionDeleteConflictDetail | null;
 export declare function sessionDeleteConflictContent(detail: Pick<SessionDeleteConflictDetail, 'kind' | 'remaining' | 'activeTaskId'>, lang?: UiLanguage): string;
+declare const FIELD_INVALID = "request.field_invalid";
 export type SettingsPermissionBucket = 'allow' | 'deny' | 'ask';
 export type SettingsPermissionBucketRefusalReason = 'over_cap' | 'bad_entry';
 export interface SettingsPermissionBucketRefusalDetail {
@@ -145,6 +146,35 @@ export interface SessionArchiveStampedDetail {
 export declare function sessionArchiveStampedFromError(err: {} | null | undefined): SessionArchiveStampedDetail | null;
 export type SessionArchiveStampedScenario = 'fork' | 'push';
 export declare function sessionArchiveStampedContent(lang?: UiLanguage, scenario?: SessionArchiveStampedScenario): string;
+export interface EnvCredentialRefusalDetail {
+    readonly code: typeof REQUEST_ENV_CREDENTIAL_REFUSED;
+    readonly names?: readonly string[];
+    readonly folded?: true;
+}
+export declare function envCredentialRefusalFromError(err: {} | null | undefined): EnvCredentialRefusalDetail | null;
+export declare function envCredentialRefusalContent(detail: Pick<EnvCredentialRefusalDetail, 'names' | 'folded'>, lang?: UiLanguage): string;
+export interface SessionIdRetiredDetail {
+    readonly code: typeof CONFLICT_SESSION_ID_RETIRED;
+    readonly folded?: true;
+}
+export declare function sessionIdRetiredFromError(err: {} | null | undefined): SessionIdRetiredDetail | null;
+export declare function sessionIdRetiredContent(detail: Pick<SessionIdRetiredDetail, 'folded'>, lang?: UiLanguage): string;
+export type UnreadRequestMembersFace = 'settings_hooks' | 'settings_env' | 'settings_other' | 'mcp_transport' | 'a2a_headers';
+export interface UnreadRequestMembersDetail {
+    readonly code: typeof FIELD_INVALID;
+    readonly field: string;
+    readonly face: UnreadRequestMembersFace;
+    readonly folded?: true;
+}
+export declare function unreadRequestMembersFromError(err: {} | null | undefined): UnreadRequestMembersDetail | null;
+export declare function unreadRequestMembersContent(detail: Pick<UnreadRequestMembersDetail, 'field' | 'face' | 'folded'>, lang?: UiLanguage): string;
+export interface RunConcurrencyCapDetail {
+    readonly code: typeof LIMIT_RATE_EXCEEDED;
+    readonly reason: typeof RATE_EXCEEDED_RUN_CONCURRENCY_CAP;
+    readonly retryAfterSec?: number;
+}
+export declare function runConcurrencyCapFromError(err: {} | null | undefined): RunConcurrencyCapDetail | null;
+export declare function runConcurrencyCapContent(detail: Pick<RunConcurrencyCapDetail, 'retryAfterSec'>, lang?: UiLanguage): string;
 export interface UnsupportedRuleRefusalProblem {
     readonly code: string;
     readonly field?: string;

package/dist/wireRefusalCopy.js

@@ -1,7 +1,8 @@
-import { PROTOCOL_ERROR_NAME, REFUSAL_PROBLEMS_READ_MAX, THROWN_SLOT_UNREADABLE, effectiveWireCodeReading, isSlotCarrier, protocolErrorNameOf, readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
+import { PROTOCOL_ERROR_NAME, REFUSAL_PROBLEMS_READ_MAX, THROWN_SLOT_UNREADABLE, effectiveWireCodeReading, isSlotCarrier, protocolErrorNameOf, readErrorNumber, readErrorPresent, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readRefusalSlots, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
 import { appendOwnElement, guardedRead, readOwnDataValue, readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, CONFLICT_SESSION_ARCHIVE_STAMPED, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, CONFLICT_SESSION_ARCHIVE_STAMPED, CONFLICT_SESSION_ID_RETIRED, FLEET_LEASE_UNAVAILABLE, LIMIT_RATE_EXCEEDED, RATE_EXCEEDED_RUN_CONCURRENCY_CAP, REQUEST_ENV_CREDENTIAL_REFUSED, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
+import { quoteUntrustedForSentence } from './displayUntrusted.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
 import { SETTINGS_ECHO_CALLER_TEXT } from './generated/settingsSchemaFns.js';
@@ -815,6 +816,162 @@ export function sessionArchiveStampedFromError(err) {
 export function sessionArchiveStampedContent(lang, scenario) {
     return renderMessage(msg(scenario === 'fork' ? 'notice.wireRefusal.sessionArchiveStamped.fork' : 'notice.wireRefusal.sessionArchiveStamped'), lang);
 }
+const ENV_CREDENTIAL_NAME_SHOWN_MAX = 80;
+const ENV_CREDENTIAL_NAMES_SHOWN = 8;
+export function envCredentialRefusalFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        const effective = effectiveWireCodeReading(err);
+        if (effective.code !== REQUEST_ENV_CREDENTIAL_REFUSED)
+            return null;
+        const names = guardedRead(() => envCredentialNamesOf(readErrorPresent(err, 'entries')));
+        return Object.freeze({
+            code: REQUEST_ENV_CREDENTIAL_REFUSED,
+            ...(names !== undefined ? { names } : {}),
+            ...(effective.folded ? { folded: true } : {}),
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function envCredentialNamesOf(list) {
+    if (!Array.isArray(list))
+        return undefined;
+    const out = [];
+    const len = Math.min(list.length, REFUSAL_PROBLEMS_READ_MAX);
+    for (let i = 0; i < len; i++) {
+        const key = guardedRead(() => {
+            const item = readOwnDataValue(list, String(i));
+            if (typeof item !== 'object' || item === null)
+                return undefined;
+            const k = readOwnDataValue(item, 'key');
+            return typeof k === 'string' && k !== '' ? k : undefined;
+        });
+        if (key !== undefined && !out.includes(key))
+            appendOwnElement(out, key);
+    }
+    return out.length === 0 ? undefined : Object.freeze(out);
+}
+export function envCredentialRefusalContent(detail, lang) {
+    const head = renderMessage(msg(detail.folded === true ? 'notice.wireRefusal.envCredential.folded' : 'notice.wireRefusal.envCredential'), lang);
+    const quoted = (detail.names ?? []).slice(0, ENV_CREDENTIAL_NAMES_SHOWN).map((n) => quoteUntrustedForSentence(n, ENV_CREDENTIAL_NAME_SHOWN_MAX)).filter((q) => q !== undefined);
+    const more = (detail.names?.length ?? 0) > ENV_CREDENTIAL_NAMES_SHOWN ? ', …' : '';
+    const named = quoted.length > 0 ? ` · ${renderMessage(msg('notice.wireRefusal.envCredential.names', { names: quoted.join(', ') + more }), lang)}` : '';
+    return `${head}${named} · ${renderMessage(msg('notice.wireRefusal.envCredential.remedy'), lang)}`;
+}
+export function sessionIdRetiredFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        const effective = effectiveWireCodeReading(err);
+        if (effective.code !== CONFLICT_SESSION_ID_RETIRED)
+            return null;
+        return Object.freeze({ code: CONFLICT_SESSION_ID_RETIRED, ...(effective.folded ? { folded: true } : {}) });
+    }
+    catch {
+        return null;
+    }
+}
+export function sessionIdRetiredContent(detail, lang) {
+    return renderMessage(msg(detail.folded === true ? 'notice.wireRefusal.sessionIdRetired.folded' : 'notice.wireRefusal.sessionIdRetired'), lang);
+}
+function isIndexedMemberCoordinate(field, list, member) {
+    const head = `${list}[`;
+    if (!field.startsWith(head))
+        return false;
+    const close = field.indexOf(']', head.length);
+    if (close < 0 || !/^[0-9]+$/.test(field.slice(head.length, close)))
+        return false;
+    const rest = field.slice(close + 1);
+    return rest === `.${member}` || rest.startsWith(`.${member}.`);
+}
+function unreadMembersFaceOf(field) {
+    if (/^settings\.hooks(?:\.|$)/.test(field))
+        return 'settings_hooks';
+    if (/^settings\.env(?:\.|$)/.test(field))
+        return 'settings_env';
+    if (/^settings\.[^\s.[\]]/.test(field))
+        return 'settings_other';
+    if (isIndexedMemberCoordinate(field, 'mcpServers', 'transport'))
+        return 'mcp_transport';
+    if (isIndexedMemberCoordinate(field, 'a2aPeers', 'headers'))
+        return 'a2a_headers';
+    return undefined;
+}
+export function unreadRequestMembersFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        const effective = effectiveWireCodeReading(err);
+        if (effective.code !== FIELD_INVALID)
+            return null;
+        const slots = readRefusalSlots(err, ['field', 'reason', 'detail']);
+        if (slots.reason.present || slots.detail.present)
+            return null;
+        const field = slots.field.word;
+        if (field === undefined)
+            return null;
+        const face = unreadMembersFaceOf(field);
+        if (face === undefined)
+            return null;
+        return Object.freeze({ code: FIELD_INVALID, field, face, ...(effective.folded ? { folded: true } : {}) });
+    }
+    catch {
+        return null;
+    }
+}
+function unreadMembersPartKey(face) {
+    switch (face) {
+        case 'settings_hooks':
+            return 'notice.wireRefusal.unreadMembers.part.settingsHooks';
+        case 'settings_env':
+            return 'notice.wireRefusal.unreadMembers.part.settingsEnv';
+        case 'settings_other':
+            return 'notice.wireRefusal.unreadMembers.part.settingsOther';
+        case 'mcp_transport':
+            return 'notice.wireRefusal.unreadMembers.part.mcpTransport';
+        case 'a2a_headers':
+            return 'notice.wireRefusal.unreadMembers.part.a2aHeaders';
+    }
+}
+const UNREAD_MEMBERS_FIELD_SHOWN_MAX = 120;
+export function unreadRequestMembersContent(detail, lang) {
+    const folded = detail.folded === true;
+    const part = renderMessage(msg(unreadMembersPartKey(detail.face)), lang);
+    const head = renderMessage(msg(folded ? 'notice.wireRefusal.unreadMembers.folded' : 'notice.wireRefusal.unreadMembers', { part }), lang);
+    const quoted = quoteUntrustedForSentence(detail.field, UNREAD_MEMBERS_FIELD_SHOWN_MAX);
+    const where = quoted !== undefined ? ` · ${renderMessage(msg('notice.wireRefusal.unreadMembers.where', { where: quoted }), lang)}` : '';
+    return `${head}${where} · ${renderMessage(msg(folded ? 'notice.wireRefusal.unreadMembers.folded.remedy' : 'notice.wireRefusal.unreadMembers.remedy'), lang)}`;
+}
+export function runConcurrencyCapFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return null;
+        if (effectiveWireCodeReading(err).code !== LIMIT_RATE_EXCEEDED)
+            return null;
+        if (readRefusalSlots(err, ['reason']).reason.word !== RATE_EXCEEDED_RUN_CONCURRENCY_CAP)
+            return null;
+        const rawSec = readErrorNumber(err, 'retryAfterSec');
+        const sec = nonNegativeFinite(rawSec)
+            ? Math.ceil(rawSec)
+            : (() => {
+                const rawMs = readThrownSlot(err, 'retryAfterMs', 'data');
+                return nonNegativeFinite(rawMs) ? Math.ceil(rawMs / 1000) : undefined;
+            })();
+        return Object.freeze({ code: LIMIT_RATE_EXCEEDED, reason: RATE_EXCEEDED_RUN_CONCURRENCY_CAP, ...(sec !== undefined ? { retryAfterSec: sec } : {}) });
+    }
+    catch {
+        return null;
+    }
+}
+export function runConcurrencyCapContent(detail, lang) {
+    const head = renderMessage(msg('notice.wireRefusal.runConcurrencyCap.head'), lang);
+    return detail.retryAfterSec !== undefined
+        ? `${head} · ${renderMessage(msg('notice.wireRefusal.sendAgainAbout', { wait: humanWait(detail.retryAfterSec) }), lang)}`
+        : `${head} · ${renderMessage(msg('notice.wireRefusal.runConcurrencyCap.unknownWait'), lang)}`;
+}
 const REQUEST_UNPROCESSABLE = 'request.unprocessable';
 const UNSUPPORTED_RULE_PROBLEMS_MAX = REFUSAL_PROBLEMS_READ_MAX;
 const nonEmptyString = (v) => (typeof v === 'string' && v !== '' ? v : undefined);
@@ -980,3 +1137,11 @@ export function userAttachmentRefusalFromError(err) {
 export function userInvokedSkillRefusalFromError(err) {
     return effectiveWireErrorCode(err) === USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE ? { code: USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE, retryable: false } : null;
 }
+const _pinRequestField = [true, true, true, true, true, true, true, true];
+void _pinRequestField;
+const _pinSettingsHooks = [true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true];
+void _pinSettingsHooks;
+const _pinAttachment = [true, true, true];
+void _pinAttachment;
+const _pinWallSource = [true, true, true];
+void _pinWallSource;