16295830656

Committed 15 Jul 2025 02:17PM UTC coverage: 76.333% (-1.2%) from 77.581%

Build # 16295830656

Build Type

Pull #361

github

Committed by

web-flow

Commit Message

Merge 17b149c84 into 48bce63a0

Pull Request Pull Request #361: feat: add streamable http [MCP-42]

Run Details

501 of 696 branches covered (71.98%)

Branch coverage included in aggregate %.

90 of 173 new or added lines in 6 files covered. (52.02%)

10 existing lines in 2 files now uncovered.

2892 of 3749 relevant lines covered (77.14%)

24.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.18

/src/server.ts

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { Session } from "./common/session.js";
import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
import { AtlasTools } from "./tools/atlas/tools.js";
import { MongoDbTools } from "./tools/mongodb/tools.js";
import logger, { LogId, LoggerBase, McpLogger, DiskLogger, ConsoleLogger } from "./common/logger.js";
import { ObjectId } from "mongodb";
import { Telemetry } from "./telemetry/telemetry.js";
import { UserConfig } from "./common/config.js";
import { type ServerEvent } from "./telemetry/types.js";
import { type ServerCommand } from "./telemetry/types.js";
import { CallToolRequestSchema, CallToolResult } from "@modelcontextprotocol/sdk/types.js";
import assert from "assert";
import { ToolBase } from "./tools/tool.js";

export interface ServerOptions {
    session: Session;
    userConfig: UserConfig;
    mcpServer: McpServer;
    telemetry: Telemetry;
}

export class Server {
    public readonly session: Session;
    public readonly mcpServer: McpServer;
    private readonly telemetry: Telemetry;
    public readonly userConfig: UserConfig;
    public readonly tools: ToolBase[] = [];
    private readonly startTime: number;

    constructor({ session, mcpServer, userConfig, telemetry }: ServerOptions) {
        this.startTime = Date.now();
        this.session = session;
        this.telemetry = telemetry;
        this.mcpServer = mcpServer;
        this.userConfig = userConfig;
    }

    async connect(transport: Transport): Promise<void> {
        await this.validateConfig();

        this.mcpServer.server.registerCapabilities({ logging: {} });

        this.registerTools();
        this.registerResources();

        // This is a workaround for an issue we've seen with some models, where they'll see that everything in the `arguments`
        // object is optional, and then not pass it at all. However, the MCP server expects the `arguments` object to be if
        // the tool accepts any arguments, even if they're all optional.
        //
        // see: https://github.com/modelcontextprotocol/typescript-sdk/blob/131776764536b5fdca642df51230a3746fb4ade0/src/server/mcp.ts#L705
        // Since paramsSchema here is not undefined, the server will create a non-optional z.object from it.
        const existingHandler = (
            this.mcpServer.server["_requestHandlers"] as Map<
                string,
                (request: unknown, extra: unknown) => Promise<CallToolResult>
            >
        ).get(CallToolRequestSchema.shape.method.value);

        assert(existingHandler, "No existing handler found for CallToolRequestSchema");

        this.mcpServer.server.setRequestHandler(CallToolRequestSchema, (request, extra): Promise<CallToolResult> => {
            if (!request.params.arguments) {
                request.params.arguments = {};
            }

            return existingHandler(request, extra);
        });

        const loggers: LoggerBase[] = [];
        if (this.userConfig.loggers.includes("mcp")) {
            loggers.push(new McpLogger(this.mcpServer));
        }
        if (this.userConfig.loggers.includes("disk")) {
            loggers.push(await DiskLogger.fromPath(this.userConfig.logPath));
        }
        if (this.userConfig.loggers.includes("stderr")) {
            loggers.push(new ConsoleLogger());
        }
        logger.setLoggers(...loggers);

        this.mcpServer.server.oninitialized = () => {
            this.session.setAgentRunner(this.mcpServer.server.getClientVersion());
            this.session.sessionId = new ObjectId().toString();

            logger.info(
                LogId.serverInitialized,
                "server",
                `Server started with transport ${transport.constructor.name} and agent runner ${this.session.agentRunner?.name}`
            );

            this.emitServerEvent("start", Date.now() - this.startTime);
        };

        this.mcpServer.server.onclose = () => {
            const closeTime = Date.now();
            this.emitServerEvent("stop", Date.now() - closeTime);
        };

        this.mcpServer.server.onerror = (error: Error) => {
            const closeTime = Date.now();
            this.emitServerEvent("stop", Date.now() - closeTime, error);
        };

        await this.mcpServer.connect(transport);
    }

