@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/src/utils/process-tree.js

@@ -0,0 +1,285 @@
+import { spawn } from 'child_process';
+import { logger, LOG_MODULES } from './logger.js';
+/**
+ * Windows Process Tree Utility Module
+ *
+ * This module provides process tree management utilities specifically for Windows.
+ * It handles the case where shell: true spawns cmd.exe which then spawns
+ * the actual working process (like node.exe, python.exe, etc.).
+ *
+ * On non-Windows platforms, all methods return safe default values
+ * and don't perform any actual operations.
+ */
+/**
+ * Gets all child process IDs for a given parent PID on Windows.
+ *
+ * @param pid - Parent process ID
+ @returns Promise resolving to array of child PID
+ */
+export async function getChildren(pid) {
+    if (process.platform !== 'win32') {
+        return [];
+    }
+    try {
+        const result = await executePowerShellCommand(`Get-CimInstance Win32_Process | Where-Object { $_.ParentProcessId -eq ${pid} } | Select-Object -ExpandProperty ProcessId`);
+        const pids = parsePidList(result);
+        return pids;
+    }
+    catch (error) {
+        logger.debug(`Failed to get children for PID ${pid}:`, error, LOG_MODULES.STDIO_TRANSPORT);
+        return [];
+    }
+}
+/**
+ * Gets the entire process tree (all descendants) for a given PID.
+ * Includes the original PID at the beginning of the array.
+ *
+ * @param pid - Root process ID
+ * @returns Array of all process IDs in the tree
+ */
+export async function getProcessTree(pid) {
+    if (process.platform !== 'win32') {
+        return [pid];
+    }
+    const tree = [pid];
+    const queue = [pid];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const children = await getChildren(current);
+        for (const child of children) {
+            if (!tree.includes(child)) {
+                tree.push(child);
+                queue.push(child);
+            }
+        }
+    }
+    return tree;
+}
+/**
+ * Checks if any process in the process tree is still running.
+ *
+ * @param pid - Root process ID
+ * @returns True if any process in the tree is running
+ */
+export async function isAnyInTreeRunning(pid) {
+    if (process.platform !== 'win32') {
+        return isProcessRunning(pid);
+    }
+    try {
+        const tree = await getProcessTree(pid);
+        for (const processId of tree) {
+            if (isProcessRunning(processId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        logger.debug(`Error checking process tree for PID ${pid}:`, error, LOG_MODULES.STDIO_TRANSPORT);
+        return isProcessRunning(pid);
+    }
+}
+/**
+ * Tries to find the actual working process PID in the tree.
+ * This looks for processes that are likely the actual worker
+ * (node.exe, python.exe, etc.) rather than shell processes.
+ *
+ * @param pid - Root process ID
+ * @returns Working process PID if found, undefined otherwise
+ */
+export async function getWorkingProcessPid(pid) {
+    if (process.platform !== 'win32') {
+        return pid;
+    }
+    try {
+        const tree = await getProcessTree(pid);
+        // If only the root process is in the tree, return it
+        if (tree.length === 1) {
+            return pid;
+        }
+        // Get process names for all PIDs in the tree
+        const processInfo = await getProcessInfo(tree);
+        // Filter out shell processes (cmd.exe, powershell.exe, etc.)
+        const workerProcesses = processInfo.filter((info) => !isShellProcess(info.name));
+        if (workerProcesses.length > 0) {
+            // Prefer the deepest (last) worker process in the tree
+            return workerProcesses[workerProcesses.length - 1].pid;
+        }
+        // If no worker processes found, return the last process in the tree
+        return tree[tree.length - 1];
+    }
+    catch (error) {
+        logger.debug(`Error finding working process for PID ${pid}:`, error, LOG_MODULES.STDIO_TRANSPORT);
+        return pid;
+    }
+}
+/**
+ * Kills the entire process tree.
+ *
+ * @param pid - Root process ID
+ * @param signal - Signal to send (default: SIGTERM)
+ */
+export async function killProcessTree(pid, signal = 'SIGTERM') {
+    if (process.platform !== 'win32') {
+        // On non-Windows, just kill the single process
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // Process might already be dead
+        }
+        return;
+    }
+    try {
+        const tree = await getProcessTree(pid);
+        // Kill processes in reverse order (children first, parent last)
+        for (let i = tree.length - 1; i >= 0; i--) {
+            const processId = tree[i];
+            try {
+                process.kill(processId, signal);
+            }
+            catch {
+                // Process might already be dead
+            }
+        }
+    }
+    catch (error) {
+        logger.debug(`Error killing process tree for PID ${pid}:`, error, LOG_MODULES.STDIO_TRANSPORT);
+        // Fallback: try to kill just the root process
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // Process might already be dead
+        }
+    }
+}
+// ==================== Internal Helper Functions ====================
+/**
+ * Checks if a single process is running.
+ *
+ * @param pid - Process ID
+ * @returns True if process is running
+ */
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Executes a PowerShell command and returns the output.
+ *
+ * @param command - PowerShell command
+ * @returns Command output
+ */
+async function executePowerShellCommand(command) {
+    return new Promise((resolve, reject) => {
+        const ps = spawn('powershell.exe', ['-Command', command], {
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        ps.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        ps.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        ps.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(`PowerShell command failed: ${stderr || stdout}`));
+            }
+        });
+        ps.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+/**
+ * Parses a list of PIDs from command output.
+ *
+ * @param output - Command output
+ * * @returns Array of PIDs
+ */
+function parsePidList(output) {
+    const lines = output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const pids = [];
+    for (const line of lines) {
+        const pid = parseInt(line, 10);
+        if (!isNaN(pid) && pid > 0) {
+            pids.push(pid);
+        }
+    }
+    return pids;
+}
+/**
+ * Gets process information for multiple PIDs.
+ *
+ * @param pids - Array of process IDs
+ * @returns Array of process info objects
+ */
+async function getProcessInfo(pids) {
+    if (pids.length === 0) {
+        return [];
+    }
+    const result = await executePowerShellCommand(`Get-CimInstance Win32_Process | Where-Object { ${pids.map((pid) => `$_.ProcessId -eq ${pid}`).join(' -or ')} } | Select-Object ProcessId, Name | ConvertTo-Csv -NoTypeInformation`);
+    return parseProcessInfoCsv(result);
+}
+/**
+ * Parses process info from CSV output.
+ *
+ * @param csvOutput - CSV output from PowerShell
+ * @ *returns Array of process info
+ */
+function parseProcessInfoCsv(csvOutput) {
+    const lines = csvOutput
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length < 2) {
+        return [];
+    }
+    const info = [];
+    // Skip header line
+    for (let i = 1; i < lines.length; i++) {
+        const parts = lines[i].split(',').map((p) => p.trim().replace(/^"|"$/g, ''));
+        if (parts.length >= 2) {
+            const pid = parseInt(parts[0], 10);
+            if (!isNaN(pid) && pid > 0) {
+                info.push({
+                    pid,
+                    name: parts[1].toLowerCase()
+                });
+            }
+        }
+    }
+    return info;
+}
+/**
+ * Checks if a process name is a shell process.
+ *
+ * @param processName - Process name (should be lowercase)
+ * @returns True if it's a shell process
+ */
+function isShellProcess(processName) {
+    const shellProcesses = [
+        'cmd.exe',
+        'powershell.exe',
+        'pwsh.exe',
+        'command.com',
+        'sh.exe',
+        'bash.exe'
+    ];
+    return shellProcesses.includes(processName.toLowerCase());
+}

package/dist/server/src/utils/sort-utils.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Object key sorting utilities for consistent configuration.
+ */
+/**
+ * Sorts object keys alphabetically using localeCompare.
+ * Returns a new object with sorted keys, preserving the original object.
+ *
+ * @param obj - Object to sort
+ * @returns New object with sorted keys
+ */
+export declare function sortObjectKeys<T extends Record<string, unknown>>(obj: T): T;
+/**
+ * Sorts object keys alphabetically, case-insensitive.
+ * Returns a new object with sorted keys, preserving the original object and original key case.
+ *
+ * @param obj - Object to sort
+ * @returns New object with sorted keys (case-insensitive sort)
+ */
+export declare function sortObjectKeysCaseInsensitive<T extends Record<string, unknown>>(obj: T): T;
+/**
+ * Recursively sorts all object keys in a nested structure.
+ * Returns a new object with all nested keys sorted, preserving the original object.
+ *
+ * @param obj - Object to sort recursively
+ * @returns New object with all nested keys sorted
+ */
+export declare function sortObjectKeysDeep<T>(obj: T): T;
+/**
+ * Sorts env and headers objects in a server configuration.
+ * This is a convenience function for server template/instance configurations.
+ * Also normalizes URL fields by removing trailing slashes.
+ *
+ * @param config - Server configuration object with optional env and headers
+ * @returns New object with sorted env and headers keys and normalized URLs
+ */
+export declare function sortServerConfigEnvHeaders<T extends {
+    env?: Record<string, string>;
+    headers?: Record<string, string>;
+}>(config: T): T;
+//# sourceMappingURL=sort-utils.d.ts.map

package/dist/server/src/utils/sort-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/sort-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAoDH;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAW3E;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAa1F;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAmB/C;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,CAAC,SAAS;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,EAC5E,MAAM,EAAE,CAAC,GAAG,CAAC,CAcd"}

package/dist/server/src/utils/sort-utils.js

@@ -0,0 +1,131 @@
+/**
+ * Object key sorting utilities for consistent configuration.
+ */
+/**
+ * Normalizes a URL string by removing trailing slashes.
+ *
+ * @param url - The URL to normalize
+ * @returns Normalized URL
+ */
+function normalizeUrl(url) {
+    return url.replace(/\/+$/, '');
+}
+/**
+ * Normalizes URL fields in a configuration object.
+ * Currently handles:
+ * - url fields at any level
+ * - proxy.url fields
+ *
+ * @param obj - Object to normalize
+ * @returns New object with normalized URLs
+ */
+function normalizeConfigUrls(obj) {
+    if (!obj) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => normalizeConfigUrls(item));
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (key === 'url' && typeof value === 'string') {
+                result[key] = normalizeUrl(value);
+            }
+            else if (key === 'proxy' && typeof value === 'object' && value !== null) {
+                const proxy = value;
+                if (typeof proxy.url === 'string') {
+                    result[key] = { ...proxy, url: normalizeUrl(proxy.url) };
+                }
+                else {
+                    result[key] = normalizeConfigUrls(value);
+                }
+            }
+            else {
+                result[key] = normalizeConfigUrls(value);
+            }
+        }
+        return result;
+    }
+    return obj;
+}
+/**
+ * Sorts object keys alphabetically using localeCompare.
+ * Returns a new object with sorted keys, preserving the original object.
+ *
+ * @param obj - Object to sort
+ * @returns New object with sorted keys
+ */
+export function sortObjectKeys(obj) {
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+        return obj;
+    }
+    const sortedObj = {};
+    const keys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
+    for (const key of keys) {
+        sortedObj[key] = obj[key];
+    }
+    return sortedObj;
+}
+/**
+ * Sorts object keys alphabetically, case-insensitive.
+ * Returns a new object with sorted keys, preserving the original object and original key case.
+ *
+ * @param obj - Object to sort
+ * @returns New object with sorted keys (case-insensitive sort)
+ */
+export function sortObjectKeysCaseInsensitive(obj) {
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+        return obj;
+    }
+    const sortedObj = {};
+    const keys = Object.keys(obj).sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
+    for (const key of keys) {
+        sortedObj[key] = obj[key];
+    }
+    return sortedObj;
+}
+/**
+ * Recursively sorts all object keys in a nested structure.
+ * Returns a new object with all nested keys sorted, preserving the original object.
+ *
+ * @param obj - Object to sort recursively
+ * @returns New object with all nested keys sorted
+ */
+export function sortObjectKeysDeep(obj) {
+    if (!obj) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => sortObjectKeysDeep(item));
+    }
+    if (typeof obj === 'object') {
+        const sortedObj = {};
+        const keys = Object.keys(obj).sort((a, b) => a.localeCompare(b));
+        for (const key of keys) {
+            sortedObj[key] = sortObjectKeysDeep(obj[key]);
+        }
+        return sortedObj;
+    }
+    return obj;
+}
+/**
+ * Sorts env and headers objects in a server configuration.
+ * This is a convenience function for server template/instance configurations.
+ * Also normalizes URL fields by removing trailing slashes.
+ *
+ * @param config - Server configuration object with optional env and headers
+ * @returns New object with sorted env and headers keys and normalized URLs
+ */
+export function sortServerConfigEnvHeaders(config) {
+    // First normalize URLs
+    const normalized = normalizeConfigUrls(config);
+    const result = { ...normalized };
+    if (result.env) {
+        result.env = sortObjectKeysCaseInsensitive(result.env);
+    }
+    if (result.headers) {
+        result.headers = sortObjectKeysCaseInsensitive(result.headers);
+    }
+    return result;
+}

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

