@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/projectMemory.js

@@ -0,0 +1,70 @@
+import { engineCapValue } from './engineCapsCache.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+export const PROJECT_MEMORY_DISABLED = 'disabled';
+export const PROJECT_MEMORY_WORDS = Object.freeze(['on', PROJECT_MEMORY_DISABLED, 'absent']);
+export function projectMemoryOf(manifest) {
+    const raw = guardedRead(() => readOwnDataValue(manifest, 'projectMemory'));
+    return typeof raw === 'string' ? PROJECT_MEMORY_WORDS.find((w) => w === raw) : undefined;
+}
+const PROJECT_MEMORY_CAPABILITY_KEY = 'projectMemory';
+const CAP_CONFIRMED = Object.freeze({ kind: 'confirmed' });
+const CAP_ABSENT = Object.freeze({ kind: 'absent' });
+const CAP_DECLINED = Object.freeze({ kind: 'declined' });
+const CAP_UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const CAP_UNOBSERVED = Object.freeze({ kind: 'unobserved' });
+export function observedProjectMemoryCapability(baseUrl) {
+    try {
+        const picked = baseUrl === undefined ? engineWireTargetBaseUrl() : baseUrl;
+        const slot = engineCapValue(typeof picked === 'string' ? picked : undefined, PROJECT_MEMORY_CAPABILITY_KEY);
+        switch (slot.kind) {
+            case 'unobserved':
+                return CAP_UNOBSERVED;
+            case 'not_reported':
+                return CAP_ABSENT;
+            case 'unreadable':
+                return CAP_UNREADABLE;
+            case 'null':
+                return CAP_DECLINED;
+            case 'value':
+                return slot.value === true ? CAP_CONFIRMED : CAP_DECLINED;
+        }
+    }
+    catch {
+        return CAP_UNOBSERVED;
+    }
+}
+const EMPTY_DECLARATION = Object.freeze({ field: Object.freeze({}) });
+function readingClassOf(reading) {
+    const kind = guardedRead(() => (typeof reading === 'object' && reading !== null ? readOwnDataValue(reading, 'kind') : undefined));
+    return kind === 'confirmed' || kind === 'absent' || kind === 'declined' ? kind : 'unreadable';
+}
+export function projectMemoryDeclaration(intent, reading) {
+    if (intent === undefined || intent === null)
+        return EMPTY_DECLARATION;
+    if (intent !== PROJECT_MEMORY_DISABLED) {
+        throw new TypeError(`projectMemoryDeclaration: projectMemory 只接受字面量 '${PROJECT_MEMORY_DISABLED}' 或缺席 —— 收到 ${Array.isArray(intent) ? 'typeof=object / array' : `typeof=${typeof intent}`}。坏词在读数判定之前就拒:「这一次不发」不许顺手吞掉一个打错字的声明。错误文本只报形状,不回显值。`);
+    }
+    const cls = readingClassOf(reading);
+    if (cls === 'confirmed')
+        return Object.freeze({ field: Object.freeze({ projectMemory: PROJECT_MEMORY_DISABLED }) });
+    return Object.freeze({
+        field: Object.freeze({}),
+        withheld: Object.freeze({ cause: (cls === 'absent' ? 'capability_absent' : cls === 'declined' ? 'capability_declined' : 'capability_unreadable') }),
+    });
+}
+const WITHHELD_KEYS = Object.freeze({
+    capability_absent: 'session.projectMemory.withheld.absent',
+    capability_declined: 'session.projectMemory.withheld.declined',
+    capability_unreadable: 'session.projectMemory.withheld.unreadable',
+});
+const WITHHELD_UNKNOWN_KEY = 'session.projectMemory.withheld.unknown';
+export function projectMemoryWithheldNotice(withheld, lang) {
+    const cause = withheldCauseOf(withheld);
+    return renderMessage(msg(cause === undefined ? WITHHELD_UNKNOWN_KEY : WITHHELD_KEYS[cause]), lang);
+}
+function withheldCauseOf(withheld) {
+    const cause = guardedRead(() => (typeof withheld === 'object' && withheld !== null ? readOwnDataValue(withheld, 'cause') : undefined));
+    return typeof cause === 'string' && Object.hasOwn(WITHHELD_KEYS, cause) ? cause : undefined;
+}