    async close(): Promise<void> {
        await this.telemetry.close();
        await this.session.close();
        await this.mcpServer.close();
    }

    /**
     * Emits a server event
     * @param command - The server command (e.g., "start", "stop", "register", "deregister")
     * @param additionalProperties - Additional properties specific to the event
     */
    private emitServerEvent(command: ServerCommand, commandDuration: number, error?: Error) {
        const event: ServerEvent = {
            timestamp: new Date().toISOString(),
            source: "mdbmcp",
            properties: {
                result: "success",
                duration_ms: commandDuration,
                component: "server",
                category: "other",
                command: command,
            },
        };

        if (command === "start") {
            event.properties.startup_time_ms = commandDuration;
            event.properties.read_only_mode = this.userConfig.readOnly || false;
            event.properties.disabled_tools = this.userConfig.disabledTools || [];
        }
        if (command === "stop") {
            event.properties.runtime_duration_ms = Date.now() - this.startTime;
            if (error) {
                event.properties.result = "failure";
                event.properties.reason = error.message;
            }
        }

        this.telemetry.emitEvents([event]).catch(() => {});
    }

    private registerTools() {
        for (const toolConstructor of [...AtlasTools, ...MongoDbTools]) {
            const tool = new toolConstructor(this.session, this.userConfig, this.telemetry);
            if (tool.register(this)) {
                this.tools.push(tool);
            }
        }
    }

    private registerResources() {
        this.mcpServer.resource(
            "config",
            "config://config",
            {
                description:
                    "Server configuration, supplied by the user either as environment variables or as startup arguments",
            },
            (uri) => {
                const result = {
                    telemetry: this.userConfig.telemetry,
                    logPath: this.userConfig.logPath,
                    connectionString: this.userConfig.connectionString
                        ? "set; access to MongoDB tools are currently available to use"
                        : "not set; before using any MongoDB tool, you need to configure a connection string, alternatively you can setup MongoDB Atlas access, more info at 'https://github.com/mongodb-js/mongodb-mcp-server'.",
                    connectOptions: this.userConfig.connectOptions,
                    atlas:
                        this.userConfig.apiClientId && this.userConfig.apiClientSecret
                            ? "set; MongoDB Atlas tools are currently available to use"
                            : "not set; MongoDB Atlas tools are currently unavailable, to have access to MongoDB Atlas tools like creating clusters or connecting to clusters make sure to setup credentials, more info at 'https://github.com/mongodb-js/mongodb-mcp-server'.",
                };
                return {
                    contents: [
                        {
                            text: JSON.stringify(result),
                            mimeType: "application/json",
                            uri: uri.href,
                        },
                    ],
                };
            }
        );
    }

