@sema-agent/client-core 0.97.1 → 0.99.0

package/dist/engineSessionMessages.d.ts

@@ -0,0 +1,68 @@
+export type EngineHistoryJson = string | number | boolean | null | readonly EngineHistoryJson[] | {
+    readonly [key: string]: EngineHistoryJson;
+};
+export interface EngineHistoryTextBlock {
+    readonly type: 'text';
+    readonly text: string;
+}
+export interface EngineHistoryThinkingBlock {
+    readonly type: 'thinking';
+    readonly thinking: string;
+    readonly signature?: string;
+}
+export interface EngineHistoryToolUseBlock {
+    readonly type: 'tool_use';
+    readonly id: string;
+    readonly name: string;
+    readonly input: {
+        readonly [key: string]: EngineHistoryJson;
+    };
+}
+export interface EngineHistoryBase64Source {
+    readonly type: 'base64';
+    readonly media_type: string;
+    readonly data: string;
+}
+export interface EngineHistoryMediaBlock {
+    readonly type: 'image' | 'document';
+    readonly source: EngineHistoryBase64Source;
+}
+export interface EngineHistoryToolResultBlock {
+    readonly type: 'tool_result';
+    readonly tool_use_id: string;
+    readonly content: readonly EngineHistoryBlock[];
+    readonly is_error: boolean;
+    readonly _sema_gate_parked?: true;
+}
+export interface EngineHistoryOpaqueBlock {
+    readonly type: string;
+    readonly [key: string]: EngineHistoryJson;
+}
+export type EngineHistoryBlock = EngineHistoryTextBlock | EngineHistoryThinkingBlock | EngineHistoryToolUseBlock | EngineHistoryMediaBlock | EngineHistoryToolResultBlock | EngineHistoryOpaqueBlock;
+export interface EngineHistoryMessageBody {
+    readonly role: 'user' | 'assistant';
+    readonly content: string | readonly EngineHistoryBlock[];
+    readonly model?: string;
+}
+export interface EngineHistoryMessage {
+    readonly type: 'user' | 'assistant';
+    readonly uuid: string;
+    readonly session_id: string;
+    readonly timestamp?: string;
+    readonly message: EngineHistoryMessageBody;
+    readonly parent_tool_use_id: null;
+}
+export interface EngineHistorySkipped {
+    readonly unreadable: number;
+    readonly unknownRole: number;
+    readonly noVisibleContent: number;
+    readonly droppedBlocks: number;
+}
+export interface EngineHistoryProjection {
+    readonly messages: readonly EngineHistoryMessage[];
+    readonly skipped: EngineHistorySkipped;
+}
+export interface EngineHistoryProjectionOpts {
+    readonly sessionId: string;
+}
+export declare function projectEngineSessionMessages<Row>(rows: readonly Row[], opts: EngineHistoryProjectionOpts): EngineHistoryProjection;

package/dist/engineSessionMessages.js

