dsh-agent-plugins-market 0.5.2 → 0.6.0

package/lib/runtime/lsp-direct-config.js

@@ -0,0 +1,44 @@
+/**
+ * Direct user configuration for LSP servers: a named table of `lspServers`
+ * entries stored under the plugin data root, merged at runtime alongside the
+ * suites' inline declarations.
+ *
+ * The file lives at `${dataRoot}/lsp-servers.json` and is the single source
+ * for the `direct` kind on the LSP status surface. Parsing reuses the same
+ * fail-closed `lsp-spec` rules as suite declarations; a broken file degrades
+ * to no direct servers plus a diagnostic, never a thrown discovery.
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { parseLspServers } from '../catalog/lsp-spec.js';
+/** The direct LSP server configuration file path. */
+export function lspServersPath(dataRoot) {
+    return join(dataRoot, 'lsp-servers.json');
+}
+/** Load the user-configured LSP servers; unreadable or invalid files yield an empty table. */
+export async function loadLspServers(dataRoot) {
+    let raw;
+    try {
+        raw = JSON.parse(await readFile(lspServersPath(dataRoot), 'utf8'));
+    }
+    catch {
+        return { servers: {}, errors: [] };
+    }
+    const errors = [];
+    const table = raw?.['lspServers'];
+    const servers = parseLspServers(table, errors);
+    return { servers, errors: errors.map(error => `lsp-servers.json: ${error}`) };
+}
+/** Validate and persist the user-configured LSP servers; returns normalized specs. */
+export async function saveLspServers(dataRoot, raw) {
+    const errors = [];
+    const table = raw?.['lspServers'];
+    const servers = parseLspServers(table, errors);
+    if (errors.length > 0) {
+        throw new Error(`invalid lspServers: ${errors[0]}`);
+    }
+    const path = lspServersPath(dataRoot);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify({ lspServers: servers }, null, 2)}\n`, 'utf8');
+    return { servers };
+}

package/lib/runtime/lsp-mounts.js

@@ -0,0 +1,236 @@
+import { DIRECT_LSP_SUITE_ID } from './lsp-status.js';
+import { qualifiedSuiteId } from '../catalog/paths.js';
+/**
+ * Bounded retry schedule for a failed mount/unmount, mirroring the MCP
+ * mounts: a permanently broken server must stop consuming attempt budget,
+ * and the schedule resets with every reconcile pass.
+ */
+const RETRY_SCHEDULE_MS = [1_500, 5_000, 15_000, 45_000, 120_000];
+const MAX_RETRY_ATTEMPTS = RETRY_SCHEDULE_MS.length;
+/** Build one dsh-lsp-stdio Config.servers entry from a normalized spec. */
+export function toLspServerConfig(spec) {
+    return {
+        command: spec.command,
+        args: spec.args,
+        extensionToLanguage: spec.extensionToLanguage,
+        ...(spec.env === undefined ? {} : { env: spec.env }),
+        ...(spec.initializationOptions === undefined ? {} : { initializationOptions: spec.initializationOptions }),
+        ...(spec.configuration === undefined ? {} : { configuration: spec.configuration })
+    };
+}
+/** Import spec kept as a string literal so the optional dependency stays dynamic. */
+const LSP_STDIO_IMPORT = '@deepseek-ai/dsh-lsp-stdio';
+export class LspMountRegistry {
+    ctx;
+    live = new Map();
+    /** Serialize mount and unmount passes so a disable cannot race an in-flight spawn. */
+    reconcileQueue = Promise.resolve();
+    /** Pending retry timers keyed by mount key, so a teardown can cancel them. */
+    retries = new Map();
+    /** Attempt count per mount key; reset whenever a retry succeeds. */
+    attempts = new Map();
+    /** Snapshot of the last reconciled suite set, replayed by retry passes. */
+    lastEnabled = [];
+    /** Host module loader; overridable for tests. */
+    loadHost;
+    /** Latest diagnostic per suite id; cleared when its suite mounts or leaves the wanted set. */
+    lastDiagnostics = new Map();
+    /** Direct (user-configured) server provider; defaults to none. */
+    directProvider = async () => ({});
+    constructor(ctx, loadHost) {
+        this.ctx = ctx;
+        this.loadHost =
+            loadHost ??
+                (async () => {
+                    try {
+                        return (await import(/* @vite-ignore */ LSP_STDIO_IMPORT));
+                    }
+                    catch {
+                        return undefined;
+                    }
+                });
+    }
+    /** Queue one reconciliation behind any in-flight mount/unmount pass. */
+    reconcile(enabledSuites) {
+        const run = this.reconcileQueue.then(() => this.reconcileNow(enabledSuites));
+        this.reconcileQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    /** Mount/unmount LSP servers to match the enabled suites plus direct config exactly. */
+    async reconcileNow(enabledSuites) {
+        this.lastEnabled = [...enabledSuites];
+        const active = enabledSuites.filter(suite => suite.activeSurfaces?.lsp !== false);
+        const wanted = new Map();
+        const diagnostics = [];
+        for (const suite of active) {
+            const servers = Object.values(suite.lsp?.servers ?? {});
+            if (servers.length === 0)
+                continue;
+            // The wanted key is the qualified suite id: bare suite ids are unique
+            // per source only, so two sources shipping the same suite name would
+            // otherwise shadow each other's mount and diagnostics.
+            const key = qualifiedSuiteId(suite.sourceId, suite.id);
+            const config = {};
+            for (const spec of servers)
+                config[`${key}/${spec.key}`] = toLspServerConfig(spec);
+            wanted.set(key, { suite, config });
+        }
+        // Direct user-configured servers ride the same mount path under the
+        // sentinel suite id, so their lifecycle (retries, diagnostics, disposal)
+        // is identical to a suite's.
+        const direct = await this.directProvider();
+        const directKeys = Object.keys(direct);
+        if (directKeys.length > 0) {
+            const config = {};
+            for (const [key, spec] of Object.entries(direct))
+                config[`${DIRECT_LSP_SUITE_ID}/${key}`] = toLspServerConfig(spec);
+            wanted.set(DIRECT_LSP_SUITE_ID, {
+                suite: {
+                    sourceId: '',
+                    id: DIRECT_LSP_SUITE_ID,
+                    root: '',
+                    manifest: { layout: 'claude-code', path: '', id: DIRECT_LSP_SUITE_ID, name: DIRECT_LSP_SUITE_ID },
+                    skills: [],
+                    surfaces: { skills: 0, mcp: 0, hooks: 0, commands: 0, agents: 0, lsp: directKeys.length },
+                    dimension: 'user',
+                    enabled: true,
+                    errors: []
+                },
+                config
+            });
+        }
+        for (const [key, live] of [...this.live]) {
+            if (!wanted.has(key)) {
+                const reason = await this.unmount(key, live);
+                this.lastDiagnostics.delete(live.suiteId);
+                if (reason !== undefined)
+                    diagnostics.push({ suiteId: live.suiteId, serverKey: live.serverKeys.join(','), reason, code: 'unmount-failed' });
+            }
+        }
+        for (const [key, entry] of wanted) {
+            if (this.live.has(key)) {
+                this.lastDiagnostics.delete(key);
+                continue;
+            }
+            const failure = await this.mountWith(key, entry.suite, entry.config);
+            if (failure !== undefined) {
+                diagnostics.push(failure);
+                this.lastDiagnostics.set(key, failure);
+                this.scheduleRetry(key, failure.code === 'host-missing' ? undefined : failure);
+            }
+            else {
+                this.lastDiagnostics.delete(key);
+            }
+        }
+        return diagnostics;
+    }
+    /** Install the direct (user-configured) server provider used at reconcile time. */
+    setDirectProvider(provider) {
+        this.directProvider = provider;
+    }
+    /** The latest mount diagnostic per suite, for the LSP status surface. */
+    diagnosticsSnapshot() {
+        return new Map(this.lastDiagnostics);
+    }
+    /** Whether at least one suite mount is live. */
+    hasLiveMounts() {
+        return this.live.size > 0;
+    }
+    /** Mount one suite's full server table as a single `dsh-lsp-stdio` instance. */
+    async mountWith(key, suite, servers) {
+        const hostKeys = Object.keys(servers).join(',');
+        const module = await this.loadHost();
+        if (module === undefined) {
+            return { suiteId: suite.id, serverKey: hostKeys, reason: HOST_MISSING_REASON, code: 'host-missing' };
+        }
+        const plugin = module.default ?? module;
+        const mountCtx = this.ctx;
+        if (typeof mountCtx.plugin !== 'function') {
+            return { suiteId: suite.id, serverKey: hostKeys, reason: 'the host context does not support dynamic plugin mounting', code: 'host-missing' };
+        }
+        let handle;
+        try {
+            handle = mountCtx.plugin(plugin, { servers });
+            await handle.await();
+        }
+        catch (error) {
+            // A failed startup can leave a half-mounted handle behind; drop it so
+            // no orphan child process survives, then report the real signal.
+            if (handle !== undefined) {
+                try {
+                    await handle.dispose();
+                }
+                catch {
+                    // Ignore teardown errors: the startup failure is the real signal.
+                }
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            const conflict = /already handled by another LSP provider|already registered/.test(message);
+            return {
+                suiteId: suite.id,
+                serverKey: hostKeys,
+                reason: `mount failed: ${message}`,
+                code: conflict ? 'seam-conflict' : 'mount-failed'
+            };
+        }
+        this.live.set(key, { suiteId: suite.id, serverKeys: Object.keys(servers), disposer: () => handle.dispose() });
+        return undefined;
+    }
+    async unmount(key, live) {
+        try {
+            await live.disposer();
+            this.live.delete(key);
+            return undefined;
+        }
+        catch (error) {
+            const reason = `unmount failed: ${error instanceof Error ? error.message : String(error)}`;
+            this.ctx.logger?.warn?.(`[dsh-agent-plugins-market] ${reason} (${live.suiteId})`);
+            return reason;
+        }
+    }
+    /**
+     * Schedule a delayed re-attempt for a mount that still is not live. A
+     * `host-missing` failure passes no diagnostic and is never retried; the
+     * schedule is bounded and resets with every reconcile pass.
+     */
+    scheduleRetry(key, failure) {
+        const pending = this.retries.get(key);
+        if (pending !== undefined)
+            clearTimeout(pending);
+        this.retries.delete(key);
+        if (failure === undefined || failure.code === 'host-missing') {
+            this.attempts.delete(key);
+            return;
+        }
+        const attempt = (this.attempts.get(key) ?? 0) + 1;
+        this.attempts.set(key, attempt);
+        if (attempt > MAX_RETRY_ATTEMPTS) {
+            this.ctx.logger?.warn?.(`[dsh-agent-plugins-market] ${failure.suiteId}: giving up after ${MAX_RETRY_ATTEMPTS} attempts — ${failure.reason}`);
+            return;
+        }
+        const delay = RETRY_SCHEDULE_MS[attempt - 1] ?? RETRY_SCHEDULE_MS[RETRY_SCHEDULE_MS.length - 1];
+        const timer = setTimeout(() => {
+            this.retries.delete(key);
+            // Re-run against the last known suite set: a retry must not resurrect
+            // servers of a suite that has since been disabled or uninstalled.
+            void this.reconcile(this.lastEnabled).catch(() => { });
+        }, delay);
+        timer.unref?.();
+        this.retries.set(key, timer);
+    }
+    /** Dispose every live mount after queued reconciliation passes settle. */
+    async disposeAll() {
+        const run = this.reconcileQueue.then(async () => {
+            for (const [key, live] of [...this.live]) {
+                await this.unmount(key, live);
+            }
+        });
+        this.reconcileQueue = run.then(() => undefined, () => undefined);
+        await run;
+        for (const timer of this.retries.values())
+            clearTimeout(timer);
+        this.retries.clear();
+        this.attempts.clear();
+    }
+}
+const HOST_MISSING_REASON = 'the @deepseek-ai/dsh-lsp-stdio package is not installed in this profile; upgrade to a DSH build carrying the LSP packages (@deepseek-ai/dsh-lsp, dsh-lsp-stdio, dsh-tool-lsp) and mount tool-lsp in the profile to expose the `lsp` tool';

package/lib/runtime/lsp-status.js

@@ -0,0 +1,96 @@
+import { qualifiedSuiteId } from '../catalog/paths.js';
+/** Sentinel suite id for user-configured (non-suite) LSP servers. */
+export const DIRECT_LSP_SUITE_ID = 'direct';
+/**
+ * Derive one row's state from its suite's diagnostic and the live-mount flag.
+ * Shared by suite rows and direct rows so both kinds report identically.
+ */
+function deriveState(disabled, diagnostic, anyLive) {
+    if (disabled)
+        return { state: 'disabled' };
+    if (diagnostic?.code === 'host-missing')
+        return { state: 'host-missing', reason: diagnostic.reason };
+    if (diagnostic?.code === 'seam-conflict')
+        return { state: 'conflict', reason: diagnostic.reason };
+    if (diagnostic?.code === 'mount-failed' || diagnostic?.code === 'unmount-failed') {
+        return { state: 'failed', reason: diagnostic.reason, retryable: true };
+    }
+    if (diagnostic !== undefined)
+        return { state: 'failed', reason: diagnostic.reason };
+    if (anyLive)
+        return { state: 'mounted' };
+    // A declaration with neither a diagnostic nor a live mount is mid-flight:
+    // the reconciler runs after the host finishes discovery, so the first
+    // panel reads during startup land here. Report `starting` — the panel
+    // polls while any row is starting — instead of the misleading
+    // host-missing verdict, which is reserved for an actual import failure.
+    return { state: 'starting' };
+}
+/** Build the status payload from declarations, direct configuration, and mount diagnostics. */
+export function buildLspStatus(suites, registry, direct = { servers: {}, errors: [] }) {
+    const diagnostics = registry.diagnosticsSnapshot();
+    const anyLive = registry.hasLiveMounts();
+    const entries = [];
+    const mountedSuiteIds = new Set();
+    for (const suite of suites) {
+        // Operational inventory, mirroring mcp-status: only installed+enabled
+        // suites' declarations appear. The diagnostic key is the qualified suite
+        // id, matching the mount registry's wanted key exactly.
+        if (suite.lsp === undefined || suite.installedAt === undefined || !suite.enabled)
+            continue;
+        const suiteKey = qualifiedSuiteId(suite.sourceId, suite.id);
+        const disabled = suite.activeSurfaces?.lsp === false;
+        const diagnostic = diagnostics.get(suiteKey);
+        const { state, reason, retryable } = deriveState(disabled, diagnostic, anyLive);
+        if (state === 'mounted')
+            mountedSuiteIds.add(suiteKey);
+        for (const spec of Object.values(suite.lsp.servers)) {
+            entries.push({
+                id: `${suiteKey}/${spec.key}`,
+                serverKey: spec.key,
+                suiteId: suiteKey,
+                suiteName: suite.manifest.name,
+                sourceId: suite.sourceId,
+                kind: 'plugin',
+                command: spec.command,
+                args: spec.args,
+                extensions: spec.extensionToLanguage,
+                state,
+                ...(reason === undefined ? {} : { reason }),
+                ...(retryable === undefined ? {} : { retryable })
+            });
+        }
+    }
+    // Direct user-configured rows: no install state or surface toggle of their
+    // own — configured means on; the mount diagnostic decides the state.
+    const directDiagnostic = diagnostics.get(DIRECT_LSP_SUITE_ID);
+    const { state: directState, reason: directReason, retryable: directRetryable } = deriveState(false, directDiagnostic, anyLive);
+    if (directState === 'mounted')
+        mountedSuiteIds.add(DIRECT_LSP_SUITE_ID);
+    for (const spec of Object.values(direct.servers)) {
+        entries.push({
+            id: `${DIRECT_LSP_SUITE_ID}/${spec.key}`,
+            serverKey: spec.key,
+            suiteId: DIRECT_LSP_SUITE_ID,
+            suiteName: spec.key,
+            sourceId: '',
+            kind: 'direct',
+            command: spec.command,
+            args: spec.args,
+            extensions: spec.extensionToLanguage,
+            state: directState,
+            ...(directReason === undefined ? {} : { reason: directReason }),
+            ...(directRetryable === undefined ? {} : { retryable: directRetryable })
+        });
+    }
+    const mounted = entries.filter(entry => entry.state === 'mounted').length;
+    const failed = entries.filter(entry => entry.state === 'failed').length;
+    const disabled = entries.filter(entry => entry.state === 'disabled').length;
+    const blocked = entries.filter(entry => entry.state === 'host-missing' || entry.state === 'conflict').length;
+    return {
+        entries,
+        observedAt: new Date().toISOString(),
+        totals: { all: entries.length, mounted, failed, blocked, disabled },
+        hostMissing: entries.length > 0 && mountedSuiteIds.size === 0 && entries.every(entry => entry.state === 'host-missing')
+    };
+}

package/lib/runtime/mcp-backend.js

@@ -0,0 +1,60 @@
+/**
+ * MCP backend selection: whether suite MCP servers mount through the
+ * market's self-built bridge (default — stdio, Streamable HTTP with OAuth,
+ * and legacy SSE) or through the host's `@deepseek-ai/dsh-mcp-client`
+ * (compatibility mode: no OAuth, no SSE, but the host-native implementation).
+ *
+ * The choice is a host settings namespace (`dsh-agent-plugins-market`,
+ * `mcpEnhanced: boolean`, default true) registered by the plugin's node half:
+ * the registration is what makes the host 插件配置 tab serve our card, the
+ * client card binds it for state, and the node half watches it to remount
+ * servers when the switch flips. `readMcpBackend` remains only as the
+ * one-time migration from the earlier data-root `settings.json` choice.
+ *
+ * @module runtime/mcp-backend
+ */
+import { readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import z from '@deepseek-ai/schemastery';
+export const MCP_BACKENDS = ['builtin', 'host'];
+/** Settings namespace this plugin registers; the key the plugin-config tab pairs our card by. */
+export const MCP_SETTINGS_NAMESPACE = 'dsh-agent-plugins-market';
+/** Schema of the market settings namespace: the MCP enhancement switch and the download region. */
+export const MarketSettingsSchema = z.object({
+    /** ON (default) = the built-in bridge with OAuth and SSE; OFF = host client compat mode. */
+    mcpEnhanced: z.boolean().default(true),
+    /** Download region for GitHub acquisition; `auto` follows the interface language. */
+    downloadRegion: z.union([z.const('auto'), z.const('global'), z.const('china')]).default('auto')
+});
+/** Path of the legacy persisted settings file under the plugin data root. */
+export function marketSettingsPath(dataRoot) {
+    return join(dataRoot, 'settings.json');
+}
+/** Read the legacy persisted backend; absent or invalid values read as the default. */
+export async function readMcpBackend(dataRoot) {
+    try {
+        const parsed = JSON.parse(await readFile(marketSettingsPath(dataRoot), 'utf8'));
+        return parsed.mcpBackend === 'host' ? 'host' : 'builtin';
+    }
+    catch {
+        return 'builtin';
+    }
+}
+/**
+ * Probe whether the host's `dsh-mcp-client` is resolvable from this plugin's
+ * module context, and at which version. Best effort: any failure reads as
+ * "unavailable", which the mount path surfaces as a per-server diagnostic
+ * when the host backend is selected.
+ */
+export async function probeHostMcpClient() {
+    try {
+        const require = createRequire(import.meta.url);
+        const manifestPath = require.resolve('@deepseek-ai/dsh-mcp-client/package.json');
+        const manifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+        return { available: true, ...(manifest.version === undefined ? {} : { version: manifest.version }) };
+    }
+    catch {
+        return { available: false };
+    }
+}

package/lib/runtime/mcp-client/bridge.js

@@ -0,0 +1,126 @@
+/**
+ * The market's self-built MCP client bridge plugin: connects to one external
+ * MCP server and registers its tools on the harness ToolRuntime under
+ * server-qualified public names (`mcp__<serverName>__<rawName>`). One plugin
+ * instance per server; the mount registry loads instances through
+ * `ctx.plugin` exactly like the host's own client, so reconcile, retry,
+ * rollback, and HMR semantics are unchanged.
+ *
+ * Namespace plugin (named exports, no default export). Lifecycle is
+ * effect-scoped: disposal disconnects from the server, unregisters all tools,
+ * and releases the `serverName` namespace reservation. HMR hot-swaps by
+ * disposing the old instance and creating a new one; identical `serverName`
+ * reproduces identical public tool names.
+ *
+ * This replaces the runtime dependency on the host's `dsh-mcp-client`
+ * package: stdio, Streamable HTTP (with OAuth 2.1), and legacy SSE all run
+ * inside this plugin from the market's own `@modelcontextprotocol/sdk`
+ * dependency.
+ *
+ * @module runtime/mcp-client/bridge
+ */
+import { resolveReconnectPolicy, startConnection } from './connection.js';
+import { validateConfig } from './config.js';
+/** Cordis plugin name used by loader diagnostics. */
+export const name = 'market-mcp-client';
+/** Services required by this plugin. */
+export const inject = ['tools'];
+/**
+ * Live `serverName` reservations per app, keyed off `ctx.root` (multiple apps
+ * in one process — tests — must not see each other's names). A duplicate
+ * namespace is a configuration error surfaced at plugin load, never silent
+ * shadowing. The mount registry deduplicates too; this is the last line of
+ * defense for direct programmatic loads.
+ */
+const activeServerNames = new WeakMap();
+/** Tolerantly read an optional service from the cordis context. */
+function optionalService(ctx, serviceName) {
+    try {
+        const reader = ctx;
+        const service = reader.get?.(serviceName);
+        // A missing service either reads as undefined or throws (cordis strict
+        // mode); both mean "not mounted".
+        return service === null ? undefined : service;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Adapt the cordis context onto the structural host the bridge modules use. */
+function toToolHost(ctx) {
+    const logger = {
+        error: (message) => {
+            ctx.logger?.error?.(message);
+        },
+        warn: (message) => {
+            ctx.logger?.warn?.(message);
+        },
+        info: (message) => {
+            ctx.logger?.info?.(message);
+        }
+    };
+    const registry = ctx;
+    return {
+        logger,
+        tools: {
+            register(definition) {
+                const register = registry.tools?.register;
+                if (typeof register !== 'function') {
+                    throw new Error('the host context does not expose a tool registry — the "tools" service is required');
+                }
+                return register.call(registry.tools, definition);
+            }
+        },
+        getService: serviceName => optionalService(ctx, serviceName)
+    };
+}
+/**
+ * Connect one MCP server and publish its initial tool generation before
+ * activation. Remains explicitly `async`: Cordis treats a prototype-bearing
+ * ordinary function as a constructor, whose returned Promise is not startup
+ * work.
+ * @param ctx - plugin context carrying the tool registry.
+ * @param config - resolved transport and server namespace configuration.
+ * @returns startup readiness after connection and initial tool discovery settle.
+ */
+export async function apply(ctx, config) {
+    // Fail loud at load: programmatic construction bypasses any schema layer,
+    // so every invariant is re-judged here before any effect registers.
+    validateConfig(config);
+    const reconnect = resolveReconnectPolicy(config.reconnect, `mcp-client(${config.serverName}): reconnect`);
+    // Reserve the namespace next: a duplicate `serverName` fails THIS instance
+    // at load with an actionable error and leaves the earlier instance intact.
+    ctx.effect(() => {
+        let names = activeServerNames.get(ctx.root);
+        if (!names) {
+            names = new Set();
+            activeServerNames.set(ctx.root, names);
+        }
+        if (names.has(config.serverName)) {
+            throw new Error(`market-mcp-client: serverName "${config.serverName}" is already in use by another bridge instance — pick a unique serverName`);
+        }
+        names.add(config.serverName);
+        return () => void names.delete(config.serverName);
+    }, 'market-mcp-client.serverName');
+    // The supervisor owns the client/transport generations, the reconnect
+    // loop, and the live tool registrations; disposal stops reconnection,
+    // quiesces in-flight work, and unregisters the current generation.
+    // Optional service: the credential store receives OAuth tokens when
+    // mounted; absence (no credentials plugin) is the supported
+    // no-persistence configuration.
+    const host = toToolHost(ctx);
+    const credentials = optionalService(ctx, 'credentials');
+    const connection = startConnection(host, config, reconnect, credentials);
+    ctx.effect(() => {
+        return () => connection.dispose();
+    }, 'market-mcp-client.connection');
+    // Block plugin activation on the initial connection + tool discovery so
+    // Cordis consumers observe the tools immediately after the fiber activates.
+    // When failOnStartupError is true, a failed initial attempt rejects the
+    // fiber (Cordis rolls it back); otherwise the error is logged and the
+    // supervisor enters its reconnect loop.
+    const outcome = await connection.ready;
+    if (outcome.error !== undefined && config.failOnStartupError) {
+        throw new Error(`mcp-client(${config.serverName}): initial connection or tool synchronization failed`, { cause: outcome.error });
+    }
+}

package/lib/runtime/mcp-client/config.js

@@ -0,0 +1,42 @@
+/**
+ * Configuration types for the market's self-built MCP client bridge. One
+ * bridge instance connects to one MCP server; mounts are built
+ * programmatically by `mcp-config.ts`, so there is no Schemastery schema —
+ * every field the supervisor relies on is re-judged at load
+ * (`resolveReconnectPolicy`, serverName pattern) and misconfiguration fails
+ * that instance loudly instead of being normalized silently.
+ *
+ * @module runtime/mcp-client/config
+ */
+export { RECONNECT_DEFAULTS } from './connection.js';
+/** Default timeout for individual MCP tool calls (ms). */
+export const DEFAULT_TOOL_CALL_TIMEOUT_MS = 60_000;
+/** Valid `serverName`, kept below the public tool-name budget. */
+export const SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]{1,32}$/;
+/**
+ * Validate one programmatically-built config. Programmatic construction
+ * bypasses any schema layer, so every invariant the bridge relies on is
+ * re-judged here — a misconfiguration rejects the mount with an actionable
+ * error before any connection is attempted.
+ * @param config - raw bridge config built by `mcp-config.ts`.
+ * @returns the same config, narrowed to the validated shape.
+ */
+export function validateConfig(config) {
+    const fields = config;
+    if (!SERVER_NAME_PATTERN.test(config.serverName)) {
+        throw new Error(`bridge config serverName "${config.serverName}" must match ${String(SERVER_NAME_PATTERN)}`);
+    }
+    if (!Number.isFinite(fields.toolCallTimeoutMs) || fields.toolCallTimeoutMs <= 0) {
+        throw new Error(`bridge config toolCallTimeoutMs must be a positive finite number`);
+    }
+    if (typeof fields.failOnStartupError !== 'boolean') {
+        throw new Error('bridge config failOnStartupError must be a boolean');
+    }
+    if (config.transport === 'stdio' && (typeof config.command !== 'string' || config.command === '')) {
+        throw new Error('bridge stdio config requires a command');
+    }
+    if (config.transport !== 'stdio' && (typeof config.url !== 'string' || config.url === '')) {
+        throw new Error(`bridge ${config.transport} config requires a url`);
+    }
+    return config;
+}