    private async validateConfig(): Promise<void> {
        const transport = this.userConfig.transport as string;
        if (transport !== "http" && transport !== "stdio") {
            throw new Error(`Invalid transport: ${transport}`);
        }

        const telemetry = this.userConfig.telemetry as string;
        if (telemetry !== "enabled" && telemetry !== "disabled") {
            throw new Error(`Invalid telemetry: ${telemetry}`);
        }

        if (this.userConfig.httpPort < 1 || this.userConfig.httpPort > 65535) {
            throw new Error(`Invalid httpPort: ${this.userConfig.httpPort}`);
        }

        if (this.userConfig.loggers.length === 0) {
            throw new Error("No loggers found in config");
        }

        const loggerTypes = new Set(this.userConfig.loggers);
        if (loggerTypes.size !== this.userConfig.loggers.length) {
            throw new Error("Duplicate loggers found in config");
        }

        for (const loggerType of this.userConfig.loggers as string[]) {
            if (loggerType !== "mcp" && loggerType !== "disk" && loggerType !== "stderr") {
                throw new Error(`Invalid logger: ${loggerType}`);
            }
        }

        if (this.userConfig.connectionString) {
            try {
                await this.session.connectToMongoDB(this.userConfig.connectionString, this.userConfig.connectOptions);
            } catch (error) {
                console.error(
                    "Failed to connect to MongoDB instance using the connection string from the config: ",
                    error
                );
                throw new Error("Failed to connect to MongoDB instance using the connection string from the config");
            }
        }

        if (this.userConfig.apiClientId && this.userConfig.apiClientSecret) {
            try {
                await this.session.apiClient.validateAccessToken();
            } catch (error) {
                if (this.userConfig.connectionString === undefined) {
                    console.error("Failed to validate MongoDB Atlas the credentials from the config: ", error);

                    throw new Error(
                        "Failed to connect to MongoDB Atlas instance using the credentials from the config"
                    );
                }
                console.error(
                    "Failed to validate MongoDB Atlas the credentials from the config, but validated the connection string."
                );
            }
        }
    }
}

