chore: refactor Transport implementations to accept driverOptions

Author: himanshusinghs

src/index.ts

@@ -36,7 +36,7 @@ function enableFipsIfRequested(): void {
 enableFipsIfRequested();
 
 import { ConsoleLogger, LogId } from "./common/logger.js";
-import { config } from "./common/config.js";
+import { config, driverOptions } from "./common/config.js";
 import crypto from "crypto";
 import { packageInfo } from "./common/packageInfo.js";
 import { StdioRunner } from "./transports/stdio.js";
@@ -49,7 +49,10 @@ async function main(): Promise<void> {
     assertHelpMode();
     assertVersionMode();
 
-    const transportRunner = config.transport === "stdio" ? new StdioRunner(config) : new StreamableHttpRunner(config);
+    const transportRunner =
+        config.transport === "stdio"
+            ? new StdioRunner(config, driverOptions)
+            : new StreamableHttpRunner(config, driverOptions);
     const shutdown = (): void => {
         transportRunner.logger.info({
             id: LogId.serverCloseRequested,

src/transports/base.ts

@@ -1,5 +1,4 @@
-import type { UserConfig } from "../common/config.js";
-import { driverOptions } from "../common/config.js";
+import type { DriverOptions, UserConfig } from "../common/config.js";
 import { packageInfo } from "../common/packageInfo.js";
 import { Server } from "../server.js";
 import { Session } from "../common/session.js";
@@ -15,7 +14,10 @@ export abstract class TransportRunnerBase {
     public logger: LoggerBase;
     public deviceId: DeviceId;
 
-    protected constructor(protected readonly userConfig: UserConfig) {
+    protected constructor(
+        protected readonly userConfig: UserConfig,
+        private readonly driverOptions: DriverOptions
+    ) {
         const loggers: LoggerBase[] = [];
         if (this.userConfig.loggers.includes("stderr")) {
             loggers.push(new ConsoleLogger());
@@ -35,37 +37,37 @@ export abstract class TransportRunnerBase {
         this.deviceId = DeviceId.create(this.logger);
     }
 
-    protected setupServer(userConfig: UserConfig): Server {
+    protected setupServer(): Server {
         const mcpServer = new McpServer({
             name: packageInfo.mcpServerName,
             version: packageInfo.version,
         });
 
         const loggers = [this.logger];
-        if (userConfig.loggers.includes("mcp")) {
+        if (this.userConfig.loggers.includes("mcp")) {
             loggers.push(new McpLogger(mcpServer));
         }
 
         const logger = new CompositeLogger(...loggers);
-        const exportsManager = ExportsManager.init(userConfig, logger);
-        const connectionManager = new ConnectionManager(userConfig, driverOptions, logger, this.deviceId);
+        const exportsManager = ExportsManager.init(this.userConfig, logger);
+        const connectionManager = new ConnectionManager(this.userConfig, this.driverOptions, logger, this.deviceId);
 
         const session = new Session({
-            apiBaseUrl: userConfig.apiBaseUrl,
-            apiClientId: userConfig.apiClientId,
-            apiClientSecret: userConfig.apiClientSecret,
+            apiBaseUrl: this.userConfig.apiBaseUrl,
+            apiClientId: this.userConfig.apiClientId,
+            apiClientSecret: this.userConfig.apiClientSecret,
             logger,
             exportsManager,
             connectionManager,
         });
 
-        const telemetry = Telemetry.create(session, userConfig, this.deviceId);
+        const telemetry = Telemetry.create(session, this.userConfig, this.deviceId);
 
         return new Server({
             mcpServer,
             session,
             telemetry,
-            userConfig,
+            userConfig: this.userConfig,
         });
     }
 

src/transports/stdio.ts

@@ -5,7 +5,7 @@ import type { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
 import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
 import { EJSON } from "bson";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import type { UserConfig } from "../common/config.js";
+import type { DriverOptions, UserConfig } from "../common/config.js";
 
 // This is almost a copy of ReadBuffer from @modelcontextprotocol/sdk
 // but it uses EJSON.parse instead of JSON.parse to handle BSON types
@@ -54,13 +54,13 @@ export function createStdioTransport(): StdioServerTransport {
 export class StdioRunner extends TransportRunnerBase {
     private server: Server | undefined;
 
-    constructor(userConfig: UserConfig) {
-        super(userConfig);
+    constructor(userConfig: UserConfig, driverOptions: DriverOptions) {
+        super(userConfig, driverOptions);
     }
 
     async start(): Promise<void> {
         try {
-            this.server = this.setupServer(this.userConfig);
+            this.server = this.setupServer();
 
             const transport = createStdioTransport();
 

src/transports/streamableHttp.ts

@@ -3,7 +3,7 @@ import type http from "http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { TransportRunnerBase } from "./base.js";
-import type { UserConfig } from "../common/config.js";
+import type { DriverOptions, UserConfig } from "../common/config.js";
 import { LogId } from "../common/logger.js";
 import { randomUUID } from "crypto";
 import { SessionStore } from "../common/sessionStore.js";
@@ -18,8 +18,8 @@ export class StreamableHttpRunner extends TransportRunnerBase {
     private httpServer: http.Server | undefined;
     private sessionStore!: SessionStore;
 
-    constructor(userConfig: UserConfig) {
-        super(userConfig);
+    constructor(userConfig: UserConfig, driverOptions: DriverOptions) {
+        super(userConfig, driverOptions);
     }
 
     async start(): Promise<void> {
@@ -89,7 +89,7 @@ export class StreamableHttpRunner extends TransportRunnerBase {
                     return;
                 }
 
-                const server = this.setupServer(this.userConfig);
+                const server = this.setupServer();
                 const transport = new StreamableHTTPServerTransport({
                     sessionIdGenerator: (): string => randomUUID().toString(),
                     onsessioninitialized: (sessionId): void => {