@sema-agent/client-core 0.108.0 → 0.110.0

package/dist/localEngineStopLadder.d.ts

@@ -0,0 +1,29 @@
+export declare const LOCAL_ENGINE_STOP_LADDER: Readonly<{
+    g: 1000;
+    P: 5000;
+    H: 20000;
+}>;
+export type StopLadderSignal = 'term' | 'term-2' | 'kill';
+export interface StopLadderState {
+    readonly mode: 'idle' | 'forced';
+    readonly target: {
+        readonly pid: number;
+        readonly startedAt?: number;
+    };
+    readonly t0: number;
+    readonly sent: readonly StopLadderSignal[];
+    readonly processedAt?: number;
+    readonly deadlineAt?: number;
+    readonly killedAt?: number;
+}
+export interface StopLadderObservation {
+    readonly nowMs: number;
+    readonly alive: 'alive' | 'gone' | 'unknown';
+    readonly health: object | null;
+}
+export interface StopLadderStepResult {
+    readonly state: StopLadderState;
+    readonly action: StopLadderSignal | 'wait' | 'done' | 'gave-up';
+    readonly waitMs?: number;
+}
+export declare function stopLadderStep(s: StopLadderState, obs: StopLadderObservation): StopLadderStepResult;

package/dist/localEngineStopLadder.js

