@cogitator-ai/mcp 17.0.10 → 18.0.0

package/dist/server/mcp-server.d.ts

@@ -28,7 +28,7 @@ import type { MCPServerConfig, MCPResourceConfig, MCPPromptConfig } from '../typ
  * ```
  */
 export declare class MCPServer {
-    private server;
+    private server?;
     private config;
     private tools;
     private resources;
@@ -88,18 +88,40 @@ export declare class MCPServer {
      * Get list of registered prompt names
      */
     getRegisteredPrompts(): string[];
+    /**
+     * Build a fresh SDK McpServer instance and register every tool, resource
+     * and prompt from the local maps onto it.
+     *
+     * The maps are the single source of truth: registration with the SDK is
+     * deferred until start() (stdio) or until each incoming request (HTTP), so
+     * unregister* calls made before start() are fully honoured and concurrent
+     * HTTP requests never share a single server/transport binding.
+     */
+    private buildServer;
     /**
      * Register a tool with the MCP server
      */
     private registerMCPTool;
     /**
-     * Build the input schema for MCP tool registration
+     * Resolve the Zod schema the SDK uses to advertise and validate tool input.
+     *
+     * The full tool schema is handed to the SDK (not just its shape) so object
+     * modifiers, refinements and transforms are honoured, and the SDK passes
+     * already-parsed arguments to the handler. Tools without a schema accept
+     * any object.
      */
     private buildInputSchema;
     /**
-     * Execute a tool and return MCP-formatted result
+     * Execute a tool with SDK-validated arguments and return an MCP-formatted result
      */
     private executeTool;
+    /**
+     * Write a diagnostic line to stderr when logging is enabled.
+     *
+     * stdout is reserved for JSON-RPC frames on the stdio transport, so every
+     * log line goes to stderr regardless of level.
+     */
+    private log;
     /**
      * Register a resource with the MCP server
      */
@@ -116,6 +138,11 @@ export declare class MCPServer {
      * Start HTTP server for MCP
      */
     private startHttpServer;
+    /**
+     * Port the HTTP transport is listening on (useful with `port: 0`).
+     * Returns undefined for stdio or before the server has started.
+     */
+    getPort(): number | undefined;
     /**
      * Stop the server
      */

package/dist/server/mcp-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../src/server/mcp-server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAe,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EAEjB,eAAe,EAChB,MAAM,UAAU,CAAC;AAUlB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,SAAS,CAAwC;IACzD,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAC,CAA6B;gBAEpC,MAAM,EAAE,eAAe;IAQnC;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAS9B;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAMlC;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAOrC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IASjD;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,IAAI;IAMrD;;;OAGG;IACH,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAOxC;;OAEG;IACH,sBAAsB,IAAI,MAAM,EAAE;IAIlC;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IAS7C;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,IAAI;IAMjD;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAOvC;;OAEG;IACH,oBAAoB,IAAI,MAAM,EAAE;IAIhC;;OAEG;IACH,OAAO,CAAC,eAAe;IAavB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;OAEG;YACW,WAAW;IAmDzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoE3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAoDzB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0C5B;;OAEG;YACW,eAAe;IAiD7B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAoB3B;;OAEG;IACH,SAAS,IAAI,OAAO;CAGrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,CAK9F"}
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../src/server/mcp-server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,IAAI,EAAe,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EAEjB,eAAe,EAGhB,MAAM,UAAU,CAAC;AAwDlB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAC,CAAY;IAC3B,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,SAAS,CAAwC;IACzD,OAAO,CAAC,OAAO,CAAsC;IACrD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAC,CAAa;gBAEpB,MAAM,EAAE,eAAe;IAInC;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAQ9B;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAMlC;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAOrC;;OAEG;IACH,kBAAkB,IAAI,MAAM,EAAE;IAI9B;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAQjD;;OAEG;IACH,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,EAAE,GAAG,IAAI;IAMrD;;;OAGG;IACH,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAOxC;;OAEG;IACH,sBAAsB,IAAI,MAAM,EAAE;IAIlC;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IAQ7C;;OAEG;IACH,eAAe,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,IAAI;IAMjD;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAOvC;;OAEG;IACH,oBAAoB,IAAI,MAAM,EAAE;IAIhC;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;IAmBnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAavB;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;OAEG;YACW,WAAW;IAyBzB;;;;;OAKG;IACH,OAAO,CAAC,GAAG;IAQX;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA2D3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA8CzB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAmC5B;;OAEG;YACW,eAAe;IA8G7B;;;OAGG;IACH,OAAO,IAAI,MAAM,GAAG,SAAS;IAK7B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B3B;;OAEG;IACH,SAAS,IAAI,OAAO;CAGrB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,SAAS,CAAC,CAK9F"}

package/dist/server/mcp-server.js

@@ -4,10 +4,45 @@
  * Exposes Cogitator tools as an MCP server that can be used by
  * other MCP clients (e.g., Claude Desktop, other AI assistants).
  */
+import { randomUUID } from 'node:crypto';
 import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { resultToMCPContent, zodToJsonSchema } from '../adapter/tool-adapter.js';
+import { resultToMCPContent } from '../adapter/tool-adapter.js';
 import { z } from 'zod';
+function toServerContent(item) {
+    switch (item.type) {
+        case 'text':
+            return { type: 'text', text: item.text ?? '' };
+        case 'image':
+        case 'audio':
+            if (typeof item.data === 'string' && typeof item.mimeType === 'string') {
+                return { type: item.type, data: item.data, mimeType: item.mimeType };
+            }
+            break;
+        case 'resource':
+        case 'resource_link': {
+            const resource = item.resource;
+            if (resource && typeof resource.blob === 'string') {
+                return {
+                    type: 'resource',
+                    resource: { uri: resource.uri, mimeType: resource.mimeType, blob: resource.blob },
+                };
+            }
+            if (resource && typeof resource.text === 'string') {
+                return {
+                    type: 'resource',
+                    resource: { uri: resource.uri, mimeType: resource.mimeType, text: resource.text },
+                };
+            }
+            break;
+        }
+    }
+    return { type: 'text', text: JSON.stringify(item) };
+}
+function errorMessageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+const PERMISSIVE_INPUT_SCHEMA = z.looseObject({});
 /**
  * MCP Server for exposing Cogitator tools
  *
@@ -39,10 +74,6 @@ export class MCPServer {
     httpServer;
     constructor(config) {
         this.config = config;
-        this.server = new McpServer({
-            name: config.name,
-            version: config.version,
-        });
     }
     /**
      * Register a single Cogitator tool
@@ -52,7 +83,6 @@ export class MCPServer {
             throw new Error('Cannot register tools after server has started');
         }
         this.tools.set(tool.name, tool);
-        this.registerMCPTool(tool);
     }
     /**
      * Register multiple Cogitator tools
@@ -87,7 +117,6 @@ export class MCPServer {
             throw new Error('Cannot register resources after server has started');
         }
         this.resources.set(config.uri, config);
-        this.registerMCPResource(config);
     }
     /**
      * Register multiple resources
@@ -121,7 +150,6 @@ export class MCPServer {
             throw new Error('Cannot register prompts after server has started');
         }
         this.prompts.set(config.name, config);
-        this.registerMCPPrompt(config);
     }
     /**
      * Register multiple prompts
@@ -147,77 +175,93 @@ export class MCPServer {
     getRegisteredPrompts() {
         return Array.from(this.prompts.keys());
     }
+    /**
+     * Build a fresh SDK McpServer instance and register every tool, resource
+     * and prompt from the local maps onto it.
+     *
+     * The maps are the single source of truth: registration with the SDK is
+     * deferred until start() (stdio) or until each incoming request (HTTP), so
+     * unregister* calls made before start() are fully honoured and concurrent
+     * HTTP requests never share a single server/transport binding.
+     */
+    buildServer() {
+        const server = new McpServer({
+            name: this.config.name,
+            version: this.config.version,
+        });
+        for (const tool of this.tools.values()) {
+            this.registerMCPTool(server, tool);
+        }
+        for (const resource of this.resources.values()) {
+            this.registerMCPResource(server, resource);
+        }
+        for (const prompt of this.prompts.values()) {
+            this.registerMCPPrompt(server, prompt);
+        }
+        return server;
+    }
     /**
      * Register a tool with the MCP server
      */
-    registerMCPTool(tool) {
-        const inputSchema = this.buildInputSchema(tool);
-        this.server.tool(tool.name, tool.description, inputSchema, async (args) => {
-            return this.executeTool(tool, args);
+    registerMCPTool(server, tool) {
+        server.registerTool(tool.name, {
+            description: tool.description,
+            inputSchema: this.buildInputSchema(tool),
+        }, async (args, extra) => {
+            return this.executeTool(tool, args, extra.signal);
         });
     }
     /**
-     * Build the input schema for MCP tool registration
+     * Resolve the Zod schema the SDK uses to advertise and validate tool input.
+     *
+     * The full tool schema is handed to the SDK (not just its shape) so object
+     * modifiers, refinements and transforms are honoured, and the SDK passes
+     * already-parsed arguments to the handler. Tools without a schema accept
+     * any object.
      */
     buildInputSchema(tool) {
-        if (tool.parameters) {
-            const jsonSchema = zodToJsonSchema(tool.parameters);
-            return jsonSchema.properties ?? {};
-        }
-        const schema = tool.toJSON();
-        return schema.parameters.properties;
+        const params = tool.parameters;
+        return params instanceof z.ZodType ? params : PERMISSIVE_INPUT_SCHEMA;
     }
     /**
-     * Execute a tool and return MCP-formatted result
+     * Execute a tool with SDK-validated arguments and return an MCP-formatted result
      */
-    async executeTool(tool, args) {
+    async executeTool(tool, args, signal) {
         const context = {
             agentId: 'mcp-server',
-            runId: `mcp_${Date.now()}`,
-            signal: new AbortController().signal,
+            runId: `mcp_${randomUUID()}`,
+            signal,
         };
         try {
-            let validatedArgs = args;
-            if (tool.parameters) {
-                const parseResult = tool.parameters.safeParse(args);
-                if (!parseResult.success) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: `Validation error: ${parseResult.error.message}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                validatedArgs = parseResult.data;
-            }
-            const result = await tool.execute(validatedArgs, context);
-            const rawContent = resultToMCPContent(result);
-            const content = rawContent.map((item) => {
-                if (item.type === 'text') {
-                    return { type: 'text', text: item.text };
-                }
-                return { type: 'text', text: JSON.stringify(item) };
-            });
-            return { content };
+            const result = await tool.execute(args ?? {}, context);
+            return { content: resultToMCPContent(result).map(toServerContent) };
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (this.config.logging) {
-                console.error(`[MCPServer] Tool ${tool.name} error:`, errorMessage);
-            }
+            const errorMessage = errorMessageOf(error);
+            this.log('error', `Tool ${tool.name} error: ${errorMessage}`);
             return {
                 content: [{ type: 'text', text: `Error: ${errorMessage}` }],
                 isError: true,
             };
         }
     }