@@ -0,0 +1,370 @@
+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) {
+    try {
+        return ownDataField(o, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function itemsOf(a) {
+    if (!Array.isArray(a))
+        return undefined;
+    const n = ownDataField(a, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < n; i += 1)
+        out.push(ownDataField(a, String(i)));
+    return out;
+}
+const JSON_MAX_DEPTH = 64;
+const JSON_MAX_NODES = 200_000;
+const NOT_JSON = Symbol('not-json');
+function isPlainShape(o) {
+    const proto = Object.getPrototypeOf(o);
+    return proto === null || (typeof proto === 'object' && Object.getPrototypeOf(proto) === null);
+}
+function jsonSnapshot(v, depth, budget) {
+    budget.nodes += 1;
+    if (budget.nodes > JSON_MAX_NODES || depth > JSON_MAX_DEPTH)
+        return NOT_JSON;
+    if (v === null || typeof v === 'string' || typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number')
+        return Number.isFinite(v) ? v : NOT_JSON;
+    if (typeof v !== 'object')
+        return NOT_JSON;
+    if (Array.isArray(v)) {
+        const n = ownDataField(v, 'length');
+        if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+            return NOT_JSON;
+        const out = [];
+        for (let i = 0; i < n; i += 1) {
+            const item = jsonSnapshot(ownSendableField(v, String(i)), depth + 1, budget);
+            if (item === NOT_JSON)
+                return NOT_JSON;
+            out.push(item);
+        }
+        return out;
+    }
+    if (!isPlainShape(v))
+        return NOT_JSON;
+    const out = {};
+    for (const k of Reflect.ownKeys(v)) {
+        if (typeof k !== 'string')
+            continue;
+        const item = jsonSnapshot(ownSendableField(v, k), depth + 1, budget);
+        if (item === NOT_JSON)
+            return NOT_JSON;
+        Object.defineProperty(out, k, { value: item, enumerable: true, writable: true, configurable: true });
+    }
+    return out;
+}
+function jsonSnapshotOf(v) {
+    try {
+        const snap = jsonSnapshot(v, 0, { nodes: 0 });
+        return snap === NOT_JSON ? undefined : snap;
+    }
+    catch {
+        return undefined;
+    }
+}
+function mapBlock(b) {
+    if (!isObjectLike(b))
+        return undefined;
+    const type = ownDataField(b, 'type');
+    if (typeof type !== 'string')
+        return undefined;
+    switch (type) {
+        case 'text': {
+            const text = ownDataField(b, 'text');
+            return typeof text === 'string' ? { type: 'text', text } : undefined;
+        }
+        case 'thinking': {
+            const thinking = ownDataField(b, 'thinking');
+            if (typeof thinking !== 'string')
+                return undefined;
+            const signature = optionalOwn(b, 'thinkingSignature');
+            return typeof signature === 'string' ? { type: 'thinking', thinking, signature } : { type: 'thinking', thinking };
+        }
+        case 'toolCall': {
+            const id = ownDataField(b, 'id');
+            const name = ownDataField(b, 'name');
+            if (typeof id !== 'string' || id.length === 0 || typeof name !== 'string' || name.length === 0)
+                return undefined;
+            const args = ownDataField(b, 'arguments');
+            if (!isObjectLike(args))
+                return { type: 'tool_use', id, name, input: {} };
+            const input = jsonSnapshotOf(args);
+            if (input === undefined || input === null || typeof input !== 'object' || Array.isArray(input))
+                return undefined;
+            return { type: 'tool_use', id, name, input: input };
+        }
+        case 'image':
+        case 'document': {
+            const data = ownDataField(b, 'data');
+            const mimeType = ownDataField(b, 'mimeType');
+            if (typeof data !== 'string' || typeof mimeType !== 'string' || mimeType.length === 0)
+                return undefined;
+            return { type, source: { type: 'base64', media_type: mimeType, data } };
+        }
+        default: {
+            const opaque = jsonSnapshotOf(b);
+            return opaque !== undefined && opaque !== null && typeof opaque === 'object' && !Array.isArray(opaque) ? opaque : undefined;
+        }
+    }
+}
+function mapBlockCounted(raw, tally) {
+    let mapped;
+    try {
+        mapped = mapBlock(raw);
+    }
+    catch {
+        mapped = undefined;
+    }
+    if (mapped === undefined)
+        tally.droppedBlocks += 1;
+    return mapped;
+}
+function mapBlocks(items, tally) {
+    const out = [];
+    for (const raw of items) {
+        const mapped = mapBlockCounted(raw, tally);
+        if (mapped !== undefined)
+            out.push(mapped);
+    }
+    return out;
+}
+function engineRegionsOf(row, flatLength) {
+    if (optionalOwn(row, 'engineMinted') === true)
+        return 'whole';
+    const segments = optionalOwn(row, 'engineSegments');
+    if (segments !== undefined) {
+        let items;
+        try {
+            items = itemsOf(segments);
+        }
+        catch {
+            items = undefined;
+        }
+        if (items === undefined)
+            return 'verbatim';
+        const out = [];
+        let floor = 0;
+        for (const item of items) {
+            if (!isObjectLike(item))
+                return 'verbatim';
+            const start = optionalOwn(item, 'start');
+            const end = optionalOwn(item, 'end');
+            if (typeof start !== 'number' || typeof end !== 'number' || !Number.isInteger(start) || !Number.isInteger(end))
+                return 'verbatim';
+            if (start < floor || end <= start || end > flatLength)
+                return 'verbatim';
+            out.push([start, end]);
+            floor = end;
+        }
+        return out;
+    }
+    const prefix = optionalOwn(row, 'enginePrefixChars');
+    if (prefix === undefined)
+        return 'verbatim';
+    if (typeof prefix !== 'number' || !Number.isInteger(prefix) || prefix <= 0 || prefix > flatLength)
+        return 'verbatim';
+    return [[0, prefix]];
+}
+function cutRegions(text, offset, regions) {
+    const end = offset + text.length;
+    let out = '';
+    let cursor = offset;
+    let touched = false;
+    for (const [rs, re] of regions) {
+        if (re <= offset || rs >= end)
+            continue;
+        touched = true;
+        const cutStart = Math.max(rs, offset);
+        const cutEnd = Math.min(re, end);
+        out += text.slice(cursor - offset, cutStart - offset);
+        cursor = cutEnd;
+    }
+    if (!touched)
+        return text;
+    out += text.slice(cursor - offset);
+    const kept = out.trim();
+    return kept === '' ? undefined : kept;
+}
+const unreadable = () => ({ kind: 'skip', why: 'unreadable' });
+const invisible = () => ({ kind: 'skip', why: 'noVisibleContent' });
+function flatTextOf(item) {
+    if (!isObjectLike(item))
+        return '';
+    const type = optionalOwn(item, 'type');
+    if (type !== 'text')
+        return '';
+    const text = optionalOwn(item, 'text');
+    return text === undefined || text === null ? '' : String(text);
+}
+function userBody(row, tally) {
+    const content = ownDataField(row, 'content');
+    if (typeof content === 'string') {
+        if (content === '')
+            return invisible();
+        const regions = engineRegionsOf(row, content.length);
+        if (regions === 'whole')
+            return invisible();
+        if (regions === 'verbatim')
+            return { kind: 'message', role: 'user', body: { role: 'user', content } };
+        const kept = cutRegions(content, 0, regions);
+        return kept === undefined ? invisible() : { kind: 'message', role: 'user', body: { role: 'user', content: kept } };
+    }
+    const items = itemsOf(content);
+    if (items === undefined)
+        return unreadable();
+    if (items.length === 0)
+        return invisible();
+    const texts = items.map(flatTextOf);
+    const flatLength = texts.reduce((n, t) => n + t.length, 0) + (items.length - 1);
+    const regions = engineRegionsOf(row, flatLength);
+    if (regions === 'whole')
+        return invisible();
+    const out = [];
+    let offset = 0;
+    for (let i = 0; i < items.length; i += 1) {
+        const text = texts[i];
+        const at = offset;
+        offset += text.length + 1;
+        const mapped = mapBlockCounted(items[i], tally);
+        if (mapped === undefined)
+            continue;
+        if (mapped.type === 'text' && regions !== 'verbatim') {
+            const kept = cutRegions(text, at, regions);
+            if (kept === undefined)
+                continue;
+            out.push(kept === text ? mapped : { type: 'text', text: kept });
+            continue;
+        }
+        out.push(mapped);
+    }
+    return out.length === 0 ? invisible() : { kind: 'message', role: 'user', body: { role: 'user', content: out } };
+}
+function assistantBody(row, tally) {
+    const content = ownDataField(row, 'content');
+    let blocks;
+    if (typeof content === 'string') {
+        blocks = [{ type: 'text', text: content }];
+    }
+    else {
+        const items = itemsOf(content);
+        if (items === undefined)
+            return unreadable();
+        blocks = mapBlocks(items, tally);
+    }
+    const model = optionalOwn(row, 'model');
+    return {
+        kind: 'message',
+        role: 'assistant',
+        body: typeof model === 'string' && model.length > 0 ? { role: 'assistant', content: blocks, model } : { role: 'assistant', content: blocks },
+    };
+}
+function toolResultBody(row, tally) {
+    const id = ownDataField(row, 'toolCallId');
+    if (typeof id !== 'string' || id.length === 0)
+        return unreadable();
+    const content = ownDataField(row, 'content');
+    let blocks;
+    if (content === undefined) {
+        blocks = [];
+    }
+    else if (typeof content === 'string') {
+        blocks = [{ type: 'text', text: content }];
+    }
+    else {
+        const items = itemsOf(content);
+        if (items === undefined)
+            return unreadable();
+        blocks = mapBlocks(items, tally);
+    }
+    const isError = ownDataField(row, 'isError') === true;
+    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))
+        return unreadable();
+    const role = ownDataField(row, 'role');
+    if (role === 'user')
+        return userBody(row, tally);
+    if (role === 'assistant')
+        return assistantBody(row, tally);
+    if (role === 'toolResult')
+        return toolResultBody(row, tally);
+    return { kind: 'skip', why: 'unknownRole' };
+}
+function timestampOf(row) {
+    const ms = optionalOwn(row, 'timestamp');
+    if (typeof ms !== 'number' || !Number.isFinite(ms))
+        return undefined;
+    const at = new Date(ms);
+    return Number.isNaN(at.getTime()) ? undefined : at.toISOString();
+}
+function sessionIdOf(opts) {
+    let sessionId;
+    try {
+        sessionId = typeof opts === 'object' && opts !== null ? ownDataField(opts, 'sessionId') : undefined;
+    }
+    catch {
+        sessionId = undefined;
+    }
+    if (typeof sessionId !== 'string' || sessionId.length === 0) {
+        throw new TypeError('projectEngineSessionMessages: opts.sessionId must be a non-empty string (the engine session id)');
+    }
+    return sessionId;
+}
+export function projectEngineSessionMessages(rows, opts) {
+    if (!Array.isArray(rows))
+        throw new TypeError('projectEngineSessionMessages: rows must be an array');
+    const sessionId = sessionIdOf(opts);
+    let count;
+    try {
+        count = ownDataField(rows, 'length');
+    }
+    catch {
+        count = undefined;
+    }
+    if (typeof count !== 'number' || !Number.isSafeInteger(count) || count < 0)
+        throw new TypeError('projectEngineSessionMessages: rows length could not be read');
+    const tally = { unreadable: 0, unknownRole: 0, noVisibleContent: 0, droppedBlocks: 0 };
+    const messages = [];
+    for (let i = 0; i < count; i += 1) {
+        let outcome;
+        let timestamp;
+        try {
+            const row = ownDataField(rows, String(i));
+            outcome = projectRow(row, tally);
+            timestamp = outcome.kind === 'message' && isObjectLike(row) ? timestampOf(row) : undefined;
+        }
+        catch {
+            outcome = unreadable();
+            timestamp = undefined;
+        }
+        if (outcome.kind === 'skip') {
+            tally[outcome.why] += 1;
+            continue;
+        }
+        messages.push({
+            type: outcome.role,
+            uuid: `restored-${sessionId}-${messages.length + 1}`,
+            session_id: sessionId,
+            ...(timestamp !== undefined ? { timestamp } : {}),
+            message: outcome.body,
+            parent_tool_use_id: null,
+        });
+    }
+    return Object.freeze({ messages, skipped: Object.freeze({ ...tally }) });
+}

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

@@ -15,13 +15,4 @@ export type EngineToolDirectory = {
     readonly mcpServerPrefixes: ReadonlySet<string>;
 };
 export declare function engineToolDirectoryOf(source: EngineToolDirectorySource | null | undefined): EngineToolDirectory;
-export type McpEntryReading = 'outside' | 'unchecked' | 'unparsable' | 'answers' | 'unanswered';
-export declare function mcpEntryReadingOf(toolName: string, directory: EngineToolDirectory | undefined): McpEntryReading;
 export declare function deniedEntryToolName(entry: string): string | undefined;
-export interface ExcludeToolsAgainstDirectory {
-    readonly send: string[];
-    readonly omitted: string[];
-    readonly verdict: 'directory_absent' | 'filtered';
-    readonly disclosure?: string;
-}
-export declare function excludeToolsAgainstDirectory(exclude: readonly string[], directory: EngineToolDirectory | undefined): ExcludeToolsAgainstDirectory;