@sema-agent/client-core 0.85.2 → 0.87.0

package/dist/toolHistoryMismatch.js

@@ -0,0 +1,425 @@
+export const TOOL_HISTORY_MISMATCH_KINDS = Object.freeze([
+    'tool_use_without_result',
+    'orphan_tool_result',
+    'duplicate_tool_use_id',
+]);
+const ID_AFTER_COLON = /^:\s*([^\s,;]+)/;
+export const TOOL_HISTORY_MISMATCH_ANCHORS = Object.freeze([
+    Object.freeze({
+        kind: 'tool_use_without_result',
+        template: /^`?tool_use`? ids were found without `?tool_result`? blocks immediately after\b/,
+        idAfter: ID_AFTER_COLON,
+    }),
+    Object.freeze({
+        kind: 'orphan_tool_result',
+        template: /^unexpected `?tool_use_id`? found in `?tool_result`?(?: blocks?)?(?=[\s:,.]|$)/,
+        idAfter: ID_AFTER_COLON,
+    }),
+    Object.freeze({
+        kind: 'duplicate_tool_use_id',
+        template: /^`?tool_use`? ids must be unique\b/,
+        idAfter: null,
+    }),
+]);
+const ENGINE_HTTP_400_LEAD = /^(?:\[invalid_request\]\s*)?[^\n:]{0,60}?\bHTTP 400:\s*/;
+const MESSAGES_LOCATOR = /^messages(?:\.[A-Za-z0-9_]+)+\s*:\s*/;
+const PROVIDER_REJECTED_REQUEST_CODE = 'invalid_request';
+function idOfToken(after, idAfter, endIsBoundary) {
+    const hit = idAfter.exec(after);
+    if (hit === null || hit[1] === undefined)
+        return undefined;
+    if (hit[0].length >= after.length && !endIsBoundary)
+        return undefined;
+    const next = after[hit[0].length];
+    let id = hit[1];
+    if (next !== ',' && next !== ';') {
+        if (id.endsWith('.'))
+            id = id.slice(0, -1);
+        if (id.endsWith('.') || id.endsWith(':'))
+            return undefined;
+    }
+    return ROW_KEY_ID.test(id) ? id : undefined;
+}
+function matchAnchoredSentence(sentence, endIsBoundary) {
+    const rest = sentence.replace(MESSAGES_LOCATOR, '');
+    for (const anchor of TOOL_HISTORY_MISMATCH_ANCHORS) {
+        const hit = anchor.template.exec(rest);
+        if (hit === null)
+            continue;
+        if (anchor.idAfter === null)
+            return { kind: anchor.kind };
+        const id = idOfToken(rest.slice(hit[0].length), anchor.idAfter, endIsBoundary);
+        return id !== undefined ? { kind: anchor.kind, toolUseId: id } : { kind: anchor.kind };
+    }
+    return null;
+}
+function envelopeMessages(body) {
+    const out = [];
+    const n = body.length;
+    let i = 0;
+    const skipWs = () => {
+        while (i < n && (body[i] === ' ' || body[i] === '\t' || body[i] === '\n' || body[i] === '\r'))
+            i++;
+    };
+    const readString = () => {
+        i++;
+        let text = '';
+        while (i < n) {
+            const c = body[i];
+            if (c === '"') {
+                i++;
+                return { text, closed: true };
+            }
+            if (c === '\\') {
+                const e = body[i + 1];
+                if (e === undefined) {
+                    i = n;
+                    break;
+                }
+                if (e === 'u') {
+                    const hex = body.slice(i + 2, i + 6);
+                    if (!/^[0-9A-Fa-f]{4}$/.test(hex)) {
+                        i = n;
+                        break;
+                    }
+                    text += String.fromCharCode(parseInt(hex, 16));
+                    i += 6;
+                    continue;
+                }
+                text += e === 'n' ? '\n' : e === 't' ? '\t' : e === 'r' ? '\r' : e === 'b' ? '\b' : e === 'f' ? '\f' : e;
+                i += 2;
+                continue;
+            }
+            text += c;
+            i++;
+        }
+        return { text, closed: false };
+    };
+    skipWs();
+    if (body[i] !== '{')
+        return out;
+    const path = [];
+    const want = [];
+    const onEnvelopePath = () => (path.length === 1 && path[0] === 'message') || (path.length === 2 && path[0] === 'error' && path[1] === 'message');
+    i++;
+    path.push(undefined);
+    want.push('key');
+    while (i < n && path.length > 0 && out.length < 4) {
+        skipWs();
+        if (i >= n)
+            break;
+        const c = body[i];
+        const top = want.length - 1;
+        const state = want[top];
+        const inArray = path[top] === null;
+        if (state === 'key') {
+            if (c === '}') {
+                i++;
+                path.pop();
+                want.pop();
+                if (want.length > 0)
+                    want[want.length - 1] = 'next';
+                continue;
+            }
+            if (c !== '"')
+                break;
+            const key = readString();
+            if (!key.closed)
+                break;
+            path[top] = key.text;
+            want[top] = 'colon';
+            continue;
+        }
+        if (state === 'colon') {
+            if (c !== ':')
+                break;
+            i++;
+            want[top] = 'value';
+            continue;
+        }
+        if (state === 'next') {
+            if (c === ',') {
+                i++;
+                want[top] = inArray ? 'value' : 'key';
+                continue;
+            }
+            if (c === (inArray ? ']' : '}')) {
+                i++;
+                path.pop();
+                want.pop();
+                if (want.length > 0)
+                    want[want.length - 1] = 'next';
+                continue;
+            }
+            break;
+        }
+        if (inArray && c === ']') {
+            i++;
+            path.pop();
+            want.pop();
+            if (want.length > 0)
+                want[want.length - 1] = 'next';
+            continue;
+        }
+        if (c === '"') {
+            const value = readString();
+            if (!path.includes(null) && onEnvelopePath())
+                out.push(value);
+            want[top] = 'next';
+            continue;
+        }
+        if (c === '{' || c === '[') {
+            i++;
+            want[top] = 'next';
+            path.push(c === '{' ? undefined : null);
+            want.push(c === '{' ? 'key' : 'value');
+            continue;
+        }
+        const lit = /^(?:true|false|null|-?[0-9][0-9.eE+-]*)/.exec(body.slice(i, i + 64));
+        if (lit === null)
+            break;
+        i += lit[0].length;
+        want[top] = 'next';
+    }
+    return out;
+}
+export function classifyToolHistoryMismatch(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    let code;
+    let status;
+    let rawMessage;
+    try {
+        code = err.code;
+        status = err.status;
+        rawMessage = err.message;
+    }
+    catch {
+        return null;
+    }
+    if (typeof rawMessage !== 'string' || rawMessage.length === 0)
+        return null;
+    if (typeof status === 'number' && status !== 400)
+        return null;
+    if (typeof code === 'string' && code.length > 0 && code !== PROVIDER_REJECTED_REQUEST_CODE)
+        return null;
+    let detail = rawMessage.trimStart();
+    const lead = ENGINE_HTTP_400_LEAD.exec(detail);
+    if (lead !== null)
+        detail = detail.slice(lead[0].length);
+    else if (status !== 400)
+        return null;
+    const body = detail.replace(/^400\s+/, '');
+    const direct = matchAnchoredSentence(body, false);
+    if (direct !== null)
+        return direct;
+    for (const value of envelopeMessages(body)) {
+        const hit = matchAnchoredSentence(value.text, value.closed);
+        if (hit !== null)
+            return hit;
+    }
+    return null;
+}
+export const TOOL_HISTORY_REWIND_SENTENCE = 'Run /rewind to recover the conversation.';
+export function toolHistoryRepeatSentence(n) {
+    return `The same error has now happened ${n} times in a row; /rewind is the only way to recover this conversation.`;
+}
+let conversationRewindJudge;
+export function _wireConversationRewindJudge(judge) {
+    conversationRewindJudge = judge;
+}
+export function toolHistoryRewindOffered(declared) {
+    const decl = declared;
+    if (decl === true)
+        return true;
+    if (typeof decl !== 'object' || decl === null)
+        return false;
+    try {
+        if (Array.isArray(decl))
+            return false;
+        const base = decl.engineBaseUrl;
+        const judge = conversationRewindJudge;
+        if (typeof base !== 'string' || base.length === 0 || judge === undefined)
+            return true;
+        return judge(base) !== 'unavailable';
+    }
+    catch {
+        return true;
+    }
+}
+const isKind = (v) => typeof v === 'string' && TOOL_HISTORY_MISMATCH_KINDS.includes(v);
+const ROW_KEY_ID = /^[A-Za-z0-9_.:-]{1,128}$/;
+export function toolHistoryMismatchRowKey(m, consecutive) {
+    return {
+        kind: m.kind,
+        ...(m.toolUseId !== undefined ? { toolUseId: m.toolUseId } : {}),
+        ...(consecutive !== undefined && consecutive >= 2 ? { consecutive } : {}),
+    };
+}
+export function readToolHistoryMismatchKey(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return undefined;
+    try {
+        const got = v;
+        const kind = got.kind;
+        if (!isKind(kind))
+            return undefined;
+        const id = got.toolUseId;
+        const n = got.consecutive;
+        return {
+            kind,
+            ...(typeof id === 'string' && ROW_KEY_ID.test(id) ? { toolUseId: id } : {}),
+            ...(typeof n === 'number' && Number.isSafeInteger(n) && n >= 2 ? { consecutive: n } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export const TOOL_HISTORY_LEDGER_CAP = 64;
+const PRIOR_RUN_IDS_CAP = 16;
+const ECHOED_SESSION_IDS_CAP = TOOL_HISTORY_LEDGER_CAP * 4;
+const toolHistoryLedger = new Map();
+let toolHistoryGenerationSeq = 0;
+const echoedSessionIds = new Set();
+let unattributedTerminalSeq = 0;
+function rememberEchoedSession(sessionId) {
+    echoedSessionIds.delete(sessionId);
+    echoedSessionIds.add(sessionId);
+    while (echoedSessionIds.size > ECHOED_SESSION_IDS_CAP) {
+        const oldest = echoedSessionIds.values().next();
+        if (oldest.done === true)
+            break;
+        echoedSessionIds.delete(oldest.value);
+    }
+}
+export function openToolHistoryGeneration() {
+    toolHistoryGenerationSeq += 1;
+    return toolHistoryGenerationSeq;
+}
+const fingerprintOf = (m) => `${m.kind}\u0000${m.toolUseId ?? ''}`;
+export function noteToolHistoryTerminal(note) {
+    const { sessionId, generation, runId, replay, mismatch } = note;
+    if (typeof sessionId !== 'string' || sessionId.length === 0) {
+        unattributedTerminalSeq += 1;
+        return undefined;
+    }
+    if (note.sessionEchoed === true)
+        rememberEchoedSession(sessionId);
+    else if (!echoedSessionIds.has(sessionId))
+        unattributedTerminalSeq += 1;
+    const row = toolHistoryLedger.get(sessionId);
+    const fingerprint = mismatch === null ? null : fingerprintOf(mismatch);
+    const run = !replay && typeof runId === 'string' && runId.length > 0 ? runId : undefined;
+    if (row !== undefined && generation < row.writtenGeneration) {
+        if (row.fingerprint !== fingerprint) {
+            touchLedgerRow(sessionId, {
+                fingerprint,
+                segmentRunIds: new Set(),
+                writtenGeneration: row.writtenGeneration,
+                unattributedMark: unattributedTerminalSeq,
+                lastRunId: undefined,
+                recentRunIds: run !== undefined ? [...row.recentRunIds, run].slice(-PRIOR_RUN_IDS_CAP) : row.recentRunIds,
+            });
+        }
+        return undefined;
+    }
+    if (row !== undefined)
+        row.writtenGeneration = generation;
+    const interrupted = row !== undefined && row.unattributedMark < unattributedTerminalSeq;
+    if (run !== undefined && row !== undefined && (row.segmentRunIds.has(run) || row.recentRunIds.includes(run))) {
+        return !interrupted && row.lastRunId === run && fingerprint !== null && row.fingerprint === fingerprint ? row.segmentRunIds.size : undefined;
+    }
+    if (row !== undefined && row.fingerprint === fingerprint && !(interrupted && fingerprint !== null && run !== undefined)) {
+        if (run === undefined)
+            return undefined;
+        if (fingerprint !== null)
+            row.segmentRunIds.add(run);
+        row.lastRunId = run;
+        row.recentRunIds = [...row.recentRunIds, run].slice(-PRIOR_RUN_IDS_CAP);
+        touchLedgerRow(sessionId, row);
+        return fingerprint === null ? undefined : row.segmentRunIds.size;
+    }
+    touchLedgerRow(sessionId, {
+        fingerprint,
+        segmentRunIds: fingerprint !== null && run !== undefined ? new Set([run]) : new Set(),
+        writtenGeneration: generation,
+        unattributedMark: unattributedTerminalSeq,
+        lastRunId: run,
+        recentRunIds: run !== undefined ? [...(row?.recentRunIds ?? []), run].slice(-PRIOR_RUN_IDS_CAP) : [...(row?.recentRunIds ?? [])],
+    });
+    return fingerprint !== null && run !== undefined ? 1 : undefined;
+}
+function touchLedgerRow(sessionId, row) {
+    toolHistoryLedger.delete(sessionId);
+    toolHistoryLedger.set(sessionId, row);
+    while (toolHistoryLedger.size > TOOL_HISTORY_LEDGER_CAP) {
+        const oldest = toolHistoryLedger.keys().next();
+        if (oldest.done === true)
+            break;
+        toolHistoryLedger.delete(oldest.value);
+    }
+}
+export function _resetToolHistoryLedgerForTest() {
+    toolHistoryLedger.clear();
+    echoedSessionIds.clear();
+}
+export const TOOL_HISTORY_UNDECIDABLE_REASONS = Object.freeze([
+    'no-mismatch',
+    'no-tool-use-id',
+    'id-not-found',
+    'prompt-not-found',
+    'prompt-without-handle',
+    'unreadable-rows',
+]);
+const listHas = (list, id) => Array.isArray(list) && list.includes(id);
+export function resolveToolHistoryRewindTarget(rows, mismatch) {
+    let kind;
+    try {
+        if (typeof mismatch !== 'object' || mismatch === null)
+            return { undecidable: 'no-mismatch' };
+        kind = mismatch.kind;
+    }
+    catch {
+        return { undecidable: 'no-mismatch' };
+    }
+    if (!isKind(kind))
+        return { undecidable: 'no-mismatch' };
+    let id;
+    try {
+        id = mismatch.toolUseId;
+    }
+    catch {
+        return { undecidable: 'no-mismatch' };
+    }
+    if (typeof id !== 'string' || id.length === 0)
+        return { undecidable: 'no-tool-use-id' };
+    try {
+        if (!Array.isArray(rows))
+            return { undecidable: 'unreadable-rows' };
+        let hit = -1;
+        for (let i = 0; i < rows.length; i++) {
+            const r = rows[i];
+            if (typeof r !== 'object' || r === null || r.local === true)
+                continue;
+            if (listHas(r.toolUseIds, id) || listHas(r.toolResultIds, id)) {
+                hit = i;
+                break;
+            }
+        }
+        if (hit < 0)
+            return { undecidable: 'id-not-found' };
+        for (let j = hit; j >= 0; j--) {
+            const r = rows[j];
+            if (typeof r !== 'object' || r === null || r.local === true || r.prompt !== true)
+                continue;
+            if (r.sessionRoot === true)
+                return { rootReopen: true };
+            return typeof r.engineHandle === 'string' && r.engineHandle.length > 0 ? { target: r } : { undecidable: 'prompt-without-handle' };
+        }
+        return { undecidable: 'prompt-not-found' };
+    }
+    catch {
+        return { undecidable: 'unreadable-rows' };
+    }
+}

package/dist/toolResult.js

@@ -3,53 +3,8 @@ import { markEngineWorkflowNotified, registerOutstandingBgTask, registerOutstand
 import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow.js';
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
-export const STRUCTURED_DETAIL_TYPES = frozenSet([
-    'edit',
-    'create',
-    'update',
-    'bash',
-    'notebook-edit',
-    'notebook',
-    'text',
-    'grep',
-    'glob',
-    'mcp',
-    'agent',
-    'task',
-    'task-list',
-    'task-output',
-    'workflow-run',
-    'web-fetch',
-    'web-search',
-    'todo',
-    'cron-create',
-    'cron-delete',
-    'cron-list',
-    'image',
-    'task-stop',
-    'tool-search',
-    'repo-map',
-    'fork',
-    'enter-plan-mode',
-    'exit-plan-mode',
-    'file_unchanged',
-    'worktree',
-    'monitor-start',
-    'path_not_in_root',
-    'readonly_out_of_root',
-    'report-findings',
-    'schedule-wakeup',
-    'send-message',
-    'agent-transcript',
-    'a2a',
-    'document',
-    'ask-question',
-    'bash_invalid_timeout',
-    'read_path_denied',
-    'list-agents',
-    'artifact',
-    'read-inbox',
-]);
+import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
+export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
 export function structuredDetailType(structured) {
     if (typeof structured !== 'object' || structured === null)
         return undefined;

package/dist/wireErrorTriage.d.ts

@@ -6,6 +6,7 @@ export type TurnWireErrorVerdict = {
     message: string;
     storedRowWhere?: string;
     sessionUnreadable?: true;
+    leaseUnavailable?: true;
 } | {
     kind: 'stream-ended-without-terminal';
 } | {

package/dist/wireErrorTriage.js

@@ -1,5 +1,6 @@
 import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { capForDisplay } from './fleetTaskDesc.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;
 function wireErrorDetail(err) {
@@ -16,6 +17,7 @@ export function classifyTurnWireError(err) {
         const message = typeof e.message === 'string' && e.message.length > 0 ? e.message : String(err);
         const storedRowWhere = corruptStoredRowWhere(err);
         const sessionUnreadable = isCorruptSessionCode(effectiveWireErrorCode(err));
+        const leaseUnavailable = fleetLeaseUnavailableFromError(err) !== null;
         return {
             kind: 'http',
             status: e.status,
@@ -23,6 +25,7 @@ export function classifyTurnWireError(err) {
             message,
             ...(storedRowWhere !== undefined ? { storedRowWhere } : {}),
             ...(sessionUnreadable ? { sessionUnreadable: true } : {}),
+            ...(leaseUnavailable ? { leaseUnavailable: true } : {}),
         };
     }
     const errName = typeof err === 'object' && err !== null && typeof err.name === 'string'

package/dist/wireFailureShape.d.ts

@@ -3,10 +3,13 @@ interface WireFailureShape {
     errorCode?: string;
     retryAfterSec?: number;
     committed?: 'no' | 'unknown' | 'unreadable';
+    bodyField?: string;
+    bodyName?: string;
     message: string;
 }
 export declare function readErrorNumber(o: object, key: string): number | 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 {};

package/dist/wireFailureShape.js

@@ -52,6 +52,33 @@ export function readErrorStringList(o, key) {
     const v = readErrorSlot(o, key, (x) => Array.isArray(x));
     return Array.isArray(v) ? v.filter((x) => typeof x === 'string') : undefined;
 }
+export function readErrorStrictStringList(o, key) {
+    const strict = (x) => {
+        if (!Array.isArray(x))
+            return false;
+        for (let i = 0; i < x.length; i++)
+            if (typeof x[i] !== 'string')
+                return false;
+        return true;
+    };
+    const v = readErrorSlot(o, key, strict);
+    if (!Array.isArray(v))
+        return undefined;
+    try {
+        const out = [];
+        const len = v.length;
+        for (let i = 0; i < len; i++) {
+            const item = v[i];
+            if (typeof item !== 'string')
+                return undefined;
+            out.push(item);
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function wireFailureShapeOf(e) {
     const o = e ?? {};
     const status = readGuarded(o, 'status');
@@ -85,6 +112,21 @@ export function wireFailureShapeOf(e) {
             }
         }
     }
+    const ownString = (key) => {
+        if (extraObj === undefined)
+            return undefined;
+        try {
+            if (!Object.hasOwn(extraObj, key))
+                return undefined;
+            const v = extraObj[key];
+            return typeof v === 'string' ? v : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const bodyField = ownString('field');
+    const bodyName = ownString('name');
     let message;
     try {
         message = typeof rawMessage === 'string' && rawMessage !== '' ? rawMessage : String(e);
@@ -107,6 +149,8 @@ export function wireFailureShapeOf(e) {
         ...(typeof errorCode === 'string' ? { errorCode } : {}),
         ...(sec !== undefined ? { retryAfterSec: sec } : {}),
         ...(committed !== undefined ? { committed } : {}),
+        ...(bodyField !== undefined ? { bodyField } : {}),
+        ...(bodyName !== undefined ? { bodyName } : {}),
         message,
     };
 }

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,5 @@
-import { USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { FLEET_LEASE_UNAVAILABLE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import type { TaskRequestLike } from './request/taskRequest.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
 export declare const CONFLICT_RUN_NOT_RUNNING = "conflict.run_not_running";
 export type CancelConflictKind = 'approval_settled' | 'run_not_running' | 'unrecognized';
@@ -14,6 +15,13 @@ export interface UsageWindowExhaustedDetail {
 }
 export declare function usageWindowExhaustedFromError(err: unknown): UsageWindowExhaustedDetail | null;
 export declare function usageWindowExhaustedContent(detail: UsageWindowExhaustedDetail): string;
+export interface FleetLeaseUnavailableDetail {
+    code: typeof FLEET_LEASE_UNAVAILABLE;
+    reason?: string;
+    retryAfterSec?: number;
+}
+export declare function fleetLeaseUnavailableFromError(err: unknown): FleetLeaseUnavailableDetail | null;
+export declare function fleetLeaseUnavailableContent(detail: FleetLeaseUnavailableDetail): string;
 export type DenyAttributionRefusalKind = 'not_in_proof' | 'decision_conflict' | 'attribution_rejected';
 export interface DenyAttributionRefusalDetail {
     kind: DenyAttributionRefusalKind;
@@ -33,3 +41,33 @@ export interface SessionDeleteConflictDetail {
 }
 export declare function sessionDeleteConflictFromError(err: unknown): SessionDeleteConflictDetail | null;
 export declare function sessionDeleteConflictContent(detail: Pick<SessionDeleteConflictDetail, 'kind' | 'remaining' | 'activeTaskId'>): string;
+export type SettingsPermissionBucket = 'allow' | 'deny' | 'ask';
+export type SettingsPermissionBucketRefusalReason = 'over_cap' | 'bad_entry';
+export interface SettingsPermissionBucketRefusalDetail {
+    readonly bucket: SettingsPermissionBucket;
+    readonly reason: SettingsPermissionBucketRefusalReason;
+    readonly count?: number;
+    readonly cap?: number;
+    readonly index?: number;
+    readonly folded?: true;
+}
+export declare function settingsPermissionBucketRefusalFromError(err: unknown): SettingsPermissionBucketRefusalDetail | null;
+export declare function settingsPermissionBucketRefusalContent(detail: SettingsPermissionBucketRefusalDetail): string;
+export interface ToolDeclarationRefusalDetail {
+    readonly code: string;
+}
+export declare function toolDeclarationRefusalFromError(err: unknown): ToolDeclarationRefusalDetail | null;
+export declare function toolDeclarationRefusalContent(_detail: Pick<ToolDeclarationRefusalDetail, 'code'>): string;
+export interface BodyShapeRefusalDetail {
+    readonly unknownKeys?: readonly string[];
+    readonly unsupportedKeys?: readonly string[];
+}
+export declare function bodyShapeRefusalFromError(err: unknown): BodyShapeRefusalDetail | null;
+export declare function bodyShapeRefusalTouchesSettings(detail: BodyShapeRefusalDetail | null | undefined, sentBody?: TaskRequestLike): boolean | undefined;
+export interface HostPostureRefusalDetail {
+    readonly code: string;
+    readonly askedWholeEnvironment?: true;
+    readonly askedOpenWriteFace?: true;
+}
+export declare function hostPostureRefusalFromError(err: unknown, sentRequest?: TaskRequestLike): HostPostureRefusalDetail | null;
+export declare function hostPostureRefusalContent(detail: Pick<HostPostureRefusalDetail, 'askedWholeEnvironment' | 'askedOpenWriteFace'>): string;