@sema-agent/client-core 0.105.0 → 0.107.0

package/dist/seatContract.js

@@ -7,6 +7,7 @@ import { guardedRead, ownDataField, ownDataRefusalKeyOf, ownSendableField, readO
 import { MCP_LIVENESS_STATES } from "./mcpLiveness.js";
 import { THINKING_LATCH_EVENTS, THINKING_LATCH_ROW_WORDS } from "./thinkingLatchWords.js";
 import { EXECUTION_PLACEMENT_ROLES } from "./executionPlacementWords.js";
+import { isSessionEngineView } from "./sessionEngine.js";
 const bad = (reason, field) => field === undefined ? { reason } : { reason, field };
 const nested = (prefix, verdict) => {
     const path = verdict.field === undefined
@@ -191,7 +192,9 @@ const keyWords = (k) => k
     .filter((w) => w.length > 0);
 const SECRET_KEY_WORDS = new Set(["token", "secret", "password", "passwd", "authorization", "bearer", "sealed"]);
 const SECRET_KEY_PAIRS = new Set(["api key", "device code", "access key", "private key"]);
-const isSecretKeyName = (k) => {
+export const isSecretKeyName = (k) => {
+    if (typeof k !== "string")
+        return false;
     const words = keyWords(k);
     for (let i = 0; i < words.length; i += 1) {
         if (SECRET_KEY_WORDS.has(words[i]))
@@ -295,6 +298,7 @@ const CHROME_ARM_SEAT_ROUTE = {
     plan_review_park: "host",
     approval_request: "host",
     approval_revoke: "host",
+    approval_complete: "host",
     task_ledger_sync: "host",
     inline_task_stats: "host",
     stream_delta: "host",
@@ -314,6 +318,7 @@ const CHROME_ARM_SEAT_ROUTE = {
     wiring_manifest: "host",
     suspended_reopened: "host",
     result_text_diverged: "host",
+    session_titled: "host",
 };
 const CHROME_EVENT_KIND_TUPLE = Object.keys(CHROME_ARM_SEAT_ROUTE).filter((k) => CHROME_ARM_SEAT_ROUTE[k] === "seat");
 export const CHROME_EVENT_KINDS = Object.freeze(CHROME_EVENT_KIND_TUPLE);
@@ -376,7 +381,7 @@ export function readSeatStreamDelta(message) {
         return Object.freeze({ kind: "malformed" });
     }
 }
-export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch"]);
+export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly"]);
 const notReported = () => Object.freeze({ kind: "not_reported" });
 const malformedReading = () => Object.freeze({ kind: "malformed" });
 const reported = (available) => Object.freeze({ kind: "reported", available });
@@ -453,6 +458,8 @@ const SEAT_CAPABILITY_PHRASES = Object.freeze({
     onboard: Object.freeze({ action: "Model setup", ability: "add models", support: "model-setup support" }),
     mcpToolToggles: Object.freeze({ action: "Per-tool switching", ability: "toggle tools", support: "per-tool switches" }),
     thinkingLatch: Object.freeze({ action: "Switching thinking", ability: "switch thinking", support: "thinking-switch support" }),
+    computerUseSwitch: Object.freeze({ action: "Computer use", ability: "be switched", support: "switch support" }),
+    engineModeDefaultOnly: Object.freeze({ action: "Default-only engine switching", ability: "keep existing sessions on their engine", support: "default-only engine switching" }),
 });
 export function seatCapabilityUnavailableDetail(name, reading) {
     const phrase = Object.hasOwn(SEAT_CAPABILITY_PHRASES, name)
@@ -886,6 +893,7 @@ const checkOnboardProvidersResult = seatShapeCheck(shapeRule("onboard providers"
         api: reqF(R_API_WORD),
         hasKey: reqF(R_BOOL),
         models: reqF(arrayRule(R_NONEMPTY)),
+        isCurrent: optF(R_BOOL),
     }))),
 }));
 const checkSessionMcpPanelFailure = seatShapeCheck(armsRule("readSessionMcpPanel failure", "kind", {
@@ -967,6 +975,95 @@ const MCP_TOOL_TOGGLE_KEY = shapeRule("toggle key", {
 });
 export const checkMcpToolToggleKey = seatShapeCheck(MCP_TOOL_TOGGLE_KEY);
 const checkMcpToolTogglesResult = seatShapeCheck(shapeRule("toggles result", { off: reqF(arrayRule(MCP_TOOL_TOGGLE_KEY)) }));
+export const COMPUTER_USE_SOURCES = Object.freeze(["env", "settings", "default"]);
+export const COMPUTER_USE_REFUSAL_REASONS = Object.freeze(["locked-by-env", "confirmation-required", "invalid-request", "write-failed"]);
+export const COMPUTER_USE_APPLIES_ON = Object.freeze(["next-engine-start"]);
+const SET_COMPUTER_USE_REQUEST_KEYS = Object.freeze(["enabled", "confirmed"]);
+const COMPUTER_USE_STATE_SHAPE = shapeRule("computer-use state", {
+    enabled: reqF(R_BOOL),
+    source: reqF(oneOfRule("computer-use source", COMPUTER_USE_SOURCES)),
+    lockedByEnv: reqF(R_BOOL),
+    appliesOn: reqF(oneOfRule("computer-use appliesOn", COMPUTER_USE_APPLIES_ON)),
+});
+const COMPUTER_USE_STATE = {
+    label: COMPUTER_USE_STATE_SHAPE.label,
+    test: (v, path) => {
+        const verdict = COMPUTER_USE_STATE_SHAPE.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rec = v;
+        return own(rec, "lockedByEnv") === true && own(rec, "source") !== "env" ? bad("lock conflict", pathAt(path, "lockedByEnv")) : true;
+    },
+};
+const checkComputerUseState = seatShapeCheck(COMPUTER_USE_STATE);
+const SET_COMPUTER_USE_RESULT = okArmsRule("setComputerUse result", { changed: reqF(R_BOOL), state: reqF(COMPUTER_USE_STATE) }, {
+    reason: reqF(oneOfRule("computer-use refusal", COMPUTER_USE_REFUSAL_REASONS)),
+    state: reqF(COMPUTER_USE_STATE),
+});
+const checkSetComputerUseResult = seatShapeCheck({
+    label: SET_COMPUTER_USE_RESULT.label,
+    test: (v, path) => {
+        const verdict = SET_COMPUTER_USE_RESULT.test(v, path);
+        if (verdict !== true)
+            return verdict;
+        const rec = v;
+        if (own(rec, "reason") === "locked-by-env" && own(own(rec, "state"), "lockedByEnv") !== true)
+            return bad("lock conflict", pathAt(path, "state.lockedByEnv"));
+        return true;
+    },
+});
+const failureOfRule = (rule, v, path) => {
+    const verdict = rule.test(v, path);
+    return verdict === true ? bad("bad value", path) : verdict;
+};
+const computerUseIntentOf = (v) => {
+    const invalid = (failure) => ({ kind: "invalid", failure });
+    if (!isPlainRecord(v))
+        return invalid(bad("not object"));
+    const snap = new Map();
+    for (const k of Reflect.ownKeys(v))
+        if (typeof k === "string")
+            snap.set(k, own(v, k));
+    for (const k of snap.keys())
+        if (!inTuple(SET_COMPUTER_USE_REQUEST_KEYS, k))
+            return invalid(bad("unknown key", k));
+    const enabled = snap.get("enabled");
+    if (enabled === undefined)
+        return invalid(bad("missing key", "enabled"));
+    if (typeof enabled !== "boolean")
+        return invalid(failureOfRule(R_BOOL, enabled, "enabled"));
+    if (!enabled)
+        return snap.has("confirmed") ? invalid(bad("unknown key", "confirmed")) : { kind: "disable" };
+    const confirmed = snap.get("confirmed");
+    if (confirmed === true)
+        return { kind: "enable" };
+    if (confirmed === undefined)
+        return { kind: "unconfirmed", failure: bad("missing key", "confirmed") };
+    if (confirmed === false)
+        return { kind: "unconfirmed", failure: failureOfRule(R_TRUE, confirmed, "confirmed") };
+    return invalid(failureOfRule(R_BOOL, confirmed, "confirmed"));
+};
+export const checkSetComputerUseRequest = seatCheck((v) => {
+    const intent = computerUseIntentOf(v);
+    return intent.kind === "disable" || intent.kind === "enable" ? true : intent.failure;
+});
+export function planSetComputerUse(request, lockedByEnv) {
+    let intent;
+    try {
+        const at = firstAccessorPath(request);
+        intent = at !== undefined ? { kind: "invalid", failure: bad(NOT_PLAIN_DATA, at) } : computerUseIntentOf(request);
+    }
+    catch {
+        intent = { kind: "invalid", failure: bad("unreadable") };
+    }
+    if (intent.kind === "invalid")
+        return Object.freeze({ kind: "refused", reason: "invalid-request" });
+    if (lockedByEnv !== false)
+        return Object.freeze({ kind: "refused", reason: "locked-by-env" });
+    if (intent.kind === "unconfirmed")
+        return Object.freeze({ kind: "refused", reason: "confirmation-required" });
+    return Object.freeze({ kind: "apply", enabled: intent.kind === "enable" });
+}
 const checkLocalSessionRecord = seatCheck((s) => {
     if (!isPlainRecord(s))
         return bad("session record is not a plain object");
@@ -1006,12 +1103,28 @@ const checkLocalSessionRecord = seatCheck((s) => {
     if (!isAbsent(rowTag) && (typeof rowTag !== "string" || rowTag.length === 0)) {
         return bad("rowTag must be a non-empty string when present (absent = this row cannot be written conditionally)", "rowTag");
     }
+    const unreadable = own(s, "unreadable");
+    if (!isAbsent(unreadable)) {
+        if (!isPlainRecord(unreadable))
+            return bad("unreadable must be a plain object when present (absent = the list did not report this session as unreadable)", "unreadable");
+        const code = own(unreadable, "errorCode");
+        if (!isAbsent(code) && (typeof code !== "string" || code.length === 0))
+            return bad("unreadable.errorCode must be a non-empty string when present", "unreadable.errorCode");
+    }
     const latch = own(s, "thinkingLatch");
     if (!isAbsent(latch)) {
         const verdict = R_THINKING_LATCH_ROW.test(latch, "thinkingLatch");
         if (verdict !== true)
             return verdict;
     }
+    const engine = own(s, "engine");
+    if (!isAbsent(engine) && !isSessionEngineView(engine)) {
+        return bad("engine must be a session engine reading (kind local|cloud + identityKind + identity{key, presentation} as the package mints it) when present (absent = the engine is not known)", "engine");
+    }
+    const lane = own(s, "executionLane");
+    if (!isAbsent(lane) && (typeof lane !== "string" || lane.length === 0)) {
+        return bad("executionLane must be a non-empty string when present (absent = no writer lane reading)", "executionLane");
+    }
     return true;
 });
 export function isLocalSessionRecord(s) {
@@ -1667,6 +1780,8 @@ export const LOCAL_SESSIONS_SPEC = {
         listMcpToolToggles: { kind: "invoke", check: checkMcpToolTogglesResult },
         setMcpToolToggle: { kind: "invoke", check: checkOkAck },
         setThinkingLatch: { kind: "invoke", check: checkOkAck },
+        getComputerUse: { kind: "invoke", check: checkComputerUseState },
+        setComputerUse: { kind: "invoke", check: checkSetComputerUseResult },
         onEvent: { kind: "event", check: checkLocalSessionEvent },
         onToolPermissionRequest: { kind: "event", check: checkToolPermissionRequest },
     },
@@ -1715,6 +1830,8 @@ export const SEAT_METHOD_NAMES = [
     "listMcpToolToggles",
     "setMcpToolToggle",
     "setThinkingLatch",
+    "getComputerUse",
+    "setComputerUse",
     "onEvent",
     "onToolPermissionRequest",
 ];
@@ -1774,7 +1891,10 @@ export const LOCAL_SESSION_RECORD_KEYS = [
     "parked",
     "pinned",
     "rowTag",
+    "unreadable",
     "thinkingLatch",
+    "engine",
+    "executionLane",
 ];
 export const SEND_MESSAGE_REQUEST_KEYS = [
     "sessionId",
@@ -1819,7 +1939,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     LocalSessionRecord: {
         guard: "isLocalSessionRecord",
         check: checkLocalSessionRecord,
-        validated: ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "rowTag", "thinkingLatch"],
+        validated: ["sessionId", "engineSessionId", "model", "title", "cwd", "isRunning", "createdAt", "lastActivityAt", "queuedMessages", "parked", "pinned", "rowTag", "unreadable", "thinkingLatch", "engine", "executionLane"],
         unchecked: [],
     },
     ToolPermissionRequest: {
@@ -1915,6 +2035,10 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
                 key: "candidateRejected",
                 why: "诊断面(0.97.0 CC-715;当前配置是候选被整拒后回落的那一份),三态读法归 modelCandidateRejectedOf(含坏形 unreadable);出站门为它拒掉整份目录 = 选单为一行诊断整个消失。",
             },
+            {
+                key: "modelPlane",
+                why: "诊断面(0.106.0 CC-1156;这台引擎服务的是哪张模型表 / 最近一份目录候选的结局),三态读法归 modelPlaneOf(含坏形 unreadable、表外词整位不给);出站门为它拒掉整份目录 = 选单为一行诊断整个消失。",
+            },
         ],
     },
     SendMessageRequest: {
@@ -2002,7 +2126,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     },
     SeatCapabilitiesState: {
         check: checkSeatCapabilitiesState,
-        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch"],
+        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly"],
         unchecked: [],
     },
     RecentFoldersResult: {
@@ -2065,6 +2189,9 @@ export const SEAT_VALIDATOR_COVERAGE_EXEMPT = [
         ["OnboardApplyRequest", checkOnboardApplyRequest],
         ["McpToolTogglesResult", checkMcpToolTogglesResult],
         ["McpToolToggleKey", checkMcpToolToggleKey],
+        ["ComputerUseState", checkComputerUseState],
+        ["SetComputerUseResult", checkSetComputerUseResult],
+        ["SetComputerUseRequest", checkSetComputerUseRequest],
     ].map(([label, check]) => ({
         label,
         check,
@@ -2120,5 +2247,9 @@ const _seatContractPins = [
     true, true, true, true, true, true,
     true, true, true,
     true, true,
+    true, true, true,
+    true, true,
+    true, true, true, true,
+    true, true,
 ];
 void _seatContractPins;

package/dist/serverSupportRange.d.ts

@@ -0,0 +1,18 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export declare const SERVER_SUPPORT_RANGE_REASONS: readonly ["below_floor", "version_absent", "version_unreadable"];
+export type ServerSupportRangeReason = (typeof SERVER_SUPPORT_RANGE_REASONS)[number];
+export type ServerSupportRangeVerdict = {
+    readonly kind: 'in_range';
+    readonly floor: string;
+} | {
+    readonly kind: 'out_of_range';
+    readonly reason: 'below_floor';
+    readonly version: string;
+    readonly floor: string;
+} | {
+    readonly kind: 'unknown';
+    readonly reason: 'version_absent' | 'version_unreadable';
+    readonly floor: string;
+};
+export declare function serverSupportRangeVerdict(version: string | undefined): ServerSupportRangeVerdict;
+export declare function serverSupportRangeSentence(verdict: ServerSupportRangeVerdict, lang?: UiLanguage): string | undefined;

package/dist/serverSupportRange.js

@@ -0,0 +1,25 @@
+import { engineSupportFloorEffective, engineVersionTier } from './supportFloor.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const SERVER_SUPPORT_RANGE_REASONS = Object.freeze(['below_floor', 'version_absent', 'version_unreadable']);
+export function serverSupportRangeVerdict(version) {
+    const floor = engineSupportFloorEffective();
+    const tier = engineVersionTier(version);
+    if (tier === 'engine')
+        return Object.freeze({ kind: 'in_range', floor });
+    if (tier === 'legacy')
+        return Object.freeze({ kind: 'out_of_range', reason: 'below_floor', version: version, floor });
+    return Object.freeze({ kind: 'unknown', reason: version === undefined ? 'version_absent' : 'version_unreadable', floor });
+}
+export function serverSupportRangeSentence(verdict, lang) {
+    try {
+        if (typeof verdict !== 'object' || verdict === null || verdict.kind !== 'out_of_range')
+            return undefined;
+        const again = serverSupportRangeVerdict(verdict.version);
+        if (again.kind !== 'out_of_range')
+            return undefined;
+        return renderMessage(msg('config.engineTarget.serverBelowSupportFloor', { version: again.version, floor: again.floor }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/sessionEngine.d.ts

@@ -0,0 +1,156 @@
+import type { EngineRowReading } from './engineDirectory.js';
+import type { EngineTargetCloudAuth } from './seatContract.js';
+import { type SessionMapRecord, type SessionMapStorePort } from './sessionMap.js';
+import { type MessageRef } from './i18n/translate.js';
+export type SessionEngineKind = 'local' | 'cloud';
+export type SessionEngineIdentityKind = 'self' | 'declared' | 'address';
+export type SessionEngineBindingInput = {
+    readonly role: 'self';
+} | SessionEngineRowInput | {
+    readonly role: 'external';
+    readonly address: string;
+};
+export interface SessionEngineRowInput {
+    readonly role: 'external';
+    readonly row: EngineRowReading;
+    readonly center: string;
+}
+export type SessionEngineBindingFailure = 'row-incomplete' | 'center-invalid' | 'address-invalid' | 'input-invalid';
+export type SessionEngineSelfPresentation = Readonly<Record<string, never>>;
+export interface SessionEngineDeclaredPresentation {
+    readonly center: string;
+    readonly scope: string;
+    readonly name: string;
+}
+export interface SessionEngineAddressPresentation {
+    readonly address: string;
+}
+export type SessionEngineBindingOk = SessionEngineSelfBinding | SessionEngineDeclaredBinding | SessionEngineAddressBinding;
+export interface SessionEngineSelfBinding {
+    readonly ok: true;
+    readonly identityKind: 'self';
+    readonly key: string;
+    readonly presentation: SessionEngineSelfPresentation;
+}
+export interface SessionEngineDeclaredBinding {
+    readonly ok: true;
+    readonly identityKind: 'declared';
+    readonly key: string;
+    readonly presentation: SessionEngineDeclaredPresentation;
+    readonly connect: {
+        readonly viaCenter: string;
+    };
+}
+export interface SessionEngineAddressBinding {
+    readonly ok: true;
+    readonly identityKind: 'address';
+    readonly key: string;
+    readonly presentation: SessionEngineAddressPresentation;
+    readonly connect: {
+        readonly url: string;
+    };
+}
+export type SessionEngineBinding = SessionEngineBindingOk | {
+    readonly ok: false;
+    readonly reason: SessionEngineBindingFailure;
+};
+export interface SessionEngineAssignment {
+    readonly kind: SessionEngineKind;
+    readonly identity: SessionEngineBindingOk;
+}
+export type SessionEngineView = SessionEngineSelfView | SessionEngineDeclaredView | SessionEngineAddressView;
+export interface SessionEngineSelfView {
+    readonly kind: SessionEngineKind;
+    readonly identityKind: 'self';
+    readonly identity: {
+        readonly key: string;
+        readonly presentation: SessionEngineSelfPresentation;
+    };
+}
+export interface SessionEngineDeclaredView {
+    readonly kind: SessionEngineKind;
+    readonly identityKind: 'declared';
+    readonly identity: {
+        readonly key: string;
+        readonly presentation: SessionEngineDeclaredPresentation;
+    };
+}
+export interface SessionEngineAddressView {
+    readonly kind: SessionEngineKind;
+    readonly identityKind: 'address';
+    readonly identity: {
+        readonly key: string;
+        readonly presentation: SessionEngineAddressPresentation;
+    };
+}
+export type SessionEngineReading = SessionEngineBoundReading | {
+    readonly kind: 'legacy';
+} | {
+    readonly kind: 'unresolved';
+} | {
+    readonly kind: 'none';
+};
+export interface SessionEngineBoundReading {
+    readonly kind: 'bound';
+    readonly binding: SessionEngineAssignment;
+    readonly engine: SessionEngineView;
+    readonly uuid: string;
+}
+export interface SessionEngineSessionRef {
+    readonly shellSessionId: string;
+    readonly uuid: string;
+}
+export type SessionEngineCommitRequest = {
+    readonly arm: 'create';
+    readonly binding: SessionEngineAssignment;
+} | {
+    readonly arm: 'resume';
+    readonly binding: SessionEngineAssignment;
+} | SessionEngineRecoverRequest;
+export interface SessionEngineRecoverRequest {
+    readonly arm: 'recover';
+    readonly binding: SessionEngineAssignment;
+    readonly chosenByUser?: true;
+}
+export type SessionEngineUnresolvedReason = 'request-invalid' | 'record-mismatch' | 'record-legacy' | 'record-unbound' | 'record-unreadable' | 'recover-unproven';
+export type SessionEngineCommitResult = SessionEngineCommitted | {
+    readonly kind: 'conflict';
+    readonly bound: SessionEngineView;
+} | {
+    readonly kind: 'unresolved';
+    readonly reason: SessionEngineUnresolvedReason;
+} | {
+    readonly kind: 'store-failed';
+};
+export interface SessionEngineCommitted {
+    readonly kind: 'committed';
+    readonly engine: SessionEngineView;
+    readonly notice?: MessageRef;
+}
+export interface SessionEngineWiring {
+    readonly id: string;
+    readonly selfSpawned: boolean;
+    readonly wiredAddresses: readonly string[];
+    readonly auth: EngineTargetCloudAuth | undefined;
+    readonly explicitAddresses?: readonly string[];
+}
+export type SessionDispatchRefusal = 'not-wired' | 'scope-mismatch' | 'scope-unproven' | 'unresolved';
+export type SessionDispatchDecision = {
+    readonly kind: 'self';
+    readonly wiringSnapshotId: string;
+} | SessionDispatchUrlTarget | SessionDispatchRefused;
+export interface SessionDispatchUrlTarget {
+    readonly kind: 'address' | 'center';
+    readonly url: string;
+    readonly wiringSnapshotId: string;
+}
+export interface SessionDispatchRefused {
+    readonly kind: 'refused';
+    readonly refusal: SessionDispatchRefusal;
+    readonly message: MessageRef;
+}
+export declare function sessionEngineBindingFor(input: SessionEngineBindingInput): SessionEngineBinding;
+export declare function isSessionEngineView(v: {} | null | undefined): boolean;
+export declare function readSessionEngine(record: SessionMapRecord | undefined): SessionEngineReading;
+export declare function commitSessionEngine(store: SessionMapStorePort, session: SessionEngineSessionRef, request: SessionEngineCommitRequest): SessionEngineCommitResult;
+export declare function sessionDispatchTarget(reading: SessionEngineReading, ctx: SessionEngineWiring): SessionDispatchDecision;