@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/liveModelCatalog.js

@@ -1,5 +1,8 @@
+import { appendOwnElement, readOwnDataValue } from './ownKey.js';
 import { frozenJsonCopyOf, liveDefaultModelCopy, liveModelRowCopy } from './model/liveCatalogShape.js';
 import { msg, renderMessage } from './i18n/translate.js';
+import { quoteUntrustedForSentence } from './displayUntrusted.js';
+import { CC_TIER_ALIASES, TIER_ORDER } from './model/tierVocabulary.js';
 let catalog = null;
 let refresher = null;
 export function setLiveModelCatalog(next) {
@@ -37,7 +40,7 @@ export function normalizeLiveModelRef(ref) {
 function ownDataOf(o, key) {
     try {
         const d = Object.getOwnPropertyDescriptor(o, key);
-        return d !== undefined && 'value' in d ? d.value : undefined;
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return undefined;
@@ -82,15 +85,20 @@ function targetRowOf(model, cat) {
     return row === undefined ? { kind: 'none', why: 'model_not_listed' } : { kind: 'row', row };
 }
 export function imageVisionOf(model, catalog = getLiveModelCatalog()) {
+    return imageVisionReadingOf(model, catalog).vision;
+}
+export function imageVisionReadingOf(model, catalog = getLiveModelCatalog()) {
     try {
         const target = targetRowOf(model, catalog);
         if (target.kind !== 'row')
-            return 'unknown';
+            return { vision: 'unknown' };
         const vision = ownDataOf(target.row, 'vision');
-        return vision === true ? 'yes' : vision === false ? 'no' : 'unknown';
+        const word = vision === true ? 'yes' : vision === false ? 'no' : 'unknown';
+        const name = ownDataOf(target.row, 'name');
+        return typeof name === 'string' && name.length > 0 ? { vision: word, model: name } : { vision: word };
     }
     catch {
-        return 'unknown';
+        return { vision: 'unknown' };
     }
 }
 const NOT_CLAMPED = Object.freeze({ kind: 'not_clamped' });
@@ -148,13 +156,119 @@ export function liveDefaultModelName() {
     const d = liveDefaultModelOf(catalog);
     return d.kind === 'listed' ? d.name : d.kind === 'not_listed' ? d.id : null;
 }
+function isReservedModelWord(word) {
+    return word === 'default' || TIER_ORDER.includes(word) || Object.hasOwn(CC_TIER_ALIASES, word);
+}
+function droppedDisabledNamed(dropped, name) {
+    if (dropped.kind !== 'reported')
+        return false;
+    return dropped.entries.some((e) => e.identity !== undefined && e.identity.enabled === false && (e.identity.name === name || e.identity.id === name));
+}
+function catalogIncomplete(cat, rows, dropped) {
+    const models = ownDataOf(cat, 'models');
+    const n = Array.isArray(models) ? ownDataOf(models, 'length') : undefined;
+    if (typeof n === 'number' && Number.isSafeInteger(n) && n > rows.length)
+        return true;
+    return dropped.kind === 'reported' ? dropped.entries.length > 0 || dropped.unreadable > 0 : dropped.kind === 'unknown';
+}
+function isPlainRecord(o) {
+    const proto = Object.getPrototypeOf(o);
+    return proto === Object.prototype || proto === null;
+}
+function rowIdentityUnreadable(row) {
+    try {
+        const name = Object.getOwnPropertyDescriptor(row, 'name');
+        if (name === undefined || !Object.hasOwn(name, 'value') || typeof name.value !== 'string' || name.value.length === 0)
+            return true;
+        const id = Object.getOwnPropertyDescriptor(row, 'id');
+        if (id !== undefined && (!Object.hasOwn(id, 'value') || typeof id.value !== 'string'))
+            return true;
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+export function modelAcceptanceOf(model, catalog = getLiveModelCatalog()) {
+    const name = typeof model === 'string' && model.length > 0 ? model : undefined;
+    try {
+        if (name === undefined)
+            return Object.freeze({ verdict: 'unknown', why: 'model_absent' });
+        const reserved = isReservedModelWord(name);
+        const unreadable = () => Object.freeze({ verdict: 'unknown', why: reserved ? 'reserved_word' : 'catalog_unreadable', model: name });
+        if (catalog === null)
+            return Object.freeze({ verdict: 'unknown', why: reserved ? 'reserved_word' : 'catalog_absent', model: name });
+        if (typeof catalog !== 'object' || Array.isArray(catalog) || !isPlainRecord(catalog))
+            return unreadable();
+        const rows = catalogRowsOf(catalog);
+        if (rows === undefined || rows.length === 0)
+            return unreadable();
+        const dm = liveDefaultModelOf(catalog);
+        let defaultModel = dm.kind === 'listed' ? dm.name : dm.kind === 'not_listed' ? dm.id : undefined;
+        if (defaultModel !== undefined) {
+            const defaultRow = liveModelRowOf(catalog, defaultModel);
+            if (defaultRow !== undefined && ownDataOf(defaultRow, 'enabled') === false)
+                defaultModel = undefined;
+        }
+        const withDefault = defaultModel === undefined ? {} : { defaultModel };
+        const reservedReading = () => Object.freeze({ verdict: 'unknown', why: 'reserved_word', model: name, ...withDefault });
+        if (reserved)
+            return reservedReading();
+        const row = liveModelRowOf(catalog, name);
+        if (row !== undefined) {
+            const normalized = ownDataOf(row, 'name');
+            if (typeof normalized !== 'string' || normalized.length === 0)
+                return Object.freeze({ verdict: 'unknown', why: 'catalog_unreadable', model: name });
+            if (isReservedModelWord(normalized))
+                return reservedReading();
+            return ownDataOf(row, 'enabled') === false
+                ? Object.freeze({ verdict: 'refused', why: 'disabled', model: name, ...withDefault })
+                : Object.freeze({ verdict: 'accepted', why: 'listed', model: name, ...withDefault });
+        }
+        if (rows.some(rowIdentityUnreadable))
+            return Object.freeze({ verdict: 'unknown', why: 'catalog_unreadable', model: name });
+        const dropped = droppedModelEntriesOf(catalog);
+        if (droppedDisabledNamed(dropped, name))
+            return Object.freeze({ verdict: 'refused', why: 'disabled', model: name, ...withDefault });
+        if (catalogIncomplete(catalog, rows, dropped))
+            return Object.freeze({ verdict: 'unknown', why: 'catalog_incomplete', model: name, ...withDefault });
+        return Object.freeze({ verdict: 'refused', why: 'not_listed', model: name, ...withDefault });
+    }
+    catch {
+        return Object.freeze({ verdict: 'unknown', why: 'catalog_unreadable', ...(name !== undefined ? { model: name } : {}) });
+    }
+}
+const NOT_SERVED_NAME_MAX = 120;
+export function modelNotServedNotice(reading, lang) {
+    try {
+        if (reading === null || typeof reading !== 'object')
+            return undefined;
+        if (ownDataOf(reading, 'verdict') !== 'refused')
+            return undefined;
+        const why = ownDataOf(reading, 'why');
+        if (why !== 'not_listed' && why !== 'disabled')
+            return undefined;
+        const model = ownDataOf(reading, 'model');
+        const shown = typeof model === 'string' && model.length > 0 ? quoteUntrustedForSentence(model, NOT_SERVED_NAME_MAX) : undefined;
+        if (shown === undefined)
+            return undefined;
+        const dm = ownDataOf(reading, 'defaultModel');
+        const fallback = typeof dm === 'string' && dm.length > 0 ? quoteUntrustedForSentence(dm, NOT_SERVED_NAME_MAX) : undefined;
+        return fallback === undefined
+            ? renderMessage(msg('model.notServed.noDefault', { model: shown }), lang)
+            : renderMessage(msg('model.notServed.withDefault', { model: shown, default: fallback }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
 const notReportedDropped = () => Object.freeze({ kind: 'not_reported' });
 const unknownDropped = (why) => Object.freeze({ kind: 'unknown', why });
 function ownDataCopy(o) {
     const out = {};
     for (const k of Object.keys(o)) {
         const d = Object.getOwnPropertyDescriptor(o, k);
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !(Object.hasOwn(d, 'value')))
             return undefined;
         Object.defineProperty(out, k, { value: d.value, enumerable: true, writable: true, configurable: true });
     }
@@ -203,7 +317,7 @@ export function droppedModelEntriesOf(catalog = getLiveModelCatalog()) {
         if (!Object.hasOwn(catalog, 'droppedEntries'))
             return notReportedDropped();
         const d = Object.getOwnPropertyDescriptor(catalog, 'droppedEntries');
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !(Object.hasOwn(d, 'value')))
             return unknownDropped('unreadable');
         const raw = d.value;
         if (raw === undefined)
@@ -217,7 +331,7 @@ export function droppedModelEntriesOf(catalog = getLiveModelCatalog()) {
         let unreadable = 0;
         for (let i = 0; i < n; i += 1) {
             const rd = Object.getOwnPropertyDescriptor(raw, String(i));
-            const row = rd !== undefined && 'value' in rd ? droppedRowOf(rd.value) : undefined;
+            const row = rd !== undefined && Object.hasOwn(rd, 'value') ? droppedRowOf(rd.value) : undefined;
             if (row === undefined)
                 unreadable += 1;
             else
@@ -237,7 +351,7 @@ export function modelCandidateRejectedOf(catalog = getLiveModelCatalog()) {
         if (!Object.hasOwn(catalog, 'candidateRejected'))
             return Object.freeze({ kind: 'not_reported' });
         const d = Object.getOwnPropertyDescriptor(catalog, 'candidateRejected');
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !(Object.hasOwn(d, 'value')))
             return unreadable;
         const v = d.value;
         if (v === undefined)
@@ -246,22 +360,22 @@ export function modelCandidateRejectedOf(catalog = getLiveModelCatalog()) {
             return unreadable;
         const own = (k) => {
             const od = Object.getOwnPropertyDescriptor(v, k);
-            return od !== undefined && 'value' in od ? od.value : undefined;
+            return od !== undefined && Object.hasOwn(od, 'value') ? od.value : undefined;
         };
         const rawDomains = own('domains');
         const at = own('at');
         const source = own('source');
         if (!Array.isArray(rawDomains) || typeof at !== 'string' || at.length === 0 || typeof source !== 'string' || source.length === 0)
             return unreadable;
-        const n = Object.getOwnPropertyDescriptor(rawDomains, 'length')?.value;
+        const n = readOwnDataValue(rawDomains, 'length');
         if (typeof n !== 'number' || !Number.isSafeInteger(n) || n <= 0)
             return unreadable;
         const domains = [];
         for (let i = 0; i < n; i += 1) {
             const id = Object.getOwnPropertyDescriptor(rawDomains, String(i));
-            if (id === undefined || !('value' in id) || typeof id.value !== 'string' || id.value.length === 0)
+            if (id === undefined || !(Object.hasOwn(id, 'value')) || typeof id.value !== 'string' || id.value.length === 0)
                 return unreadable;
-            domains.push(id.value);
+            appendOwnElement(domains, id.value);
         }
         return Object.freeze({ kind: 'rejected', domains: Object.freeze(domains), at, source });
     }
@@ -303,7 +417,7 @@ function envelopeKey(o, key) {
     const d = Object.getOwnPropertyDescriptor(o, key);
     if (d === undefined)
         return { present: false };
-    if (!('value' in d))
+    if (!(Object.hasOwn(d, 'value')))
         throw new Error('accessor');
     return { present: true, value: d.value };
 }
@@ -327,7 +441,7 @@ export function readLiveModelCatalog(body) {
         let unreadableRows = 0;
         for (let i = 0; i < len; i += 1) {
             const d = Object.getOwnPropertyDescriptor(raw, String(i));
-            const row = d !== undefined && 'value' in d ? liveModelRowCopy(d.value) : undefined;
+            const row = d !== undefined && Object.hasOwn(d, 'value') ? liveModelRowCopy(d.value) : undefined;
             if (row === undefined || names.has(row.name)) {
                 unreadableRows += 1;
                 continue;
@@ -359,13 +473,13 @@ export function readLiveModelCatalog(body) {
 function droppedEntriesCopy(v) {
     if (!Array.isArray(v))
         return frozenJsonCopyOf(v) ?? null;
-    const n = Object.getOwnPropertyDescriptor(v, 'length')?.value;
+    const n = readOwnDataValue(v, 'length');
     if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
         return null;
     const out = [];
     for (let i = 0; i < n; i += 1) {
         const d = Object.getOwnPropertyDescriptor(v, String(i));
-        out.push((d !== undefined && 'value' in d ? frozenJsonCopyOf(d.value) : undefined) ?? null);
+        appendOwnElement(out, (d !== undefined && Object.hasOwn(d, 'value') ? frozenJsonCopyOf(d.value) : undefined) ?? null);
     }
     return Object.freeze(out);
 }
@@ -398,7 +512,7 @@ export function atMentionOf(model, catalog = getLiveModelCatalog()) {
         const d = Object.getOwnPropertyDescriptor(target.row, 'atMentionable');
         if (d === undefined)
             return Object.freeze({ kind: 'not_governed' });
-        if (!('value' in d))
+        if (!(Object.hasOwn(d, 'value')))
             return Object.freeze({ kind: 'unknown', why: 'unreadable' });
         if (d.value === undefined)
             return Object.freeze({ kind: 'not_governed' });
@@ -420,7 +534,7 @@ export function modelCompatOf(model, catalog = getLiveModelCatalog()) {
         const d = Object.getOwnPropertyDescriptor(target.row, 'compat');
         if (d === undefined)
             return Object.freeze({ kind: 'not_declared' });
-        if (!('value' in d))
+        if (!(Object.hasOwn(d, 'value')))
             return Object.freeze({ kind: 'unknown', why: 'unreadable' });
         if (d.value === undefined)
             return Object.freeze({ kind: 'not_declared' });

package/dist/mcpPanel.js

@@ -78,7 +78,7 @@ export function mcpPanelRefusalOf(view) {
         if (view === null || typeof view !== 'object')
             return undefined;
         const d = Object.getOwnPropertyDescriptor(view, 'scenarioRefusal');
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !Object.hasOwn(d, 'value'))
             return undefined;
         const r = d.value;
         return r !== null && typeof r === 'object' && !Array.isArray(r) ? r : undefined;

package/dist/mcpProbeCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
@@ -21,7 +21,7 @@ const reader = createEngineCapReader({
     name: 'mcpProbe',
     project: projectMcpProbeCapability,
 });
-export function observedMcpProbe(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedMcpProbe(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function mcpProbeAvailable(reading) {

package/dist/mcpStatusSupersetKeys.d.ts

@@ -0,0 +1,24 @@
+import type { McpEngineLegConnection } from './mcpEngineLeg.js';
+export interface McpShellConnectionFact {
+    readonly status: string;
+    readonly serves: 'prompts_resources';
+    readonly error?: string;
+}
+export interface McpStatusSupersetKeys {
+    readonly _sema_engineLeg?: McpEngineLegConnection;
+    readonly _sema_shellConnection?: McpShellConnectionFact;
+}
+export interface McpReconnectSupersetKeys {
+    readonly _sema_shellConnection?: McpShellConnectionFact;
+}
+export interface McpStatusSupersetInput {
+    readonly engineLeg: McpEngineLegConnection | undefined;
+    readonly localClientType: string | undefined;
+    readonly localError?: string | undefined;
+}
+export interface McpReconnectSupersetInput {
+    readonly localClientType: string | undefined;
+    readonly localError?: string | undefined;
+}
+export declare function mcpStatusSupersetKeys(input: McpStatusSupersetInput): McpStatusSupersetKeys;
+export declare function mcpReconnectSupersetKeys(input: McpReconnectSupersetInput): McpReconnectSupersetKeys;

package/dist/mcpStatusSupersetKeys.js

@@ -0,0 +1,45 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+function slot(input, key) {
+    return guardedRead(() => readOwnDataValue(input, key));
+}
+function shellConnectionOf(input) {
+    const type = slot(input, 'localClientType');
+    if (typeof type !== 'string' || type === '')
+        return undefined;
+    const error = type === 'failed' ? slot(input, 'localError') : undefined;
+    return Object.freeze({
+        status: type,
+        serves: 'prompts_resources',
+        ...(typeof error === 'string' && error !== '' ? { error } : {}),
+    });
+}
+function frozenCopyOfEngineLeg(leg) {
+    if (typeof leg !== 'object' || leg === null)
+        return undefined;
+    const copy = {};
+    let keys;
+    try {
+        keys = Object.keys(leg);
+    }
+    catch {
+        return undefined;
+    }
+    for (const k of keys) {
+        const v = slot(leg, k);
+        if (typeof v === 'string' || typeof v === 'boolean' || (typeof v === 'number' && Number.isFinite(v)))
+            Object.defineProperty(copy, k, { value: v, enumerable: true, writable: true, configurable: true });
+    }
+    return typeof copy['state'] === 'string' ? Object.freeze(copy) : undefined;
+}
+export function mcpStatusSupersetKeys(input) {
+    const engineLeg = frozenCopyOfEngineLeg(slot(input, 'engineLeg'));
+    const shell = shellConnectionOf(input);
+    return Object.freeze({
+        ...(engineLeg !== undefined ? { _sema_engineLeg: engineLeg } : {}),
+        ...(shell !== undefined ? { _sema_shellConnection: shell } : {}),
+    });
+}
+export function mcpReconnectSupersetKeys(input) {
+    const shell = shellConnectionOf(input);
+    return Object.freeze(shell !== undefined ? { _sema_shellConnection: shell } : {});
+}

package/dist/mcpToolToggles.js

@@ -1,3 +1,4 @@
+import { readOwnDataValue } from './ownKey.js';
 import { checkMcpToolToggleKey } from './seatContract.js';
 function keyOf(key, index) {
     const refuse = (why) => new TypeError(`mcpToolTogglesToExcludeTools: keys[${index}] 不是逐工具开关键 { server, tool }(${why})—— 值不回显。` +
@@ -7,7 +8,7 @@ function keyOf(key, index) {
         throw refuse(`${shape.reason}${shape.field !== undefined ? ` @ ${shape.field}` : ''}`);
     let snap;
     try {
-        snap = { server: Object.getOwnPropertyDescriptor(key, 'server')?.value, tool: Object.getOwnPropertyDescriptor(key, 'tool')?.value };
+        snap = { server: readOwnDataValue(key, 'server'), tool: readOwnDataValue(key, 'tool') };
     }
     catch {
         throw refuse('读不出');

package/dist/mcpWireCaps.d.ts

@@ -17,6 +17,16 @@ export interface McpConfigLike {
     toolAxes?: unknown;
     startupTimeoutMs?: number;
 }
+export type McpTransportEntryLike = Pick<McpConfigLike, 'type' | 'command' | 'args' | 'env' | 'url' | 'headers' | 'principalHeader' | 'assertionHeader'>;
+export type McpTransportVerdict = {
+    readonly kind: 'ok';
+    readonly transport: McpServerSpec['transport'];
+    readonly lost: readonly McpEntryKeyIssue[];
+} | {
+    readonly kind: 'bad';
+    readonly key: string;
+    readonly detail: string;
+};
 export type McpHttpIdentityHeaders = {
     readonly kind: 'ok';
     readonly principalHeader?: string;
@@ -26,6 +36,7 @@ export type McpHttpIdentityHeaders = {
 };
 export declare function readMcpHttpIdentityHeaders(transport: object): McpHttpIdentityHeaders;
 export declare function mcpConfigToSpec(name: string, c: McpConfigLike): McpServerSpec | null;
+export declare function mcpTransportVerdict(entry: McpTransportEntryLike | null | undefined): McpTransportVerdict;
 export declare function mcpConfigsToSpecs(servers: Record<string, McpConfigLike> | undefined): McpServerSpec[];
 export type McpToolAxesVerdict = {
     readonly kind: 'ok';
@@ -37,13 +48,40 @@ export type McpToolAxesVerdict = {
     readonly kind: 'unavailable';
 };
 export declare function mcpToolAxesVerdict(declared: {} | null | undefined): McpToolAxesVerdict;
+export type McpToolFacesVerdict = {
+    readonly kind: 'ok';
+    readonly toolFaces?: Readonly<Record<string, object>>;
+} | {
+    readonly kind: 'bad';
+    readonly problem: string;
+} | {
+    readonly kind: 'unavailable';
+};
+export declare function mcpToolFacesVerdict(declared: {} | null | undefined): McpToolFacesVerdict;
 export declare function mcpElicitationVerdict(declared: {} | null | undefined): {
     readonly kind: 'ok';
     readonly elicitation?: boolean;
 } | {
     readonly kind: 'bad';
 };
-export type McpConfigDropReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'transport_invalid' | 'identity_headers_both_set' | 'tool_axes_invalid' | 'elicitation_invalid';
+export type McpAllowToolsVerdict = {
+    readonly kind: 'ok';
+    readonly allowTools?: string[];
+} | {
+    readonly kind: 'bad';
+    readonly path: string;
+    readonly problem: string;
+};
+export declare function mcpAllowToolsVerdict(read: () => {} | null | undefined, keyPrefix?: string): McpAllowToolsVerdict;
+export type McpConfigDropReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long' | 'transport_invalid' | 'identity_headers_both_set' | 'tool_axes_invalid' | 'tool_faces_invalid' | 'elicitation_invalid' | 'allow_tools_invalid' | 'entry_not_object' | 'entry_unreadable';
+export type McpServerNameUnusableReason = 'name_blank' | 'name_edge_whitespace' | 'name_collides_after_trim' | 'name_too_long';
+export type McpServerNameVerdict = {
+    readonly usable: true;
+} | {
+    readonly usable: false;
+    readonly reason: McpServerNameUnusableReason;
+};
+export declare function mcpServerNameVerdict(name: string | null | undefined, siblings?: Iterable<string>): McpServerNameVerdict;
 export interface McpConfigDropped {
     readonly name: string;
     readonly reason: McpConfigDropReason;