package/dist/promptBlockedCopy.d.ts

@@ -1,5 +1,6 @@
 import type { RunTerminalRead } from './runTerminal.js';
-export declare const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = "UserPromptSubmit operation blocked by hook";
+import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD } from './rowKind.js';
+export { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD };
 export declare function runBlockedText(blocked: Extract<RunTerminalRead, {
     kind: 'blocked';
 }>): string;

package/dist/promptBlockedCopy.js

@@ -1,6 +1,7 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { stripSystemReminderTagTokens, unwrapSystemReminder } from './systemReminderTag.js';
-export const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = 'UserPromptSubmit operation blocked by hook';
+import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD } from './rowKind.js';
+export { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD };
 const RUN_BLOCKED_REASONED = 'Run blocked';
 const RUN_BLOCKED_NO_REASON = 'Run blocked (the agent reported it cannot proceed)';
 const HOOK_WORDS_SHOWN_MAX = 1000;

package/dist/promptDelivery.d.ts

@@ -3,16 +3,35 @@ import { type SelfHealOutcome } from './adapter/activeRunSelfHeal.js';
 import type { HumanTurnDelivered } from './humanTurn.js';
 export interface PromptDeliveryRecord {
     readonly u: string;
-    readonly s: 'a' | 'd';
+    readonly s: 'a' | 'd' | 'r';
     readonly by?: 'frame' | 'steer_receipt';
     readonly share?: 'full' | 'partial';
+    readonly n?: string;
+    readonly why?: NotDeliveredWhy;
 }
