@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/mcpProbeWire.d.ts

@@ -1,6 +1,7 @@
 import type { McpProbeFace, McpServerSpec } from '@sema-agent/sdk';
 import { type WiringManifestMcpEntryView } from './adapter/downstream/eventToSdkMessage.js';
 import { type McpProbeReading } from './mcpProbeCapability.js';
+import { type ScenarioRefusalReading } from './scenarioRefusal.js';
 export interface McpProbeFacade {
     mcpCapabilities(opts?: {
         signal?: AbortSignal;
@@ -9,7 +10,7 @@ export interface McpProbeFacade {
         signal?: AbortSignal;
     }): Promise<McpProbeFace>;
 }
-export declare const MCP_PROBE_REFUSAL_CAUSES: readonly ["face_absent", "client_too_old", "unreadable_request", "injection_not_honored", "body_shape", "field_invalid", "body_unparseable", "payload_too_large", "rate_limited", "unauthorized", "principal_required", "principal_unverified"];
+export declare const MCP_PROBE_REFUSAL_CAUSES: readonly ["face_absent", "client_too_old", "unreadable_request", "injection_not_honored", "body_shape", "field_invalid", "body_unparseable", "payload_too_large", "rate_limited", "unauthorized", "principal_required", "principal_unverified", "scenario_refused"];
 export type McpProbeRefusalCause = (typeof MCP_PROBE_REFUSAL_CAUSES)[number];
 export declare const MCP_PROBE_UNKNOWN_WHYS: readonly ["no_verdict", "probe_incomplete", "server_fault", "result_unreadable", "index_misaligned", "unclassified"];
 export type McpProbeUnknownWhy = (typeof MCP_PROBE_UNKNOWN_WHYS)[number];
@@ -18,6 +19,7 @@ export type McpProbeRefused = {
     cause: McpProbeRefusalCause;
     message: string;
     retryAfterSec?: number;
+    scenarioRefusal?: ScenarioRefusalReading;
 };
 export type McpProbeUnknown = {
     status: 'unknown';

package/dist/mcpProbeWire.js

@@ -1,6 +1,7 @@
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { wireFailureShapeOf } from './wireFailureShape.js';
 import { mcpProbeAvailable } from './mcpProbeCapability.js';
+import { scenarioRefusalFromError } from './scenarioRefusal.js';
 export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
     'face_absent',
     'client_too_old',
@@ -14,6 +15,7 @@ export const MCP_PROBE_REFUSAL_CAUSES = Object.freeze([
     'unauthorized',
     'principal_required',
     'principal_unverified',
+    'scenario_refused',
 ]);
 export const MCP_PROBE_UNKNOWN_WHYS = Object.freeze([
     'no_verdict',
@@ -168,6 +170,9 @@ export async function readMcpCapabilities(facade, call, opts) {
         res = await facade.mcpCapabilities(opts);
     }
     catch (e) {
+        const refusal = scenarioRefusalFromError(e);
+        if (refusal !== null)
+            return { ...refusedBy('scenario_refused', wireFailureShapeOf(e).message), scenarioRefusal: refusal };
         return classifyMcpProbeFailure(e);
     }
     const narrowed = narrowProbeFace(res);

package/dist/mcpWireCaps.d.ts

@@ -1,4 +1,5 @@
 import type { McpServerSpec } from '@sema-agent/sdk';
+import type { UiLanguage } from './env/uiLanguage.js';
 export type { McpServerSpec };
 export declare const MCP_CAPS: {
     readonly items: 32;
@@ -13,6 +14,7 @@ export interface McpConfigLike {
     principalHeader?: string;
     assertionHeader?: string;
     allowTools?: string[];
+    elicitation?: {} | null | undefined;
     toolFaces?: unknown;
     toolAxes?: unknown;
 }
@@ -26,4 +28,36 @@ export type McpHttpIdentityHeaders = {
 export declare function readMcpHttpIdentityHeaders(transport: object): McpHttpIdentityHeaders;
 export declare function mcpConfigToSpec(name: string, c: McpConfigLike): McpServerSpec | null;
 export declare function mcpConfigsToSpecs(servers: Record<string, McpConfigLike> | undefined): McpServerSpec[];
+export type McpToolAxesVerdict = {
+    readonly kind: 'ok';
+    readonly toolAxes?: Readonly<Record<string, object>>;
+} | {
+    readonly kind: 'bad';
+    readonly problem: string;
+} | {
+    readonly kind: 'unavailable';
+};
+export declare function mcpToolAxesVerdict(declared: {} | null | undefined): McpToolAxesVerdict;
+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' | 'tool_axes_invalid' | 'elicitation_invalid';
+export interface McpConfigDropped {
+    readonly name: string;
+    readonly reason: McpConfigDropReason;
+    readonly problem?: string;
+    readonly notice: string;
+}
+export interface McpConfigProjection {
+    readonly specs: McpServerSpec[];
+    readonly dropped: readonly McpConfigDropped[];
+}
+export interface ProjectMcpConfigsOptions {
+    readonly sourceLabel?: (serverName: string) => string | undefined;
+    readonly lang?: UiLanguage;
+}
+export declare function projectMcpConfigs(servers: Record<string, McpConfigLike> | undefined, opts?: ProjectMcpConfigsOptions): McpConfigProjection;
 export declare function mcpAssertionHeaderNotSentNotice(specs: readonly McpServerSpec[]): string | undefined;

package/dist/mcpWireCaps.js

@@ -1,11 +1,15 @@
 import { guardedRead } from './ownKey.js';
+import { readMcpToolAxes } from './coreValuePorts.js';
+import { capForDisplay } from './fleetTaskDesc.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const _mcpServerSpecPin = true;
 void _mcpServerSpecPin;
 export const MCP_CAPS = { items: 32 };
-function transparentKeys(c) {
+function transparentKeys(c, axes, elicitation) {
     return {
         ...(c.toolFaces !== undefined ? { toolFaces: c.toolFaces } : {}),
-        ...(c.toolAxes !== undefined ? { toolAxes: c.toolAxes } : {}),
+        ...(axes !== undefined ? { toolAxes: axes } : {}),
+        ...(elicitation !== undefined ? { elicitation } : {}),
     };
 }
 function presentHeaderName(v) {
@@ -24,9 +28,24 @@ export function readMcpHttpIdentityHeaders(transport) {
     };
 }
 export function mcpConfigToSpec(name, c) {
-    const n = (name ?? '').trim();
-    if (!n)
-        return null;
+    return mcpConfigEntry(name, c).spec;
+}
+function mcpConfigEntry(name, c) {
+    if (mcpNameFlaw(name) !== undefined)
+        return { spec: null };
+    const declared = c.toolAxes;
+    const verdict = mcpToolAxesVerdict(declared);
+    const elDeclared = c.elicitation;
+    const elVerdict = mcpElicitationVerdict(elDeclared);
+    if (verdict.kind === 'bad' || elVerdict.kind === 'bad') {
+        const rest = specOf(name, c, undefined, undefined);
+        if (rest === null)
+            return { spec: null };
+        return verdict.kind === 'bad' ? { spec: null, axesProblem: verdict.problem } : { spec: null, elicitationInvalid: true };
+    }
+    return { spec: specOf(name, c, verdict.kind === 'ok' ? verdict.toolAxes : declared, elVerdict.elicitation) };
+}
+function specOf(n, c, axes, elicitation) {
     const kind = c.type ?? 'stdio';
     if (kind === 'stdio') {
         if (!c.command)
@@ -39,8 +58,8 @@ export function mcpConfigToSpec(name, c) {
                 ...(c.args && c.args.length > 0 ? { args: c.args } : {}),
                 ...(c.env ? { env: c.env } : {}),
             },
-            ...(c.allowTools && c.allowTools.length > 0 ? { allowTools: c.allowTools } : {}),
-            ...transparentKeys(c),
+            ...(Array.isArray(c.allowTools) ? { allowTools: c.allowTools } : {}),
+            ...transparentKeys(c, axes, elicitation),
         };
     }
     if (kind === 'http') {
@@ -58,22 +77,103 @@ export function mcpConfigToSpec(name, c) {
                 ...(id.principalHeader !== undefined ? { principalHeader: id.principalHeader } : {}),
                 ...(id.assertionHeader !== undefined ? { assertionHeader: id.assertionHeader } : {}),
             },
-            ...(c.allowTools && c.allowTools.length > 0 ? { allowTools: c.allowTools } : {}),
-            ...transparentKeys(c),
+            ...(Array.isArray(c.allowTools) ? { allowTools: c.allowTools } : {}),
+            ...transparentKeys(c, axes, elicitation),
         };
     }
     return null;
 }
 export function mcpConfigsToSpecs(servers) {
-    const out = [];
-    for (const [name, c] of Object.entries(servers ?? {})) {
-        if (out.length >= MCP_CAPS.items)
+    return projectMcpConfigs(servers).specs;
+}
+export function mcpToolAxesVerdict(declared) {
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    const read = readMcpToolAxes(declared);
+    if (read === undefined || read === null || typeof read !== 'object')
+        return Object.freeze({ kind: 'unavailable' });
+    if (read.ok === true) {
+        const copy = read.toolAxes;
+        return Object.freeze(typeof copy === 'object' && copy !== null ? { kind: 'ok', toolAxes: copy } : { kind: 'ok' });
+    }
+    if (read.ok === false) {
+        const problem = read.problem;
+        return Object.freeze({ kind: 'bad', problem: typeof problem === 'string' && problem.length > 0 ? problem : renderMessage(msg('config.mcp.toolAxesFallbackProblem')) });
+    }
+    return Object.freeze({ kind: 'unavailable' });
+}
+export function mcpElicitationVerdict(declared) {
+    if (declared === undefined)
+        return Object.freeze({ kind: 'ok' });
+    return typeof declared === 'boolean' ? Object.freeze({ kind: 'ok', elicitation: declared }) : Object.freeze({ kind: 'bad' });
+}
+function mcpNameFlaw(name) {
+    if (typeof name !== 'string')
+        return 'name_blank';
+    const t = name.trim();
+    if (t.length === 0)
+        return 'name_blank';
+    return t === name ? undefined : 'name_edge_whitespace';
+}
+const DROP_NAME_SHOWN = 80;
+const DROP_LABEL_SHOWN = 140;
+const DROP_PROBLEM_SHOWN = 300;
+function dropNotice(name, reason, problem, opts) {
+    let label;
+    try {
+        label = opts?.sourceLabel?.(name);
+    }
+    catch {
+        label = undefined;
+    }
+    const where = typeof label === 'string' && label.length > 0 ? ` (${capForDisplay(label, DROP_LABEL_SHOWN)})` : '';
+    const quoted = `"${capForDisplay(name, DROP_NAME_SHOWN)}"`;
+    const ref = reason === 'tool_axes_invalid'
+        ? msg('config.mcp.toolAxesInvalid', { name: quoted, where, problem: capForDisplay(problem ?? renderMessage(msg('config.mcp.toolAxesFallbackProblem')), DROP_PROBLEM_SHOWN) })
+        : reason === 'elicitation_invalid'
+            ? msg('config.mcp.elicitationInvalid', { name: quoted, where })
+            : reason === 'name_blank'
+                ? msg('config.mcp.nameBlank', { name: quoted, where })
+                : reason === 'name_collides_after_trim'
+                    ? msg('config.mcp.nameCollides', { name: quoted, where })
+                    : msg('config.mcp.nameEdgeWhitespace', { name: quoted, where });
+    return renderMessage(ref, opts?.lang);
+}
+export function projectMcpConfigs(servers, opts) {
+    const specs = [];
+    const dropped = [];
+    const entries = Object.entries(servers ?? {});
+    const exactNames = new Set();
+    const trimmedCount = new Map();
+    for (const [name] of entries) {
+        const flaw = mcpNameFlaw(name);
+        if (flaw === undefined)
+            exactNames.add(name);
+        else if (flaw === 'name_edge_whitespace')
+            trimmedCount.set(name.trim(), (trimmedCount.get(name.trim()) ?? 0) + 1);
+    }
+    for (const [name, c] of entries) {
+        if (specs.length >= MCP_CAPS.items)
             break;
-        const spec = mcpConfigToSpec(name, c);
-        if (spec)
-            out.push(spec);
+        const flaw = mcpNameFlaw(name);
+        if (flaw !== undefined) {
+            const reason = flaw === 'name_edge_whitespace' && (exactNames.has(name.trim()) || (trimmedCount.get(name.trim()) ?? 0) > 1) ? 'name_collides_after_trim' : flaw;
+            dropped.push({ name, reason, notice: dropNotice(name, reason, undefined, opts) });
+            continue;
+        }
+        const out = mcpConfigEntry(name, c);
+        if (out.spec !== null) {
+            specs.push(out.spec);
+            continue;
+        }
+        if (out.axesProblem !== undefined) {
+            dropped.push({ name, reason: 'tool_axes_invalid', problem: out.axesProblem, notice: dropNotice(name, 'tool_axes_invalid', out.axesProblem, opts) });
+        }
+        else if (out.elicitationInvalid === true) {
+            dropped.push({ name, reason: 'elicitation_invalid', notice: dropNotice(name, 'elicitation_invalid', undefined, opts) });
+        }
     }
-    return out;
+    return { specs, dropped: Object.freeze(dropped) };
 }
 function assertionDeclaringServerName(spec) {
     const t = spec?.transport;
@@ -97,6 +197,6 @@ export function mcpAssertionHeaderNotSentNotice(specs) {
     const parts = distinct.slice(0, ASSERTION_NOTICE_NAMES_SHOWN).map((x) => `"${x}"`);
     if (distinct.length > ASSERTION_NOTICE_NAMES_SHOWN)
         parts.push(`+${distinct.length - ASSERTION_NOTICE_NAMES_SHOWN} more`);
-    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.129.1 accept this setting but do not send the header, ` +
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.131.0 accept this setting but do not send the header, ` +
         'and this client cannot tell whether the engine it uses sends it; a connector that requires the header will refuse requests from these servers');
 }

package/dist/memoryEntriesWire.js

@@ -1,3 +1,4 @@
+import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
 function nonEmptyString(v) {
     return typeof v === 'string' && v !== '';
 }
@@ -216,16 +217,10 @@ export function readMemoryEraseReceipt(body) {
             return { kind: 'malformed', why: 'body_unreadable' };
         o = body;
         envelopeSeen = ['v', 'requestId', 'status', 'erased', 'notFound'].some((k) => Object.hasOwn(o, k));
-        rawV = Object.hasOwn(o, 'v') ? o.v : undefined;
-        rawRequestId = o.requestId;
-        rawStatus = o.status;
-        rawEvidence = o.evidenceCapability;
-        rawCustody = o.custodyState;
-        rawSelected = o.resolvedIds;
-        rawErased = o.erased;
-        rawNotFound = o.notFound;
-        rawPreviously = Object.hasOwn(o, 'erasedPreviously') ? o.erasedPreviously : undefined;
-        rawConflicts = o.conflicts;
+        const slots = ['v', 'requestId', 'status', 'evidenceCapability', 'custodyState', 'resolvedIds', 'erased', 'notFound', 'erasedPreviously', 'conflicts'].map((k) => readThrownSlot(o, k, 'data'));
+        if (slots.includes(THROWN_SLOT_UNREADABLE))
+            return { kind: 'malformed', why: 'body_unreadable' };
+        [rawV, rawRequestId, rawStatus, rawEvidence, rawCustody, rawSelected, rawErased, rawNotFound, rawPreviously, rawConflicts] = slots;
     }
     catch {
         return { kind: 'malformed', why: 'body_unreadable' };

package/dist/model/onboardJudgement.d.ts

@@ -0,0 +1,93 @@
+import type { ModelApiWord } from './providerPresets.js';
+import type { OnboardCatalogIssue, OnboardProbeResult, OnboardProbeVerdict, OnboardRefusal } from '../seatContract.js';
+import { type ModelProbeResult } from '../modelCapabilityProbe.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
+export declare function onboardBaseUrlProblem(url: string, lang?: UiLanguage): string | undefined;
+export interface OnboardProbeTarget {
+    readonly baseUrl: string;
+    readonly api: ModelApiWord;
+    readonly modelId?: string | undefined;
+    readonly apiKey?: string | undefined;
+    readonly auth?: 'bearer' | 'x-api-key' | undefined;
+}
+export interface OnboardProbeRequestInit {
+    method?: string;
+    headers: Record<string, string>;
+    body?: string;
+    redirect: 'manual';
+    signal: AbortSignal;
+}
+export interface OnboardProbeBodyReader {
+    read(): Promise<{
+        readonly done: boolean;
+        readonly value?: Uint8Array | undefined;
+    }>;
+    cancel(): Promise<void>;
+}
+export interface OnboardProbeResponse {
+    readonly status: number;
+    readonly ok: boolean;
+    readonly headers: {
+        get(name: string): string | null;
+    };
+    readonly body?: {
+        getReader(): OnboardProbeBodyReader;
+    } | null | undefined;
+    text(): Promise<string>;
+}
+export type OnboardProbeFetch = (url: string, init: OnboardProbeRequestInit) => Promise<OnboardProbeResponse>;
+export interface OnboardProbeDeps {
+    readonly fetchImpl?: OnboardProbeFetch | undefined;
+    readonly timeoutMs?: number | undefined;
+    readonly firstTokenMs?: number | undefined;
+}
+export declare function probeModelEndpoint(target: OnboardProbeTarget, deps?: OnboardProbeDeps): Promise<OnboardProbeResult>;
+export type OnboardWriteVerdict = {
+    readonly write: true;
+    readonly unverified: boolean;
+} | {
+    readonly write: false;
+    readonly refusal: 'probe_failed' | 'probe_unverified';
+};
+export declare function onboardWriteVerdict(verdict: OnboardProbeVerdict, acceptUnverified?: boolean): OnboardWriteVerdict;
+export declare function keyEnvNameForEntry(entryName: string): string;
+export declare function poolEntryNameOf(modelId: string, channel: string, taken: ReadonlySet<string>): string;
+export interface OnboardPlanEntry {
+    readonly modelId: string;
+    readonly api: ModelApiWord;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly providerName: string;
+    readonly contextWindow: number;
+    readonly maxTokens: number;
+    readonly channel: string;
+}
+export interface OnboardJsonObject {
+    readonly [key: string]: {} | null;
+}
+export interface OnboardWritePlanInput {
+    readonly modelsDoc: OnboardJsonObject | undefined;
+    readonly settingsEnv: OnboardJsonObject | undefined;
+    readonly effectiveEnv: Readonly<Record<string, string | undefined>>;
+    readonly entry: OnboardPlanEntry;
+    readonly probe: OnboardProbeResult;
+    readonly makeDefault: boolean;
+    readonly now: number;
+    readonly thinking?: ModelProbeResult | undefined;
+    readonly engineMode?: 'local' | 'cloud' | undefined;
+}
+export type OnboardWritePlan = {
+    readonly ok: true;
+    readonly entryName: string;
+    readonly keyEnv: string;
+    readonly updatedExisting: boolean;
+    readonly nextModelsDoc: OnboardJsonObject;
+    readonly nextSettingsEnv: OnboardJsonObject;
+    readonly otherIssues: readonly OnboardCatalogIssue[];
+} | {
+    readonly ok: false;
+    readonly refusal: Extract<OnboardRefusal, 'input' | 'catalog_unreadable' | 'credential_unpaired' | 'engine_is_remote' | 'env_catalog_present'>;
+    readonly detail: string;
+};
+export declare function onboardWritePlan(input: OnboardWritePlanInput): OnboardWritePlan;
+export declare function onboardRefusalText(refusal: OnboardRefusal, lang?: UiLanguage): string;