@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/src/utils/transports/stdio-transport.d.ts

@@ -1,21 +1,16 @@
-import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { StdioServerParameters } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
 import type { LogStorageService } from '../../services/log-storage.service.js';
-export interface StdioServerParameters {
-    command: string;
-    args?: string[];
-    env?: NodeJS.ProcessEnv;
-    stderr?: 'inherit' | 'pipe' | 'ignore';
-    cwd?: string;
-}
+import { PassThrough } from 'stream';
 export interface StdioTransportOptions {
-    serverId?: string;
+    compositeKey?: string;
     logStorage?: LogStorageService;
 }
 /**
  * A transport implementation for communicating with MCP (Model Context Protocol) servers
- * via standard input/output streams. This transport spawns a child process and establishes
- * bidirectional communication using stdin/stdout for JSON-RPC message exchange.
+ * via standard input/output streams. This transport wraps the official SDK's StdioClientTransport
+ * and provides consistent logging and integration with the MCP Hub Lite system.
  *
  * The StdioTransport handles:
  * - Cross-platform process spawning (including Windows batch file compatibility)
@@ -30,19 +25,11 @@ export interface StdioTransportOptions {
  * @implements {Transport}
  */
 export declare class StdioTransport implements Transport {
-    private _process?;
-    private _readBuffer;
-    private _stderrStream;
-    private _serverParams;
+    private _transport;
     private _serverName?;
-    private _serverId?;
+    private _compositeKey?;
     private _logStorage?;
-    /**
-     * Gets the process ID of the spawned child process.
-     *
-     * @returns {number | undefined} The PID of the child process, or undefined if not started
-     */
-    get pid(): number | undefined;
+    private _stderrStream;
     onclose?: () => void;
     onerror?: (error: Error) => void;
     onmessage?: (message: JSONRPCMessage) => void;
@@ -59,11 +46,11 @@ export declare class StdioTransport implements Transport {
     /**
      * Starts the transport by spawning the child process and establishing communication channels.
      *
-     * This method handles platform-specific considerations:
-     * - On Windows, it automatically wraps batch commands (like npx, npm, etc.) with cmd.exe /c
-     * - Sets up proper stdio configuration based on the server parameters
-     * - Configures event listeners for process lifecycle events
-     * - Establishes data flow for stdout and stderr handling
+     * This method delegates to the SDK's StdioClientTransport.start() method which handles:
+     * - Platform-specific process spawning (including Windows batch file compatibility)
+     * - Proper stdio configuration
+     * - Event listeners for process lifecycle events
+     * - Data flow for stdout and stderr handling
      *
      * @returns {Promise<void>} Resolves when the child process is successfully spawned
      * @throws {Error} If the transport is already started
@@ -72,36 +59,23 @@ export declare class StdioTransport implements Transport {
     /**
      * Gets the stderr stream for the child process.
      *
-     * Returns a PassThrough stream if stderr is configured as 'pipe', otherwise returns
-     * the actual stderr stream from the child process, or null if no stderr is available.
+     * Returns our PassThrough stream that captures stderr data.
      *
-     * @returns {PassThrough | NodeJS.ReadableStream | null} The stderr stream or null
+     * @returns {PassThrough | null} The stderr stream or null
      */
-    get stderr(): import("node:stream").Readable | null;
+    get stderr(): PassThrough | null;
     /**
-     * Processes the internal read buffer to extract and dispatch JSON-RPC messages.
-     *
-     * This method continuously reads complete JSON-RPC messages from the buffer
-     * and dispatches them to the onmessage callback. It handles partial messages
-     * by leaving incomplete data in the buffer for future processing.
-     *
-     * The method uses a while loop to process all available complete messages
-     * in a single call, ensuring efficient message handling without blocking.
+     * Gets the process ID of the spawned child process.
      *
-     * @private
+     * @returns {number | undefined} The PID of the child process, or undefined if not started
      */
-    processReadBuffer(): void;
+    get pid(): number | undefined;
     /**
      * Closes the transport by gracefully terminating the child process.
      *
-     * This method implements a graceful shutdown sequence:
-     * 1. Sends SIGTERM to allow the child process to clean up
-     * 2. Waits up to 5 seconds for graceful termination
-     * 3. Forces termination with SIGKILL if the process doesn't exit
-     * 4. Cleans up internal state and resolves the promise
-     *
-     * The method ensures proper cleanup of the read buffer and handles
-     * any errors that occur during the shutdown process.
+     * This method delegates to the SDK's StdioClientTransport.close() method which handles:
+     * - Graceful shutdown sequence with SIGTERM/SIGKILL
+     * - Proper cleanup of internal state
      *
      * @returns {Promise<void>} Resolves when the transport is fully closed
      */
@@ -109,13 +83,10 @@ export declare class StdioTransport implements Transport {
     /**
      * Sends a JSON-RPC message to the child process via stdin.
      *
-     * This method serializes the message to JSON, appends a newline character,
-     * and writes it to the child process's stdin stream. It validates that
-     * the transport is connected before attempting to send the message.
+     * This method delegates to the SDK's StdioClientTransport.send() method.
      *
      * @param {JSONRPCMessage} message - The JSON-RPC message to send
      * @returns {Promise<void>} Resolves when the message is written to stdin
-     * @throws {Error} If the transport is not connected (no active child process)
      */
     send(message: JSONRPCMessage): Promise<void>;
 }

package/dist/server/src/utils/transports/stdio-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stdio-transport.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/stdio-transport.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAE1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAgC1E,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,MAAM,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;IACvC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,YAAW,SAAS;IAC9C,OAAO,CAAC,QAAQ,CAAC,CAAe;IAChC,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAC,CAAoB;IAExC;;;;OAIG;IACH,IAAW,GAAG,IAAI,MAAM,GAAG,SAAS,CAEnC;IAEM,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEzC;;;;;;OAMG;gBACS,MAAM,EAAE,qBAAqB,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB;IAU/F;;;;;;;;;;;OAWG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAmJ5B;;;;;;;OAOG;IACH,IAAI,MAAM,0CAET;IAED;;;;;;;;;;;OAWG;IACH,iBAAiB;IAcjB;;;;;;;;;;;;;OAaG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0C5B;;;;;;;;;;OAUG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAOnD"}
+{"version":3,"file":"stdio-transport.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/stdio-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,qBAAqB,EACtB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAErC,MAAM,WAAW,qBAAqB;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,YAAW,SAAS;IAC9C,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,WAAW,CAAC,CAAoB;IACxC,OAAO,CAAC,aAAa,CAA4B;IAE1C,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEzC;;;;;;OAMG;gBACS,MAAM,EAAE,qBAAqB,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB;IAiB/F;;;;;;;;;;;OAWG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2C5B;;;;;;OAMG;IACH,IAAI,MAAM,uBAET;IAED;;;;OAIG;IACH,IAAW,GAAG,IAAI,MAAM,GAAG,SAAS,CAEnC;IAED;;;;;;;;OAQG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;;;;;;OAOG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAGnD"}

package/dist/server/src/utils/transports/stdio-transport.js

@@ -1,37 +1,10 @@
-import { spawn } from 'child_process';
-import { PassThrough } from 'stream';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { logger } from '../logger.js';
-// Re-implement ReadBuffer as it is not exported from SDK root
-class ReadBuffer {
-    _buffer;
-    append(chunk) {
-        this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
-    }
-    readMessage() {
-        if (!this._buffer) {
-            return null;
-        }
-        const index = this._buffer.indexOf('\n');
-        if (index === -1) {
-            return null;
-        }
-        const line = this._buffer.toString('utf8', 0, index).replace(/\r$/, '');
-        this._buffer = this._buffer.subarray(index + 1);
-        try {
-            return JSON.parse(line);
-        }
-        catch {
-            return null;
-        }
-    }
-    clear() {
-        this._buffer = undefined;
-    }
-}
+import { PassThrough } from 'stream';
 /**
  * A transport implementation for communicating with MCP (Model Context Protocol) servers
- * via standard input/output streams. This transport spawns a child process and establishes
- * bidirectional communication using stdin/stdout for JSON-RPC message exchange.
+ * via standard input/output streams. This transport wraps the official SDK's StdioClientTransport
+ * and provides consistent logging and integration with the MCP Hub Lite system.
  *
  * The StdioTransport handles:
  * - Cross-platform process spawning (including Windows batch file compatibility)
@@ -46,21 +19,11 @@ class ReadBuffer {
  * @implements {Transport}
  */
 export class StdioTransport {
-    _process;
-    _readBuffer = new ReadBuffer();
-    _stderrStream = null;
-    _serverParams;
+    _transport;
     _serverName;
-    _serverId;
+    _compositeKey;
     _logStorage;
-    /**
-     * Gets the process ID of the spawned child process.
-     *
-     * @returns {number | undefined} The PID of the child process, or undefined if not started
-     */
-    get pid() {
-        return this._process?.pid;
-    }
+    _stderrStream = null;
     onclose;
     onerror;
     onmessage;
@@ -74,251 +37,107 @@ export class StdioTransport {
      * @param {StdioTransportOptions} [options] - Additional options for the transport
      */
     constructor(server, serverName, options) {
-        this._serverParams = server;
+        // Convert our server parameters to match SDK format
+        const sdkParams = {
+            command: server.command,
+            args: server.args,
+            env: server.env,
+            stderr: 'pipe', // Always use pipe for stderr to enable logging
+            cwd: server.cwd
+        };
+        this._transport = new StdioClientTransport(sdkParams);
         this._serverName = serverName;
-        this._serverId = options?.serverId;
+        this._compositeKey = options?.compositeKey;
         this._logStorage = options?.logStorage;
-        if (server.stderr === 'pipe') {
-            this._stderrStream = new PassThrough();
-        }
+        this._stderrStream = new PassThrough();
     }
     /**
      * Starts the transport by spawning the child process and establishing communication channels.
      *
-     * This method handles platform-specific considerations:
-     * - On Windows, it automatically wraps batch commands (like npx, npm, etc.) with cmd.exe /c
-     * - Sets up proper stdio configuration based on the server parameters
-     * - Configures event listeners for process lifecycle events
-     * - Establishes data flow for stdout and stderr handling
+     * This method delegates to the SDK's StdioClientTransport.start() method which handles:
+     * - Platform-specific process spawning (including Windows batch file compatibility)
+     * - Proper stdio configuration
+     * - Event listeners for process lifecycle events
+     * - Data flow for stdout and stderr handling
      *
      * @returns {Promise<void>} Resolves when the child process is successfully spawned
      * @throws {Error} If the transport is already started
      */
     async start() {
-        if (this._process) {
-            throw new Error('StdioTransport already started!');
-        }
-        let command = this._serverParams.command;
-        let args = this._serverParams.args ?? [];
-        // Windows compatibility: Batch files (npx, npm, etc.) need cmd.exe /c to run with shell: false
-        if (process.platform === 'win32') {
-            const knownBatchCommands = ['npx', 'npm', 'pnpm', 'yarn', 'uvx'];
-            if (knownBatchCommands.includes(command) ||
-                command.endsWith('.cmd') ||
-                command.endsWith('.bat')) {
-                // Use cmd.exe /c to execute the batch file
-                args = ['/c', command, ...args];
-                command = 'cmd.exe';
-            }
-        }
-        return new Promise((resolve, reject) => {
-            this._process = spawn(command, args, {
-                env: { ...process.env, ...this._serverParams.env },
-                stdio: [
-                    'pipe',
-                    'pipe',
-                    this._serverParams.stderr === 'pipe' ? 'pipe' : this._serverParams.stderr || 'inherit'
-                ],
-                shell: false,
-                windowsHide: true, // Force hide window on Windows
-                cwd: this._serverParams.cwd
-            });
-            this._process.on('error', (error) => {
-                reject(error);
-                this.onerror?.(error);
-            });
-            this._process.on('spawn', () => {
-                resolve();
-            });
-            this._process.on('close', () => {
-                this._process = undefined;
-                this.onclose?.();
-            });
-            this._process.stdin?.on('error', (error) => {
-                this.onerror?.(error);
-            });
-            this._process.stdout?.on('data', (chunk) => {
-                const dataStr = chunk.toString('utf8');
-                // Forward raw stdout data
-                this.onstdout?.(dataStr);
-                // Don't log raw JSON-RPC communication to avoid log noise
-                // Only need to view raw communication during development debugging
-                // Parse JSON-RPC messages
-                this._readBuffer.append(chunk);
-                this.processReadBuffer();
-            });
-            this._process.stdout?.on('error', (error) => {
-                this.onerror?.(error);
-            });
-            /**
-             * Handles stderr data with common processing logic.
-             *
-             * @param chunk - The stderr data chunk
-             * @param writeToStream - Whether to write data to the PassThrough stream
-             */
-            const handleStderrData = (chunk, writeToStream = false) => {
-                const dataStr = chunk.toString('utf8');
+        // Set up event handlers before starting
+        this._transport.onmessage = (message) => {
+            this.onmessage?.(message);
+        };
+        this._transport.onerror = (error) => {
+            this.onerror?.(error);
+        };
+        this._transport.onclose = () => {
+            this.onclose?.();
+        };
+        // Start the underlying transport
+        await this._transport.start();
+        // Handle stderr data by listening to the transport's stderr stream
+        if (this._transport.stderr) {
+            this._transport.stderr.on('data', (chunk) => {
+                const dataStr = chunk.toString('utf8').trim();
+                if (!dataStr)
+                    return;
                 // Forward raw stderr data
                 this.onstderr?.(dataStr);
-                const trimmedData = dataStr.trim();
-                let logLevel = 'info';
-                // Identify log levels by keywords: only explicit error/warning markers
-                // use corresponding levels, everything else defaults to info
-                const lowerData = trimmedData.toLowerCase();
-                // Error level keywords
-                if (lowerData.includes('error') ||
-                    lowerData.includes('err') ||
-                    lowerData.includes('exception') ||
-                    lowerData.includes('fatal') ||
-                    lowerData.includes('critical')) {
-                    logLevel = 'error';
-                }
-                // Warn level keywords
-                else if (lowerData.includes('warn') ||
-                    lowerData.includes('wrn') ||
-                    lowerData.includes('warning') ||
-                    lowerData.includes('deprecation') ||
-                    lowerData.includes('deprecated')) {
-                    logLevel = 'warn';
+                // Log stderr output (per MCP spec, stderr is not necessarily errors)
+                const serverIdentifier = this._compositeKey || this._serverName || 'Unknown Server';
+                logger.serverLog('info', serverIdentifier, dataStr, { pid: this.pid });
+                if (this._logStorage && this._compositeKey) {
+                    this._logStorage.append(this._compositeKey, 'info', dataStr);
                 }
-                if (this._serverName) {
-                    logger.serverLog(logLevel, this._serverName, trimmedData, {
-                        pid: this._process?.pid
-                    });
+                // Also write to our PassThrough stream for compatibility
+                // Guard against write after end during close() race condition
+                if (this._stderrStream && !this._stderrStream.writableEnded) {
+                    this._stderrStream.write(chunk);
                 }
-                else {
-                    logger.serverLog(logLevel, 'Unknown Server', trimmedData, {
-                        pid: this._process?.pid
-                    });
-                }
-                // Store in logStorage for frontend display if available
-                if (this._logStorage && this._serverId) {
-                    this._logStorage.append(this._serverId, logLevel, `[${this._serverName || 'Unknown Server'}] [STDERR] ${trimmedData}`);
-                }
-                // Optionally write to PassThrough stream if configured
-                if (writeToStream) {
-                    this._stderrStream?.write(chunk);
-                }
-            };
-            if (this._stderrStream && this._process.stderr) {
-                this._process.stderr.on('data', (chunk) => {
-                    handleStderrData(chunk, true); // Write to PassThrough stream for piped stderr
-                });
-            }
-            else if (this._process.stderr) {
-                // If stderr is not in pipe mode, listen directly
-                this._process.stderr.on('data', (chunk) => {
-                    handleStderrData(chunk, false); // No PassThrough stream for non-piped stderr
-                });
-            }
-        });
+            });
+        }
     }
     /**
      * Gets the stderr stream for the child process.
      *
-     * Returns a PassThrough stream if stderr is configured as 'pipe', otherwise returns
-     * the actual stderr stream from the child process, or null if no stderr is available.
+     * Returns our PassThrough stream that captures stderr data.
      *
-     * @returns {PassThrough | NodeJS.ReadableStream | null} The stderr stream or null
+     * @returns {PassThrough | null} The stderr stream or null
      */
     get stderr() {
-        return this._stderrStream ?? this._process?.stderr ?? null;
+        return this._stderrStream;
     }
     /**
-     * Processes the internal read buffer to extract and dispatch JSON-RPC messages.
-     *
-     * This method continuously reads complete JSON-RPC messages from the buffer
-     * and dispatches them to the onmessage callback. It handles partial messages
-     * by leaving incomplete data in the buffer for future processing.
-     *
-     * The method uses a while loop to process all available complete messages
-     * in a single call, ensuring efficient message handling without blocking.
+     * Gets the process ID of the spawned child process.
      *
-     * @private
+     * @returns {number | undefined} The PID of the child process, or undefined if not started
      */
-    processReadBuffer() {
-        while (true) {
-            try {
-                const message = this._readBuffer.readMessage();
-                if (message === null) {
-                    break;
-                }
-                this.onmessage?.(message);
-            }
-            catch (error) {
-                this.onerror?.(error);
-            }
-        }
+    get pid() {
+        return this._transport.pid ?? undefined;
     }
     /**
      * Closes the transport by gracefully terminating the child process.
      *
-     * This method implements a graceful shutdown sequence:
-     * 1. Sends SIGTERM to allow the child process to clean up
-     * 2. Waits up to 5 seconds for graceful termination
-     * 3. Forces termination with SIGKILL if the process doesn't exit
-     * 4. Cleans up internal state and resolves the promise
-     *
-     * The method ensures proper cleanup of the read buffer and handles
-     * any errors that occur during the shutdown process.
+     * This method delegates to the SDK's StdioClientTransport.close() method which handles:
+     * - Graceful shutdown sequence with SIGTERM/SIGKILL
+     * - Proper cleanup of internal state
      *
      * @returns {Promise<void>} Resolves when the transport is fully closed
      */
     async close() {
-        if (this._process) {
-            return new Promise((resolve) => {
-                // Listen for child process exit events
-                const cleanup = () => {
-                    this._process = undefined;
-                    this._readBuffer.clear();
-                    resolve();
-                };
-                if (this._process) {
-                    this._process.once('close', cleanup);
-                    this._process.once('exit', cleanup);
-                    // Send SIGTERM signal to give child process a chance to shut down gracefully
-                    try {
-                        this._process.kill('SIGTERM');
-                        // Set timeout protection to force kill if child process doesn't exit within 5 seconds
-                        const timeout = setTimeout(() => {
-                            if (this._process) {
-                                logger.warn('Child process did not exit gracefully, force killing...');
-                                this._process.kill('SIGKILL');
-                            }
-                        }, 5000);
-                        // Ensure timeout timer is cleared after process exits
-                        this._process.once('close', () => clearTimeout(timeout));
-                        this._process.once('exit', () => clearTimeout(timeout));
-                    }
-                    catch (error) {
-                        logger.error('Error closing stdio transport:', error);
-                        cleanup();
-                    }
-                }
-                else {
-                    // Process is already undefined, just resolve
-                    resolve();
-                }
-            });
-        }
-        this._readBuffer.clear();
+        await this._transport.close();
+        this._stderrStream?.end();
     }
     /**
      * Sends a JSON-RPC message to the child process via stdin.
      *
-     * This method serializes the message to JSON, appends a newline character,
-     * and writes it to the child process's stdin stream. It validates that
-     * the transport is connected before attempting to send the message.
+     * This method delegates to the SDK's StdioClientTransport.send() method.
      *
      * @param {JSONRPCMessage} message - The JSON-RPC message to send
      * @returns {Promise<void>} Resolves when the message is written to stdin
-     * @throws {Error} If the transport is not connected (no active child process)
      */
     async send(message) {
-        if (!this._process?.stdin) {
-            throw new Error('Not connected');
-        }
-        const json = JSON.stringify(message) + '\n';
-        this._process.stdin.write(json);
+        await this._transport.send(message);
     }
 }

package/dist/server/src/utils/transports/streamable-http-transport.d.ts

@@ -29,6 +29,7 @@ export declare class StreamableHttpTransport implements Transport {
     private url;
     private headers;
     private timeout;
+    private proxy?;
     /**
      * Internal reference to the underlying MCP SDK transport instance
      * @private
@@ -40,6 +41,16 @@ export declare class StreamableHttpTransport implements Transport {
      * @private
      */
     private isClosing;
+    /**
+     * Server name for logging context
+     * @private
+     */
+    private _serverName?;
+    /**
+     * Composite key (serverName-serverIndex) for logging context
+     * @private
+     */
+    private _compositeKey?;
     /**
      * Event handler called when a JSON-RPC message is received from the server
      * @public
@@ -63,8 +74,20 @@ export declare class StreamableHttpTransport implements Transport {
      *                 Commonly used for authentication tokens, API keys, or custom headers
      * @param timeout - Request timeout in milliseconds (default: 30000 = 30 seconds)
      *                  Controls how long to wait for HTTP responses before timing out
+     * @param proxy - Optional proxy configuration
+     * @param serverName - Optional server name for logging
+     * @param compositeKey - Optional composite key (serverName-serverIndex) for logging
+     */
+    constructor(url: string, headers?: Record<string, string>, timeout?: number, proxy?: {
+        url: string;
+    } | undefined, serverName?: string, compositeKey?: string);
+    /**
+     * Helper method to format log messages with server context.
+     *
+     * @param message - The base message
+     * @returns Formatted message with server context if available
      */
-    constructor(url: string, headers?: Record<string, string>, timeout?: number);
+    private formatLogMessage;
     /**
      * Initializes and starts the Streamable HTTP transport connection
      *

package/dist/server/src/utils/transports/streamable-http-transport.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"streamable-http-transport.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/streamable-http-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAK1E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,uBAAwB,YAAW,SAAS;IA0CrD,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IA3CjB;;;OAGG;IACH,OAAO,CAAC,SAAS,CAA8C;IAE/D;;;;OAIG;IACH,OAAO,CAAC,SAAS,CAAS;IAE1B;;;OAGG;IACI,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAErD;;;OAGG;IACI,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAExC;;;OAGG;IACI,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAE5B;;;;;;;;OAQG;gBAEO,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACpC,OAAO,GAAE,MAAc;IAGjC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAwD5B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAoBnD"}
+{"version":3,"file":"streamable-http-transport.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/streamable-http-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAM1E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,uBAAwB,YAAW,SAAS;IAyDrD,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,KAAK,CAAC;IA3DhB;;;OAGG;IACH,OAAO,CAAC,SAAS,CAA8C;IAE/D;;;;OAIG;IACH,OAAO,CAAC,SAAS,CAAS;IAE1B;;;OAGG;IACH,OAAO,CAAC,WAAW,CAAC,CAAS;IAE7B;;;OAGG;IACH,OAAO,CAAC,aAAa,CAAC,CAAS;IAE/B;;;OAGG;IACI,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAErD;;;OAGG;IACI,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAExC;;;OAGG;IACI,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAE5B;;;;;;;;;;;OAWG;gBAEO,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACpC,OAAO,GAAE,MAAc,EACvB,KAAK,CAAC,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,YAAA,EAC/B,UAAU,CAAC,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,MAAM;IAMvB;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA6G5B;;;;;;;;;;;;;;;;;;;OAmBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CA6BnD"}