+export type NotDeliveredWhy = 'pre_send' | 'engine_rejected' | 'encoder_refused';
+export type DeliveryState = 'delivered' | 'refused' | 'unknown';
 export interface PromptDeliveryLedger {
     attempted(batchUuids: readonly string[], opts?: {
         readonly generation?: number;
+        readonly attemptId?: string;
     }): readonly PromptDeliveryRecord[];
-    deliveredByFrame(batchUuids: readonly string[] | HumanTurnDelivered, event: AgentEvent): readonly PromptDeliveryRecord[];
-    deliveredBySteerReceipt(batchUuids: readonly string[] | HumanTurnDelivered, outcome: SelfHealOutcome): readonly PromptDeliveryRecord[];
+    deliveredByFrame(batchUuids: readonly string[] | HumanTurnDelivered, event: AgentEvent, opts?: {
+        readonly attemptId?: string;
+    }): readonly PromptDeliveryRecord[];
+    deliveredBySteerReceipt(batchUuids: readonly string[] | HumanTurnDelivered, outcome: SelfHealOutcome, opts?: {
+        readonly attemptId?: string;
+    }): readonly PromptDeliveryRecord[];
+    notDelivered(batchUuids: readonly string[], opts: {
+        readonly attemptId: string;
+        readonly why: NotDeliveredWhy;
+    }): readonly PromptDeliveryRecord[];
+    deliveryStateOf(uuid: string): DeliveryState;
+    attemptedItems(groups: readonly (readonly string[])[], opts?: {
+        readonly generation?: number;
+        readonly attemptId?: string;
+    }): readonly PromptDeliveryRecord[];
+    batchGroupsOf(uuid: string): readonly (readonly string[])[] | undefined;
     isAttempted(uuid: string): boolean;
     isDelivered(uuid: string): boolean;
     knownUndelivered(uuid: string): boolean;
@@ -23,6 +42,7 @@ export interface PromptDeliveryLedger {
     toRecords(): readonly PromptDeliveryRecord[];
     fromRecords(records: readonly PromptDeliveryRecord[]): readonly PromptDeliveryRecord[];
     knownUndeliveredMessage(message: object | null | undefined): boolean;
+    deliveryStateOfMessage(message: object | null | undefined): DeliveryState;
     withoutUndelivered<T>(messages: readonly T[]): T[];
 }
 export declare function frameProvesDelivery(event: object | null | undefined): boolean;

package/dist/promptDelivery.js

@@ -1,5 +1,6 @@
 import { activeRunBusySignal } from './adapter/runStream.js';
 import { selfHealSubmissionDisposition } from './adapter/activeRunSelfHeal.js';
+import { guardedRead, readOwnDataValue } from './ownKey.js';
 const uuidOk = (u) => typeof u === 'string' && u.length > 0;
 function isArraySafe(v) {
     try {
@@ -21,6 +22,15 @@ function generationOpt(opts) {
         return undefined;
     }
 }
+function attemptIdOpt(opts) {
+    const v = ownDataOf(opts, 'attemptId');
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+const ownDataOf = (o, key) => guardedRead(() => readOwnDataValue(o, key));
+function notDeliveredWhyWord(v) {
+    const words = { pre_send: true, engine_rejected: true, encoder_refused: true };
+    return typeof v === 'string' && Object.hasOwn(words, v) ? v : undefined;
+}
 const levelOf = (rec) => !Object.hasOwn(rec, 'by') ? 1 : Object.hasOwn(rec, 'share') && rec.share === 'partial' ? 2 : 3;
 function deliveredByWord(v) {
     const words = { frame: true, steer_receipt: true };
@@ -34,7 +44,7 @@ function ownExtension(rec, key) {
     const desc = Object.getOwnPropertyDescriptor(rec, key);
     if (desc === undefined)
         return key in rec ? { kind: 'unreadable' } : { kind: 'absent' };
-    return 'value' in desc ? { kind: 'value', value: desc.value } : { kind: 'unreadable' };
+    return Object.hasOwn(desc, 'value') ? { kind: 'value', value: desc.value } : { kind: 'unreadable' };
 }
 function cleanBatch(batch) {
     if (!isArraySafe(batch))
@@ -68,24 +78,41 @@ function readRecord(raw) {
     catch {
         return undefined;
     }
-    if (!uuidOk(u) || (s !== 'a' && s !== 'd'))
+    if (!uuidOk(u) || (s !== 'a' && s !== 'd' && s !== 'r'))
         return undefined;
     const legacy = { u, s };
     try {
         let rec = legacy;
-        if (s === 'd') {
-            const byExt = ownExtension(raw, 'by');
-            const shareExt = ownExtension(raw, 'share');
-            const by = byExt.kind === 'value' ? deliveredByWord(byExt.value) : undefined;
-            const share = shareExt.kind === 'value' ? deliveredShareWord(shareExt.value) : undefined;
-            if (by !== undefined && (shareExt.kind === 'absent' || share !== undefined))
-                rec = share === undefined ? { u, s, by } : { u, s, by, share };
+        if (s === 'r') {
+            const nExt = ownExtension(raw, 'n');
+            const whyExt = ownExtension(raw, 'why');
+            const n = nExt.kind === 'value' && typeof nExt.value === 'string' && nExt.value.length > 0 ? nExt.value : undefined;
+            const why = whyExt.kind === 'value' ? notDeliveredWhyWord(whyExt.value) : undefined;
+            if (n === undefined || why === undefined)
+                return undefined;
+            rec = { u, s, n, why };
+        }
+        else {
+            const nExt = ownExtension(raw, 'n');
+            const n = nExt.kind === 'value' && typeof nExt.value === 'string' && nExt.value.length > 0 ? nExt.value : undefined;
+            if (s === 'd') {
+                const byExt = ownExtension(raw, 'by');
+                const shareExt = ownExtension(raw, 'share');
+                const by = byExt.kind === 'value' ? deliveredByWord(byExt.value) : undefined;
+                const share = shareExt.kind === 'value' ? deliveredShareWord(shareExt.value) : undefined;
+                if (by !== undefined && (shareExt.kind === 'absent' || share !== undefined)) {
+                    rec = { u, s, by, ...(share !== undefined ? { share } : {}), ...(n !== undefined ? { n } : {}) };
+                }
+            }
+            else if (n !== undefined) {
+                rec = { u, s, n };
+            }
         }
         const dropped = Object.keys(raw).filter((k) => !Object.hasOwn(rec, k)).length;
         return { rec, dropped };
     }
     catch {
-        return { rec: legacy, dropped: 0 };
+        return s === 'r' ? undefined : { rec: legacy, dropped: 0 };
     }
 }
 function readTierStrict(holder, key) {
@@ -154,9 +181,22 @@ export function createPromptDeliveryLedger() {
     const attemptedSet = new Set();
     const deliveredLevel = new Map();
     const batchOfMap = new Map();
+    const groupsOfMap = new Map();
     const generationOf = new Map();
+    const attempts = new Map();
+    const startedAttempts = new Map();
+    const legacyOpen = new Set();
     const log = [];
     let droppedKeys = 0;
+    const attemptStateOf = (u, n) => attempts.get(u)?.get(n);
+    const setAttempt = (u, n, st) => {
+        let m = attempts.get(u);
+        if (m === undefined) {
+            m = new Map();
+            attempts.set(u, m);
+        }
+        m.set(n, st);
+    };
     const keep = (rec, into) => {
         const frozen = Object.freeze(rec);
         log.push(frozen);
@@ -164,50 +204,149 @@ export function createPromptDeliveryLedger() {
     };
     const add = (rec, into) => {
         if (rec.s === 'a') {
-            if (attemptedSet.has(rec.u))
+            if (rec.n === undefined) {
+                if (legacyOpen.has(rec.u))
+                    return;
+                attemptedSet.add(rec.u);
+                legacyOpen.add(rec.u);
+                keep(rec, into);
                 return;
+            }
+            let started = startedAttempts.get(rec.u);
+            if (started === undefined) {
+                started = new Set();
+                startedAttempts.set(rec.u, started);
+            }
+            if (started.has(rec.n))
+                return;
+            started.add(rec.n);
+            if (attemptStateOf(rec.u, rec.n) === undefined)
+                setAttempt(rec.u, rec.n, 'open');
+            attemptedSet.add(rec.u);
+            keep(rec, into);
+            return;
+        }
+        if (rec.s === 'r') {
+            if (rec.n === undefined)
+                return;
+            const st = attemptStateOf(rec.u, rec.n);
+            if (st === 'refused' || st === 'delivered')
+                return;
+            setAttempt(rec.u, rec.n, 'refused');
             attemptedSet.add(rec.u);
             keep(rec, into);
             return;
         }
         const level = levelOf(rec);
-        if ((deliveredLevel.get(rec.u) ?? 0) >= level)
+        const had = deliveredLevel.get(rec.u) ?? 0;
+        const settles = rec.n !== undefined && attemptStateOf(rec.u, rec.n) !== 'delivered';
+        if (had >= level && !settles)
             return;
-        deliveredLevel.set(rec.u, level);
+        if (level > had)
+            deliveredLevel.set(rec.u, level);
+        if (rec.n !== undefined)
+            setAttempt(rec.u, rec.n, 'delivered');
         keep(rec, into);
     };
-    const markDelivered = (batch, by) => {
+    const markDelivered = (batch, by, attemptId) => {
         const added = [];
         const { full, partial } = batchTiers(batch);
+        const n = attemptId === undefined ? {} : { n: attemptId };
         for (const u of full)
-            add({ u, s: 'd', by }, added);
+            add({ u, s: 'd', by, ...n }, added);
         for (const u of partial)
-            add({ u, s: 'd', by, share: 'partial' }, added);
+            add({ u, s: 'd', by, share: 'partial', ...n }, added);
         return Object.freeze(added);
     };
     const levelNow = (uuid) => (uuidOk(uuid) ? (deliveredLevel.get(uuid) ?? 0) : 0);
     const knownUndeliveredUuid = (uuid) => uuidOk(uuid) && attemptedSet.has(uuid) && !deliveredLevel.has(uuid);
+    const deliveryStateUuid = (uuid) => {
+        if (!uuidOk(uuid))
+            return 'unknown';
+        if (levelNow(uuid) >= 2)
+            return 'delivered';
+        if (levelNow(uuid) === 1)
+            return 'unknown';
+        const m = attempts.get(uuid);
+        if (m === undefined || m.size === 0 || legacyOpen.has(uuid))
+            return 'unknown';
+        for (const st of m.values())
+            if (st !== 'refused')
+                return 'unknown';
+        return 'refused';
+    };
+    const attemptedImpl = (batchUuids, opts) => {
+        const generation = generationOpt(opts);
+        const attemptId = attemptIdOpt(opts);
+        const batch = Object.freeze(cleanBatch(batchUuids));
+        const added = [];
+        for (const u of batch) {
+            batchOfMap.set(u, batch);
+            groupsOfMap.delete(u);
+            if (generation !== undefined) {
+                generationOf.delete(u);
+                generationOf.set(u, generation);
+            }
+            add(attemptId === undefined ? { u, s: 'a' } : { u, s: 'a', n: attemptId }, added);
+        }
+        return Object.freeze(added);
+    };
     const ledger = Object.freeze({
         attempted(batchUuids, opts) {
-            const generation = generationOpt(opts);
-            const batch = Object.freeze(cleanBatch(batchUuids));
+            return attemptedImpl(batchUuids, opts);
+        },
+        deliveredByFrame(batchUuids, event, opts) {
+            return frameProvesDelivery(event) ? markDelivered(batchUuids, 'frame', attemptIdOpt(opts)) : Object.freeze([]);
+        },
+        deliveredBySteerReceipt(batchUuids, outcome, opts) {
+            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids, 'steer_receipt', attemptIdOpt(opts)) : Object.freeze([]);
+        },
+        notDelivered(batchUuids, opts) {
             const added = [];
-            for (const u of batch) {
-                batchOfMap.set(u, batch);
-                if (generation !== undefined) {
-                    generationOf.delete(u);
-                    generationOf.set(u, generation);
-                }
-                add({ u, s: 'a' }, added);
+            const n = attemptIdOpt(opts);
+            const why = notDeliveredWhyWord(ownDataOf(opts, 'why'));
+            if (n === undefined || why === undefined)
+                return Object.freeze(added);
+            for (const u of cleanBatch(batchUuids)) {
+                if (attemptStateOf(u, n) !== 'open')
+                    continue;
+                add({ u, s: 'r', n, why }, added);
             }
             return Object.freeze(added);
         },
-        deliveredByFrame(batchUuids, event) {
-            return frameProvesDelivery(event) ? markDelivered(batchUuids, 'frame') : Object.freeze([]);
-        },
-        deliveredBySteerReceipt(batchUuids, outcome) {
-            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids, 'steer_receipt') : Object.freeze([]);
+        deliveryStateOf: (uuid) => deliveryStateUuid(uuid),
+        deliveryStateOfMessage: (message) => deliveryStateUuid(uuidOfMessage(message)),
+        attemptedItems(groups, opts) {
+            const clean = [];
+            if (isArraySafe(groups)) {
+                try {
+                    for (const g of groups) {
+                        const one = cleanBatch(g);
+                        if (one.length > 0)
+                            clean.push(Object.freeze(one));
+                    }
+                }
+                catch {
+                    clean.length = 0;
+                }
+            }
+            const flat = [];
+            const seen = new Set();
+            for (const g of clean) {
+                for (const u of g) {
+                    if (seen.has(u))
+                        continue;
+                    seen.add(u);
+                    flat.push(u);
+                }
+            }
+            const added = attemptedImpl(flat, opts);
+            const frozenGroups = Object.freeze(clean);
+            for (const u of flat)
+                groupsOfMap.set(u, frozenGroups);
+            return added;
         },
+        batchGroupsOf: (uuid) => (uuidOk(uuid) ? groupsOfMap.get(uuid) : undefined),
         isAttempted: (uuid) => uuidOk(uuid) && attemptedSet.has(uuid),
         isDelivered: (uuid) => levelNow(uuid) >= 2,
         knownUndelivered: (uuid) => knownUndeliveredUuid(uuid),

package/dist/providerRejection.d.ts

@@ -1,7 +1,25 @@
+import type { SDKAssistantMessageError } from '@sema-agent/agent-types';
 import { type RunTerminalFailureDetail } from './runTerminal.js';
 import { type ToolHistoryErrorCarrier } from './toolHistoryMismatch.js';
-export declare const PROVIDER_REJECTION_KINDS: readonly ["schema_invalid", "auth", "rate_limited", "resend_eligible", "unknown"];
+export declare function ccErrorOfProviderStatus(status: number): SDKAssistantMessageError | undefined;
+export declare function isMintedRowCcError(v: {} | null | undefined): v is SDKAssistantMessageError;
+export declare const PROVIDER_REJECTION_KINDS: readonly ["schema_invalid", "auth", "rate_limited", "resend_eligible", "unknown", "quota_exhausted"];
 export type ProviderRejectionKind = (typeof PROVIDER_REJECTION_KINDS)[number];
+export type ProviderRecourse = 'check_credentials' | 'switch_model' | 'fix_request';
+export declare function conditionRecourseOf(word: string | undefined): 'switch_model' | 'fix_request' | undefined;
+export declare function isServiceSideStatus(http: number): boolean;
+export declare function isHttpStatus(n: number | undefined): n is number;
+export declare function terminalRecourseOf(status: number | undefined, providerCondition: string | undefined): ProviderRecourse | undefined;
+export interface ResultWayOutFacts {
+    readonly status?: number;
+    readonly providerCondition?: string;
+    readonly credentialSource?: string;
+}
+export interface ProviderWayOut {
+    readonly word: ProviderRecourse;
+    readonly keySource?: string;
+}
+export declare function wayOutOfApiErrorFacts(facts: ResultWayOutFacts | undefined): ProviderWayOut | undefined;
 export interface ProviderRejectionResend {
     resend: 'edit_and_resend' | 'not_by_editing';
     text: string;

package/dist/providerRejection.js

@@ -1,3 +1,5 @@
+import { readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { readRunTerminal } from './runTerminal.js';
 import { classifyToolHistoryMismatch } from './toolHistoryMismatch.js';
 const PROVIDER_STATUS_TIERS = Object.freeze([
@@ -17,8 +19,19 @@ function providerStatusTier(status) {
             return tier;
     return UNTIERED;
 }
+export function ccErrorOfProviderStatus(status) {
+    if (typeof status !== 'number' || !Number.isInteger(status) || status < 100 || status > 999)
+        return undefined;
+    for (const [lo, hi, tier] of PROVIDER_STATUS_TIERS)
+        if (status >= lo && status <= hi)
+            return tier;
+    return undefined;
+}
+export function isMintedRowCcError(v) {
+    return typeof v === 'string' && PROVIDER_STATUS_TIERS.some((t) => t[2] === v);
+}
 const EDITABLE_TIER = 'invalid_request';
-export const PROVIDER_REJECTION_KINDS = Object.freeze(['schema_invalid', 'auth', 'rate_limited', 'resend_eligible', 'unknown']);
+export const PROVIDER_REJECTION_KINDS = Object.freeze(['schema_invalid', 'auth', 'rate_limited', 'resend_eligible', 'unknown', 'quota_exhausted']);
 const SCHEMA_INVALID_CODES = new Set([
     'invalid_type',
     'missing_required_parameter',
@@ -30,6 +43,51 @@ const SCHEMA_INVALID_CODES = new Set([
 function schemaTierStatus(status) {
     return status === 400 || status === 422;
 }
+const CONDITION_RECOURSE = Object.freeze({
+    quota_exhausted: 'switch_model',
+    throttled: 'switch_model',
+    overloaded: 'switch_model',
+    stop_other: 'fix_request',
+    unknown: null,
+});
+export function conditionRecourseOf(word) {
+    if (word === undefined || !Object.hasOwn(CONDITION_RECOURSE, word))
+        return undefined;
+    return CONDITION_RECOURSE[word] ?? undefined;
+}
+export function isServiceSideStatus(http) {
+    return http === 429 || (http >= 500 && http <= 599);
+}
+export function isHttpStatus(n) {
+    return typeof n === 'number' && Number.isInteger(n) && n >= 100 && n <= 999;
+}
+export function terminalRecourseOf(status, providerCondition) {
+    const http = isHttpStatus(status) ? status : undefined;
+    const byCondition = conditionRecourseOf(providerCondition);
+    if (http === undefined && byCondition === undefined)
+        return undefined;
+    if (http === 401 || http === 403)
+        return 'check_credentials';
+    return byCondition ?? (http !== undefined && isServiceSideStatus(http) ? 'switch_model' : undefined);
+}
+export function wayOutOfApiErrorFacts(facts) {
+    try {
+        if (typeof facts !== 'object' || facts === null)
+            return undefined;
+        const status = readOwnDataValue(facts, 'status');
+        const providerCondition = readOwnDataValue(facts, 'providerCondition');
+        const word = terminalRecourseOf(typeof status === 'number' ? status : undefined, typeof providerCondition === 'string' && providerCondition !== '' ? providerCondition : undefined);
+        if (word === undefined)
+            return undefined;
+        if (word !== 'check_credentials')
+            return Object.freeze({ word });
+        const credentialSource = readOwnDataValue(facts, 'credentialSource');
+        return Object.freeze(typeof credentialSource === 'string' && credentialSource !== '' ? { word, keySource: credentialSource } : { word });
+    }
+    catch {
+        return undefined;
+    }
+}
 function kindOfStatus(status, code) {
     const tier = providerStatusTier(status);
     if (tier === 'authentication_failed')
@@ -40,6 +98,14 @@ function kindOfStatus(status, code) {
         return code !== undefined && schemaTierStatus(status) && SCHEMA_INVALID_CODES.has(code) ? 'schema_invalid' : 'resend_eligible';
     return 'unknown';
 }
+const QUOTA_CONDITION = 'quota_exhausted';
+function quotaOverridesTier(status) {
+    const tier = providerStatusTier(status);
+    return tier === EDITABLE_TIER || tier === 'rate_limit' || tier === UNTIERED;
+}
+function kindOfRejection(status, code, condition) {
+    return condition === QUOTA_CONDITION && quotaOverridesTier(status) ? 'quota_exhausted' : kindOfStatus(status, code);
+}
 const NOT_BY_EDITING_TAIL = new Map([
     ['authentication_failed', ': check the provider credentials or access for this account.'],
     ['model_not_found', ': the model is not available from this provider — choose another model.'],
@@ -99,12 +165,17 @@ function readRejection(detail) {
     const status = Object.hasOwn(read, 'status') ? read.status : undefined;
     if (status === undefined)
         return undefined;
-    return { status, code: Object.hasOwn(read, 'code') ? read.code : undefined };
+    return { status, code: Object.hasOwn(read, 'code') ? read.code : undefined, providerCondition: Object.hasOwn(read, 'providerCondition') ? read.providerCondition : undefined };
 }
 function schemaInvalidText(status) {
     return `The model provider rejected the structure of this request (HTTP ${status}) — rewording the message will not fix this. Check that the configured model and endpoint accept this kind of request, or report the problem to whoever runs the engine.`;
 }
 function verdictOf(status, kind) {
+    if (kind === 'quota_exhausted') {
+        if (!quotaOverridesTier(status))
+            return undefined;
+        return { resend: 'not_by_editing', text: renderMessage(msg('notice.providerRejection.quotaExhausted', { status })), kind };
+    }
     if (kind === 'schema_invalid') {
         if (providerStatusTier(status) !== EDITABLE_TIER || !schemaTierStatus(status))
             return undefined;
@@ -131,9 +202,9 @@ export function providerRejectionResend(detail, carrier) {
         return undefined;
     if (toolHistoryMismatchCarrier(carrier))
         return undefined;
-    return verdictOf(r.status, kindOfStatus(r.status, r.code));
+    return verdictOf(r.status, kindOfRejection(r.status, r.code, r.providerCondition));
 }
 export function providerRejectionKind(detail) {
     const r = readRejection(detail);
-    return r === undefined ? 'unknown' : kindOfStatus(r.status, r.code);
+    return r === undefined ? 'unknown' : kindOfRejection(r.status, r.code, r.providerCondition);
 }

package/dist/queuedDelivery.d.ts

@@ -0,0 +1,48 @@
+import { encodeHumanTurn, type HumanTurnCaps, type HumanTurnItem } from './humanTurn.js';
+import { type LiveModelCatalog } from './liveModelCatalog.js';
+import type { HooksWirePlan } from './pluginHooksWire.js';
+export type QueueEntryKind = 'prompt' | 'bash' | 'slash' | 'injected' | 'other';
+export type QueueShellBlock = 'origin' | 'subagent' | 'replay' | 'structured';
+export interface QueueEntry {
+    readonly uuid: string;
+    readonly kind: QueueEntryKind;
+    readonly shellBlock?: QueueShellBlock;
+    readonly item: HumanTurnItem;
+    readonly steerState: 'none' | 'in_flight' | 'attempted';
+    readonly held?: boolean;
+    readonly injection?: string;
+    readonly hidden?: boolean;
+    readonly intentKey?: string;
+    readonly screening?: 'pending' | 'result';
+    readonly upsExecutor?: 'shell' | 'engine' | 'unknown' | 'none';
+}
+export type QueuedHoldReason = 'barrier' | 'share_incomplete' | 'not_steerable' | 'in_flight' | 'attempted' | 'no_run';
+export interface QueuedDeliveryPlan {
+    readonly steerNow: readonly {
+        readonly uuid: string;
+        readonly payload: Extract<ReturnType<typeof encodeHumanTurn>, {
+            ok: true;
+            lane: 'steer';
+        }>;
+    }[];
+    readonly held: readonly {
+        readonly uuid: string;
+        readonly reason: QueuedHoldReason;
+    }[];
+    readonly canSendNow: boolean;
+}
+export declare function batchCompatible(head: QueueEntry, follower: QueueEntry, plan: HooksWirePlan | undefined): boolean;
+export declare function planQueuedDelivery(entries: readonly QueueEntry[], run: {
+    readonly live: boolean;
+    readonly steerVerb: boolean;
+}, caps: HumanTurnCaps, policy?: {
+    readonly overtakeBashHead?: boolean;
+}): QueuedDeliveryPlan;
+export declare function selfHealSteerEligible(items: readonly HumanTurnItem[], caps: HumanTurnCaps): boolean;
+export interface HumanTurnCapsFacts {
+    readonly model?: string;
+    readonly baseUrl?: string;
+    readonly catalog?: LiveModelCatalog | null;
+}
+export declare function humanTurnCapsOf(facts?: HumanTurnCapsFacts): HumanTurnCaps;
+export declare function humanTextForKeywordScan(items: readonly HumanTurnItem[]): string;