@@ -0,0 +1,139 @@
+import { readEngineHealthFacts } from './engineHealthFacts.js';
+import { readOwnDataValue } from './ownKey.js';
+export const LOCAL_ENGINE_STOP_LADDER = Object.freeze({ g: 1000, P: 5000, H: 20000 });
+const SIGTERM_ACTION_ID = 'signal:SIGTERM';
+function own(v, key) {
+    if (typeof v !== 'object' || v === null)
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isTime(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
+function isPid(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+const SIGNALS = Object.freeze(['term', 'term-2', 'kill']);
+function stateOf(s) {
+    const mode = own(s, 'mode');
+    if (mode !== 'idle' && mode !== 'forced')
+        return undefined;
+    const target = own(s, 'target');
+    const pid = own(target, 'pid');
+    if (!isPid(pid))
+        return undefined;
+    const startedAt = own(target, 'startedAt');
+    const t0 = own(s, 't0');
+    if (!isTime(t0))
+        return undefined;
+    const sentRaw = own(s, 'sent');
+    let sent = [];
+    try {
+        if (!Array.isArray(sentRaw))
+            return undefined;
+        for (let i = 0; i < sentRaw.length; i++) {
+            const x = own(sentRaw, String(i));
+            if (!SIGNALS.includes(x))
+                return undefined;
+            if (!sent.includes(x))
+                sent.push(x);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    sent = SIGNALS.filter((x) => sent.includes(x));
+    const processedAt = own(s, 'processedAt');
+    const deadlineAt = own(s, 'deadlineAt');
+    const killedAt = own(s, 'killedAt');
+    if (processedAt !== undefined && !isTime(processedAt))
+        return undefined;
+    if (deadlineAt !== undefined && !isTime(deadlineAt))
+        return undefined;
+    if (killedAt !== undefined && !isTime(killedAt))
+        return undefined;
+    return {
+        mode,
+        target: isTime(startedAt) && startedAt > 0 ? { pid, startedAt } : { pid },
+        t0,
+        sent,
+        ...(processedAt !== undefined ? { processedAt } : {}),
+        ...(deadlineAt !== undefined ? { deadlineAt } : {}),
+        ...(killedAt !== undefined ? { killedAt } : {}),
+    };
+}
+function frozen(s) {
+    return Object.freeze({ ...s, target: Object.freeze({ ...s.target }), sent: Object.freeze([...s.sent]) });
+}
+function result(s, action, waitMs) {
+    return Object.freeze({ state: frozen(s), action, ...(waitMs !== undefined ? { waitMs: Math.max(0, waitMs) } : {}) });
+}
+export function stopLadderStep(s, obs) {
+    const st = stateOf(s);
+    if (st === undefined) {
+        return Object.freeze({ state: s, action: 'gave-up' });
+    }
+    const nowMs = own(obs, 'nowMs');
+    const alive = own(obs, 'alive');
+    if (alive === 'gone')
+        return result(st, 'done');
+    if (!isTime(nowMs))
+        return result(st, 'wait');
+    const { g, P, H } = LOCAL_ENGINE_STOP_LADDER;
+    const health = own(obs, 'health');
+    let facts;
+    try {
+        facts = typeof health === 'object' && health !== null ? readEngineHealthFacts(health) : undefined;
+    }
+    catch {
+        facts = undefined;
+    }
+    const draining = facts?.draining;
+    let next = st;
+    if (draining !== undefined) {
+        if (st.mode === 'idle') {
+            next = { ...next, deadlineAt: Math.max(st.deadlineAt ?? draining.deadlineAt, draining.deadlineAt) };
+        }
+        else if (st.processedAt === undefined && st.sent.includes('term') && draining.actionId === SIGTERM_ACTION_ID && draining.since >= st.t0) {
+            next = { ...next, processedAt: nowMs };
+        }
+    }
+    const isAlive = alive === 'alive';
+    if (next.sent.length === 0) {
+        if (isAlive)
+            return result({ ...next, sent: ['term'] }, 'term');
+        return result(next, nowMs >= next.t0 + H ? 'gave-up' : 'wait', next.t0 + H - nowMs);
+    }
+    const killAt = next.mode === 'idle'
+        ? Math.max(next.t0, next.deadlineAt ?? next.t0) + H
+        : next.processedAt !== undefined && next.processedAt <= next.t0 + P
+            ? next.processedAt + g + H
+            : next.t0 + H;
+    if (next.killedAt !== undefined || next.sent.includes('kill')) {
+        const giveUpAt = (next.killedAt ?? killAt) + H;
+        if (nowMs >= giveUpAt)
+            return result(next, 'gave-up');
+        return result(next, 'wait', giveUpAt - nowMs);
+    }
+    if (!isAlive) {
+        if (nowMs >= killAt)
+            return result(next, 'gave-up');
+        return result(next, 'wait', killAt - nowMs);
+    }
+    if (nowMs >= killAt)
+        return result({ ...next, sent: [...next.sent, 'kill'], killedAt: nowMs }, 'kill');
+    if (next.mode === 'forced' &&
+        next.processedAt !== undefined &&
+        nowMs >= next.processedAt + g &&
+        draining !== undefined &&
+        !next.sent.includes('term-2')) {
+        return result({ ...next, sent: [...next.sent.filter((x) => x !== 'kill'), 'term-2'] }, 'term-2');
+    }
+    const term2At = next.mode === 'forced' && next.processedAt !== undefined && !next.sent.includes('term-2') ? next.processedAt + g : Infinity;
+    return result(next, 'wait', Math.min(killAt, term2At) - nowMs);
+}

package/dist/localEngineSwapCard.d.ts

@@ -0,0 +1,43 @@
+import type { LocalEngineAnchoredProcess, LocalEngineRef } from './localEngineJudge.js';
+import type { LocalEngineOccupancy } from './localEngineOccupancy.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const LOCAL_ENGINE_SWAP_CAUSES: readonly ["version", "config", "credential", "model-default", "user", "unresponsive"];
+export type LocalEngineSwapCause = (typeof LOCAL_ENGINE_SWAP_CAUSES)[number];
+export interface LocalEngineSwapPolicy {
+    readonly credentialAuto?: boolean;
+}
+export declare function localEngineSwapAutoable(cause: LocalEngineSwapCause, serving: boolean, policy?: LocalEngineSwapPolicy): boolean;
+export type EngineSwapCardTarget = LocalEngineRef | LocalEngineAnchoredProcess;
+export type EngineSwapCardUnknown = 'others' | 'inflight' | 'bg' | 'self';
+export interface EngineSwapCardInput {
+    readonly cause: LocalEngineSwapCause;
+    readonly target: EngineSwapCardTarget;
+    readonly running?: string;
+    readonly own?: string;
+    readonly occupancy: LocalEngineOccupancy;
+    readonly bgIds: readonly string[] | null;
+}
+export interface EngineSwapCardOthers {
+    readonly total: number;
+    readonly midTurn: number;
+}
+export interface EngineSwapCard {
+    readonly cause: LocalEngineSwapCause;
+    readonly target: EngineSwapCardTarget;
+    readonly running?: string;
+    readonly own?: string;
+    readonly others: EngineSwapCardOthers | null;
+    readonly inflight: number | null;
+    readonly bgLive: number | null;
+    readonly unknown: readonly EngineSwapCardUnknown[];
+    readonly forcedWithinMs: number;
+    readonly fingerprint: string;
+}
+export declare function engineSwapCardOf(input: EngineSwapCardInput): EngineSwapCard | undefined;
+export interface EngineSwapCardText {
+    readonly title: string;
+    readonly lines: readonly string[];
+    readonly force: string;
+    readonly wait: string;
+}
+export declare function engineSwapCardText(card: EngineSwapCard, lang?: UiLanguage): EngineSwapCardText | undefined;

package/dist/localEngineSwapCard.js

@@ -0,0 +1,205 @@
+import { engineIdentityOf } from './engineIdentity.js';
+import { readOwnDataValue } from './ownKey.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { LOCAL_ENGINE_STOP_LADDER } from './localEngineStopLadder.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const LOCAL_ENGINE_SWAP_CAUSES = Object.freeze(['version', 'config', 'credential', 'model-default', 'user', 'unresponsive']);
+function isCause(v) {
+    return typeof v === 'string' && LOCAL_ENGINE_SWAP_CAUSES.includes(v);
+}
+function isRecord(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function isArray(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function own(v, key) {
+    if (!isRecord(v) && !isArray(v))
+        return undefined;
+    try {
+        return readOwnDataValue(v, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isCount(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+}
+function isPid(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
+export function localEngineSwapAutoable(cause, serving, policy) {
+    if (!isCause(cause))
+        return false;
+    if (serving === false)
+        return true;
+    if (cause === 'version' || cause === 'user')
+        return true;
+    return cause === 'credential' && own(policy, 'credentialAuto') === true;
+}
+const FORCED_WITHIN_MS = LOCAL_ENGINE_STOP_LADDER.P + LOCAL_ENGINE_STOP_LADDER.g + LOCAL_ENGINE_STOP_LADDER.H;
+function targetOf(t) {
+    const pid = own(t, 'pid');
+    if (!isPid(pid))
+        return undefined;
+    const identity = own(t, 'identity');
+    if (isRecord(identity)) {
+        const port = own(t, 'port');
+        if (typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65535)
+            return undefined;
+        const id = Object.freeze({ ...engineIdentityOf(identity) });
+        const version = own(t, 'version');
+        const target = Object.freeze({ pid, port, identity: id, ...(typeof version === 'string' && version.length > 0 ? { version } : {}) });
+        return { target, key: id };
+    }
+    const startedAt = own(t, 'startedAt');
+    const target = Object.freeze({ pid, ...(typeof startedAt === 'number' && Number.isFinite(startedAt) && startedAt > 0 ? { startedAt } : {}) });
+    return { target, key: engineIdentityOf(target) };
+}
+export function engineSwapCardOf(input) {
+    try {
+        const cause = own(input, 'cause');
+        if (!isCause(cause))
+            return undefined;
+        const t = targetOf(own(input, 'target'));
+        if (t === undefined)
+            return undefined;
+        const occ = own(input, 'occupancy');
+        const unknown = [];
+        const o = own(occ, 'others');
+        const total = own(o, 'total');
+        const midTurn = own(o, 'midTurn');
+        const others = own(o, 'known') === true && isCount(total) && isCount(midTurn) ? Object.freeze({ total, midTurn }) : null;
+        if (others === null)
+            unknown.push('others');
+        const inflightRaw = own(occ, 'inflight');
+        const inflight = isCount(inflightRaw) ? inflightRaw : null;
+        if (inflight === null)
+            unknown.push('inflight');
+        const bgRaw = own(occ, 'bgLive');
+        const idsRaw = own(input, 'bgIds');
+        let bgIds = null;
+        if (Array.isArray(idsRaw)) {
+            const list = [];
+            let readable = true;
+            for (let i = 0; i < idsRaw.length && readable; i++) {
+                const id = own(idsRaw, String(i));
+                if (typeof id === 'string')
+                    list.push(id);
+                else
+                    readable = false;
+            }
+            bgIds = readable ? list : null;
+        }
+        const bgLive = isCount(bgRaw) && bgIds !== null && bgIds.length === bgRaw ? bgRaw : null;
+        if (bgLive === null) {
+            unknown.push('bg');
+            bgIds = null;
+        }
+        const self = own(occ, 'self');
+        if (self !== 'idle' && self !== 'busy')
+            unknown.push('self');
+        const runningRaw = own(input, 'running');
+        const ownRaw = own(input, 'own');
+        const running = typeof runningRaw === 'string' && runningRaw.length > 0 ? runningRaw : undefined;
+        const mine = typeof ownRaw === 'string' && ownRaw.length > 0 ? ownRaw : undefined;
+        const k = t.key;
+        const fingerprint = JSON.stringify([
+            'local-engine-swap-card/1',
+            cause,
+            [t.target.pid, k.pid ?? null, k.instanceId ?? null, k.startedAt ?? null],
+            running ?? null,
+            mine ?? null,
+            others === null ? null : [others.total, others.midTurn],
+            inflight,
+            bgLive,
+            bgIds === null ? null : [...bgIds].sort(),
+            unknown,
+            self === 'idle' || self === 'busy' ? self : null,
+        ]);
+        return Object.freeze({
+            cause,
+            target: t.target,
+            ...(running !== undefined ? { running } : {}),
+            ...(mine !== undefined ? { own: mine } : {}),
+            others,
+            inflight,
+            bgLive,
+            unknown: Object.freeze(unknown),
+            forcedWithinMs: FORCED_WITHIN_MS,
+            fingerprint,
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+const TITLE_KEYS = Object.freeze({
+    version: 'localEngine.card.title.version',
+    config: 'localEngine.card.title.config',
+    credential: 'localEngine.card.title.credential',
+    'model-default': 'localEngine.card.title.modelDefault',
+    user: 'localEngine.card.title.user',
+    unresponsive: 'localEngine.card.title.unresponsive',
+});
+const VERSION_DISPLAY_MAX = 64;
+export function engineSwapCardText(card, lang) {
+    try {
+        const cause = own(card, 'cause');
+        const forcedWithinMs = own(card, 'forcedWithinMs');
+        if (!isCause(cause) || !isCount(forcedWithinMs))
+            return undefined;
+        const say = (key, params) => renderMessage(msg(key, params), lang);
+        const lines = [];
+        const running = own(card, 'running');
+        const mine = own(card, 'own');
+        if (typeof running === 'string' && running.length > 0 && typeof mine === 'string' && mine.length > 0) {
+            lines.push(say('localEngine.card.versions', { running: displayUntrusted(running, { max: VERSION_DISPLAY_MAX }), own: displayUntrusted(mine, { max: VERSION_DISPLAY_MAX }) }));
+        }
+        const others = own(card, 'others');
+        const total = own(others, 'total');
+        const midTurn = own(others, 'midTurn');
+        if (isCount(total) && isCount(midTurn))
+            lines.push(say(total === 1 ? 'localEngine.card.others.one' : 'localEngine.card.others.other', { total, midTurn }));
+        else
+            lines.push(say('localEngine.card.others.unknown'));
+        const inflight = own(card, 'inflight');
+        if (isCount(inflight))
+            lines.push(say(inflight === 1 ? 'localEngine.card.inflight.one' : 'localEngine.card.inflight.other', { count: inflight }));
+        else
+            lines.push(say('localEngine.card.inflight.unknown'));
+        const bgLive = own(card, 'bgLive');
+        if (isCount(bgLive))
+            lines.push(say(bgLive === 1 ? 'localEngine.card.background.one' : 'localEngine.card.background.other', { count: bgLive }));
+        else
+            lines.push(say('localEngine.card.background.unknown'));
+        if (isCount(inflight) && inflight > 0 && isCount(bgLive) && bgLive > 0)
+            lines.push(say('localEngine.card.overlap'));
+        const unknown = own(card, 'unknown');
+        if (Array.isArray(unknown) && unknown.includes('self'))
+            lines.push(say('localEngine.card.selfUnknown'));
+        lines.push(say('localEngine.card.parked'));
+        return Object.freeze({
+            title: say(TITLE_KEYS[cause]),
+            lines: Object.freeze(lines),
+            force: say('localEngine.card.force', { seconds: Math.ceil(forcedWithinMs / 1000) }),
+            wait: say('localEngine.card.wait'),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/localEngineTiming.d.ts

@@ -0,0 +1,8 @@
+export declare const LOCAL_ENGINE_TIMING: Readonly<{
+    unansweredWaitMs: 60000;
+    prepareTimeoutMs: 10000;
+    stopProbeTimeoutMs: 4000;
+    crashWindowMs: 300000;
+    crashMaxDeaths: 3;
+    cooldownMs: readonly [60000, 120000, 240000, 480000, 600000, 600000];
+}>;

package/dist/localEngineTiming.js

@@ -0,0 +1,8 @@
+export const LOCAL_ENGINE_TIMING = Object.freeze({
+    unansweredWaitMs: 60000,
+    prepareTimeoutMs: 10000,
+    stopProbeTimeoutMs: 4000,
+    crashWindowMs: 300000,
+    crashMaxDeaths: 3,
+    cooldownMs: Object.freeze([60000, 120000, 240000, 480000, 600000, 600000]),
+});

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;