+    /**
+     * Write a diagnostic line to stderr when logging is enabled.
+     *
+     * stdout is reserved for JSON-RPC frames on the stdio transport, so every
+     * log line goes to stderr regardless of level.
+     */
+    log(level, message) {
+        if (!this.config.logging) {
+            return;
+        }
+        const prefix = level === 'error' ? '[MCPServer] ERROR' : '[MCPServer]';
+        console.error(`${prefix} ${message}`);
+    }
     /**
      * Register a resource with the MCP server
      */
-    registerMCPResource(config) {
+    registerMCPResource(server, config) {
         const isTemplate = config.uri.includes('{');
         const formatContents = (result, uriHref) => {
             const contents = Array.isArray(result) ? result : [result];
@@ -228,100 +272,84 @@ export class MCPServer {
                 if (c.mimeType || config.mimeType) {
                     base.mimeType = c.mimeType || config.mimeType;
                 }
-                if (c.blob) {
+                if (typeof c.blob === 'string') {
                     return { ...base, blob: c.blob };
                 }
-                return { ...base, text: c.text || '' };
+                return { ...base, text: c.text ?? '' };
             });
         };
+        const readResource = async (params) => {
+            try {
+                return await config.read(params);
+            }
+            catch (error) {
+                this.log('error', `Resource ${config.name} error: ${errorMessageOf(error)}`);
+                throw error;
+            }
+        };
         if (isTemplate) {
-            this.server.registerResource(config.name, new ResourceTemplate(config.uri, { list: undefined }), {
+            server.registerResource(config.name, new ResourceTemplate(config.uri, { list: undefined }), {
                 description: config.description,
                 mimeType: config.mimeType,
             }, async (uri, variables) => {
-                try {
-                    const params = {};
-                    for (const [key, value] of Object.entries(variables)) {
-                        params[key] = Array.isArray(value) ? value[0] || '' : value;
-                    }
-                    const result = await config.read(params);
-                    return { contents: formatContents(result, uri.href) };
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    if (this.config.logging) {
-                        console.error(`[MCPServer] Resource ${config.name} error:`, errorMessage);
-                    }
-                    return { contents: [{ uri: uri.href, text: `Error: ${errorMessage}` }] };
+                const params = {};
+                for (const [key, value] of Object.entries(variables)) {
+                    params[key] = Array.isArray(value) ? value.join(',') : value;
                 }
+                return { contents: formatContents(await readResource(params), uri.href) };
             });
         }
         else {
-            this.server.registerResource(config.name, config.uri, {
+            server.registerResource(config.name, config.uri, {
                 description: config.description,
                 mimeType: config.mimeType,
             }, async (uri) => {
-                try {
-                    const result = await config.read({});
-                    return { contents: formatContents(result, uri.href) };
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    if (this.config.logging) {
-                        console.error(`[MCPServer] Resource ${config.name} error:`, errorMessage);
-                    }
-                    return { contents: [{ uri: uri.href, text: `Error: ${errorMessage}` }] };
-                }
+                return { contents: formatContents(await readResource({}), uri.href) };
             });
         }
     }
     /**
      * Register a prompt with the MCP server
      */
-    registerMCPPrompt(config) {
-        const argsSchema = {};
-        for (const arg of config.arguments || []) {
-            let schema = z.string();
-            if (arg.description) {
-                schema = schema.describe(arg.description);
-            }
-            if (!arg.required) {
-                schema = schema.optional();
-            }
-            argsSchema[arg.name] = schema;
-        }
-        this.server.registerPrompt(config.name, {
-            title: config.title || config.name,
-            description: config.description,
-            argsSchema,
-        }, async (args) => {
+    registerMCPPrompt(server, config) {
+        const render = async (args) => {
+            let result;
             try {
-                const result = await config.get(args);
-                return {
-                    description: result.description,
-                    messages: result.messages.map((m) => ({
-                        role: m.role,
-                        content: {
-                            type: 'text',
-                            text: typeof m.content === 'string' ? m.content : m.content.text || '',
-                        },
-                    })),
-                };
+                result = await config.get(args);
             }
             catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                if (this.config.logging) {
-                    console.error(`[MCPServer] Prompt ${config.name} error:`, errorMessage);
+                this.log('error', `Prompt ${config.name} error: ${errorMessageOf(error)}`);
+                throw error;
+            }
+            return {
+                description: result.description,
+                messages: result.messages.map((m) => ({
+                    role: m.role,
+                    content: typeof m.content === 'string'
+                        ? { type: 'text', text: m.content }
+                        : toServerContent(m.content),
+                })),
+            };
+        };
+        const metadata = { title: config.title || config.name, description: config.description };
+        const promptArgs = config.arguments ?? [];
+        if (promptArgs.length === 0) {
+            server.registerPrompt(config.name, metadata, async () => render({}));
+            return;
+        }
+        const argsSchema = {};
+        for (const arg of promptArgs) {
+            const base = arg.description ? z.string().describe(arg.description) : z.string();
+            argsSchema[arg.name] = arg.required ? base : base.optional();
+        }
+        server.registerPrompt(config.name, { ...metadata, argsSchema }, async (args) => {
+            const stringArgs = {};
+            for (const [key, value] of Object.entries(args ?? {})) {
+                if (typeof value === 'string') {
+                    stringArgs[key] = value;
                 }
-                return {
-                    messages: [
-                        {
-                            role: 'assistant',
-                            content: { type: 'text', text: `Error: ${errorMessage}` },
-                        },
-                    ],
-                };
             }
+            return render(stringArgs);
         });
     }
     /**
@@ -331,14 +359,13 @@ export class MCPServer {
         if (this.started) {
             throw new Error('Server already started');
         }
-        if (this.config.logging) {
-            console.log(`[MCPServer] Starting ${this.config.name} v${this.config.version}`);
-            console.log(`[MCPServer] Registered tools: ${this.getRegisteredTools().join(', ') || '(none)'}`);
-            console.log(`[MCPServer] Registered resources: ${this.getRegisteredResources().join(', ') || '(none)'}`);
-            console.log(`[MCPServer] Registered prompts: ${this.getRegisteredPrompts().join(', ') || '(none)'}`);
-        }
+        this.log('info', `Starting ${this.config.name} v${this.config.version}`);
+        this.log('info', `Registered tools: ${this.getRegisteredTools().join(', ') || '(none)'}`);
+        this.log('info', `Registered resources: ${this.getRegisteredResources().join(', ') || '(none)'}`);
+        this.log('info', `Registered prompts: ${this.getRegisteredPrompts().join(', ') || '(none)'}`);
         switch (this.config.transport) {
             case 'stdio': {
+                this.server = this.buildServer();
                 const transport = new StdioServerTransport();
                 await this.server.connect(transport);
                 break;
@@ -352,9 +379,7 @@ export class MCPServer {
                 throw new Error(`Unknown transport: ${this.config.transport}`);
         }
         this.started = true;
-        if (this.config.logging) {
-            console.log(`[MCPServer] Server started on ${this.config.transport} transport`);
-        }
+        this.log('info', `Server started on ${this.config.transport} transport`);
     }
     /**
      * Start HTTP server for MCP
@@ -364,39 +389,107 @@ export class MCPServer {
         const { StreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/streamableHttp.js');
         const port = this.config.port ?? 3000;
         const host = this.config.host ?? 'localhost';
+        const maxBodySize = this.config.maxBodySize ?? 10 * 1024 * 1024;
+        const corsOrigin = this.config.corsOrigin ?? '*';
         this.httpServer = createServer(async (req, res) => {
-            res.setHeader('Access-Control-Allow-Origin', '*');
-            res.setHeader('Access-Control-Allow-Methods', 'POST, OPTIONS');
-            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            res.setHeader('Access-Control-Allow-Origin', corsOrigin);
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Mcp-Session-Id');
+            res.setHeader('Access-Control-Expose-Headers', 'Mcp-Session-Id');
             if (req.method === 'OPTIONS') {
                 res.writeHead(204);
                 res.end();
                 return;
             }
-            if (req.method !== 'POST' || req.url !== '/mcp') {
+            const pathname = new URL(req.url ?? '/', 'http://localhost').pathname;
+            if (pathname !== '/mcp') {
                 res.writeHead(404);
                 res.end('Not Found');
                 return;
             }
-            const chunks = [];
-            for await (const chunk of req) {
-                chunks.push(chunk);
-            }
-            const body = JSON.parse(Buffer.concat(chunks).toString());
+            const server = this.buildServer();
             const transport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: undefined,
             });
-            await this.server.connect(transport);
-            await transport.handleRequest(req, res, body);
-        });
-        await new Promise((resolve) => {
-            this.httpServer.listen(port, host, () => {
-                if (this.config.logging) {
-                    console.log(`[MCPServer] HTTP server listening on http://${host}:${port}/mcp`);
-                }
-                resolve();
+            res.on('close', () => {
+                transport.close().catch(() => { });
+                server.close().catch(() => { });
             });
+            try {
+                await server.connect(transport);
+                if (req.method === 'POST') {
+                    const chunks = [];
+                    let totalSize = 0;
+                    let tooLarge = false;
+                    for await (const chunk of req) {
+                        const buffer = chunk;
+                        totalSize += buffer.length;
+                        if (totalSize > maxBodySize) {
+                            tooLarge = true;
+                            break;
+                        }
+                        chunks.push(buffer);
+                    }
+                    if (tooLarge) {
+                        res.writeHead(413, { 'Content-Type': 'text/plain' });
+                        res.end('Payload Too Large');
+                        req.destroy();
+                        return;
+                    }
+                    let body;
+                    try {
+                        body = JSON.parse(Buffer.concat(chunks).toString());
+                    }
+                    catch {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({
+                            jsonrpc: '2.0',
+                            error: { code: -32700, message: 'Parse error: invalid JSON' },
+                            id: null,
+                        }));
+                        return;
+                    }
+                    await transport.handleRequest(req, res, body);
+                }
+                else if (req.method === 'GET' || req.method === 'DELETE') {
+                    await transport.handleRequest(req, res);
+                }
+                else {
+                    res.writeHead(405, { 'Content-Type': 'text/plain' });
+                    res.end('Method Not Allowed');
+                }
+            }
+            catch (error) {
+                this.log('error', `HTTP request error: ${errorMessageOf(error)}`);
+                if (!res.headersSent) {
+                    res.writeHead(500, { 'Content-Type': 'text/plain' });
+                    res.end('Internal Server Error');
+                }
+            }
         });
+        const httpServer = this.httpServer;
+        try {
+            await new Promise((resolve, reject) => {
+                httpServer.once('error', reject);
+                httpServer.listen(port, host, () => {
+                    httpServer.off('error', reject);
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            this.httpServer = undefined;
+            throw error;
+        }
+        this.log('info', `HTTP server listening on http://${host}:${this.getPort() ?? port}/mcp`);
+    }
+    /**
+     * Port the HTTP transport is listening on (useful with `port: 0`).
+     * Returns undefined for stdio or before the server has started.
+     */
+    getPort() {
+        const address = this.httpServer?.address();
+        return address && typeof address === 'object' ? address.port : undefined;
     }
     /**
      * Stop the server
@@ -405,17 +498,25 @@ export class MCPServer {
         if (!this.started) {
             return;
         }
-        if (this.httpServer) {
-            await new Promise((resolve, reject) => {
-                this.httpServer.close((err) => (err ? reject(err) : resolve()));
-            });
-            this.httpServer = undefined;
+        try {
+            const httpServer = this.httpServer;
+            if (httpServer) {
+                this.httpServer = undefined;
+                await new Promise((resolve, reject) => {
+                    httpServer.close((err) => (err ? reject(err) : resolve()));
+                    httpServer.closeAllConnections();
+                });
+            }
         }
-        await this.server.close();
-        this.started = false;
-        if (this.config.logging) {
-            console.log('[MCPServer] Server stopped');
+        finally {
+            const server = this.server;
+            this.server = undefined;
+            this.started = false;
+            if (server) {
+                await server.close();
+            }
         }
+        this.log('info', 'Server stopped');
     }
     /**
      * Check if server is running