@@ -31,9 +31,12 @@ export declare class SseTransport implements Transport {
     private headers;
     private reconnectInterval;
     private maxReconnectAttempts;
+    private proxy?;
     private eventSource;
     private reconnectAttempts;
     private isClosing;
+    private _serverName?;
+    private _compositeKey?;
     onmessage?: (message: JSONRPCMessage) => void;
     onerror?: (error: Error) => void;
     onclose?: () => void;
@@ -44,8 +47,20 @@ export declare class SseTransport implements Transport {
      * @param headers - Optional HTTP headers to include in the SSE connection request
      * @param reconnectInterval - Time interval (in milliseconds) between reconnection attempts (default: 3000ms)
      * @param maxReconnectAttempts - Maximum number of reconnection attempts before giving up (default: 5)
+     * @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>, reconnectInterval?: number, maxReconnectAttempts?: number);
+    constructor(url: string, headers?: Record<string, string>, reconnectInterval?: number, maxReconnectAttempts?: 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
+     */
+    private formatLogMessage;
     /**
      * Initializes and starts the SSE connection to the specified URL.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"sse-transport.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/sse-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAM1E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,YAAa,YAAW,SAAS;IAkB1C,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,iBAAiB;IACzB,OAAO,CAAC,oBAAoB;IApB9B,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,SAAS,CAAS;IAEnB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAE5B;;;;;;;OAOG;gBAEO,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACpC,iBAAiB,GAAE,MAAa,EAChC,oBAAoB,GAAE,MAAU;IAG1C;;;;;;;;;OASG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0D5B;;;;;;;;OAQG;YACW,OAAO;IAOrB;;;;;;;OAOG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;;;;;;;OAQG;YACW,aAAa;IAQ3B;;;;;;;;;;;;OAYG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAqBnD"}
+{"version":3,"file":"sse-transport.d.ts","sourceRoot":"","sources":["../../../../../src/utils/transports/sse-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAQ1E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,YAAa,YAAW,SAAS;IAuB1C,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,iBAAiB;IACzB,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,KAAK,CAAC;IA1BhB,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAAC,CAAS;IAC7B,OAAO,CAAC,aAAa,CAAC,CAAS;IAExB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAE5B;;;;;;;;;;OAUG;gBAEO,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EACpC,iBAAiB,GAAE,MAAa,EAChC,oBAAoB,GAAE,MAAU,EAChC,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;;;;;;;;;OASG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyG5B;;;;;;;;OAQG;YACW,OAAO;IAOrB;;;;;;;OAOG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B;;;;;;;;OAQG;YACW,aAAa;IAQ3B;;;;;;;;;;;;OAYG;IACG,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAyBnD"}

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

@@ -1,4 +1,6 @@
 import { logger } from '../logger.js';
+import { LOG_MODULES } from '../logger/log-modules.js';
+import { ProxyAgent, fetch as undiciFetch } from 'undici';
 // Use EventSource from the 'eventsource' package for Node.js compatibility
 import { EventSource } from 'eventsource';
 /**
@@ -32,9 +34,12 @@ export class SseTransport {
     headers;
     reconnectInterval;
     maxReconnectAttempts;
+    proxy;
     eventSource = null;
     reconnectAttempts = 0;
     isClosing = false;
+    _serverName;
+    _compositeKey;
     onmessage;
     onerror;
     onclose;
@@ -45,12 +50,35 @@ export class SseTransport {
      * @param headers - Optional HTTP headers to include in the SSE connection request
      * @param reconnectInterval - Time interval (in milliseconds) between reconnection attempts (default: 3000ms)
      * @param maxReconnectAttempts - Maximum number of reconnection attempts before giving up (default: 5)
+     * @param proxy - Optional proxy configuration
+     * @param serverName - Optional server name for logging
+     * @param compositeKey - Optional composite key (serverName-serverIndex) for logging
      */
-    constructor(url, headers = {}, reconnectInterval = 3000, maxReconnectAttempts = 5) {
+    constructor(url, headers = {}, reconnectInterval = 3000, maxReconnectAttempts = 5, proxy, serverName, compositeKey) {
         this.url = url;
         this.headers = headers;
         this.reconnectInterval = reconnectInterval;
         this.maxReconnectAttempts = maxReconnectAttempts;
+        this.proxy = proxy;
+        this._serverName = serverName;
+        this._compositeKey = compositeKey;
+    }
+    /**
+     * Helper method to format log messages with server context.
+     *
+     * @param message - The base message
+     * @returns Formatted message with server context if available
+     */
+    formatLogMessage(message) {
+        if (this._compositeKey) {
+            return `${message} (compositeKey=${this._compositeKey}, url=${this.url})`;
+        }
+        else if (this._serverName) {
+            return `${message} (server=${this._serverName}, url=${this.url})`;
+        }
+        else {
+            return `${message} (url=${this.url})`;
+        }
     }
     /**
      * Initializes and starts the SSE connection to the specified URL.
@@ -75,6 +103,24 @@ export class SseTransport {
             if (Object.keys(this.headers).length > 0) {
                 options.headers = this.headers;
             }
+            const proxyInfo = this.proxy?.url ? `, proxy=${this.proxy.url}` : '';
+            logger.info(this.formatLogMessage(`Attempting to connect to SSE server${proxyInfo}`), LOG_MODULES.SSE_TRANSPORT);
+            // Add proxy support if configured
+            if (this.proxy?.url) {
+                const agent = new ProxyAgent(this.proxy.url);
+                // Create custom fetch function with proxy
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const customFetch = (input, init) => {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const fetchOptions = {
+                        ...init,
+                        dispatcher: agent
+                    };
+                    return undiciFetch(input, fetchOptions);
+                };
+                options.fetch = customFetch;
+                logger.info(this.formatLogMessage(`SSE transport configured with proxy: ${this.proxy.url}`), LOG_MODULES.SSE_TRANSPORT);
+            }
             this.eventSource = new EventSource(this.url, options);
             this.eventSource.onmessage = (event) => {
                 try {
@@ -83,34 +129,34 @@ export class SseTransport {
                     this.reconnectAttempts = 0; // Reset on successful message
                 }
                 catch (error) {
-                    logger.error('Failed to parse SSE message:', error);
+                    logger.error(this.formatLogMessage('Failed to parse SSE message'), error, LOG_MODULES.SSE_TRANSPORT);
                     this.onerror?.(new Error(`Invalid JSON in SSE message: ${event.data}`));
                 }
             };
             this.eventSource.onerror = () => {
                 const error = new Error(`SSE connection error for ${this.url}`);
-                logger.error('SSE connection error:', error);
+                logger.error(this.formatLogMessage('SSE connection error'), error, LOG_MODULES.SSE_TRANSPORT);
                 if (!this.isClosing) {
                     this.reconnectAttempts++;
                     if (this.reconnectAttempts <= this.maxReconnectAttempts) {
-                        logger.info(`Attempting to reconnect SSE (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`);
+                        logger.info(this.formatLogMessage(`Attempting to reconnect SSE (${this.reconnectAttempts}/${this.maxReconnectAttempts})...`), LOG_MODULES.SSE_TRANSPORT);
                         setTimeout(() => {
                             this.restart();
                         }, this.reconnectInterval);
                     }
                     else {
-                        logger.error('Max reconnection attempts reached for SSE');
+                        logger.error(this.formatLogMessage('Max reconnection attempts reached for SSE'), LOG_MODULES.SSE_TRANSPORT);
                         this.onerror?.(error);
                         this.closeInternal();
                     }
                 }
             };
             this.eventSource.onopen = () => {
-                logger.info(`SSE connection opened to ${this.url}`);
+                logger.info(this.formatLogMessage('SSE connection opened'), LOG_MODULES.SSE_TRANSPORT);
             };
         }
         catch (error) {
-            logger.error('Failed to create SSE connection:', error);
+            logger.error(this.formatLogMessage('Failed to create SSE connection'), error, LOG_MODULES.SSE_TRANSPORT);
             throw error;
         }
     }
@@ -180,10 +226,10 @@ export class SseTransport {
         // Type-safe way to access message properties
         const messageId = 'id' in message ? String(message.id) : 'unknown';
         const method = 'method' in message ? String(message.method) : 'unknown';
-        logger.warn('Attempted to send message via SSE transport', {
+        logger.warn(this.formatLogMessage('Attempted to send message via SSE transport'), {
             messageId,
             method
-        });
+        }, LOG_MODULES.SSE_TRANSPORT);
         throw error;
     }
 }