Merge branch 'main' into chore/mcp-92

Author: kmruiz

.github/workflows/check.yml

@@ -55,4 +55,4 @@ jobs:
           rm -rf node_modules
           npm pkg set scripts.prepare="exit 0"
           npm install --omit=dev
-      - run: npx -y @modelcontextprotocol/inspector@0.16.2 --cli --method tools/list -- node dist/esm/index.js
+      - run: npx -y @modelcontextprotocol/inspector@0.16.5 --cli --method tools/list -- node dist/esm/index.js

.github/workflows/prepare_release.yaml

@@ -28,6 +28,8 @@ jobs:
           node-version-file: package.json
           registry-url: "https://registry.npmjs.org"
           cache: "npm"
+      - name: Install dependencies
+        run: npm ci
       - name: Bump version
         id: bump-version
         run: |

package-lock.json

@@ -62,7 +62,7 @@
     "@ai-sdk/google": "^1.2.22",
     "@ai-sdk/openai": "^1.3.23",
     "@eslint/js": "^9.30.1",
-    "@modelcontextprotocol/inspector": "^0.16.0",
+    "@modelcontextprotocol/inspector": "^0.16.5",
     "@mongodb-js/oidc-mock-provider": "^0.11.3",
     "@redocly/cli": "^2.0.7",
     "@types/express": "^5.0.1",

package.json

