@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/interactiveInterrupt.js

@@ -1,6 +1,17 @@
 import { atMostOnceVerdictOf } from './atMostOnce.js';
 import { readOwnDataValue } from './ownKey.js';
 import { noteInteractiveStopRequested, ownSlotOf } from './sessionBackground.js';
+function isLocalBodyShapeRefusal(e) {
+    if (e === null || typeof e !== 'object')
+        return false;
+    try {
+        const d = Object.getOwnPropertyDescriptor(e, 'errorCode');
+        return d !== undefined && Object.hasOwn(d, 'value') && d.value === 'request.body_shape';
+    }
+    catch {
+        return false;
+    }
+}
 function guardedSlot(e, key) {
     if (e === null || (typeof e !== 'object' && typeof e !== 'function'))
         return undefined;
@@ -59,10 +70,17 @@ export async function fireInteractiveInterrupt(runs, taskId, opts = {}) {
     };
     let receipt;
     try {
-        receipt = await verb.call(runs, taskId, undefined, callOpts);
+        receipt = await verb.call(runs, taskId, callOpts);
     }
     catch (e) {
-        return outcomeOfFailure(e);
+        if (!isLocalBodyShapeRefusal(e))
+            return outcomeOfFailure(e);
+        try {
+            receipt = await verb.call(runs, taskId, undefined, callOpts);
+        }
+        catch (e2) {
+            return outcomeOfFailure(e2);
+        }
     }
     const turnCut = turnCutOf(receipt);
     return { kind: 'halted', ...(turnCut !== undefined ? { turnCut } : {}) };

package/dist/interruptRefusalNote.d.ts

@@ -0,0 +1,2 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare function interruptRefusalNote(reason: string | null | undefined, lang?: UiLanguage): string;

package/dist/interruptRefusalNote.js

@@ -0,0 +1,17 @@
+import { INTERRUPT_NOT_HELD, INTERRUPT_NOTHING_IN_FLIGHT, STEERING_NOT_RUNNING } from './engineErrorCodes.js';
+import { msg, renderMessage } from './i18n/translate.js';
+function interruptRefusalKeyOf(reason) {
+    switch (reason) {
+        case INTERRUPT_NOTHING_IN_FLIGHT:
+            return 'session.interruptRefusal.nothingInFlight';
+        case INTERRUPT_NOT_HELD:
+            return 'session.interruptRefusal.notHeld';
+        case STEERING_NOT_RUNNING:
+            return 'session.interruptRefusal.notRunning';
+        default:
+            return 'session.interruptRefusal.unrecognised';
+    }
+}
+export function interruptRefusalNote(reason, lang) {
+    return renderMessage(msg(interruptRefusalKeyOf(reason)), lang);
+}

package/dist/liveModelCatalog.d.ts

@@ -36,6 +36,8 @@ export declare function imageVisionReadingOf(model: string | undefined, catalog?
     readonly vision: ImageVision;
     readonly model?: string;
 };
+export type ModelReasoning = 'yes' | 'no' | 'unknown';
+export declare function modelReasoningOf(model: string | undefined, catalog?: LiveModelCatalog | null): ModelReasoning;
 export type EffortLevelsReading = {
     readonly kind: 'clamped';
     readonly levels: readonly string[];

package/dist/liveModelCatalog.js

@@ -2,7 +2,7 @@ import { appendOwnElement, readOwnDataValue } from './ownKey.js';
 import { frozenJsonCopyOf, liveDefaultModelCopy, liveModelRowCopy } from './model/liveCatalogShape.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { quoteUntrustedForSentence } from './displayUntrusted.js';
-import { CC_TIER_ALIASES, TIER_ORDER } from './model/tierVocabulary.js';
+import { engineModelWordKindOf } from './model/engineModelWords.js';
 let catalog = null;
 let refresher = null;
 export function setLiveModelCatalog(next) {
@@ -46,6 +46,9 @@ function ownDataOf(o, key) {
         return undefined;
     }
 }
+function capabilityWordOf(declared) {
+    return declared === true ? 'yes' : declared === false ? 'no' : 'unknown';
+}
 function liveModelRowOf(cat, ref) {
     const rows = catalogRowsOf(cat);
     if (rows === undefined)
@@ -92,8 +95,7 @@ export function imageVisionReadingOf(model, catalog = getLiveModelCatalog()) {
         const target = targetRowOf(model, catalog);
         if (target.kind !== 'row')
             return { vision: 'unknown' };
-        const vision = ownDataOf(target.row, 'vision');
-        const word = vision === true ? 'yes' : vision === false ? 'no' : 'unknown';
+        const word = capabilityWordOf(ownDataOf(target.row, 'vision'));
         const name = ownDataOf(target.row, 'name');
         return typeof name === 'string' && name.length > 0 ? { vision: word, model: name } : { vision: word };
     }
@@ -101,6 +103,18 @@ export function imageVisionReadingOf(model, catalog = getLiveModelCatalog()) {
         return { vision: 'unknown' };
     }
 }
+export function modelReasoningOf(model, catalog = getLiveModelCatalog()) {
+    try {
+        const target = targetRowOf(model, catalog);
+        return target.kind === 'row' ? reasoningWordOfRow(target.row) : 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function reasoningWordOfRow(row) {
+    return capabilityWordOf(ownDataOf(row, 'reasoning'));
+}
 const NOT_CLAMPED = Object.freeze({ kind: 'not_clamped' });
 const NOT_APPLICABLE = Object.freeze({ kind: 'not_applicable' });
 const unknownEffort = (why) => Object.freeze({ kind: 'unknown', why });
@@ -127,10 +141,10 @@ export function effortLevelsOf(model, catalog = getLiveModelCatalog()) {
             }
             return Object.freeze({ kind: 'clamped', levels: Object.freeze(out) });
         }
-        const reasoning = ownDataOf(row, 'reasoning');
-        if (reasoning === true)
+        const reasoning = reasoningWordOfRow(row);
+        if (reasoning === 'yes')
             return NOT_CLAMPED;
-        if (reasoning === false)
+        if (reasoning === 'no')
             return NOT_APPLICABLE;
         return unknownEffort('reasoning_unreported');
     }
@@ -157,7 +171,7 @@ export function liveDefaultModelName() {
     return d.kind === 'listed' ? d.name : d.kind === 'not_listed' ? d.id : null;
 }
 function isReservedModelWord(word) {
-    return word === 'default' || TIER_ORDER.includes(word) || Object.hasOwn(CC_TIER_ALIASES, word);
+    return engineModelWordKindOf(word) !== undefined;
 }
 function droppedDisabledNamed(dropped, name) {
     if (dropped.kind !== 'reported')
@@ -747,14 +761,14 @@ export function liveModelRowsOf(catalog = getLiveModelCatalog()) {
             seen.add(name);
             const id = nonEmptyString(ownDataOf(row, 'id'));
             const provider = nonEmptyString(ownDataOf(row, 'provider'));
-            const reasoning = ownDataOf(row, 'reasoning');
+            const reasoning = reasoningWordOfRow(row);
             const contextWindow = positiveFinite(ownDataOf(row, 'contextWindow'));
             const maxOutputTokens = positiveFinite(ownDataOf(row, 'maxOutputTokens'));
             out.push(Object.freeze({
                 name,
                 ...(id !== undefined ? { id } : {}),
                 ...(provider !== undefined ? { provider } : {}),
-                ...(typeof reasoning === 'boolean' ? { reasoning } : {}),
+                ...(reasoning !== 'unknown' ? { reasoning: reasoning === 'yes' } : {}),
                 ...(contextWindow !== undefined ? { contextWindow } : {}),
                 ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}),
                 isDefault: def.kind === 'listed' && def.name === name,

package/dist/liveQuestionStore.d.ts

@@ -1,10 +1,13 @@
 import type { AskQuestion, AskQuestionOption, QuestionAnswer, QuestionFrame } from '@sema-agent/sdk';
 export type { AskQuestion, AskQuestionOption, QuestionAnswer, QuestionFrame };
+import type { HostWithdrawal } from './hitl/hostWithdrawal.js';
 type QuestionFrameHandler = (frame: QuestionFrame) => void;
 type RespondFn = (id: string, answer: QuestionAnswer, opts?: {
     signal?: AbortSignal;
 }) => Promise<unknown>;
-export declare function registerLocalQuestionResponder(id: string, fn: RespondFn): () => void;
+type WithdrawHook = (withdrawal: HostWithdrawal) => void;
+export declare function registerLocalQuestionResponder(id: string, fn: RespondFn, onWithdraw?: WithdrawHook): () => void;
+export declare function takeLocalQuestionWithdrawHook(id: string): WithdrawHook | 'no_card' | 'not_withdrawable';
 export declare function unregisterLocalQuestionResponder(id: string): boolean;
 export declare function hasLocalQuestionResponder(id: string): boolean;
 export declare function publishQuestionFrame(frame: QuestionFrame): void;

package/dist/liveQuestionStore.js

@@ -2,12 +2,21 @@ import { createSessionSlot, DEFAULT_SESSION_KEY } from './sessionSlot.js';
 const frameHandlerByKey = createSessionSlot();
 let respondFn = null;
 const localResponders = new Map();
-export function registerLocalQuestionResponder(id, fn) {
-    localResponders.set(id, fn);
+export function registerLocalQuestionResponder(id, fn, onWithdraw) {
+    localResponders.set(id, typeof onWithdraw === 'function' ? { respond: fn, withdraw: onWithdraw } : { respond: fn });
     return () => {
         localResponders.delete(id);
     };
 }
+export function takeLocalQuestionWithdrawHook(id) {
+    const entry = localResponders.get(id);
+    if (entry === undefined)
+        return 'no_card';
+    if (entry.withdraw === undefined)
+        return 'not_withdrawable';
+    localResponders.delete(id);
+    return entry.withdraw;
+}
 export function unregisterLocalQuestionResponder(id) {
     return localResponders.delete(id);
 }
@@ -50,7 +59,7 @@ export function respondToQuestion(id, answer, opts) {
     const local = localResponders.get(id);
     if (local) {
         localResponders.delete(id);
-        return local(id, answer, opts);
+        return local.respond(id, answer, opts);
     }
     if (!respondFn) {
         return Promise.reject(new Error('no live question respond wired (offline/mock path)'));

package/dist/localEngineSeatReading.d.ts

@@ -14,9 +14,9 @@ export declare function localEngineSeatSentence(reading: LocalEngineSeatReading,
 export declare function localEngineNoticeText(notice: LocalEngineNotice, lang?: UiLanguage): string | undefined;
 export declare function localEngineFailText(code: LocalEngineFailCode, lang?: UiLanguage): string | undefined;
 export declare function engineTargetLocalOf(input: {
-    readonly lifecycle: LocalEngineSeatReading;
+    readonly lifecycle: LocalEngineSeatReading | undefined;
     readonly mcp?: SeatLocalMcpReading;
-}, lang?: UiLanguage): EngineTargetLocal;
+}, lang?: UiLanguage): EngineTargetLocal | undefined;
 export interface EngineRestartOperation {
     readonly before: LocalEngineState;
     readonly after: LocalEngineState;

package/dist/localEngineSeatReading.js

@@ -95,7 +95,7 @@ export function localEngineSeatReadingOf(state, host) {
         return undefined;
     }
 }
-const STATE_DOWN = Object.freeze(['lock-unavailable', 'spawn-failed', 'spawn-refused', 'stop-failed', 'crash-loop', 'high-water-unreadable']);
+const STATE_DOWN = Object.freeze(['lock-unavailable', 'spawn-failed', 'spawn-refused', 'stop-failed', 'crash-loop', 'high-water-unreadable', 'exited-once']);
 const DOWN_KEYS = Object.freeze({
     'lock-unavailable': 'localEngine.down.lockUnavailable',
     'spawn-failed': 'localEngine.down.spawnFailed',
@@ -103,6 +103,7 @@ const DOWN_KEYS = Object.freeze({
     'stop-failed': 'localEngine.down.stopFailed',
     'crash-loop': 'localEngine.down.crashLoop',
     'high-water-unreadable': 'localEngine.down.highWaterUnreadable',
+    'exited-once': 'localEngine.down.exitedOnce',
 });
 function downSentence(reason, lang) {
     if (reason === 'principal-unknown')
@@ -207,6 +208,7 @@ const FAIL_KEYS = Object.freeze({
     'local_engine.stop_failed': 'localEngine.down.stopFailed',
     'local_engine.crash_loop': 'localEngine.down.crashLoop',
     'local_engine.high_water_unreadable': 'localEngine.down.highWaterUnreadable',
+    'local_engine.exited_once': 'localEngine.down.exitedOnce',
 });
 export function localEngineFailText(code, lang) {
     try {
@@ -224,7 +226,7 @@ export function engineTargetLocalOf(input, lang) {
         const lifecycle = raw === undefined ? undefined : ownSnapshotTyped(raw);
         const phase = own(lifecycle, 'phase');
         if (lifecycle === undefined || typeof phase !== 'string')
-            return Object.freeze({});
+            return undefined;
         const out = { lifecycle };
         if (phase === 'down') {
             const line = downSentence(own(lifecycle, 'reason'), lang);
@@ -238,7 +240,7 @@ export function engineTargetLocalOf(input, lang) {
         return deepFreeze(out);
     }
     catch {
-        return Object.freeze({});
+        return undefined;
     }
 }
 function attachedId(s) {

package/dist/localEngineSpawn.d.ts

@@ -103,11 +103,4 @@ export interface LocalEnginePrincipalView {
 }
 export declare function localEnginePrincipalOf(view: LocalEnginePrincipalView): LocalEnginePrincipal;
 export declare function localEnginePrincipalSentence(p: LocalEnginePrincipal, lang?: UiLanguage): string | undefined;
-export interface LocalEngineBootRefusal {
-    readonly code?: string;
-    readonly hint?: string;
-    readonly text: string;
-}
-export declare function engineBootRefusalOf(lines: readonly string[], scrub: (s: string) => string): LocalEngineBootRefusal | undefined;
-export declare function engineBootRefusalSentence(refusal: LocalEngineBootRefusal, lang?: UiLanguage): string | undefined;
 export declare function localEngineFirstShareSentence(lang?: UiLanguage): string;

package/dist/localEngineSpawn.js

@@ -61,14 +61,6 @@ function stringOf(x) {
         return undefined;
     }
 }
-function parseJsonLine(t) {
-    try {
-        return JSON.parse(t);
-    }
-    catch {
-        return undefined;
-    }
-}
 function freezeRecord(rows) {
     const out = {};
     for (const [k, v] of rows)
@@ -397,90 +389,6 @@ export function localEnginePrincipalSentence(p, lang) {
         return undefined;
     }
 }
-const BOOT_REFUSAL_MAX_CHARS = 800;
-const BOOT_REFUSAL_MAX_HINTS = 2;
-const CONFIG_CODE = /^config\.[A-Za-z0-9_.-]+$/;
-function capSentence(s) {
-    const t = s.trim();
-    return t.length > BOOT_REFUSAL_MAX_CHARS ? `${t.slice(0, BOOT_REFUSAL_MAX_CHARS)}…` : t;
-}
-export function engineBootRefusalOf(lines, scrub) {
-    try {
-        const clean = (s) => {
-            try {
-                const out = scrub(s);
-                return typeof out === 'string' ? out : undefined;
-            }
-            catch {
-                return undefined;
-            }
-        };
-        const hints = [];
-        let code;
-        let hint;
-        let fatal;
-        const list = Array.isArray(lines) ? [...lines] : [];
-        for (const raw of list) {
-            if (typeof raw !== 'string')
-                continue;
-            const line = clean(raw);
-            if (line === undefined)
-                continue;
-            const t = line.trim();
-            if (!t.startsWith('{'))
-                continue;
-            const o = parseJsonLine(t);
-            if (!isRecord(o))
-                continue;
-            const m = own(o, 'msg');
-            const err = own(o, 'err');
-            if (m === 'fatal' && typeof err === 'string' && err.trim() !== '') {
-                const full = clean(err);
-                const s = full === undefined ? undefined : full.replace(/^\s*Error:\s*/, '');
-                if (s !== undefined && s.trim() !== '')
-                    fatal = capSentence(s);
-                continue;
-            }
-            const c = own(o, 'code');
-            const h = own(o, 'hint');
-            if (typeof c === 'string' && CONFIG_CODE.test(c) && typeof h === 'string' && h.trim() !== '') {
-                const model = own(o, 'model');
-                const who = typeof model === 'string' && model !== '' ? `"${model}": ` : '';
-                const s = clean(`${who}${h}`);
-                const cc = clean(c);
-                if (s === undefined || cc === undefined || !CONFIG_CODE.test(cc))
-                    continue;
-                const sentence = capSentence(s);
-                code = cc;
-                const ch = clean(h);
-                hint = ch === undefined ? undefined : capSentence(ch);
-                if (hints.includes(sentence))
-                    continue;
-                hints.push(sentence);
-                if (hints.length > BOOT_REFUSAL_MAX_HINTS)
-                    hints.shift();
-            }
-        }
-        const parts = [...hints, ...(fatal !== undefined ? [fatal] : [])];
-        if (parts.length === 0)
-            return undefined;
-        return Object.freeze({ ...(code !== undefined ? { code } : {}), ...(hint !== undefined ? { hint } : {}), text: parts.join('\n') });
-    }
-    catch {
-        return undefined;
-    }
-}
-export function engineBootRefusalSentence(refusal, lang) {
-    try {
-        const text = own(refusal, 'text');
-        if (typeof text !== 'string' || text.trim() === '')
-            return undefined;
-        return renderMessage(msg('localEngine.bootRefusal', { reason: text }), lang);
-    }
-    catch {
-        return undefined;
-    }
-}
 export function localEngineFirstShareSentence(lang) {
     return renderMessage(msg('localEngine.firstShare'), lang);
 }

package/dist/localEngineStep.d.ts

@@ -14,7 +14,7 @@ export interface LocalEngineStepOccupancy extends LocalEngineOccupancy {
     readonly bgIds: readonly string[] | null;
 }
 export type LocalEngineTarget = EngineSwapCardTarget;
-export type LocalEngineStateDownReason = 'lock-unavailable' | 'spawn-failed' | 'spawn-refused' | 'stop-failed' | 'crash-loop' | 'high-water-unreadable';
+export type LocalEngineStateDownReason = 'lock-unavailable' | 'spawn-failed' | 'spawn-refused' | 'stop-failed' | 'crash-loop' | 'high-water-unreadable' | 'exited-once';
 export interface LocalEngineCauseEntry {
     readonly cause: LocalEngineSwapCause;
     readonly fingerprint: string;
@@ -189,7 +189,7 @@ export type LocalEngineEvent = {
     readonly clean: boolean | 'unknown';
     readonly nowMs: number;
 };
-export declare const LOCAL_ENGINE_FAIL_CODES: readonly ["local_engine.behind", "local_engine.legacy_below_floor", "local_engine.unresponsive", "local_engine.swap_pending", "local_engine.drain_overdue", "local_engine.unanswered_unverifiable", "local_engine.lock_unavailable", "local_engine.spawn_failed", "local_engine.spawn_refused", "local_engine.stop_failed", "local_engine.crash_loop", "local_engine.high_water_unreadable", "local_engine.principal_unknown"];
+export declare const LOCAL_ENGINE_FAIL_CODES: readonly ["local_engine.behind", "local_engine.legacy_below_floor", "local_engine.unresponsive", "local_engine.swap_pending", "local_engine.drain_overdue", "local_engine.unanswered_unverifiable", "local_engine.lock_unavailable", "local_engine.spawn_failed", "local_engine.spawn_refused", "local_engine.stop_failed", "local_engine.crash_loop", "local_engine.high_water_unreadable", "local_engine.exited_once", "local_engine.principal_unknown"];
 export type LocalEngineFailCode = (typeof LOCAL_ENGINE_FAIL_CODES)[number];
 export type LocalEngineNotice = {
     readonly key: 'versionUnknown';

package/dist/localEngineStep.js

@@ -18,6 +18,7 @@ export const LOCAL_ENGINE_FAIL_CODES = Object.freeze([
     'local_engine.stop_failed',
     'local_engine.crash_loop',
     'local_engine.high_water_unreadable',
+    'local_engine.exited_once',
     'local_engine.principal_unknown',
 ]);
 function isRecord(v) {
@@ -210,6 +211,7 @@ const DOWN_FAIL = Object.freeze({
     'stop-failed': 'local_engine.stop_failed',
     'crash-loop': 'local_engine.crash_loop',
     'high-water-unreadable': 'local_engine.high_water_unreadable',
+    'exited-once': 'local_engine.exited_once',
 });
 function showCard(p, hold, occ, fx, policy) {
     if (headless(policy)) {

package/dist/mcpEngineLeg.d.ts

@@ -1,5 +1,6 @@
 import type { WiringManifestMcpEntryView } from './adapter/downstream/eventToSdkMessage.js';
 import { type McpAuthorizationView } from './mcpLiveness.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export type McpEngineLegLiveness = {
     kind: 'unobserved';
 } | {
@@ -43,6 +44,8 @@ export type McpEngineLegConnection = {
     status: string;
 };
 export declare function mcpEngineLegConnectionOf(serverName: string, rows: readonly WiringManifestMcpEntryView[] | null | undefined): McpEngineLegConnection;
+export declare function mcpNeedsReauth(reading: {} | null | undefined): boolean | undefined;
+export declare function mcpFailureStatusSuffix(reading: {} | null | undefined, lang?: UiLanguage): string;
 export interface McpDetailLegNoteInput {
     localClientFailed: boolean;
     engineHostedToolCount: number | undefined;

package/dist/mcpEngineLeg.js

@@ -1,5 +1,7 @@
-import { isMcpLivenessState, readMcpAuthorization } from './mcpLiveness.js';
+import { isMcpLivenessState, MCP_FAILURE_UNAUTHORIZED, readMcpAuthorization } from './mcpLiveness.js';
 import { mcpSectionDroppedNamedRowsOf } from './ownKey.js';
+import { slotReadOf } from './wireFailureShape.js';
+import { msg, renderMessage } from './i18n/translate.js';
 void true;
 void true;
 void true;
@@ -132,6 +134,41 @@ export function mcpEngineLegConnectionOf(serverName, rows) {
         ...(authorization.kind === 'record' ? { authorization: authorization.authorization } : authorizationUnreadable ? { authorizationUnreadable: true } : {}),
     };
 }
+export function mcpNeedsReauth(reading) {
+    try {
+        if (reading === null || typeof reading !== 'object' || Array.isArray(reading))
+            return undefined;
+        const slot = slotReadOf(reading, 'errorCode');
+        if (slot.presence === 'absent')
+            return false;
+        if (slot.presence !== 'present')
+            return undefined;
+        const code = slot.value;
+        if (typeof code !== 'string' || code === '')
+            return undefined;
+        return code === MCP_FAILURE_UNAUTHORIZED;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function mcpFailureStatusSuffix(reading, lang) {
+    try {
+        if (reading === null || typeof reading !== 'object' || Array.isArray(reading))
+            return '';
+        const slot = slotReadOf(reading, 'httpStatus');
+        const status = slot.presence === 'present' && typeof slot.value === 'number' && Number.isInteger(slot.value) && slot.value > 0 ? slot.value : undefined;
+        const number = status === undefined ? '' : ` ${status}`;
+        if (mcpNeedsReauth(reading) === true)
+            return `${number}${renderMessage(msg('session.mcpFailure.reauthorizeSuffix'), lang)}`;
+        if (status !== undefined && status >= 500 && status <= 599)
+            return `${number}${renderMessage(msg('session.mcpFailure.serverDownSuffix'), lang)}`;
+        return number;
+    }
+    catch {
+        return '';
+    }
+}
 const rosterReadingOf = (v) => {
     if (v === UNREADABLE_CELL)
         return 'unreadable';

package/dist/mcpPanel.js

@@ -122,6 +122,8 @@ const _mcpPanelShapePin = (p) => p;
 void _mcpPanelShapePin;
 const _mcpPanelRefusalPin = (p) => p;
 void _mcpPanelRefusalPin;
+const _pinMcpPanel = [true, true, true, true, true, true, true, true, true, true];
+void _pinMcpPanel;
 export function mcpEngineLegPresence(view) {
     if (view === undefined)
         return 'unknown';

package/dist/mcpReconnect.d.ts

@@ -1,4 +1,5 @@
 import { type McpAuthorizationView } from './mcpLiveness.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export declare const MCP_RECONNECT_OUTCOMES: readonly string[];
 export declare const MCP_RECONNECT_TRANSACTION_NOTICE: string;
 export declare const MCP_RECONNECT_UNSETTLED_NOTICE: string;
@@ -76,4 +77,11 @@ export declare function reconnectMcpServer(client: McpReconnectClientLike, sessi
     signal?: AbortSignal;
 }): Promise<McpReconnectVerdict>;
 export declare function projectMcpReconnectCapability(caps: unknown): 'available' | 'unavailable' | 'not_reported' | undefined;
-export declare function mcpReconnectOutcomeDetail(view: McpReconnectResultView): string;
+export declare function mcpReconnectOutcomeDetail(view: McpReconnectResultView, lang?: UiLanguage): string;
+export type McpReconnectNotSentVerdict = {
+    readonly kind: 'no_session';
+} | {
+    readonly kind: 'unavailable';
+};
+export type McpReconnectDetailVerdict = McpReconnectVerdict | McpReconnectNotSentVerdict;
+export declare function mcpReconnectVerdictDetail(verdict: McpReconnectDetailVerdict, server: string, lang?: UiLanguage): string | undefined;