@synthaer/resonance 0.1.0

package/dist/mcp-server.js

@@ -0,0 +1,722 @@
+import { Router } from 'express';
+import { ExperienceKind, KnowledgeKind } from './types.js';
+import { initializePKI, signContent, requestCertificateSigning } from './pki.js';
+// ---------------------------------------------------------------------------
+// PKI state — initialized once on server start, shared across requests
+// ---------------------------------------------------------------------------
+let pkiIdentity = null;
+let pkiInitPromise = null;
+let pkiConfig = null;
+export function getPkiIdentity() {
+    return pkiIdentity;
+}
+export function isPkiReady() {
+    return pkiIdentity !== null && pkiIdentity.certificate !== null;
+}
+/**
+ * Initialize PKI. Called once on server start. If a signed certificate is
+ * not yet available, the identity is created but writes that require signing
+ * will be blocked until the certificate is obtained.
+ */
+export async function initializeServerPKI(config) {
+    pkiConfig = config;
+    pkiIdentity = await initializePKI(config);
+    return pkiIdentity;
+}
+/**
+ * Request certificate signing from cloud PKI and update the local identity.
+ */
+export async function requestServerCertSigning(authToken) {
+    if (!pkiIdentity || !pkiConfig) {
+        throw new Error('PKI not initialized. Call initializeServerPKI first.');
+    }
+    await requestCertificateSigning(pkiIdentity.csr, authToken, pkiConfig.cloudPkiUrl, pkiConfig.dataDir);
+    // Re-initialize to pick up the new cert
+    pkiIdentity = await initializePKI(pkiConfig);
+    return pkiIdentity;
+}
+/**
+ * Sign content using the local identity for ratification.
+ */
+export function signContentWithLocalIdentity(content) {
+    if (!pkiIdentity || !pkiIdentity.fingerprint) {
+        return null;
+    }
+    return signContent(content, pkiIdentity.privateKey, pkiIdentity.fingerprint);
+}
+const DIKW_STAGES = ['nascent', 'emerging', 'established', 'canonical'];
+const MCP_PROTOCOL_VERSION = '2024-11-05';
+const DEFAULT_LIMITS = {
+    edition: 'local',
+    maxProjects: 0,
+    maxConcurrentFleet: 0,
+    recallWindowSize: 0,
+    allowedDikwStages: DIKW_STAGES,
+    allowMassImport: true,
+    allowFleetKnowledge: true,
+    allowFullPromotion: true,
+};
+class ToolParamError extends Error {
+    code = -32602;
+    data;
+    constructor(message, data) {
+        super(message);
+        this.name = 'ToolParamError';
+        this.data = data;
+    }
+}
+const MCP_TOOLS = [
+    {
+        name: 'store_knowledge',
+        description: 'Store a knowledge item in local Resonance memory.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string' },
+                kind: { type: ['number', 'string'] },
+                tags: { type: 'array', items: { type: 'string' } },
+                projectId: { type: 'string' },
+                dikwStage: { type: 'string', enum: DIKW_STAGES },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'recall_knowledge',
+        description: 'Keyword search across stored knowledge.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                limit: { type: 'number' },
+                minStrength: { type: 'number' },
+                projectId: { type: 'string' },
+                tags: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'get_knowledge',
+        description: 'Fetch a single knowledge item by id.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'promote_knowledge',
+        description: 'Promote a knowledge item to a higher DIKW stage.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                toStage: { type: 'string', enum: DIKW_STAGES },
+                reason: { type: 'string' },
+            },
+            required: ['id', 'toStage', 'reason'],
+        },
+    },
+    {
+        name: 'store_experience',
+        description: 'Store an agent experience record.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string' },
+                kind: { type: ['number', 'string'] },
+                agentId: { type: 'string' },
+                sessionId: { type: 'string' },
+                projectId: { type: 'string' },
+                relatedKnowledgeIds: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['content'],
+        },
+    },
+    {
+        name: 'recall_experiences',
+        description: 'Keyword search across stored experiences.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                limit: { type: 'number' },
+                projectId: { type: 'string' },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'semantic_search',
+        description: 'Hybrid semantic search across knowledge + experiences.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                limit: { type: 'number' },
+                minStrength: { type: 'number' },
+                projectId: { type: 'string' },
+                tags: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['query'],
+        },
+    },
+    {
+        name: 'session_resume',
+        description: 'Resume or create session memory for agent/project.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                projectId: { type: 'string' },
+            },
+            required: ['agentId', 'projectId'],
+        },
+    },
+    {
+        name: 'memory_append',
+        description: 'Append a memory item to an active session.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string' },
+                role: { type: 'string', enum: ['system', 'user', 'assistant'] },
+                content: { type: 'string' },
+                timestamp: { type: 'string' },
+            },
+            required: ['sessionId', 'role', 'content'],
+        },
+    },
+    {
+        name: 'memory_checkpoint',
+        description: 'Persist a checkpoint for a session memory thread.',
+        inputSchema: {
+            type: 'object',
+            properties: { sessionId: { type: 'string' } },
+            required: ['sessionId'],
+        },
+    },
+    {
+        name: 'update_experience',
+        description: 'Update an existing experience record.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                content: { type: 'string' },
+                kind: { type: ['number', 'string'] },
+                agentId: { type: 'string' },
+                sessionId: { type: 'string' },
+                projectId: { type: 'string' },
+                relatedKnowledgeIds: { type: 'array', items: { type: 'string' } },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'delete_experience',
+        description: 'Delete an experience record by id.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'get_experience',
+        description: 'Fetch a single experience record by id.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'update_knowledge',
+        description: 'Update an existing knowledge item.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                content: { type: 'string' },
+                kind: { type: ['number', 'string'] },
+                tags: { type: 'array', items: { type: 'string' } },
+                projectId: { type: 'string' },
+                dikwStage: { type: 'string', enum: DIKW_STAGES },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'delete_knowledge',
+        description: 'Delete a knowledge item by id.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'health',
+        description: 'Return local MCP health and knowledge counts.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+];
+function resolveLimits(limits) {
+    return {
+        ...DEFAULT_LIMITS,
+        ...limits,
+        allowedDikwStages: limits?.allowedDikwStages ?? DEFAULT_LIMITS.allowedDikwStages,
+    };
+}
+function clampDikwStage(stage, limits) {
+    if (limits.allowedDikwStages.includes(stage)) {
+        return stage;
+    }
+    return limits.allowedDikwStages.at(-1) ?? 'nascent';
+}
+function asRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}
+function asString(value, field) {
+    if (typeof value === 'string' && value.trim().length > 0)
+        return value.trim();
+    throw new ToolParamError(`'${field}' must be a non-empty string`);
+}
+function asOptionalString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asOptionalNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+        .map((entry) => entry.trim());
+}
+function parseKnowledgeKind(value) {
+    if (typeof value === 'number' && value >= 1 && value <= 5)
+        return value;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'fact')
+            return KnowledgeKind.Fact;
+        if (normalized === 'pattern')
+            return KnowledgeKind.Pattern;
+        if (normalized === 'error')
+            return KnowledgeKind.Error;
+        if (normalized === 'decision')
+            return KnowledgeKind.Decision;
+        if (normalized === 'principle')
+            return KnowledgeKind.Principle;
+    }
+    return KnowledgeKind.Fact;
+}
+function parseExperienceKind(value) {
+    if (typeof value === 'number' && value >= 1 && value <= 4)
+        return value;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === 'success')
+            return ExperienceKind.Success;
+        if (normalized === 'failure')
+            return ExperienceKind.Failure;
+        if (normalized === 'discovery')
+            return ExperienceKind.Discovery;
+        if (normalized === 'blocker')
+            return ExperienceKind.Blocker;
+    }
+    return ExperienceKind.Discovery;
+}
+function parseDikwStage(value) {
+    if (typeof value !== 'string')
+        return 'nascent';
+    const normalized = value.trim().toLowerCase();
+    if (DIKW_STAGES.includes(normalized))
+        return normalized;
+    return 'nascent';
+}
+function toMcpResult(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload) }],
+    };
+}
+function jsonRpcError(id, code, message, data) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        error: { code, message, data },
+    };
+}
+function jsonRpcSuccess(id, result) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        result,
+    };
+}
+function extractUserId(req) {
+    const authHeader = req.headers.authorization;
+    if (authHeader?.startsWith('Bearer ')) {
+        try {
+            const token = authHeader.slice(7);
+            const payloadB64 = token.split('.')[1];
+            if (payloadB64) {
+                const payload = JSON.parse(Buffer.from(payloadB64, 'base64url').toString());
+                if (typeof payload.sub === 'string' && payload.sub.length > 0) {
+                    return payload.sub;
+                }
+            }
+        }
+        catch {
+            // Fall through to other methods.
+        }
+    }
+    const headerUserId = req.headers['x-user-id'];
+    if (typeof headerUserId === 'string' && headerUserId.trim().length > 0) {
+        return headerUserId.trim();
+    }
+    const queryUserId = req.query['userId'];
+    if (typeof queryUserId === 'string' && queryUserId.trim().length > 0) {
+        return queryUserId.trim();
+    }
+    return 'system';
+}
+function buildToolHandlers(localResonance, limits) {
+    return {
+        async store_knowledge(args) {
+            if (!localResonance.knowledgeEnabled) {
+                throw new ToolParamError('Sign in to Synthaer to access your knowledge base. Local experiences are always available.');
+            }
+            const content = asString(args.content, 'content');
+            const requestedStage = parseDikwStage(args.dikwStage);
+            const clampedStage = clampDikwStage(requestedStage, limits);
+            const id = await localResonance.storeKnowledge({
+                content,
+                kind: parseKnowledgeKind(args.kind),
+                dikwStage: clampedStage,
+                strength: asOptionalNumber(args.strength) ?? 0.5,
+                tags: asStringArray(args.tags),
+                sourceCount: asOptionalNumber(args.sourceCount) ?? 1,
+                contextCount: asOptionalNumber(args.contextCount) ?? 1,
+                projectId: asOptionalString(args.projectId),
+                decayRate: asOptionalNumber(args.decayRate) ?? 0.01,
+            });
+            const item = await localResonance.getKnowledge(id);
+            return { id, item, edition: limits.edition, stageClamped: requestedStage !== clampedStage };
+        },
+        async recall_knowledge(args) {
+            if (!localResonance.knowledgeEnabled) {
+                throw new ToolParamError('Sign in to Synthaer to access your knowledge base. Local experiences are always available.');
+            }
+            const query = asString(args.query, 'query');
+            const requestedLimit = asOptionalNumber(args.limit);
+            const maxLimit = limits.recallWindowSize > 0
+                ? Math.min(requestedLimit ?? 20, limits.recallWindowSize)
+                : requestedLimit;
+            const options = {
+                limit: maxLimit,
+                minStrength: asOptionalNumber(args.minStrength),
+                projectId: asOptionalString(args.projectId),
+                tags: asStringArray(args.tags),
+            };
+            const items = await localResonance.recallKnowledge(query, options);
+            return { total: items.length, items, recallWindowSize: limits.recallWindowSize };
+        },
+        async get_knowledge(args) {
+            if (!localResonance.knowledgeEnabled) {
+                throw new ToolParamError('Sign in to Synthaer to access your knowledge base. Local experiences are always available.');
+            }
+            const id = asString(args.id, 'id');
+            const item = await localResonance.getKnowledge(id);
+            return { found: Boolean(item), item };
+        },
+        async promote_knowledge(args) {
+            if (!localResonance.knowledgeEnabled) {
+                throw new ToolParamError('Sign in to Synthaer to access your knowledge base. Local experiences are always available.');
+            }
+            const id = asString(args.id, 'id');
+            const requestedStage = parseDikwStage(args.toStage);
+            const clampedStage = clampDikwStage(requestedStage, limits);
+            if (!limits.allowFullPromotion && requestedStage !== clampedStage) {
+                throw new ToolParamError(`Stage '${requestedStage}' is not available in ${limits.edition} edition. ` +
+                    `Allowed stages: ${limits.allowedDikwStages.join(', ')}. Upgrade to unlock full DIKW.`);
+            }
+            const reason = asString(args.reason, 'reason');
+            await localResonance.promoteKnowledge(id, clampedStage, reason);
+            const item = await localResonance.getKnowledge(id);
+            return { id, item };
+        },
+        async store_experience(args) {
+            const content = asString(args.content, 'content');
+            const id = await localResonance.storeExperience({
+                content,
+                kind: parseExperienceKind(args.kind),
+                agentId: asOptionalString(args.agentId),
+                sessionId: asOptionalString(args.sessionId),
+                projectId: asOptionalString(args.projectId),
+                relatedKnowledgeIds: asStringArray(args.relatedKnowledgeIds),
+            });
+            const item = await localResonance.store.getExperience(id);
+            return { id, item };
+        },
+        async recall_experiences(args) {
+            const query = asString(args.query, 'query');
+            const options = {
+                limit: asOptionalNumber(args.limit),
+                projectId: asOptionalString(args.projectId),
+            };
+            const items = await localResonance.recallExperiences(query, options);
+            return { total: items.length, items };
+        },
+        async semantic_search(args) {
+            const query = asString(args.query, 'query');
+            const options = {
+                limit: asOptionalNumber(args.limit),
+                minStrength: asOptionalNumber(args.minStrength),
+                projectId: asOptionalString(args.projectId),
+                tags: asStringArray(args.tags),
+            };
+            const results = await localResonance.semanticSearch(query, options);
+            return { total: results.length, results };
+        },
+        async session_resume(args) {
+            const agentId = asString(args.agentId, 'agentId');
+            const projectId = asString(args.projectId, 'projectId');
+            const session = await localResonance.sessionResume(agentId, projectId);
+            return { session };
+        },
+        async memory_append(args) {
+            const sessionId = asString(args.sessionId, 'sessionId');
+            const roleValue = asString(args.role, 'role');
+            if (roleValue !== 'system' && roleValue !== 'user' && roleValue !== 'assistant') {
+                throw new ToolParamError("'role' must be one of: system, user, assistant");
+            }
+            const memoryItem = {
+                role: roleValue,
+                content: asString(args.content, 'content'),
+                timestamp: asOptionalString(args.timestamp) ?? new Date().toISOString(),
+            };
+            await localResonance.memoryAppend(sessionId, memoryItem);
+            return { ok: true };
+        },
+        async memory_checkpoint(args) {
+            const sessionId = asString(args.sessionId, 'sessionId');
+            await localResonance.memoryCheckpoint(sessionId);
+            return { ok: true };
+        },
+        async update_experience(args) {
+            const id = asString(args.id, 'id');
+            const updates = {};
+            if (args.content !== undefined)
+                updates.content = asString(args.content, 'content');
+            if (args.kind !== undefined)
+                updates.kind = parseExperienceKind(args.kind);
+            if (args.agentId !== undefined)
+                updates.agentId = asOptionalString(args.agentId);
+            if (args.sessionId !== undefined)
+                updates.sessionId = asOptionalString(args.sessionId);
+            if (args.projectId !== undefined)
+                updates.projectId = asOptionalString(args.projectId);
+            if (args.relatedKnowledgeIds !== undefined)
+                updates.relatedKnowledgeIds = asStringArray(args.relatedKnowledgeIds);
+            await localResonance.updateExperience(id, updates);
+            const item = await localResonance.store.getExperience(id);
+            return { id, item };
+        },
+        async delete_experience(args) {
+            const id = asString(args.id, 'id');
+            await localResonance.deleteExperience(id);
+            return { id, deleted: true };
+        },
+        async get_experience(args) {
+            const id = asString(args.id, 'id');
+            const item = await localResonance.store.getExperience(id);
+            return { found: Boolean(item), item };
+        },
+        async update_knowledge(args) {
+            if (!localResonance.knowledgeEnabled) {
+                throw new ToolParamError('Sign in to Synthaer to access your knowledge base. Local experiences are always available.');
+            }
+            const id = asString(args.id, 'id');
+            const updates = {};
+            if (args.content !== undefined)
+                updates.content = asString(args.content, 'content');
+            if (args.kind !== undefined)
+                updates.kind = parseKnowledgeKind(args.kind);
+            if (args.tags !== undefined)
+                updates.tags = asStringArray(args.tags);
+            if (args.projectId !== undefined)
+                updates.projectId = asOptionalString(args.projectId);
+            if (args.dikwStage !== undefined) {
+                const requestedStage = parseDikwStage(args.dikwStage);
+                updates.dikwStage = clampDikwStage(requestedStage, limits);
+            }
+            await localResonance.store.updateKnowledge(id, updates);
+            const item = await localResonance.getKnowledge(id);
+            return { id, item };
+        },
+        async delete_knowledge(args) {
+            if (!localResonance.knowledgeEnabled) {
+                throw new ToolParamError('Sign in to Synthaer to access your knowledge base. Local experiences are always available.');
+            }
+            const id = asString(args.id, 'id');
+            await localResonance.store.deleteKnowledge(id);
+            return { id, deleted: true };
+        },
+        async health() {
+            let knowledgeCount = 0;
+            let experienceCount = 0;
+            try {
+                const knowledge = await localResonance.store.getAllKnowledge();
+                knowledgeCount = knowledge.length;
+            }
+            catch {
+                // Knowledge may be unavailable without auth
+            }
+            try {
+                const experiences = await localResonance.store.getAllExperiences();
+                experienceCount = experiences.length;
+            }
+            catch {
+                // Shouldn't fail, but be safe
+            }
+            return {
+                status: 'ok',
+                edition: limits.edition,
+                tools: MCP_TOOLS.length,
+                knowledgeEnabled: localResonance.knowledgeEnabled,
+                counts: {
+                    knowledge: knowledgeCount,
+                    experiences: experienceCount,
+                    knowledgeLimit: 200,
+                },
+                limits: {
+                    maxProjects: limits.maxProjects,
+                    maxConcurrentFleet: limits.maxConcurrentFleet,
+                    recallWindowSize: limits.recallWindowSize,
+                    allowedDikwStages: limits.allowedDikwStages,
+                    allowMassImport: limits.allowMassImport,
+                    allowFleetKnowledge: limits.allowFleetKnowledge,
+                },
+                pki: {
+                    initialized: pkiIdentity !== null,
+                    hasCertificate: isPkiReady(),
+                    machineId: pkiIdentity?.machineId ?? null,
+                    fingerprint: pkiIdentity?.fingerprint ?? null,
+                    expiresAt: pkiIdentity?.expiresAt?.toISOString() ?? null,
+                },
+            };
+        },
+    };
+}
+export function createLocalMcpRuntime(localResonance, limits) {
+    const resolvedLimits = resolveLimits(limits);
+    const handlers = buildToolHandlers(localResonance, resolvedLimits);
+    return {
+        listTools: () => MCP_TOOLS,
+        async callTool(name, args = {}) {
+            const handler = handlers[name];
+            if (!handler) {
+                throw new ToolParamError(`Tool not found: ${name}`);
+            }
+            return handler(args);
+        },
+    };
+}
+export function createResonanceMcpRouter(localResonance, options) {
+    const router = Router();
+    const limits = resolveLimits(options?.limits);
+    const serverName = options?.serverName ?? 'resonance-local-mcp';
+    const runtime = createLocalMcpRuntime(localResonance, limits);
+    // Initialize PKI in the background if config is provided
+    if (options?.pkiConfig && !pkiInitPromise) {
+        pkiInitPromise = initializeServerPKI(options.pkiConfig).catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`[resonance-local] PKI initialization failed: ${message}`);
+            return null;
+        });
+    }
+    router.get('/', (_req, res) => {
+        res.json({
+            name: serverName,
+            edition: limits.edition,
+            transport: 'json-rpc-http',
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            endpoint: '/mcp',
+            tools: MCP_TOOLS.length,
+        });
+    });
+    router.get('/tools', (_req, res) => {
+        res.json({ tools: MCP_TOOLS });
+    });
+    router.post('/', async (req, res) => {
+        const body = req.body;
+        const id = body?.id ?? null;
+        const userId = extractUserId(req);
+        res.setHeader('x-resonance-user-id', userId);
+        if (!body || typeof body !== 'object') {
+            res.status(400).json(jsonRpcError(id, -32600, 'Invalid JSON-RPC request body'));
+            return;
+        }
+        if (body.jsonrpc !== '2.0' || typeof body.method !== 'string') {
+            res.status(400).json(jsonRpcError(id, -32600, 'Invalid JSON-RPC envelope'));
+            return;
+        }
+        try {
+            if (body.method === 'initialize') {
+                res.json(jsonRpcSuccess(id, {
+                    protocolVersion: MCP_PROTOCOL_VERSION,
+                    serverInfo: {
+                        name: serverName,
+                        version: '0.1.0',
+                    },
+                    capabilities: {
+                        tools: {
+                            listChanged: false,
+                        },
+                    },
+                }));
+                return;
+            }
+            if (body.method === 'ping') {
+                res.json(jsonRpcSuccess(id, { ok: true }));
+                return;
+            }
+            if (body.method === 'tools/list') {
+                res.json(jsonRpcSuccess(id, { tools: runtime.listTools() }));
+                return;
+            }
+            if (body.method !== 'tools/call') {
+                res.status(404).json(jsonRpcError(id, -32601, `Method not found: ${body.method}`));
+                return;
+            }
+            const scopedResonance = localResonance.forUser(userId);
+            const scopedRuntime = createLocalMcpRuntime(scopedResonance, limits);
+            const params = asRecord(body.params);
+            const name = asString(params.name, 'name');
+            const args = asRecord(params.arguments);
+            const payload = await scopedRuntime.callTool(name, args);
+            res.json(jsonRpcSuccess(id, toMcpResult(payload)));
+        }
+        catch (err) {
+            if (err instanceof ToolParamError) {
+                res.status(422).json(jsonRpcError(id, err.code, err.message, err.data));
+                return;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            res.status(500).json(jsonRpcError(id, -32000, message));
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=mcp-server.js.map