@@ -116,6 +116,7 @@ export interface UserConfig extends CliOptions {
     transport: "stdio" | "http";
     httpPort: number;
     httpHost: string;
+    httpHeaders: Record<string, string>;
     loggers: Array<"stderr" | "disk" | "mcp">;
     idleTimeoutMs: number;
     notificationTimeoutMs: number;
@@ -137,6 +138,7 @@ export const defaultUserConfig: UserConfig = {
     loggers: ["disk", "mcp"],
     idleTimeoutMs: 600000, // 10 minutes
     notificationTimeoutMs: 540000, // 9 minutes
+    httpHeaders: {},
 };
 
 export const config = setupUserConfig({

src/common/config.ts

@@ -2,9 +2,9 @@ import fs from "fs/promises";
 import type { MongoLogId, MongoLogWriter } from "mongodb-log-writer";
 import { mongoLogId, MongoLogManager } from "mongodb-log-writer";
 import redact from "mongodb-redact";
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { LoggingMessageNotification } from "@modelcontextprotocol/sdk/types.js";
 import { EventEmitter } from "events";
+import type { Server } from "../lib.js";
 
 export type LogLevel = LoggingMessageNotification["params"]["level"];
 
@@ -51,6 +51,8 @@ export const LogId = {
     streamableHttpTransportSessionCloseNotificationFailure: mongoLogId(1_006_004),
     streamableHttpTransportRequestFailure: mongoLogId(1_006_005),
     streamableHttpTransportCloseFailure: mongoLogId(1_006_006),
+    streamableHttpTransportKeepAliveFailure: mongoLogId(1_006_007),
+    streamableHttpTransportKeepAlive: mongoLogId(1_006_008),
 
     exportCleanupError: mongoLogId(1_007_001),
     exportCreationError: mongoLogId(1_007_002),
@@ -64,7 +66,7 @@ export const LogId = {
     oidcFlow: mongoLogId(1_008_001),
 } as const;
 
-interface LogPayload {
+export interface LogPayload {
     id: MongoLogId;
     context: string;
     message: string;
@@ -152,6 +154,26 @@ export abstract class LoggerBase<T extends EventMap<T> = DefaultEventMap> extend
     public emergency(payload: LogPayload): void {
         this.log("emergency", payload);
     }
+
+    protected mapToMongoDBLogLevel(level: LogLevel): "info" | "warn" | "error" | "debug" | "fatal" {
+        switch (level) {
+            case "info":
+                return "info";
+            case "warning":
+                return "warn";
+            case "error":
+                return "error";
+            case "notice":
+            case "debug":
+                return "debug";
+            case "critical":
+            case "alert":
+            case "emergency":
+                return "fatal";
+            default:
+                return "info";
+        }
+    }
 }
 
 export class ConsoleLogger extends LoggerBase {
@@ -225,42 +247,40 @@ export class DiskLogger extends LoggerBase<{ initialized: [] }> {
 
         this.logWriter[mongoDBLevel]("MONGODB-MCP", id, context, message, payload.attributes);
     }
-
-    private mapToMongoDBLogLevel(level: LogLevel): "info" | "warn" | "error" | "debug" | "fatal" {
-        switch (level) {
-            case "info":
-                return "info";
-            case "warning":
-                return "warn";
-            case "error":
-                return "error";
-            case "notice":
-            case "debug":
-                return "debug";
-            case "critical":
-            case "alert":
-            case "emergency":
-                return "fatal";
-            default:
-                return "info";
-        }
-    }
 }
 
 export class McpLogger extends LoggerBase {
-    public constructor(private readonly server: McpServer) {
+    private static readonly LOG_LEVELS: LogLevel[] = [
+        "debug",
+        "info",
+        "notice",
+        "warning",
+        "error",
+        "critical",
+        "alert",
+        "emergency",
+    ];
+
+    public constructor(private readonly server: Server) {
         super();
     }
 
     protected readonly type: LoggerType = "mcp";
 
     protected logCore(level: LogLevel, payload: LogPayload): void {
         // Only log if the server is connected
-        if (!this.server?.isConnected()) {
+        if (!this.server.mcpServer.isConnected()) {
+            return;
+        }
+
+        const minimumLevel = McpLogger.LOG_LEVELS.indexOf(this.server.mcpLogLevel);
+        const currentLevel = McpLogger.LOG_LEVELS.indexOf(level);
+        if (minimumLevel > currentLevel) {
+            // Don't log if the requested level is lower than the minimum level
             return;
         }
 
-        void this.server.server.sendLoggingMessage({
+        void this.server.mcpServer.server.sendLoggingMessage({
             level,
             data: `[${payload.context}]: ${payload.message}`,
         });
@@ -286,7 +306,11 @@ export class CompositeLogger extends LoggerBase {
     public log(level: LogLevel, payload: LogPayload): void {
         // Override the public method to avoid the base logger redacting the message payload
         for (const logger of this.loggers) {
-            logger.log(level, { ...payload, attributes: { ...this.attributes, ...payload.attributes } });
+            const attributes =
+                Object.keys(this.attributes).length > 0 || payload.attributes
+                    ? { ...this.attributes, ...payload.attributes }
+                    : undefined;
+            logger.log(level, { ...payload, attributes });
         }
     }
 

src/common/logger.ts

@@ -1,94 +1,63 @@
 import { getDeviceId } from "@mongodb-js/device-id";
-import nodeMachineId from "node-machine-id";
+import * as nodeMachineId from "node-machine-id";
 import type { LoggerBase } from "../common/logger.js";
 import { LogId } from "../common/logger.js";
 
 export const DEVICE_ID_TIMEOUT = 3000;
 
 export class DeviceId {
-    private deviceId: string | undefined = undefined;
-    private deviceIdPromise: Promise<string> | undefined = undefined;
-    private abortController: AbortController | undefined = undefined;
+    private static readonly UnknownDeviceId = Promise.resolve("unknown");
+
+    private deviceIdPromise: Promise<string>;
+    private abortController: AbortController;
     private logger: LoggerBase;
     private readonly getMachineId: () => Promise<string>;
     private timeout: number;
-    private static instance: DeviceId | undefined = undefined;
 
     private constructor(logger: LoggerBase, timeout: number = DEVICE_ID_TIMEOUT) {
         this.logger = logger;
         this.timeout = timeout;
         this.getMachineId = (): Promise<string> => nodeMachineId.machineId(true);
+        this.abortController = new AbortController();
+
+        this.deviceIdPromise = DeviceId.UnknownDeviceId;
     }
 
-    public static create(logger: LoggerBase, timeout?: number): DeviceId {
-        if (this.instance) {
-            throw new Error("DeviceId instance already exists, use get() to retrieve the device ID");
-        }
+    private initialize(): void {
+        this.deviceIdPromise = getDeviceId({
+            getMachineId: this.getMachineId,
+            onError: (reason, error) => {
+                this.handleDeviceIdError(reason, String(error));
+            },
+            timeout: this.timeout,
+            abortSignal: this.abortController.signal,
+        });
+    }
 
+    public static create(logger: LoggerBase, timeout?: number): DeviceId {
         const instance = new DeviceId(logger, timeout ?? DEVICE_ID_TIMEOUT);
-        instance.setup();
-
-        this.instance = instance;
+        instance.initialize();
 
         return instance;
     }
 
-    private setup(): void {
-        this.deviceIdPromise = this.calculateDeviceId();
-    }
-
     /**
      * Closes the device ID calculation promise and abort controller.
      */
     public close(): void {
-        if (this.abortController) {
-            this.abortController.abort();
-            this.abortController = undefined;
-        }
-
-        this.deviceId = undefined;
-        this.deviceIdPromise = undefined;
-        DeviceId.instance = undefined;
+        this.abortController.abort();
     }
 
     /**
      * Gets the device ID, waiting for the calculation to complete if necessary.
      * @returns Promise that resolves to the device ID string
      */
     public get(): Promise<string> {
-        if (this.deviceId) {
-            return Promise.resolve(this.deviceId);
-        }
-
-        if (this.deviceIdPromise) {
-            return this.deviceIdPromise;
-        }
-
-        return this.calculateDeviceId();
-    }
-
-    /**
-     * Internal method that performs the actual device ID calculation.
-     */
-    private async calculateDeviceId(): Promise<string> {
-        if (!this.abortController) {
-            this.abortController = new AbortController();
-        }
-
-        this.deviceIdPromise = getDeviceId({
-            getMachineId: this.getMachineId,
-            onError: (reason, error) => {
-                this.handleDeviceIdError(reason, String(error));
-            },
-            timeout: this.timeout,
-            abortSignal: this.abortController.signal,
-        });
-
         return this.deviceIdPromise;
     }
 
     private handleDeviceIdError(reason: string, error: string): void {
-        this.deviceIdPromise = Promise.resolve("unknown");
+        this.deviceIdPromise = DeviceId.UnknownDeviceId;
 
         switch (reason) {
             case "resolutionError":

src/helpers/deviceId.ts

@@ -91,8 +91,10 @@ async function main(): Promise<void> {
         transportRunner.logger.info({
             id: LogId.serverCloseRequested,
             context: "server",
-            message: "Closing server",
+            message: `Closing server due to error: ${error as string}`,
+            noRedaction: true,
         });
+
         try {
             await transportRunner.close();
             transportRunner.logger.info({

src/index.ts

@@ -1,4 +1,7 @@
 export { Server, type ServerOptions } from "./server.js";
 export { Telemetry } from "./telemetry/telemetry.js";
 export { Session, type SessionOptions } from "./common/session.js";
-export type { UserConfig } from "./common/config.js";
+export { type UserConfig, defaultUserConfig } from "./common/config.js";
+export { StreamableHttpRunner } from "./transports/streamableHttp.js";
+export { LoggerBase } from "./common/logger.js";
+export type { LogPayload, LoggerType, LogLevel } from "./common/logger.js";

src/lib.ts

@@ -4,6 +4,7 @@ import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { AtlasTools } from "./tools/atlas/tools.js";
 import { MongoDbTools } from "./tools/mongodb/tools.js";
 import { Resources } from "./resources/resources.js";
+import type { LogLevel } from "./common/logger.js";
 import { LogId } from "./common/logger.js";
 import type { Telemetry } from "./telemetry/telemetry.js";
 import type { UserConfig } from "./common/config.js";
@@ -12,6 +13,7 @@ import { type ServerCommand } from "./telemetry/types.js";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import {
     CallToolRequestSchema,
+    SetLevelRequestSchema,
     SubscribeRequestSchema,
     UnsubscribeRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
@@ -32,6 +34,13 @@ export class Server {
     private readonly telemetry: Telemetry;
     public readonly userConfig: UserConfig;
     public readonly tools: ToolBase[] = [];
+
+    private _mcpLogLevel: LogLevel = "debug";
+
+    public get mcpLogLevel(): LogLevel {
+        return this._mcpLogLevel;
+    }
+
     private readonly startTime: number;
     private readonly subscriptions = new Set<string>();
 
@@ -97,6 +106,11 @@ export class Server {
             return {};
         });
 
+        this.mcpServer.server.setRequestHandler(SetLevelRequestSchema, ({ params }) => {
+            this._mcpLogLevel = params.level;
+            return {};
+        });
+
         this.mcpServer.server.oninitialized = (): void => {
             this.session.setMcpClient(this.mcpServer.server.getClientVersion());
             // Placed here to start the connection to the config connection string as soon as the server is initialized.