@nogataka/smart-edit 0.0.14

package/dist/serena/mcp.js

@@ -0,0 +1,904 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ErrorCode, McpError, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { URL as NodeURL } from 'node:url';
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { DEFAULT_CONTEXT, DEFAULT_MODES } from './constants.js';
+import { SerenaAgentContext, SerenaAgentMode } from './config/context_mode.js';
+import { SerenaConfig } from './config/serena_config.js';
+import { createRequire } from 'node:module';
+import { showFatalExceptionSafe } from './util/exception.js';
+import { createSerenaLogger } from './util/logging.js';
+import { SerenaAgent } from './agent.js';
+const require = createRequire(import.meta.url);
+const packageJson = require('../../package.json');
+const { logger: log } = createSerenaLogger({ name: 'serena.mcp' });
+function unwrapZodObject(schema) {
+    if (!schema) {
+        return undefined;
+    }
+    if (schema instanceof z.ZodObject) {
+        return schema;
+    }
+    if (schema instanceof z.ZodEffects) {
+        const inner = schema._def.schema;
+        return unwrapZodObject(inner);
+    }
+    if (schema instanceof z.ZodDefault) {
+        const inner = schema._def.innerType;
+        return unwrapZodObject(inner);
+    }
+    if (schema instanceof z.ZodNullable || schema instanceof z.ZodOptional) {
+        const base = schema.unwrap();
+        return unwrapZodObject(base);
+    }
+    return undefined;
+}
+function toZodRawShape(schema) {
+    const objectSchema = unwrapZodObject(schema);
+    if (!objectSchema) {
+        return undefined;
+    }
+    return objectSchema.shape;
+}
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function deepCloneJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => deepCloneJsonValue(item));
+    }
+    if (isJsonObject(value)) {
+        const clone = {};
+        for (const [key, child] of Object.entries(value)) {
+            clone[key] = child === undefined ? undefined : deepCloneJsonValue(child);
+        }
+        return clone;
+    }
+    return value;
+}
+function cloneJsonSchema(schema) {
+    const structured = globalThis.structuredClone;
+    if (typeof structured === 'function') {
+        return structured(schema);
+    }
+    return deepCloneJsonValue(schema);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function sanitizeJsonSchemaForOpenAi(schema) {
+    const cloned = cloneJsonSchema(schema);
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            return node.map((item) => walk(item));
+        }
+        if (isJsonObject(node)) {
+            const record = node;
+            const typeValue = record['type'];
+            if (typeof typeValue === 'string') {
+                if (typeValue === 'integer') {
+                    record['type'] = 'number';
+                    if (record['multipleOf'] === undefined) {
+                        record['multipleOf'] = 1;
+                    }
+                }
+            }
+            else if (Array.isArray(typeValue)) {
+                const stringEntries = typeValue.filter((entry) => typeof entry === 'string');
+                const filteredStrings = stringEntries
+                    .map((entry) => (entry === 'integer' ? 'number' : entry))
+                    .filter((entry) => entry !== 'null');
+                if (filteredStrings.length === 0) {
+                    record['type'] = 'object';
+                }
+                else if (filteredStrings.length === 1) {
+                    record['type'] = filteredStrings[0];
+                }
+                else {
+                    record['type'] = filteredStrings;
+                }
+                if (stringEntries.includes('integer') || filteredStrings.includes('number')) {
+                    record['multipleOf'] = record['multipleOf'] ?? 1;
+                }
+            }
+            const enumValue = record['enum'];
+            if (Array.isArray(enumValue)) {
+                const values = enumValue;
+                if (values.length > 0 && values.every((value) => typeof value === 'number' && Number.isInteger(value))) {
+                    record['type'] = record['type'] ?? 'number';
+                    record['multipleOf'] = record['multipleOf'] ?? 1;
+                }
+            }
+            for (const key of ['oneOf', 'anyOf']) {
+                const value = record[key];
+                if (Array.isArray(value)) {
+                    const sanitized = value.map((entry) => walk(entry));
+                    if (sanitized.length === 2) {
+                        const types = sanitized.map((entry) => (isJsonObject(entry) ? entry['type'] : undefined));
+                        if (types.includes('null')) {
+                            const nonNullIndex = types.findIndex((type) => type !== 'null');
+                            const nonNull = nonNullIndex >= 0 ? sanitized[nonNullIndex] : undefined;
+                            if (isJsonObject(nonNull)) {
+                                Object.assign(record, nonNull);
+                                delete record[key];
+                                continue;
+                            }
+                        }
+                    }
+                    try {
+                        const serialized = sanitized.map((entry) => JSON.stringify(entry));
+                        const unique = new Set(serialized);
+                        if (unique.size === 1) {
+                            const only = sanitized[0];
+                            if (isJsonObject(only)) {
+                                Object.assign(record, only);
+                                delete record[key];
+                                continue;
+                            }
+                        }
+                    }
+                    catch {
+                        // Keep original structure if serialization fails.
+                    }
+                    record[key] = sanitized;
+                }
+            }
+            for (const [key, value] of Object.entries(record)) {
+                if (value === undefined) {
+                    continue;
+                }
+                if (Array.isArray(value) || isJsonObject(value)) {
+                    record[key] = walk(value);
+                }
+            }
+            return record;
+        }
+        return node;
+    };
+    return walk(cloned);
+}
+function maybeCreateJsonSchema(schema, options) {
+    const objectSchema = unwrapZodObject(schema);
+    if (!objectSchema) {
+        return undefined;
+    }
+    const jsonSchema = zodToJsonSchema(objectSchema, {
+        name: options.name,
+        target: 'jsonSchema7',
+        $refStrategy: 'none'
+    });
+    if (!jsonSchema || typeof jsonSchema !== 'object') {
+        return undefined;
+    }
+    if (options.sanitizeForOpenAiTools) {
+        return sanitizeJsonSchemaForOpenAi(jsonSchema);
+    }
+    return jsonSchema;
+}
+function createDefaultServerInfo() {
+    const version = typeof packageJson.version === 'string' ? packageJson.version : '0.0.0';
+    return {
+        name: 'FastMCP',
+        version
+    };
+}
+/*
+ * NOTE: The MCP SDK currently ships without fully typed ESM re-exports, which
+ * causes TypeScript to treat several helper methods as `any`. We perform
+ * runtime guards before calling into the SDK and suppress the lint warnings
+ * locally to avoid scattering disable directives at call sites.
+ */
+function registerToolWithServer(server, options) {
+    const toolMethod = server.tool.bind(server);
+    const registered = options.annotations && Object.keys(options.annotations).length > 0
+        ? toolMethod(options.name, options.description, options.inputSchema, options.annotations, options.callback)
+        : toolMethod(options.name, options.description, options.inputSchema, options.callback);
+    if (options.outputSchema) {
+        registered.update({ outputSchema: options.outputSchema });
+    }
+    const serverWithTracking = server;
+    serverWithTracking.__serenaRegisteredTools ??= new Map();
+    const annotations = options.annotations && Object.keys(options.annotations).length > 0 ? options.annotations : undefined;
+    serverWithTracking.__serenaRegisteredTools.set(options.name, {
+        description: options.description,
+        annotations,
+        _meta: undefined,
+        callback: options.callback
+    });
+    return registered;
+}
+export class SerenaMCPFactory {
+    context;
+    project;
+    agent = null;
+    requestContext = null;
+    constructor(context = DEFAULT_CONTEXT, project = null) {
+        this.context = SerenaAgentContext.load(context);
+        this.project = project ?? null;
+    }
+    getAgent() {
+        if (!this.agent) {
+            throw new Error('Serena agent has not been instantiated yet.');
+        }
+        return this.agent;
+    }
+    setAgent(agent) {
+        this.agent = agent;
+        this.requestContext = { agent };
+    }
+    getRequestContext() {
+        if (!this.requestContext) {
+            throw new Error('Request context not initialized.');
+        }
+        return this.requestContext;
+    }
+    isOpenAiCompatibleContext() {
+        return ['chatgpt', 'codex', 'oaicompat-agent'].includes(this.context.name);
+    }
+    registerDefaultCapabilities(mcpServer) {
+        const server = mcpServer.server;
+        server.registerCapabilities({
+            experimental: {},
+            prompts: {
+                listChanged: false
+            },
+            resources: {
+                subscribe: false,
+                listChanged: false
+            }
+        });
+        const agent = this.getAgent();
+        const promptFactory = agent.promptFactory;
+        const memoriesManager = agent.memoriesManager;
+        server.setRequestHandler(ListPromptsRequestSchema, () => ({
+            prompts: this.buildPromptMetadata(promptFactory)
+        }));
+        server.setRequestHandler(GetPromptRequestSchema, (request) => this.buildPromptResult(promptFactory, request.params.name, request.params.arguments ?? {}));
+        server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+            resources: await this.buildResourceList(memoriesManager)
+        }));
+        server.setRequestHandler(ListResourceTemplatesRequestSchema, () => ({
+            resourceTemplates: this.buildResourceTemplates(memoriesManager)
+        }));
+        server.setRequestHandler(ReadResourceRequestSchema, async (request) => this.readResource(memoriesManager, request.params.uri));
+    }
+    buildPromptMetadata(promptFactory) {
+        const names = promptFactory.listPromptTemplateNames();
+        return names.map((name) => {
+            const params = promptFactory.getPromptTemplateParameters(name);
+            return {
+                name,
+                description: this.describePromptTemplate(name),
+                arguments: params.length === 0
+                    ? undefined
+                    : params.map((param) => ({
+                        name: param,
+                        required: true
+                    }))
+            };
+        });
+    }
+    buildPromptResult(promptFactory, promptName, rawArgs) {
+        if (!promptFactory.hasPromptTemplate(promptName)) {
+            throw new McpError(ErrorCode.InvalidParams, `Prompt ${promptName} not found`);
+        }
+        const requiredParams = promptFactory.getPromptTemplateParameters(promptName);
+        const missingParams = requiredParams.filter((param) => !(param in rawArgs));
+        if (missingParams.length > 0) {
+            throw new McpError(ErrorCode.InvalidParams, `Missing required arguments for prompt ${promptName}: ${missingParams.join(', ')}`);
+        }
+        const rendered = promptFactory.renderPrompt(promptName, rawArgs);
+        return {
+            description: this.describePromptTemplate(promptName),
+            messages: [
+                {
+                    role: 'assistant',
+                    content: [
+                        {
+                            type: 'text',
+                            text: rendered
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+    describePromptTemplate(name) {
+        const readable = name.replace(/[_-]+/g, ' ').replace(/\s+/g, ' ').trim();
+        if (!readable) {
+            return undefined;
+        }
+        return readable.charAt(0).toUpperCase() + readable.slice(1);
+    }
+    async buildResourceList(manager) {
+        if (!manager) {
+            return [];
+        }
+        const names = await this.listMemories(manager);
+        return names.map((name) => ({
+            uri: this.formatMemoryUri(name),
+            name,
+            description: 'Serena project memory entry',
+            mimeType: 'text/markdown'
+        }));
+    }
+    buildResourceTemplates(manager) {
+        if (!manager) {
+            return [];
+        }
+        return [
+            {
+                name: 'serena-memory',
+                uriTemplate: 'serena://memory/{name}',
+                description: 'Template for accessing Serena project memory entries',
+                mimeType: 'text/markdown'
+            }
+        ];
+    }
+    async readResource(manager, uri) {
+        const memoryName = this.parseMemoryUri(uri);
+        if (!memoryName) {
+            throw new McpError(ErrorCode.InvalidParams, `Unsupported resource URI: ${uri}`);
+        }
+        if (!manager) {
+            throw new McpError(ErrorCode.InvalidParams, 'Memory store is unavailable');
+        }
+        const content = await this.loadMemory(manager, memoryName);
+        return {
+            contents: [
+                {
+                    type: 'text',
+                    text: content,
+                    mimeType: 'text/markdown'
+                }
+            ]
+        };
+    }
+    parseMemoryUri(uri) {
+        if (!uri.toLowerCase().startsWith('serena://memory/')) {
+            return null;
+        }
+        const suffix = uri.slice('serena://memory/'.length);
+        if (!suffix) {
+            return null;
+        }
+        try {
+            return decodeURIComponent(suffix);
+        }
+        catch {
+            return suffix;
+        }
+    }
+    formatMemoryUri(name) {
+        return `serena://memory/${encodeURIComponent(name)}`;
+    }
+    async listMemories(manager) {
+        const listFn = this.bindManagerFunction(manager, ['listMemories', 'list_memories']);
+        const raw = await Promise.resolve(listFn());
+        if (!raw) {
+            return [];
+        }
+        if (Array.isArray(raw)) {
+            return raw.map((entry) => this.stringifyUnknown(entry));
+        }
+        if (this.isIterable(raw)) {
+            const result = [];
+            for (const entry of raw) {
+                result.push(this.stringifyUnknown(entry));
+            }
+            return result;
+        }
+        return [this.stringifyUnknown(raw)];
+    }
+    async loadMemory(manager, name) {
+        const loadFn = this.bindManagerFunction(manager, ['loadMemory', 'load_memory']);
+        const raw = await Promise.resolve(loadFn(name));
+        const text = this.stringifyUnknown(raw);
+        return text;
+    }
+    bindManagerFunction(manager, candidateNames) {
+        for (const candidate of candidateNames) {
+            const fn = Reflect.get(manager, candidate);
+            if (typeof fn === 'function') {
+                return (...fnArgs) => fn.apply(manager, fnArgs);
+            }
+        }
+        throw new Error(`Memories manager does not implement any of: ${candidateNames.join(', ')}`);
+    }
+    stringifyUnknown(value) {
+        if (value === undefined || value === null) {
+            return '';
+        }
+        if (typeof value === 'string') {
+            return value;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value === 'symbol') {
+            return value.toString();
+        }
+        if (typeof value === 'function') {
+            return '[function]';
+        }
+        if (typeof value === 'object') {
+            try {
+                return JSON.stringify(value);
+            }
+            catch {
+                return Object.prototype.toString.call(value);
+            }
+        }
+        return '[unrecognized]';
+    }
+    isIterable(value) {
+        return typeof value === 'object' && value !== null && Symbol.iterator in value;
+    }
+    registerTools(server, openAiToolCompatible) {
+        const tools = Array.from(this.iterTools());
+        for (const tool of tools) {
+            this.registerTool(server, tool, openAiToolCompatible);
+        }
+        log.info(`Registered ${tools.length} MCP tools: ${tools.map((tool) => tool.getName()).join(', ')}`);
+    }
+    registerTool(server, tool, openAiToolCompatible) {
+        const toolName = tool.getName();
+        const metadata = tool.getApplyFnMetadata();
+        const descriptionOverride = this.context.toolDescriptionOverrides[toolName];
+        let description = descriptionOverride ?? metadata.description ?? '';
+        description = description.trim();
+        if (description.length > 0 && !description.endsWith('.')) {
+            description += '.';
+        }
+        const inputSchemaShape = toZodRawShape(metadata.inputSchema);
+        if (!inputSchemaShape) {
+            throw new Error(`Tool ${toolName} must expose a Zod object input schema.`);
+        }
+        const outputSchemaShape = toZodRawShape(metadata.outputSchema);
+        const inputJsonSchema = openAiToolCompatible
+            ? maybeCreateJsonSchema(metadata.inputSchema, {
+                name: `${toolName}Input`,
+                sanitizeForOpenAiTools: true
+            })
+            : undefined;
+        const outputJsonSchema = metadata.outputSchema
+            ? maybeCreateJsonSchema(metadata.outputSchema, {
+                name: `${toolName}Output`,
+                sanitizeForOpenAiTools: openAiToolCompatible
+            })
+            : undefined;
+        const annotations = openAiToolCompatible
+            ? {
+                'serena/openaiToolCompatible': true,
+                ...(inputJsonSchema ? { 'serena/openaiToolInputSchema': inputJsonSchema } : {}),
+                ...(outputJsonSchema ? { 'serena/openaiToolOutputSchema': outputJsonSchema } : {})
+            }
+            : undefined;
+        const callback = async (args, extra) => {
+            try {
+                const normalizedArgs = args;
+                log.debug('MCP invoking tool', {
+                    tool: toolName,
+                    normalizedArgs,
+                    hasAgent: this.agent !== null
+                });
+                const result = await tool.applyEx(normalizedArgs, { logCall: true, catchExceptions: true });
+                log.debug('Tool result before structured output handling', {
+                    tool: toolName,
+                    mode: metadata.structuredOutput ? 'structured' : 'text',
+                    result
+                });
+                if (metadata.structuredOutput && outputJsonSchema && metadata.outputSchema) {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(result);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Failed to parse structured output from tool ${toolName}: ${message}`
+                                }
+                            ],
+                            isError: true
+                        };
+                    }
+                    if (!isRecord(parsed)) {
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Tool ${toolName} must return a JSON object when structuredOutput is enabled.`
+                                }
+                            ],
+                            isError: true
+                        };
+                    }
+                    return {
+                        content: [],
+                        structuredContent: parsed
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: result
+                        }
+                    ]
+                };
+            }
+            catch (error) {
+                log.error('MCP tool execution threw an unexpected error', { err: error, tool: toolName, extra });
+                throw error;
+            }
+        };
+        const registered = registerToolWithServer(server, {
+            name: toolName,
+            description,
+            inputSchema: inputSchemaShape,
+            annotations,
+            callback,
+            outputSchema: outputSchemaShape
+        });
+        return registered;
+    }
+    createMcpServer(options = {}) {
+        try {
+            const config = SerenaConfig.fromConfigFile();
+            if (options.enableWebDashboard !== undefined && options.enableWebDashboard !== null) {
+                config.webDashboard = options.enableWebDashboard;
+            }
+            if (options.enableGuiLogWindow !== undefined && options.enableGuiLogWindow !== null) {
+                config.guiLogWindowEnabled = options.enableGuiLogWindow;
+            }
+            if (options.logLevel) {
+                const normalized = options.logLevel.toUpperCase();
+                const level = LOG_LEVEL_MAP[normalized] ?? LOG_LEVEL_MAP.INFO;
+                config.logLevel = level;
+            }
+            if (options.traceLspCommunication !== undefined && options.traceLspCommunication !== null) {
+                config.traceLspCommunication = options.traceLspCommunication;
+            }
+            if (options.toolTimeout !== undefined && options.toolTimeout !== null) {
+                config.toolTimeout = options.toolTimeout;
+            }
+            const modesInput = options.modes ? Array.from(options.modes) : Array.from(DEFAULT_MODES);
+            const modes = modesInput.map((mode) => SerenaAgentMode.load(mode));
+            const agent = this.instantiateAgent({
+                serenaConfig: config,
+                modes
+            });
+            this.setAgent(agent);
+            const instructions = options.instructionsOverride !== undefined
+                ? options.instructionsOverride ?? ''
+                : this.getInitialInstructions();
+            const serverInfo = options.serverInfo ?? createDefaultServerInfo();
+            const serverOptions = {
+                ...(options.serverOptions ?? {}),
+                instructions
+            };
+            const mcpServer = new McpServer(serverInfo, serverOptions);
+            this.registerTools(mcpServer, this.isOpenAiCompatibleContext());
+            this.registerDefaultCapabilities(mcpServer);
+            return mcpServer;
+        }
+        catch (error) {
+            void showFatalExceptionSafe(error);
+            throw error;
+        }
+    }
+    getLogger() {
+        return log;
+    }
+}
+const LOG_LEVEL_MAP = {
+    DEBUG: 10,
+    INFO: 20,
+    WARNING: 30,
+    ERROR: 40,
+    CRITICAL: 50
+};
+export class SerenaMCPFactorySingleProcess extends SerenaMCPFactory {
+    memoryLogHandler;
+    agentFactory;
+    cachedTools = null;
+    constructor(options = {}) {
+        super(options.context, options.project ?? null);
+        this.memoryLogHandler = options.memoryLogHandler ?? null;
+        this.agentFactory =
+            options.agentFactory ??
+                ((factoryOptions) => new SerenaAgent({
+                    project: factoryOptions.project,
+                    serenaConfig: factoryOptions.serenaConfig,
+                    context: factoryOptions.context,
+                    modes: factoryOptions.modes,
+                    memoryLogHandler: factoryOptions.memoryLogHandler ?? undefined
+                }));
+    }
+    instantiateAgent({ serenaConfig, modes }) {
+        if (!this.agentFactory) {
+            throw new Error('SerenaAgent factory not provided. Inject a factory via SerenaMCPFactorySingleProcessOptions.agentFactory once the agent implementation is available.');
+        }
+        const agent = this.agentFactory({
+            project: this.project,
+            serenaConfig,
+            context: this.context,
+            modes,
+            memoryLogHandler: this.memoryLogHandler
+        });
+        const toolProvider = agent;
+        if (typeof toolProvider.getExposedToolInstances === 'function') {
+            this.cachedTools = Array.from(toolProvider.getExposedToolInstances());
+        }
+        else if (typeof toolProvider.get_exposed_tool_instances === 'function') {
+            this.cachedTools = Array.from(toolProvider.get_exposed_tool_instances());
+        }
+        else {
+            this.cachedTools = null;
+        }
+        return agent;
+    }
+    iterTools() {
+        if (this.cachedTools !== null) {
+            return this.cachedTools;
+        }
+        const agent = this.getAgent();
+        if (typeof agent.getExposedToolInstances === 'function') {
+            const tools = Array.from(agent.getExposedToolInstances());
+            this.cachedTools = tools;
+            return tools;
+        }
+        if (typeof agent.get_exposed_tool_instances === 'function') {
+            const tools = Array.from(agent.get_exposed_tool_instances());
+            this.cachedTools = tools;
+            return tools;
+        }
+        throw new Error('Agent does not expose tool discovery methods.');
+    }
+    getInitialInstructions() {
+        const agent = this.getAgent();
+        if (typeof agent.createSystemPrompt === 'function') {
+            const prompt = agent.createSystemPrompt();
+            if (typeof prompt === 'string' && prompt.length > 0) {
+                return prompt;
+            }
+        }
+        if (typeof agent.create_system_prompt === 'function') {
+            const prompt = agent.create_system_prompt();
+            if (typeof prompt === 'string' && prompt.length > 0) {
+                return prompt;
+            }
+        }
+        throw new Error('Agent did not provide a system prompt.');
+    }
+}
+const DEFAULT_HTTP_PATH = '/mcp';
+function normalizeHttpPath(path) {
+    if (path === undefined || path === null || path === '') {
+        return DEFAULT_HTTP_PATH;
+    }
+    return path.startsWith('/') ? path : `/${path}`;
+}
+function resolveRequestPath(req, defaultHost) {
+    if (!req.url) {
+        return null;
+    }
+    try {
+        const hostHeader = req.headers.host ?? defaultHost;
+        const parsed = new NodeURL(req.url, `http://${hostHeader}`);
+        return parsed.pathname;
+    }
+    catch {
+        return null;
+    }
+}
+function respondWithJson(res, statusCode, body) {
+    if (res.headersSent) {
+        return;
+    }
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Cache-Control': 'no-store'
+    });
+    res.end(JSON.stringify(body));
+}
+export function createSerenaHttpRequestHandler({ transport, path, defaultHost }) {
+    const normalizedPath = normalizeHttpPath(path);
+    const fallbackHost = defaultHost ?? '127.0.0.1';
+    return async (req, res) => {
+        const requestPath = resolveRequestPath(req, fallbackHost);
+        if (requestPath !== normalizedPath) {
+            respondWithJson(res, 404, {
+                jsonrpc: '2.0',
+                error: {
+                    code: -32601,
+                    message: 'Not Found'
+                },
+                id: null
+            });
+            return;
+        }
+        try {
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            log.error('Unhandled error while processing HTTP MCP request', { err: error });
+            if (!res.headersSent) {
+                respondWithJson(res, 500, {
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32000,
+                        message: 'Internal Server Error',
+                        data: error instanceof Error ? error.message : String(error)
+                    },
+                    id: null
+                });
+            }
+            else {
+                try {
+                    res.end();
+                }
+                catch {
+                    // ignore secondary failures when the connection is already broken
+                }
+            }
+        }
+    };
+}
+async function listenHttpServer(server, port, host) {
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off('listening', onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        server.once('error', onError);
+        server.listen(port, host, onListening);
+    });
+}
+async function closeHttpServer(server) {
+    await new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function deriveServerUrl(address, path, fallbackHost) {
+    if (!address) {
+        throw new Error('Failed to determine HTTP server address.');
+    }
+    if (typeof address === 'string') {
+        const normalized = address.endsWith('/') ? address.slice(0, -1) : address;
+        if (normalized.startsWith('http://') || normalized.startsWith('https://')) {
+            return new NodeURL(`${normalized}${path}`);
+        }
+        return new NodeURL(`http://${fallbackHost}${path}`);
+    }
+    const host = address.family === 'IPv6' ? `[${address.address}]` : address.address;
+    const resolvedHost = host === '::' || host === '0.0.0.0' ? fallbackHost : host;
+    return new NodeURL(`http://${resolvedHost}:${address.port}${path}`);
+}
+export async function createSerenaHttpServer(factory, options = {}) {
+    const host = options.host ?? '127.0.0.1';
+    const port = options.port ?? 0;
+    const path = normalizeHttpPath(options.path);
+    const transportOptions = options.transportOptions ?? {};
+    const sessionIdGenerator = options.sessionIdGenerator === null
+        ? undefined
+        : options.sessionIdGenerator ?? transportOptions.sessionIdGenerator ?? (() => randomUUID());
+    const httpTransport = new StreamableHTTPServerTransport({
+        ...transportOptions,
+        sessionIdGenerator
+    });
+    const mcpServer = factory.createMcpServer(options);
+    await mcpServer.connect(httpTransport);
+    const handler = createSerenaHttpRequestHandler({
+        transport: httpTransport,
+        path,
+        defaultHost: host
+    });
+    const httpServer = createServer((req, res) => {
+        void handler(req, res);
+    });
+    await listenHttpServer(httpServer, port, host);
+    const addressInfo = httpServer.address();
+    const url = deriveServerUrl(addressInfo, path, host);
+    return {
+        httpServer,
+        transport: httpTransport,
+        mcpServer,
+        url,
+        async close() {
+            await Promise.allSettled([httpTransport.close(), mcpServer.close()]);
+            await closeHttpServer(httpServer);
+        }
+    };
+}
+class SerenaStdioServerTransport extends StdioServerTransport {
+    stdin;
+    handleStreamEnd;
+    handleStreamClose;
+    closePromise = null;
+    constructor(stdin = process.stdin, stdout = process.stdout) {
+        super(stdin, stdout);
+        this.stdin = stdin;
+        this.handleStreamEnd = () => {
+            void this.ensureClosed().catch((error) => {
+                this.reportError(error);
+            });
+        };
+        this.handleStreamClose = () => {
+            void this.ensureClosed().catch((error) => {
+                this.reportError(error);
+            });
+        };
+        this.stdin.on('end', this.handleStreamEnd);
+        this.stdin.on('close', this.handleStreamClose);
+    }
+    ensureClosed() {
+        if (!this.closePromise) {
+            this.stdin.off('end', this.handleStreamEnd);
+            this.stdin.off('close', this.handleStreamClose);
+            this.closePromise = super.close();
+        }
+        return this.closePromise;
+    }
+    async close() {
+        await this.ensureClosed();
+    }
+    reportError(error) {
+        if (error instanceof Error) {
+            this.onerror?.(error);
+            return;
+        }
+        let message;
+        if (typeof error === 'string') {
+            message = error;
+        }
+        else {
+            try {
+                message = JSON.stringify(error);
+            }
+            catch {
+                message = '[unknown error]';
+            }
+        }
+        this.onerror?.(new Error(message));
+    }
+}
+export async function createSerenaStdioServer(factory, options = {}) {
+    const transport = new SerenaStdioServerTransport();
+    const mcpServer = factory.createMcpServer(options);
+    await mcpServer.connect(transport);
+    return {
+        transport,
+        mcpServer,
+        async close() {
+            await Promise.allSettled([transport.close(), mcpServer.close()]);
+        }
+    };
+}
+export async function createSerenaGrpcServer(_factory, _options = {}) {
+    try {
+        await import('@grpc/grpc-js');
+    }
+    catch (error) {
+        throw new Error('gRPCトランスポートPoCは未実装です。@grpc/grpc-js を導入後に createSerenaGrpcServer を拡張してください。', { cause: error });
+    }
+    throw new Error('gRPCトランスポートPoCは未実装です。HTTPモードのPoCは createSerenaHttpServer を利用してください。');
+}