1	import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
2	import { Session } from "./common/session.js";
3	import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
4	import { AtlasTools } from "./tools/atlas/tools.js";	2✔
5	import { MongoDbTools } from "./tools/mongodb/tools.js";	2✔
6	import logger, { LogId, LoggerBase, McpLogger, DiskLogger, ConsoleLogger } from "./common/logger.js";	2✔
7	import { ObjectId } from "mongodb";	2✔
8	import { Telemetry } from "./telemetry/telemetry.js";
9	import { UserConfig } from "./common/config.js";
10	import { type ServerEvent } from "./telemetry/types.js";
11	import { type ServerCommand } from "./telemetry/types.js";
12	import { CallToolRequestSchema, CallToolResult } from "@modelcontextprotocol/sdk/types.js";	2✔
13	import assert from "assert";	2✔
14	import { ToolBase } from "./tools/tool.js";
15
16	export interface ServerOptions {
17	session: Session;
18	userConfig: UserConfig;
19	mcpServer: McpServer;
20	telemetry: Telemetry;
21	}
22
23	export class Server {	2✔
24	public readonly session: Session;
25	public readonly mcpServer: McpServer;
26	private readonly telemetry: Telemetry;
27	public readonly userConfig: UserConfig;
28	public readonly tools: ToolBase[] = [];	2✔
29	private readonly startTime: number;
30
31	constructor({ session, mcpServer, userConfig, telemetry }: ServerOptions) {	2✔
32	this.startTime = Date.now();	34✔
33	this.session = session;	34✔
34	this.telemetry = telemetry;	34✔
35	this.mcpServer = mcpServer;	34✔
36	this.userConfig = userConfig;	34✔
37	}	34✔
38
39	async connect(transport: Transport): Promise<void> {	2✔
40	await this.validateConfig();	34✔
41
42	this.mcpServer.server.registerCapabilities({ logging: {} });	34✔
43
44	this.registerTools();	34✔
45	this.registerResources();	34✔
46
47	// This is a workaround for an issue we've seen with some models, where they'll see that everything in the `arguments`
48	// object is optional, and then not pass it at all. However, the MCP server expects the `arguments` object to be if
49	// the tool accepts any arguments, even if they're all optional.
50	//
51	// see: https://github.com/modelcontextprotocol/typescript-sdk/blob/131776764536b5fdca642df51230a3746fb4ade0/src/server/mcp.ts#L705
52	// Since paramsSchema here is not undefined, the server will create a non-optional z.object from it.
53	const existingHandler = (	34✔
54	this.mcpServer.server["_requestHandlers"] as Map<	34✔
55	string,
56	(request: unknown, extra: unknown) => Promise<CallToolResult>
57	>
58	).get(CallToolRequestSchema.shape.method.value);	34✔
59
60	assert(existingHandler, "No existing handler found for CallToolRequestSchema");	34✔
61
62	this.mcpServer.server.setRequestHandler(CallToolRequestSchema, (request, extra): Promise<CallToolResult> => {	34✔
63	if (!request.params.arguments) {	372!
64	request.params.arguments = {};	1✔
65	}	1✔
66
67	return existingHandler(request, extra);	372✔
68	});	34✔
69
70	const loggers: LoggerBase[] = [];	34✔
71	if (this.userConfig.loggers.includes("mcp")) {	34✔
72	loggers.push(new McpLogger(this.mcpServer));	2✔
73	}	2✔
74	if (this.userConfig.loggers.includes("disk")) {	34✔
75	loggers.push(await DiskLogger.fromPath(this.userConfig.logPath));	2✔
76	}	2✔
77	if (this.userConfig.loggers.includes("stderr")) {	34✔
78	loggers.push(new ConsoleLogger());	32✔
79	}	32✔
80	logger.setLoggers(...loggers);	34✔
81
82	this.mcpServer.server.oninitialized = () => {	34✔
83	this.session.setAgentRunner(this.mcpServer.server.getClientVersion());	34✔
84	this.session.sessionId = new ObjectId().toString();	34✔
85
86	logger.info(	34✔
87	LogId.serverInitialized,	34✔
88	"server",	34✔
89	`Server started with transport ${transport.constructor.name} and agent runner ${this.session.agentRunner?.name}`	34✔
90	);	34✔
91
92	this.emitServerEvent("start", Date.now() - this.startTime);	34✔
93	};	34✔
94
95	this.mcpServer.server.onclose = () => {	34✔
96	const closeTime = Date.now();	34✔
97	this.emitServerEvent("stop", Date.now() - closeTime);	34✔
98	};	34✔
99
100	this.mcpServer.server.onerror = (error: Error) => {	34✔
101	const closeTime = Date.now();	×
102	this.emitServerEvent("stop", Date.now() - closeTime, error);	×
103	};	×
104
105	await this.mcpServer.connect(transport);	34✔
106	}	34✔
107
108	async close(): Promise<void> {	2✔
109	await this.telemetry.close();	34✔
110	await this.session.close();	34✔
111	await this.mcpServer.close();	34✔
112	}	34✔
113
114	/**
115	* Emits a server event
116	* @param command - The server command (e.g., "start", "stop", "register", "deregister")
117	* @param additionalProperties - Additional properties specific to the event
118	*/
119	private emitServerEvent(command: ServerCommand, commandDuration: number, error?: Error) {	2✔
120	const event: ServerEvent = {	68✔
121	timestamp: new Date().toISOString(),	68✔
122	source: "mdbmcp",	68✔
123	properties: {	68✔
124	result: "success",	68✔
125	duration_ms: commandDuration,	68✔
126	component: "server",	68✔
127	category: "other",	68✔
128	command: command,	68✔
129	},	68✔
130	};	68✔
131
132	if (command === "start") {	68✔
133	event.properties.startup_time_ms = commandDuration;	34✔
134	event.properties.read_only_mode = this.userConfig.readOnly \|\| false;	34✔
135	event.properties.disabled_tools = this.userConfig.disabledTools \|\| [];	34!
136	}	34✔
137	if (command === "stop") {	68✔
138	event.properties.runtime_duration_ms = Date.now() - this.startTime;	34✔
139	if (error) {	34!
140	event.properties.result = "failure";	×
141	event.properties.reason = error.message;	×
142	}	×
143	}	34✔
144
145	this.telemetry.emitEvents([event]).catch(() => {});	68✔
146	}	68✔
147
148	private registerTools() {	2✔
149	for (const toolConstructor of [...AtlasTools, ...MongoDbTools]) {	34✔
150	const tool = new toolConstructor(this.session, this.userConfig, this.telemetry);	1,088✔
151	if (tool.register(this)) {	1,088✔
152	this.tools.push(tool);	761✔
153	}	761✔
154	}	1,088✔
155	}	34✔
156
157	private registerResources() {	2✔
158	this.mcpServer.resource(	34✔
159	"config",	34✔
160	"config://config",	34✔
161	{	34✔
162	description:	34✔
163	"Server configuration, supplied by the user either as environment variables or as startup arguments",	34✔
164	},	34✔
165	(uri) => {	34✔
166	const result = {	×
167	telemetry: this.userConfig.telemetry,	×
168	logPath: this.userConfig.logPath,	×
169	connectionString: this.userConfig.connectionString	×
170	? "set; access to MongoDB tools are currently available to use"	×
171	: "not set; before using any MongoDB tool, you need to configure a connection string, alternatively you can setup MongoDB Atlas access, more info at 'https://github.com/mongodb-js/mongodb-mcp-server'.",	×
172	connectOptions: this.userConfig.connectOptions,	×
173	atlas:	×
174	this.userConfig.apiClientId && this.userConfig.apiClientSecret	×
175	? "set; MongoDB Atlas tools are currently available to use"	×
176	: "not set; MongoDB Atlas tools are currently unavailable, to have access to MongoDB Atlas tools like creating clusters or connecting to clusters make sure to setup credentials, more info at 'https://github.com/mongodb-js/mongodb-mcp-server'.",	×
177	};	×
178	return {	×
179	contents: [	×
180	{	×
181	text: JSON.stringify(result),	×
182	mimeType: "application/json",	×
183	uri: uri.href,	×
184	},	×
185	],	×
186	};	×
187	}	×
188	);	34✔
189	}	34✔
190
191	private async validateConfig(): Promise<void> {	2✔
192	const transport = this.userConfig.transport as string;	34✔
193	if (transport !== "http" && transport !== "stdio") {	34!
NEW 194	throw new Error(`Invalid transport: ${transport}`);	×
NEW 195	}	×
196
197	const telemetry = this.userConfig.telemetry as string;	34✔
198	if (telemetry !== "enabled" && telemetry !== "disabled") {	34!
NEW 199	throw new Error(`Invalid telemetry: ${telemetry}`);	×
NEW 200	}	×
201
202	if (this.userConfig.httpPort < 1 \|\| this.userConfig.httpPort > 65535) {	34!
NEW 203	throw new Error(`Invalid httpPort: ${this.userConfig.httpPort}`);	×
NEW 204	}	×
205
206	if (this.userConfig.loggers.length === 0) {	34!
NEW 207	throw new Error("No loggers found in config");	×
NEW 208	}	×
209
210	const loggerTypes = new Set(this.userConfig.loggers);	34✔
211	if (loggerTypes.size !== this.userConfig.loggers.length) {	34!
NEW 212	throw new Error("Duplicate loggers found in config");	×
NEW 213	}	×
214
215	for (const loggerType of this.userConfig.loggers as string[]) {	34✔
216	if (loggerType !== "mcp" && loggerType !== "disk" && loggerType !== "stderr") {	36!
NEW 217	throw new Error(`Invalid logger: ${loggerType}`);	×
NEW 218	}	×
219	}	36✔
220
221	if (this.userConfig.connectionString) {	34!
222	try {	1✔
223	await this.session.connectToMongoDB(this.userConfig.connectionString, this.userConfig.connectOptions);	1✔
224	} catch (error) {	1!
225	console.error(	×
226	"Failed to connect to MongoDB instance using the connection string from the config: ",	×
227	error	×
228	);	×
229	throw new Error("Failed to connect to MongoDB instance using the connection string from the config");	×
230	}	×
231	}	1✔
232
233	if (this.userConfig.apiClientId && this.userConfig.apiClientSecret) {	34✔
234	try {	8✔
235	await this.session.apiClient.validateAccessToken();	8✔
236	} catch (error) {	8!
237	if (this.userConfig.connectionString === undefined) {	×
238	console.error("Failed to validate MongoDB Atlas the credentials from the config: ", error);	×
239
240	throw new Error(	×
241	"Failed to connect to MongoDB Atlas instance using the credentials from the config"	×
242	);	×
243	}	×
244	console.error(	×
245	"Failed to validate MongoDB Atlas the credentials from the config, but validated the connection string."	×
246	);	×
247	}	×
248	}	8✔
249	}	34✔
250	}	2✔

mongodb-js / mongodb-mcp-server / 16295830656

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous