@sema-agent/client-core 0.98.0 → 0.100.0

package/dist/engineAgentPanelStore.d.ts

@@ -2,6 +2,10 @@ import { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_T
 import type { EngineAgentPanelCycleIdentity } from './cycleOrder.js';
 export { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS };
 export type { EngineAgentPanelCycleIdentity, EnginePanelTaskIdentity };
+type PanelFinalityFlags = {
+    totalTokens?: true;
+    toolUses?: true;
+};
 export type EngineAgentPanelEvent = {
     kind: 'tick';
     taskId: string;
@@ -16,6 +20,8 @@ export type EngineAgentPanelEvent = {
     cardBound?: true;
     wireTaskId?: string;
     taskIdOrigin?: 'fleet-row' | 'wire';
+    cycleSeq?: number;
+    final?: PanelFinalityFlags;
 } | {
     kind: 'fleet-row';
     taskId: string;
@@ -33,10 +39,7 @@ export type EngineAgentPanelEvent = {
     parentToolCallId?: string;
     wireTaskId?: string;
     taskIdOrigin?: 'wire';
-    final?: {
-        totalTokens?: true;
-        toolUses?: true;
-    };
+    final?: PanelFinalityFlags;
 } | {
     kind: 'end';
     taskId: string;
@@ -46,6 +49,7 @@ export type EngineAgentPanelEvent = {
     report?: string;
     wireTaskId?: string;
     taskIdOrigin?: 'fleet-row' | 'wire';
+    sessionId?: string;
 } | {
     kind: 'sweep';
 };
@@ -58,6 +62,12 @@ export declare function clearEnginePanelTaskResidentByWire(wireTaskId: string, c
 export declare function __resetEngineAgentPanelIdentityForTests(): void;
 export declare function __resetEnginePanelStateForTests(): void;
 export declare function publishEngineAgentPanelEvent(ev: EngineAgentPanelEvent): void;
+export interface EngineAgentPanelStart {
+    taskId: string;
+    startedAt?: number;
+    workflowRunId?: string;
+}
+export declare function publishEngineAgentPanelStart(ev: EngineAgentPanelStart): void;
 export declare function subscribeEnginePanelRows(fn: (delta: PanelDelta) => void): () => void;
 export interface EngineAgentPanelAbsence {
     taskId: string;

package/dist/engineAgentPanelStore.js

@@ -1,4 +1,5 @@
 import { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, panelIsResident, panelResolveTaskId, MAX_HELD_WIRE_TICK_BEATS, } from './panelReduce.js';
+import { guardedRead, readOwnDataFiniteNumber, readOwnDataNonEmptyString } from './ownKey.js';
 import { clearEnginePanelIdentity, panelStateNow, stepEnginePanel, subscribeRows, resetEnginePanelHolder } from './panelStateHolder.js';
 export { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS };
 const _panelToolUsesLanePins = [true, true];
@@ -31,6 +32,19 @@ export function __resetEnginePanelStateForTests() {
 export function publishEngineAgentPanelEvent(ev) {
     stepEnginePanel(ev);
 }
+export function publishEngineAgentPanelStart(ev) {
+    const taskId = guardedRead(() => readOwnDataNonEmptyString(ev, 'taskId'));
+    if (taskId === undefined)
+        return;
+    const startedAt = guardedRead(() => readOwnDataFiniteNumber(ev, 'startedAt'));
+    const workflowRunId = guardedRead(() => readOwnDataNonEmptyString(ev, 'workflowRunId'));
+    stepEnginePanel({
+        kind: 'start',
+        taskId,
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...(workflowRunId !== undefined ? { workflowRunId } : {}),
+    });
+}
 export function subscribeEnginePanelRows(fn) {
     return subscribeRows(fn);
 }

package/dist/engineCapReader.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 interface EngineCapReaderSpec<R> {
     name: string;
     project: (caps: unknown) => R | undefined;
@@ -12,7 +13,7 @@ interface EngineCapReader<R> {
     observed(baseUrl: string | undefined): R | ReaderUnobserved | ReaderUnreadable;
 }
 export declare function createEngineCapReader<R>(spec: EngineCapReaderSpec<R>): EngineCapReader<R>;
-export declare function unreadableReadingDetail(subject?: string): string;
+export declare function unreadableReadingDetail(subject?: string, lang?: UiLanguage): string;
 export type StoreSeat = {
     kind: 'object';
     store: object;

package/dist/engineCapReader.js

@@ -1,7 +1,10 @@
 import { engineCapsLandingOf } from './engineCapsCache.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
-const unobserved = () => ({ kind: 'unobserved' });
-const unreadable = () => ({ kind: 'unreadable' });
+const UNOBSERVED = Object.freeze({ kind: 'unobserved' });
+const UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const unobserved = () => UNOBSERVED;
+const unreadable = () => UNREADABLE;
 function freezeReading(reading, seen = new Set()) {
     if (reading === null || typeof reading !== 'object' || seen.has(reading))
         return reading;
@@ -49,9 +52,8 @@ export function createEngineCapReader(spec) {
         },
     };
 }
-export function unreadableReadingDetail(subject) {
-    const head = typeof subject === 'string' && subject.length > 0 ? `${subject} could not be read` : 'could not be read';
-    return `${head} — the engine's /v1/capabilities report arrived, but this entry is not in a form this client reads, so it is shown as unknown, not as absent; probing the same engine again will not change it while the engine reports it this way`;
+export function unreadableReadingDetail(subject, lang) {
+    return renderMessage(typeof subject === 'string' && subject.length > 0 ? msg('notice.capability.unreadable.subject', { subject }) : msg('notice.capability.unreadable.bare'), lang);
 }
 export function storeSeatOf(caps) {
     try {

package/dist/engineCapsCache.d.ts

@@ -6,6 +6,11 @@ export type EngineCapsLanding = {
 } | {
     readonly kind: 'unreadable';
 };
+export interface EngineCapsChange {
+    readonly kind: 'landed' | 'invalidated' | 'replaced';
+    readonly baseUrl: string;
+    readonly generation: number;
+}
 export declare function engineCapsGeneration(baseUrl: string): number;
 export declare function engineCapsLandingOf(baseUrl: string | undefined): EngineCapsLanding;
 export declare function kickEngineCapsProbe(baseUrl: string, probe: () => Promise<unknown>): void;
@@ -42,6 +47,9 @@ export declare function engineCapString(baseUrl: string | undefined, key: string
 export declare function invalidateEngineCaps(baseUrl: string | undefined, probe?: () => Promise<unknown>): void;
 export type EngineCapsProbeRotation = 'started' | 'registered' | 'ignored';
 export declare function rotateEngineCapsProbe(baseUrl: string | undefined, probe: () => Promise<unknown>): EngineCapsProbeRotation;
+export type EngineCapsReprobe = 'reprobed' | 'no_probe' | 'ignored';
+export declare function invalidateEngineCapsAndReprobe(baseUrl: string | undefined): EngineCapsReprobe;
+export declare function registerCapsChangeDelivery(baseUrl: string | undefined, deliver: (change: EngineCapsChange) => void): () => void;
 export declare function refreshEngineCapsOnce(baseUrl: string | undefined, opts?: {
     withinMs?: number;
 }): Promise<'settled' | 'timed_out' | 'no_probe'>;

package/dist/engineCapsCache.js

@@ -4,11 +4,11 @@ const NOT_LANDED = Object.freeze({ kind: 'not_landed' });
 const capsByBase = new Map();
 const inFlight = new Set();
 const settleByBase = new Map();
-const genByBase = new Map();
+const stateByBase = new Map();
 const probeByBase = new Map();
 const refreshByBase = new Map();
 function capsGeneration(baseUrl) {
-    return genByBase.get(baseUrl) ?? 0;
+    return stateByBase.get(baseUrl)?.gen ?? 0;
 }
 export function engineCapsGeneration(baseUrl) {
     return capsGeneration(baseUrl);
@@ -169,6 +169,7 @@ function landCapsSnapshot(baseUrl, gen, caps) {
         ? Object.freeze({ kind: 'unreadable' })
         : Object.freeze({ kind: 'landed', caps: snapshot });
     capsByBase.set(baseUrl, record);
+    publishCapsChange(baseUrl, 'landed');
     return 'landed';
 }
 function snapshotCapsBody(body) {
@@ -355,18 +356,25 @@ export function invalidateEngineCaps(baseUrl, probe) {
         return;
     if (probe === undefined)
         probeByBase.delete(baseUrl);
-    const hadState = capsByBase.has(baseUrl) ||
+    const hadLanding = capsByBase.has(baseUrl);
+    const hadState = hadLanding ||
         inFlight.has(baseUrl) ||
         settleByBase.has(baseUrl) ||
-        genByBase.has(baseUrl);
+        stateByBase.get(baseUrl)?.gen !== undefined;
     if (hadState) {
-        genByBase.set(baseUrl, capsGeneration(baseUrl) + 1);
+        const st = stateByBase.get(baseUrl);
+        if (st === undefined)
+            stateByBase.set(baseUrl, { gen: 1, subscribers: new Set() });
+        else
+            st.gen = capsGeneration(baseUrl) + 1;
         capsByBase.delete(baseUrl);
         inFlight.delete(baseUrl);
         settleByBase.get(baseUrl)?.wake();
     }
     if (probe !== undefined)
         kickEngineCapsProbe(baseUrl, probe);
+    if (hadLanding)
+        publishCapsChange(baseUrl, probe !== undefined ? 'replaced' : 'invalidated');
 }
 export function rotateEngineCapsProbe(baseUrl, probe) {
     try {
@@ -381,6 +389,51 @@ export function rotateEngineCapsProbe(baseUrl, probe) {
         return 'ignored';
     }
 }
+export function invalidateEngineCapsAndReprobe(baseUrl) {
+    try {
+        if (typeof baseUrl !== 'string' || baseUrl === '')
+            return 'ignored';
+        const probe = probeByBase.get(baseUrl);
+        if (probe === undefined)
+            return 'no_probe';
+        invalidateEngineCaps(baseUrl, probe);
+        return 'reprobed';
+    }
+    catch {
+        return 'ignored';
+    }
+}
+export function registerCapsChangeDelivery(baseUrl, deliver) {
+    if (typeof baseUrl !== 'string' || baseUrl === '' || typeof deliver !== 'function')
+        return () => { };
+    let st = stateByBase.get(baseUrl);
+    if (st === undefined) {
+        st = { gen: undefined, subscribers: new Set() };
+        stateByBase.set(baseUrl, st);
+    }
+    const sub = { deliver, live: true };
+    const owner = st;
+    owner.subscribers.add(sub);
+    return () => {
+        if (!sub.live)
+            return;
+        sub.live = false;
+        owner.subscribers.delete(sub);
+        if (owner.subscribers.size === 0 && owner.gen === undefined && stateByBase.get(baseUrl) === owner)
+            stateByBase.delete(baseUrl);
+    };
+}
+function publishCapsChange(baseUrl, kind) {
+    const subs = stateByBase.get(baseUrl)?.subscribers;
+    if (subs === undefined || subs.size === 0)
+        return;
+    const change = Object.freeze({ kind, baseUrl, generation: capsGeneration(baseUrl) });
+    for (const sub of [...subs]) {
+        if (!sub.live)
+            continue;
+        sub.deliver(change);
+    }
+}
 export async function refreshEngineCapsOnce(baseUrl, opts) {
     try {
         if (typeof baseUrl !== 'string' || baseUrl === '')
@@ -454,7 +507,7 @@ export function __resetEngineCapsCacheForTests() {
     capsByBase.clear();
     inFlight.clear();
     settleByBase.clear();
-    genByBase.clear();
+    stateByBase.clear();
     probeByBase.clear();
     refreshByBase.clear();
 }

package/dist/engineCapsChange.d.ts

@@ -0,0 +1,2 @@
+import { type EngineCapsChange } from './engineCapsCache.js';
+export declare function onEngineCapsChange(baseUrl: string | undefined, listener: (change: EngineCapsChange) => void): () => void;

package/dist/engineCapsChange.js

@@ -0,0 +1,9 @@
+import { registerCapsChangeDelivery } from './engineCapsCache.js';
+import { invokeHostCallbackIsolated } from './hostCallbackGuard.js';
+export function onEngineCapsChange(baseUrl, listener) {
+    if (typeof listener !== 'function')
+        return () => { };
+    return registerCapsChangeDelivery(baseUrl, (change) => {
+        invokeHostCallbackIsolated('engineCapsChange: listener', () => listener(change));
+    });
+}

package/dist/engineErrorCodes.d.ts

@@ -16,8 +16,9 @@ export declare const CONFIG_MEMORY_PROJECT_KEY_SPELLING = "config.memory_project
 export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_scope_mismatch";
 export declare const CONFIG_LEGACY_TOOL_NAME = "config.legacy_tool_name";
 export declare const CONFIG_IMAGE_INVALID = "config.image_invalid";
-export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;
 export declare const CONFIG_AGENT_UNKNOWN_TOOL = "config.agent.unknown_tool";
+export declare const CONFIG_TOOL_FACE_CONTROL = "config.tool_face_control";
+export declare const PROMPT_ASSEMBLED_ROLE_REFUSED = "prompt.assembled_role_refused";
 export declare const CONFIG_OUTPUT_STYLE_INVALID = "config.output_style_invalid";
 export declare const RULES_INERT_ENTRY = "rules.inert_entry";
 export declare const RULES_INVALID_SHAPE = "rules.invalid_shape";
@@ -35,6 +36,9 @@ export declare const TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN = "interrupted_outcome
 export declare function isInterruptedToolEndCode(code: string | undefined): boolean;
 export declare const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = "capability.self_orchestration_required";
 export declare const CAPABILITY_IMAGE_INDEX_REQUIRED = "capability.image_index_required";
+export declare const CAPABILITY_K8S_LANE_REQUIRED = "capability.k8s_lane_required";
+export declare const NOT_FOUND_IMAGE = "not_found.image";
+export declare const REQUEST_PRECONDITION_UNMET = "request.precondition_unmet";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
 export declare const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = "conflict.idempotency_payload_mismatch";
@@ -58,7 +62,6 @@ export declare const STOP_PARK_RESUME_WON = "stop.park_resume_won";
 export declare const STOP_NOT_LANDED = "stop.not_landed";
 export declare const STOP_NOT_LOCAL = "stop.not_local";
 export declare const STOP_PARKED = "stop.parked";
-export declare const STOP_CONFLICT_CODES: readonly ["stop.park_arbiter_unreachable", "stop.park_resume_won", "stop.not_landed", "stop.not_local", "stop.parked"];
 export declare const OUTPUT_INVALID = "output.invalid";
 export declare const RESUME_POLICY_FOLD_CODE = "resume_blocked_by_policy";
 export declare const STATUS_DERIVED_COARSE_CODES: readonly ["request.rejected", "auth.unauthorized", "auth.forbidden", "not_found.resource", "request.payload_too_large", "request.unprocessable", "limit.rate_exceeded", "capability.unavailable", "internal.error"];
@@ -111,6 +114,10 @@ export declare const DECIDE_ALREADY_RESOLVED_CODES: readonly string[];
 export declare function isDecideAlreadyResolvedCode(code: string | null | undefined): boolean;
 export declare const ASK_GONE = "gone.ask";
 export declare const ASK_GONE_PARKED = "gone.ask_parked";
+export declare const ASK_NOT_FOUND = "not_found.ask";
+export declare const ASK_IDEMPOTENCY_CONFLICT = "conflict.ask_idempotency";
+export declare const ASK_PARKING_RETRY = "parking.ask_retry";
+export declare const ASK_DECISION_LANE_DISABLED = "feature.approval_ask_disabled";
 export declare const ASK_GONE_DENIED_WORD: "routing_failure_fail_closed";
 export declare const RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
 export type { RunDeathVerdictCode };
@@ -128,6 +135,8 @@ export declare function isWorkflowParkRefusalCode(code: unknown): boolean;
 export declare const DRAINING_ERROR_CODE = "draining";
 export declare const SCENARIO_NOT_ALLOWED_ERROR_CODE = "scenario_not_allowed";
 export declare const SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE = "state.scenario_assignment_unknown";
+export declare const USER_ATTACHMENT_INVALID_ERROR_CODE = "config.user_attachment_invalid";
+export declare const USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE = "config.user_invoked_skill_unknown";
 export declare const STREAM_MAX_DURATION = "STREAM_MAX_DURATION";
 export type ModelFallbackReason = 'inherit_no_tier_binding';
 export declare const MODEL_FALLBACK_INHERIT_NO_TIER_BINDING: ModelFallbackReason;

package/dist/engineErrorCodes.js

@@ -21,12 +21,9 @@ export const CONFIG_MEMORY_PROJECT_KEY_SPELLING = 'config.memory_project_key_spe
 export const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = 'config.memory_write_scope_mismatch';
 export const CONFIG_LEGACY_TOOL_NAME = 'config.legacy_tool_name';
 export const CONFIG_IMAGE_INVALID = 'config.image_invalid';
-const IMAGE_INVALID_FAILURE_NOTE = 'This run did not start: an image sent with the message was refused before the model was called — the engine’s own error text says which image and what is wrong with it. ' +
-    'Nothing was sent to the model; remove or replace that image, then send the message again.';
-export function imageInvalidFailureNoteOf(code) {
-    return code === CONFIG_IMAGE_INVALID ? IMAGE_INVALID_FAILURE_NOTE : undefined;
-}
 export const CONFIG_AGENT_UNKNOWN_TOOL = 'config.agent.unknown_tool';
+export const CONFIG_TOOL_FACE_CONTROL = 'config.tool_face_control';
+export const PROMPT_ASSEMBLED_ROLE_REFUSED = 'prompt.assembled_role_refused';
 export const CONFIG_OUTPUT_STYLE_INVALID = 'config.output_style_invalid';
 export const RULES_INERT_ENTRY = 'rules.inert_entry';
 export const RULES_INVALID_SHAPE = 'rules.invalid_shape';
@@ -65,6 +62,9 @@ export function isInterruptedToolEndCode(code) {
 }
 export const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = 'capability.self_orchestration_required';
 export const CAPABILITY_IMAGE_INDEX_REQUIRED = 'capability.image_index_required';
+export const CAPABILITY_K8S_LANE_REQUIRED = 'capability.k8s_lane_required';
+export const NOT_FOUND_IMAGE = 'not_found.image';
+export const REQUEST_PRECONDITION_UNMET = 'request.precondition_unmet';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
 export const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = 'conflict.idempotency_payload_mismatch';
@@ -111,13 +111,6 @@ export const STOP_PARK_RESUME_WON = 'stop.park_resume_won';
 export const STOP_NOT_LANDED = 'stop.not_landed';
 export const STOP_NOT_LOCAL = 'stop.not_local';
 export const STOP_PARKED = 'stop.parked';
-export const STOP_CONFLICT_CODES = Object.freeze([
-    STOP_PARK_ARBITER_UNREACHABLE,
-    STOP_PARK_RESUME_WON,
-    STOP_NOT_LANDED,
-    STOP_NOT_LOCAL,
-    STOP_PARKED,
-]);
 export const OUTPUT_INVALID = 'output.invalid';
 export const RESUME_POLICY_FOLD_CODE = 'resume_blocked_by_policy';
 export const STATUS_DERIVED_COARSE_CODES = SDK_STATUS_DERIVED_COARSE_CODES;
@@ -215,6 +208,10 @@ export function isDecideAlreadyResolvedCode(code) {
 }
 export const ASK_GONE = 'gone.ask';
 export const ASK_GONE_PARKED = 'gone.ask_parked';
+export const ASK_NOT_FOUND = 'not_found.ask';
+export const ASK_IDEMPOTENCY_CONFLICT = 'conflict.ask_idempotency';
+export const ASK_PARKING_RETRY = 'parking.ask_retry';
+export const ASK_DECISION_LANE_DISABLED = 'feature.approval_ask_disabled';
 export const ASK_GONE_DENIED_WORD = SDK_DENY_REASON_ROUTING_FAILURE;
 export const RUN_DEATH_VERDICT_CODES = SDK_RUN_DEATH_VERDICT_CODES;
 const _runDeathVerdictCodePin = true;
@@ -266,6 +263,8 @@ export function isWorkflowParkRefusalCode(code) {
 export const DRAINING_ERROR_CODE = 'draining';
 export const SCENARIO_NOT_ALLOWED_ERROR_CODE = 'scenario_not_allowed';
 export const SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE = 'state.scenario_assignment_unknown';
+export const USER_ATTACHMENT_INVALID_ERROR_CODE = 'config.user_attachment_invalid';
+export const USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE = 'config.user_invoked_skill_unknown';
 export const STREAM_MAX_DURATION = 'STREAM_MAX_DURATION';
 export const MODEL_FALLBACK_INHERIT_NO_TIER_BINDING = 'inherit_no_tier_binding';
 export function asModelFallbackReason(v) {

package/dist/engineRowRef.js

@@ -93,6 +93,10 @@ export const TRANSCRIPT_ROW_SIDECAR_KEYS = Object.freeze([
     '_sema_interrupted_never_started',
     '_sema_approval_window_expired',
     '_sema_denial_limit_window_expired',
+    '_sema_api_error_status',
+    '_sema_api_error_code',
+    '_sema_provider_condition',
+    '_sema_terminal_owner',
 ]);
 export function parkHeldCallIdOf(carrier) {
     return readFrameStringKey(carrier, 'toolCallId');

package/dist/engineSessionMessages.d.ts

@@ -32,6 +32,7 @@ export interface EngineHistoryToolResultBlock {
     readonly tool_use_id: string;
     readonly content: readonly EngineHistoryBlock[];
     readonly is_error: boolean;
+    readonly _sema_gate_parked?: true;
 }
 export interface EngineHistoryOpaqueBlock {
     readonly type: string;

package/dist/engineSessionMessages.js

@@ -1,3 +1,4 @@
+import { isGateParkedToolEnd } from './gateOutcome.js';
 import { ownDataField, ownSendableField } from './ownKey.js';
 const isObjectLike = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 function optionalOwn(o, key) {
@@ -286,7 +287,12 @@ function toolResultBody(row, tally) {
         blocks = mapBlocks(items, tally);
     }
     const isError = ownDataField(row, 'isError') === true;
-    return { kind: 'message', role: 'user', body: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content: blocks, is_error: isError }] } };
+    const parked = isGateParkedToolEnd(row);
+    return {
+        kind: 'message',
+        role: 'user',
+        body: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content: blocks, is_error: isError, ...(parked ? { _sema_gate_parked: true } : {}) }] },
+    };
 }
 function projectRow(row, tally) {
     if (!isObjectLike(row))

package/dist/engineTargetSeat.d.ts

@@ -0,0 +1,27 @@
+import type { CloudLoginFailure, CloudLoginFailureReading, EipcStoreClient, EngineTargetRefusal, EngineTargetRefused, EngineTargetState, SeatLocalMcpReading } from './seatContract.js';
+import type { McpProbeOutcome } from './mcpProbeWire.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export interface CloudLoginFailureContext {
+    readonly deadlineReached?: boolean;
+    readonly cancelled?: boolean;
+}
+export declare function cloudLoginFailureOf(err: {} | null | undefined, ctx?: CloudLoginFailureContext): CloudLoginFailureReading;
+export declare function cloudLoginFailureText(failure: CloudLoginFailure | CloudLoginFailureReading, lang?: UiLanguage): string;
+export declare function engineTargetRefusalText(refused: EngineTargetRefusal | EngineTargetRefused, lang?: UiLanguage): string;
+export type EngineTargetReading = {
+    readonly kind: 'state';
+    readonly state: EngineTargetState;
+} | {
+    readonly kind: 'not_reported';
+} | {
+    readonly kind: 'malformed';
+};
+export interface EngineTargetWatch {
+    stop(): void;
+    isCurrent(generation: number): boolean;
+}
+export declare function watchEngineTarget(store: EipcStoreClient<EngineTargetState> | undefined, onState: (reading: EngineTargetReading, switched: boolean) => void): EngineTargetWatch;
+export declare function seatMcpReadingOf(outcome: McpProbeOutcome, readAt: string, extra?: {
+    readonly restartRequired?: true;
+    readonly forcedAsk?: Readonly<Record<string, readonly string[]>>;
+}): SeatLocalMcpReading;

package/dist/engineTargetSeat.js

@@ -0,0 +1,199 @@
+import { CLOUD_LOGIN_FAILURES, ENGINE_TARGET_REFUSALS, LOCAL_SESSIONS_SPEC } from './seatContract.js';
+import { ownDataField } from './ownKey.js';
+import { readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { msg, renderMessage } from './i18n/translate.js';
+const field = (v, key) => {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    try {
+        return ownDataField(v, key);
+    }
+    catch {
+        return undefined;
+    }
+};
+const OAUTH_WORDS = ['access_denied', 'expired_token', 'invalid_grant'];
+export function cloudLoginFailureOf(err, ctx) {
+    if (field(ctx, 'cancelled') === true)
+        return Object.freeze({ failure: 'cancelled' });
+    if (field(ctx, 'deadlineReached') === true)
+        return Object.freeze({ failure: 'expired_token' });
+    if (err !== null && typeof err === 'object') {
+        const code = readThrownSlot(err, 'code', 'data');
+        if (typeof code === 'string' && code.length > 0) {
+            const word = OAUTH_WORDS.find((w) => w === code);
+            return Object.freeze({ failure: word ?? 'other' });
+        }
+        const status = readThrownStatusSlot(err);
+        if (typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 599)
+            return Object.freeze({ failure: 'refused', status });
+    }
+    return Object.freeze({ failure: 'transport' });
+}
+const LOGIN_KEYS = {
+    access_denied: 'config.cloudLogin.accessDenied',
+    expired_token: 'config.cloudLogin.expiredToken',
+    invalid_grant: 'config.cloudLogin.invalidGrant',
+    cancelled: 'config.cloudLogin.cancelled',
+    transport: 'config.cloudLogin.transport',
+    refused: 'config.cloudLogin.refused',
+    no_tokens: 'config.cloudLogin.noTokens',
+    other: 'config.cloudLogin.other',
+};
+export function cloudLoginFailureText(failure, lang) {
+    const word = typeof failure === 'string' ? failure : field(failure, 'failure');
+    const known = CLOUD_LOGIN_FAILURES.find((w) => w === word) ?? 'other';
+    if (known === 'refused') {
+        const status = typeof failure === 'string' ? undefined : field(failure, 'status');
+        if (typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 599) {
+            return renderMessage(msg('config.cloudLogin.refusedStatus', { status }), lang);
+        }
+    }
+    return renderMessage(msg(LOGIN_KEYS[known]), lang);
+}
+const REFUSAL_KEYS = {
+    busy: 'config.engineTarget.busy',
+    switching: 'config.engineTarget.switching',
+    not_configured: 'config.engineTarget.notConfigured',
+    not_signed_in: 'config.engineTarget.notSignedIn',
+    probe_failed: 'config.engineTarget.probeFailed',
+    org_policy: 'config.engineTarget.orgPolicy',
+    url_refused: 'config.engineTarget.urlRefused',
+    login_failed: 'config.engineTarget.loginFailed',
+    storage_unavailable: 'config.engineTarget.storageUnavailable',
+    no_local_runtime: 'config.engineTarget.noLocalRuntime',
+    input: 'config.engineTarget.input',
+};
+export function engineTargetRefusalText(refused, lang) {
+    const word = typeof refused === 'string' ? refused : field(refused, 'refusal');
+    const known = ENGINE_TARGET_REFUSALS.find((w) => w === word);
+    if (known === undefined)
+        return renderMessage(msg('config.engineTarget.unknown'), lang);
+    if (known === 'login_failed' && typeof refused !== 'string') {
+        const failure = field(refused, 'failure');
+        if (CLOUD_LOGIN_FAILURES.some((w) => w === failure)) {
+            const status = field(refused, 'status');
+            return cloudLoginFailureText({ failure: failure, ...(typeof status === 'number' ? { status } : {}) }, lang);
+        }
+    }
+    return renderMessage(msg(REFUSAL_KEYS[known]), lang);
+}
+const checkState = (v) => {
+    const check = LOCAL_SESSIONS_SPEC.stores?.['engineTargetState']?.check;
+    return typeof check === 'function' && check(v) === true;
+};
+export function watchEngineTarget(store, onState) {
+    let current;
+    let trusted = false;
+    let active = true;
+    let off;
+    const deliver = (state) => {
+        if (!active)
+            return;
+        let ok = false;
+        try {
+            ok = checkState(state);
+        }
+        catch {
+            ok = false;
+        }
+        if (!ok) {
+            trusted = false;
+            onState(Object.freeze({ kind: 'malformed' }), false);
+            return;
+        }
+        const s = state;
+        const switched = current !== undefined && s.generation !== current;
+        current = s.generation;
+        trusted = true;
+        onState(Object.freeze({ kind: 'state', state: s }), switched);
+    };
+    const handle = {
+        stop: () => {
+            if (!active)
+                return;
+            active = false;
+            try {
+                if (typeof off === 'function')
+                    off();
+            }
+            catch {
+                off = undefined;
+            }
+        },
+        isCurrent: (generation) => active && trusted && current !== undefined && generation === current,
+    };
+    if (store === undefined || store === null) {
+        onState(Object.freeze({ kind: 'not_reported' }), false);
+        active = false;
+        return handle;
+    }
+    try {
+        if (typeof store !== 'object' || typeof store.onStateChange !== 'function' || typeof store.getStateSync !== 'function') {
+            onState(Object.freeze({ kind: 'malformed' }), false);
+            active = false;
+            return handle;
+        }
+        off = store.onStateChange((state) => deliver(state));
+    }
+    catch {
+        onState(Object.freeze({ kind: 'malformed' }), false);
+        active = false;
+        return handle;
+    }
+    let now;
+    try {
+        now = store.getStateSync();
+    }
+    catch {
+        trusted = false;
+        if (active)
+            onState(Object.freeze({ kind: 'malformed' }), false);
+        return handle;
+    }
+    deliver(now);
+    return handle;
+}
+const MCP_DETAIL_MAX = 200;
+export function seatMcpReadingOf(outcome, readAt, extra) {
+    const restart = field(extra, 'restartRequired') === true ? { restartRequired: true } : {};
+    const status = field(outcome, 'status');
+    if (status === 'face') {
+        const face = field(outcome, 'face');
+        const servers = field(face, 'servers');
+        if (Array.isArray(servers)) {
+            const forced = field(extra, 'forcedAsk');
+            const rows = [];
+            for (const row of servers) {
+                const name = field(row, 'name');
+                const st = field(row, 'status');
+                if (typeof name !== 'string' || name.length === 0 || typeof st !== 'string')
+                    continue;
+                const tc = field(row, 'toolCount');
+                const liveness = field(field(row, 'liveness'), 'state');
+                const ec = field(row, 'errorCode');
+                const fa = field(forced, name);
+                const forcedAsk = Array.isArray(fa) ? fa.filter((n) => typeof n === 'string' && n.length > 0) : [];
+                rows.push(Object.freeze({
+                    name,
+                    status: st,
+                    ...(typeof tc === 'number' && Number.isSafeInteger(tc) && tc >= 0 ? { toolCount: tc } : {}),
+                    ...(typeof liveness === 'string' && liveness.length > 0 ? { liveness } : {}),
+                    ...(typeof ec === 'string' && ec.length > 0 ? { errorCode: ec } : {}),
+                    ...(forcedAsk.length > 0 ? { forcedAsk: [...forcedAsk] } : {}),
+                }));
+            }
+            return Object.freeze({ status: 'listed', servers: rows, readAt, ...restart });
+        }
+    }
+    const cause = status === 'refused' ? field(outcome, 'cause') : status === 'unknown' ? field(outcome, 'why') : undefined;
+    const message = field(outcome, 'message');
+    return Object.freeze({
+        status: 'unreadable',
+        cause: typeof cause === 'string' && cause.length > 0 ? cause : 'no_verdict',
+        ...(typeof message === 'string' && message.length > 0 ? { detail: displayUntrusted(message, { max: MCP_DETAIL_MAX }) } : {}),
+        readAt,
+        ...restart,
+    });
+}

package/dist/engineToolDirectory.d.ts

@@ -10,6 +10,9 @@ export type EngineToolDirectory = {
     readonly state: 'not_landed';
 } | {
     readonly state: 'unreadable';
+} | {
+    readonly state: 'request_only';
+    readonly requestMcpServerPrefixes: ReadonlySet<string>;
 } | {
     readonly state: 'directory';
     readonly mcpServerPrefixes: ReadonlySet<string>;