From 064731e7a918c3cd9b36acdae984ae62aad4e16b Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Thu, 29 May 2025 10:28:31 +0000 Subject: [PATCH 01/19] feat: Implement enhanced error handling and retry mechanisms This commit introduces several improvements to the MCP proxy server's reliability: 1. **Error Propagation:** Ensured that errors from backend MCP services are consistently propagated to you in a standard JSON-RPC error format. 2. **SSE Auto-Reconnect and Retry:** * For operations to SSE-based backends, if a connection-related error occurs, the proxy will automatically attempt to re-establish the connection and retry the call once. * This feature is configurable via the `proxy.retrySseToolCallOnDisconnect` setting in `mcp_server.json` (defaults to `true`). 3. **HTTP Request Retry:** * For operations to HTTP-based backends, if a connection error occurs, the proxy will automatically retry the request using an exponential backoff strategy. * This is configurable via settings in `mcp_server.json`: * `proxy.retryHttpToolCall` (boolean, default: `true`) * `proxy.httpToolCallMaxRetries` (number, default: `2`) * `proxy.httpToolCallRetryDelayBaseMs` (number, default: `300`ms) 4. **Configuration:** Updated `src/config.ts` to load and manage these new settings with appropriate defaults. 5. **Documentation:** Updated `README.md` to reflect these new features and their configuration. These changes aim to make the MCP proxy server more resilient to transient network issues and backend unavailability. --- README.md | 99 ++++++++++++++ src/client.ts | 147 ++++++++++++++++++++- src/config.ts | 54 +++++++- src/mcp-proxy.ts | 332 ++++++++++++++++++++++++++++++++++++++++++----- 4 files changed, 594 insertions(+), 38 deletions(-) diff --git a/README.md b/README.md index 3fb97fd..bb46d3e 100644 --- a/README.md +++ b/README.md @@ -174,6 +174,105 @@ Example `config/tool_config.json`: export TOOLS_FOLDER=/srv/mcp_tools ``` +### 4. Proxy Behavior Configuration (Error Handling & Retries) +These settings are configured within `config/mcp_server.json` under a top-level `proxy` object. + +Example: +```json +{ + "mcpServers": { + "...": "..." + }, + "proxy": { + "retrySseToolCallOnDisconnect": true, + "retryHttpToolCall": true, + "httpToolCallMaxRetries": 2, + "httpToolCallRetryDelayBaseMs": 300 + } +} +``` +See the "Enhanced Reliability Features" section for details on these options. + + +## Enhanced Reliability Features + +The MCP Proxy Server includes features to improve its resilience and the reliability of interactions with backend MCP services. + +### 1. Error Propagation +The proxy server ensures that errors originating from backend MCP services are consistently propagated to the requesting client. These errors are formatted as standard JSON-RPC error responses, making it easier for clients to handle them uniformly. + +### 2. SSE Connection Retry for Tool Calls +When a `tools/call` operation is made to an SSE-based backend server, and the underlying connection is lost or experiences an error, the proxy server will automatically attempt to: +1. Re-establish the connection to the SSE backend. +2. If reconnection is successful, it will retry the original `tools/call` request **once**. + +This behavior helps mitigate transient network issues that might temporarily disrupt SSE connections. + +**Configuration:** +This feature is controlled by the `retrySseToolCallOnDisconnect` property within the `proxy` object in your `config/mcp_server.json` file. +- **`retrySseToolCallOnDisconnect`** (boolean): + - Set to `true` to enable the automatic reconnect and retry. + - Set to `false` to disable this feature. + - **Default:** `true`. + +**Example (`config/mcp_server.json`):** +```json +{ + "mcpServers": { + "my-sse-server": { + "type": "sse", + "url": "http://example.com/sse-endpoint" + // ... other server config + } + }, + "proxy": { + "retrySseToolCallOnDisconnect": true + // ... other proxy settings + } +} +``` + +### 3. HTTP Request Retry for Tool Calls +For `tools/call` operations directed to HTTP-based backend servers, the proxy implements a retry mechanism for connection errors (e.g., "failed to fetch", network timeouts). + +**Retry Mechanism:** +If an initial HTTP request fails due to a connection error, the proxy will retry the request using an exponential backoff strategy. This means the delay before each subsequent retry attempt increases exponentially, with a small amount of jitter (randomness) added to prevent thundering herd scenarios. + +**Configuration:** +These settings are configured within the `proxy` object in your `config/mcp_server.json` file. + +- **`retryHttpToolCall`** (boolean): + - Set to `true` to enable retries for HTTP tool calls. + - Set to `false` to disable this feature. + - **Default:** `true`. + +- **`httpToolCallMaxRetries`** (number): + - Specifies the maximum number of retry attempts *after* the initial failed attempt. For example, if set to `2`, there will be one initial attempt and up to two retry attempts, totaling a maximum of three attempts. + - **Default:** `2`. + +- **`httpToolCallRetryDelayBaseMs`** (number): + - The base delay in milliseconds used in the exponential backoff calculation. The delay before the *n*-th retry (0-indexed) is roughly `httpToolCallRetryDelayBaseMs * (2^n) + jitter`. + - **Default:** `300` (milliseconds). + +**Example (`config/mcp_server.json`):** +```json +{ + "mcpServers": { + "my-http-server": { + "type": "http", + "url": "http://example.com/mcp-endpoint" + // ... other server config + } + }, + "proxy": { + "retryHttpToolCall": true, + "httpToolCallMaxRetries": 3, + "httpToolCallRetryDelayBaseMs": 500 + // ... other proxy settings + } +} +``` + ## Development Install dependencies: diff --git a/src/client.ts b/src/client.ts index 7404dbe..0a47da6 100644 --- a/src/client.ts +++ b/src/client.ts @@ -11,13 +11,17 @@ export interface ConnectedClient { client: Client; cleanup: () => Promise; name: string; + config: TransportConfig; // Added config + transportType: 'sse' | 'stdio' | 'http'; // Added transportType } -const createClient = (name: string, transportConfig: TransportConfig): { client: Client | undefined, transport: Transport | undefined } => { +const createClient = (name: string, transportConfig: TransportConfig): { client: Client | undefined, transport: Transport | undefined, transportType: 'sse' | 'stdio' | 'http' | undefined } => { let transport: Transport | null = null; + let transportType: 'sse' | 'stdio' | 'http' | undefined = undefined; try { if (isSSEConfig(transportConfig)) { + transportType = 'sse'; const transportOptions: SSEClientTransportOptions = {}; let customHeaders: Record | undefined; @@ -53,6 +57,7 @@ const createClient = (name: string, transportConfig: TransportConfig): { client: transport = new SSEClientTransport(new URL(transportConfig.url), transportOptions); } else if (isStdioConfig(transportConfig)) { + transportType = 'stdio'; const mergedEnv = { ...process.env, ...transportConfig.env @@ -69,6 +74,7 @@ const createClient = (name: string, transportConfig: TransportConfig): { client: env: filteredEnv }); } else if (isHttpConfig(transportConfig)) { + transportType = 'http'; const transportOptions: StreamableHTTPClientTransportOptions = {}; let customHeaders: Record | undefined; @@ -97,9 +103,9 @@ const createClient = (name: string, transportConfig: TransportConfig): { client: console.error(`Failed to create transport ${transportType} to ${name}:`, error); } - if (!transport) { - console.warn(`Transport for ${name} not available.`); - return { transport: undefined, client: undefined }; + if (!transport || !transportType) { // Also check transportType + console.warn(`Transport or transportType for ${name} not available.`); + return { transport: undefined, client: undefined, transportType: undefined }; } const client = new Client({ @@ -113,7 +119,7 @@ const createClient = (name: string, transportConfig: TransportConfig): { client: } }); - return { client, transport } + return { client, transport, transportType } } export const createClients = async (mcpServers: Record): Promise => { @@ -129,8 +135,9 @@ export const createClients = async (mcpServers: Record) while (retry) { - const { client, transport } = createClient(name, transportConfig); - if (!client || !transport) { + const { client, transport, transportType } = createClient(name, transportConfig); // Capture transportType + if (!client || !transport || !transportType) { // Check transportType + console.warn(`Skipping client ${name} due to failed client/transport creation.`); break; } @@ -141,6 +148,8 @@ export const createClients = async (mcpServers: Record) clients.push({ client, name: name, + config: transportConfig, // Store config + transportType: transportType, // Store transportType cleanup: async () => { await transport.close(); } @@ -167,3 +176,127 @@ export const createClients = async (mcpServers: Record) return clients; }; + +// No longer using ReconnectedClientResult, returning full ConnectedClient-like structure +// but as a direct object, which refreshBackendConnection will use to create a full ConnectedClient. + +export async function reconnectSingleClient( + name: string, + transportConfig: TransportConfig, + existingCleanup?: () => Promise +): Promise> { // Returns the parts needed to reconstruct a ConnectedClient + console.log(`Attempting to reconnect client: ${name}`); + + if (existingCleanup) { + try { + await existingCleanup(); + console.log(`Existing client ${name} cleaned up before reconnecting.`); + } catch (e: any) { + console.warn(`Error during cleanup of existing client ${name} before reconnect: ${e.message}`); + } + } + + let transport: Transport | null = null; + let determinedTransportType: 'sse' | 'stdio' | 'http' | undefined = undefined; + + try { + if (isSSEConfig(transportConfig)) { + determinedTransportType = 'sse'; + const transportOptions: SSEClientTransportOptions = {}; + let customHeaders: Record | undefined; + if (transportConfig.bearerToken) { + customHeaders = { 'Authorization': `Bearer ${transportConfig.bearerToken}` }; + console.log(` Using Bearer Token for SSE connection to ${name} (reconnect)`); + } else if (transportConfig.apiKey) { + customHeaders = { 'X-Api-Key': transportConfig.apiKey }; + console.log(` Using X-Api-Key for SSE connection to ${name} (reconnect)`); + } + if (customHeaders) { + transportOptions.requestInit = { headers: customHeaders }; + const headersToAdd = customHeaders; // Closure for fetch + transportOptions.eventSourceInit = { + fetch(input: RequestInfo | URL, init?: RequestInit): Promise { + const originalHeaders = new Headers(init?.headers || {}); + for (const key in headersToAdd) { + originalHeaders.set(key, headersToAdd[key]); + } + return fetch(input, { ...init, headers: originalHeaders }); + }, + } as any; + } + transport = new SSEClientTransport(new URL(transportConfig.url), transportOptions); + } else if (isStdioConfig(transportConfig)) { + determinedTransportType = 'stdio'; + const mergedEnv = { ...process.env, ...transportConfig.env }; + const filteredEnv: Record = {}; + for (const key in mergedEnv) { + if (Object.prototype.hasOwnProperty.call(mergedEnv, key) && mergedEnv[key] !== undefined) { + filteredEnv[key] = mergedEnv[key] as string; + } + } + transport = new StdioClientTransport({ + command: transportConfig.command, + args: transportConfig.args, + env: filteredEnv + }); + console.log(` Configured Stdio transport for ${name} (reconnect)`); + } else if (isHttpConfig(transportConfig)) { + determinedTransportType = 'http'; + const transportOptions: StreamableHTTPClientTransportOptions = {}; + let customHeaders: Record | undefined; + if (transportConfig.bearerToken) { + customHeaders = { 'Authorization': `Bearer ${transportConfig.bearerToken}` }; + console.log(` Using Bearer Token for StreamableHTTP connection to ${name} (reconnect)`); + } else if (transportConfig.apiKey) { + customHeaders = { 'X-Api-Key': transportConfig.apiKey }; + console.log(` Using X-Api-Key for StreamableHTTP connection to ${name} (reconnect)`); + } + if (customHeaders) { + transportOptions.requestInit = { headers: customHeaders }; + } + transport = new StreamableHTTPClientTransport(new URL(transportConfig.url), transportOptions); + } else { + throw new Error(`Invalid or unknown transport type in configuration for server: ${name}`); + } + } catch (error: any) { + console.error(`Failed to create transport for ${name} during reconnect: ${error.message}`); + throw error; + } + + if (!transport || !determinedTransportType) { // Check determinedTransportType as well + throw new Error(`Transport or transport type for ${name} could not be created during reconnect.`); + } + + const newSdkClient = new Client({ + name: 'mcp-proxy-client-reconnect', + version: '1.0.1', + }, { + capabilities: { prompts: {}, resources: { subscribe: true }, tools: {} } + }); + + try { + await newSdkClient.connect(transport); + console.log(`Successfully reconnected to server: ${name}`); + const finalTransport = transport; // Capture for closure + return { + client: newSdkClient, + config: transportConfig, // Return config + transportType: determinedTransportType, // Return transportType + cleanup: async () => { + if (finalTransport) { + await finalTransport.close(); + } + } + }; + } catch (error: any) { + console.error(`Failed to connect to ${name} during reconnect attempt: ${error.message}`); + try { + if (transport) { + await transport.close(); + } + } catch (closeError: any) { + console.warn(`Failed to close transport for ${name} after reconnect failure: ${closeError.message}`); + } + throw error; + } +} diff --git a/src/config.ts b/src/config.ts index c5f1fa7..3a30d77 100644 --- a/src/config.ts +++ b/src/config.ts @@ -34,8 +34,16 @@ export type TransportConfigHTTP = { export type TransportConfig = (TransportConfigStdio | TransportConfigSSE | TransportConfigHTTP) & { name?: string, active?: boolean, type: 'stdio' | 'sse' | 'http' }; +export interface ProxySettings { + retrySseToolCallOnDisconnect?: boolean; + retryHttpToolCall?: boolean; + httpToolCallMaxRetries?: number; + httpToolCallRetryDelayBaseMs?: number; +} + export interface Config { mcpServers: Record; + proxy?: ProxySettings; } @@ -74,10 +82,52 @@ export const loadConfig = async (): Promise => { throw new Error('Invalid config format: mcpServers object not found.'); } - return parsedConfig; + // Initialize proxy settings with defaults + const defaultProxySettings: Required = { + retrySseToolCallOnDisconnect: true, + retryHttpToolCall: true, + httpToolCallMaxRetries: 2, + httpToolCallRetryDelayBaseMs: 300, + }; + + const configWithDefaults: Config = { + ...parsedConfig, + proxy: { + ...defaultProxySettings, + ...(parsedConfig.proxy || {}), // Spread any existing proxy settings to override defaults + } + }; + + // Ensure specific boolean and number types if they exist in parsedConfig.proxy + if (parsedConfig.proxy) { + if (typeof parsedConfig.proxy.retrySseToolCallOnDisconnect === 'boolean') { + configWithDefaults.proxy!.retrySseToolCallOnDisconnect = parsedConfig.proxy.retrySseToolCallOnDisconnect; + } + if (typeof parsedConfig.proxy.retryHttpToolCall === 'boolean') { + configWithDefaults.proxy!.retryHttpToolCall = parsedConfig.proxy.retryHttpToolCall; + } + if (typeof parsedConfig.proxy.httpToolCallMaxRetries === 'number') { + configWithDefaults.proxy!.httpToolCallMaxRetries = parsedConfig.proxy.httpToolCallMaxRetries; + } + if (typeof parsedConfig.proxy.httpToolCallRetryDelayBaseMs === 'number') { + configWithDefaults.proxy!.httpToolCallRetryDelayBaseMs = parsedConfig.proxy.httpToolCallRetryDelayBaseMs; + } + } + + console.log("Loaded config with proxy settings:", configWithDefaults.proxy); + return configWithDefaults; } catch (error) { console.error(`Error loading config/mcp_server.json:`, error); - return { mcpServers: {} }; + // Return default structure in case of error + return { + mcpServers: {}, + proxy: { // Ensure all defaults are present here too + retrySseToolCallOnDisconnect: true, + retryHttpToolCall: true, + httpToolCallMaxRetries: 2, + httpToolCallRetryDelayBaseMs: 300, + } + }; } }; diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 235e2c0..368fb5e 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -17,8 +17,8 @@ import { CompatibilityCallToolResultSchema, GetPromptResultSchema } from "@modelcontextprotocol/sdk/types.js"; -import { createClients, ConnectedClient } from './client.js'; -import { Config, loadConfig, TransportConfig, isSSEConfig, isStdioConfig, ToolConfig, loadToolConfig } from './config.js'; +import { createClients, ConnectedClient, reconnectSingleClient } from './client.js'; +import { Config, loadConfig, TransportConfig, isSSEConfig, isStdioConfig, isHttpConfig, ToolConfig, loadToolConfig } from './config.js'; import { z } from 'zod'; import * as eventsource from 'eventsource'; @@ -31,32 +31,36 @@ const toolToClientMap = new Map(); const promptToClientMap = new Map(); let currentToolConfig: ToolConfig = { tools: {} }; // Store loaded tool config +let currentActiveServersConfig: Record = {}; // Added for retry logic +let currentProxyConfig: Config['proxy'] = { retrySseToolCallOnDisconnect: true }; // Added for proxy settings // --- Function to update backend connections and maps --- export const updateBackendConnections = async (newServerConfig: Config, newToolConfig: ToolConfig) => { console.log("Starting update of backend connections..."); currentToolConfig = newToolConfig; // Update stored tool config + currentProxyConfig = newServerConfig.proxy || { retrySseToolCallOnDisconnect: true }; // Store proxy settings - const activeServersConfig: Record = {}; + const activeServersConfigLocal: Record = {}; // Renamed to avoid conflict with module-level for (const serverKey in newServerConfig.mcpServers) { if (Object.prototype.hasOwnProperty.call(newServerConfig.mcpServers, serverKey)) { const serverConf = newServerConfig.mcpServers[serverKey]; const isActive = !(serverConf.active === false || String(serverConf.active).toLowerCase() === 'false'); if (isActive) { - activeServersConfig[serverKey] = serverConf; + activeServersConfigLocal[serverKey] = serverConf; } else { const serverName = serverConf.name || (isSSEConfig(serverConf) ? serverConf.url : isStdioConfig(serverConf) ? serverConf.command : serverKey); console.log(`Skipping inactive server during update: ${serverName}`); } } } + currentActiveServersConfig = activeServersConfigLocal; // Update module-level variable - const newClientKeys = new Set(Object.keys(activeServersConfig)); + const newClientKeys = new Set(Object.keys(activeServersConfigLocal)); const currentClientKeys = new Set(currentConnectedClients.map(c => c.name)); const clientsToRemove = currentConnectedClients.filter(c => !newClientKeys.has(c.name)); const clientsToKeep = currentConnectedClients.filter(c => newClientKeys.has(c.name)); - const keysToAdd = Object.keys(activeServersConfig).filter(key => !currentClientKeys.has(key)); + const keysToAdd = Object.keys(activeServersConfigLocal).filter(key => !currentClientKeys.has(key)); console.log(`Clients to remove: ${clientsToRemove.map(c => c.name).join(', ') || 'None'}`); console.log(`Clients to keep: ${clientsToKeep.map(c => c.name).join(', ') || 'None'}`); @@ -79,7 +83,7 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC let newlyConnectedClients: ConnectedClient[] = []; if (keysToAdd.length > 0) { const configToAdd: Record = {}; - keysToAdd.forEach(key => { configToAdd[key] = activeServersConfig[key]; }); + keysToAdd.forEach(key => { configToAdd[key] = activeServersConfigLocal[key]; }); console.log(`Connecting ${keysToAdd.length} new clients...`); newlyConnectedClients = await createClients(configToAdd); console.log(`Successfully connected to ${newlyConnectedClients.length} out of ${keysToAdd.length} new clients.`); @@ -150,6 +154,132 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC console.log("Backend connections update finished."); }; +async function refreshBackendConnection(serverKey: string, serverConfig: TransportConfig): Promise { + console.log(`Attempting to refresh backend connection for server: ${serverKey}`); + const existingClientIndex = currentConnectedClients.findIndex(c => c.name === serverKey); + let oldCleanup: (() => Promise) | undefined = undefined; + let existingConfig: TransportConfig | undefined = currentConnectedClients[existingClientIndex]?.config; + + if (existingClientIndex !== -1 && currentConnectedClients[existingClientIndex]) { + oldCleanup = currentConnectedClients[existingClientIndex].cleanup; + existingConfig = currentConnectedClients[existingClientIndex].config; + } else { + // Fallback to currentActiveServersConfig if not found in currentConnectedClients (should be rare for refresh) + existingConfig = currentActiveServersConfig[serverKey]; + } + + if (!existingConfig) { + console.error(`Configuration for server ${serverKey} not found. Cannot refresh.`); + return false; + } + // Use the passed serverConfig if available (e.g. from initial load), otherwise fallback to existingConfig. + // The `serverConfig` parameter in refreshBackendConnection might be more up-to-date if called during a config reload. + const configToUse = serverConfig || existingConfig; + + + try { + // reconnectSingleClient returns Omit + const reconnectedClientParts = await reconnectSingleClient(serverKey, configToUse, oldCleanup); + + const newConnectedClientEntry: ConnectedClient = { + ...reconnectedClientParts, // Spread the parts (client, cleanup, config, transportType) + name: serverKey, // Add the name back + }; + + if (existingClientIndex !== -1) { + currentConnectedClients[existingClientIndex] = newConnectedClientEntry; + console.log(`Updated existing client entry for ${serverKey} in currentConnectedClients.`); + } else { + currentConnectedClients.push(newConnectedClientEntry); + console.log(`Added new client entry for ${serverKey} to currentConnectedClients (this path might be taken if client was previously removed due to error).`); + } + + // Clear existing entries for this client + for (const [key, value] of toolToClientMap.entries()) { + if (value.client.name === serverKey) { + toolToClientMap.delete(key); + } + } + for (const [key, value] of resourceToClientMap.entries()) { + // Assuming value is ConnectedClient, so value.name is the server key + if (value.name === serverKey) { + resourceToClientMap.delete(key); + } + } + for (const [key, value] of promptToClientMap.entries()) { + // Assuming value is ConnectedClient, so value.name is the server key + if (value.name === serverKey) { + promptToClientMap.delete(key); + } + } + console.log(`Cleared map entries for ${serverKey}.`); + + // Repopulate maps for the reconnected client + const connectedClient = newConnectedClientEntry; + try { + const result = await connectedClient.client.request({ method: 'tools/list', params: {} }, ListToolsResultSchema); + if (result.tools && result.tools.length > 0) { + for (const tool of result.tools) { + const qualifiedName = `${connectedClient.name}--${tool.name}`; + const toolSettings = currentToolConfig.tools[qualifiedName]; + const isEnabled = !toolSettings || toolSettings.enabled !== false; + if (isEnabled) { + toolToClientMap.set(qualifiedName, { client: connectedClient, toolInfo: tool }); + } + } + } + } catch (error: any) { + if (!(error?.name === 'McpError' && error?.code === -32601)) { + console.error(`Error fetching tools from ${connectedClient.name} during refresh:`, error?.message || error); + } + } + + try { + const result = await connectedClient.client.request({ method: 'resources/list', params: {} }, ListResourcesResultSchema); + if (result.resources) { + result.resources.forEach(resource => resourceToClientMap.set(resource.uri, connectedClient)); + } + } catch (error: any) { + if (!(error?.name === 'McpError' && error?.code === -32601)) { + console.error(`Error fetching resources from ${connectedClient.name} during refresh:`, error?.message || error); + } + } + + try { + const result = await connectedClient.client.request({ method: 'prompts/list', params: {} }, ListPromptsResultSchema); + if (result.prompts) { + result.prompts.forEach(prompt => promptToClientMap.set(prompt.name, connectedClient)); + } + } catch (error: any) { + if (!(error?.name === 'McpError' && error?.code === -32601)) { + console.error(`Error fetching prompts from ${connectedClient.name} during refresh:`, error?.message || error); + } + } + console.log(`Repopulated maps for ${serverKey}.`); + return true; + + } catch (error) { + console.error(`Failed to refresh backend connection for ${serverKey}:`, error); + // If refresh failed, we remove the client to prevent further attempts with a known bad state. + // This also cleans up its entries from the maps. + if (existingClientIndex !== -1) { + currentConnectedClients.splice(existingClientIndex, 1); + } + // Clear any potentially lingering map entries if refresh failed mid-way + for (const [key, value] of toolToClientMap.entries()) { + if (value.client.name === serverKey) toolToClientMap.delete(key); + } + for (const [key, value] of resourceToClientMap.entries()) { + if (value.name === serverKey) resourceToClientMap.delete(key); + } + for (const [key, value] of promptToClientMap.entries()) { + if (value.name === serverKey) promptToClientMap.delete(key); + } + console.log(`Removed client ${serverKey} and its map entries after failed refresh.`); + return false; + } +} + // --- Function to get current proxy state --- export const getCurrentProxyState = () => { // Return copies or relevant info to avoid direct mutation @@ -177,9 +307,71 @@ export const createServer = async () => { const initialServerConfig = await loadConfig(); const initialToolConfig = await loadToolConfig(); + // Initialize currentActiveServersConfig from the initial load + const initialActiveServers: Record = {}; + for (const serverKey in initialServerConfig.mcpServers) { + if (Object.prototype.hasOwnProperty.call(initialServerConfig.mcpServers, serverKey)) { + const serverConf = initialServerConfig.mcpServers[serverKey]; + const isActive = !(serverConf.active === false || String(serverConf.active).toLowerCase() === 'false'); + if (isActive) { + initialActiveServers[serverKey] = serverConf; + } + } + } + currentActiveServersConfig = initialActiveServers; + + // Perform initial connection and map population + await updateBackendConnections(initialServerConfig, initialToolConfig); + +// Helper function to identify connection errors +const isConnectionError = (err: any): boolean => { + if (err && err.message) { + const lowerMessage = err.message.toLowerCase(); + return lowerMessage.includes("disconnected") || + lowerMessage.includes("not connected") || + lowerMessage.includes("connection closed") || + lowerMessage.includes("transport is closed") || // SDK specific + lowerMessage.includes("failed to fetch"); // Network level + } + return false; +}; + +// --- Server Creation --- +export const createServer = async () => { + // Load initial config + const initialServerConfig = await loadConfig(); // This now includes proxy settings + const initialToolConfig = await loadToolConfig(); + + // Initialize currentActiveServersConfig AND currentProxyConfig from the initial load + const initialActiveServers: Record = {}; + for (const serverKey in initialServerConfig.mcpServers) { + if (Object.prototype.hasOwnProperty.call(initialServerConfig.mcpServers, serverKey)) { + const serverConf = initialServerConfig.mcpServers[serverKey]; + const isActive = !(serverConf.active === false || String(serverConf.active).toLowerCase() === 'false'); + if (isActive) { + initialActiveServers[serverKey] = serverConf; + } + } + } + currentActiveServersConfig = initialActiveServers; + // Ensure all default proxy settings are applied if some are missing + const defaultProxySettings: Required = { + retrySseToolCallOnDisconnect: true, + retryHttpToolCall: true, + httpToolCallMaxRetries: 2, + httpToolCallRetryDelayBaseMs: 300, + }; + currentProxyConfig = { + ...defaultProxySettings, + ...(initialServerConfig.proxy || {}), + }; + + // Perform initial connection and map population await updateBackendConnections(initialServerConfig, initialToolConfig); + const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms)); // Define sleep + // Create the main proxy server instance const server = new Server( { @@ -252,30 +444,104 @@ export const createServer = async () => { } // Now we have the correct mapEntry and the originalQualifiedName - const { client: clientForTool, toolInfo } = mapEntry; // toolInfo here is the correct one from the found mapEntry + let { client: clientForTool, toolInfo } = mapEntry; // toolInfo here is the correct one from the found mapEntry const originalToolNameForBackend = toolInfo.name; // The actual name the backend server expects (from the original toolInfo) try { - // Log using the exposed name and the original name for clarity - console.log(`Received tool call for exposed name '${requestedExposedName}' (original qualified name: '${originalQualifiedName}'). Forwarding to server '${clientForTool.name}' as tool '${originalToolNameForBackend}'`); - - // Access the actual MCP client via clientForTool.client + console.log(`Received tool call for exposed name '${requestedExposedName}' (original qualified name: '${originalQualifiedName}'). Forwarding to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt 1)`); return await clientForTool.client.request( { method: 'tools/call', - params: { - name: originalToolNameForBackend, // Send the original tool name (from toolInfo.name) to the backend - arguments: args || {}, - _meta: { - progressToken: request.params._meta?.progressToken - } - } + params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, CompatibilityCallToolResultSchema ); - } catch (error) { - console.error(`Error calling tool through ${clientForTool.name}:`, error); // Access name via clientForTool - throw error; + } catch (error: any) { + console.warn(`Initial attempt to call tool '${requestedExposedName}' failed: ${error.message}`); + + const shouldRetrySse = currentProxyConfig?.retrySseToolCallOnDisconnect !== false; + + if (clientForTool.transportType === 'sse' && isConnectionError(error) && shouldRetrySse) { + console.log(`SSE connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting reconnect and retry.`); + const clientTransportConfig = currentActiveServersConfig[clientForTool.name]; + if (!clientTransportConfig) { + console.error(`Cannot retry SSE: TransportConfig for server '${clientForTool.name}' not found.`); + throw new Error(`Error calling tool '${requestedExposedName}': Original error: ${error.message}. SSE Retry failed: server configuration not found.`); + } + const refreshed = await refreshBackendConnection(clientForTool.name, clientTransportConfig); + if (refreshed) { + console.log(`Successfully reconnected to server '${clientForTool.name}' via SSE. Retrying tool call for '${requestedExposedName}'.`); + const newMapEntry = toolToClientMap.get(originalQualifiedName); + if (!newMapEntry) { + console.error(`Tool '${originalQualifiedName}' not found in map after successful SSE refresh for server '${clientForTool.name}'.`); + throw new Error(`Error calling tool '${requestedExposedName}': Original error: ${error.message}. SSE Retry failed: tool not found in map after refresh.`); + } + clientForTool = newMapEntry.client; + toolInfo = newMapEntry.toolInfo; + try { + console.log(`Retrying tool call (SSE) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt 2)`); + return await clientForTool.client.request( + { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, + CompatibilityCallToolResultSchema + ); + } catch (retryError: any) { + const errorMessage = `Error calling tool '${requestedExposedName}' (on backend '${clientForTool.name}') after SSE retry: ${retryError.message || 'An unknown error occurred during retry'}`; + console.error(errorMessage, retryError); + throw new Error(errorMessage); + } + } else { + const errorMessage = `Error calling tool '${requestedExposedName}': SSE Reconnection to server '${clientForTool.name}' failed. Original error: ${error.message || 'An unknown error occurred'}`; + console.error(errorMessage); + throw new Error(errorMessage); + } + } + // HTTP Retry Logic + else if (clientForTool.transportType === 'http' && + (currentProxyConfig?.retryHttpToolCall !== false) && // Retry enabled by default + isConnectionError(error)) { + + const maxRetries = currentProxyConfig.httpToolCallMaxRetries ?? 2; + const retryDelayBaseMs = currentProxyConfig.httpToolCallRetryDelayBaseMs ?? 300; + let lastError: any = error; + + console.log(`HTTP connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting up to ${maxRetries} retries.`); + + for (let attempt = 0; attempt < maxRetries; attempt++) { + try { + const delay = retryDelayBaseMs * Math.pow(2, attempt) + (Math.random() * retryDelayBaseMs * 0.5); + console.log(`HTTP tool call failed for '${requestedExposedName}'. Attempt ${attempt + 1}/${maxRetries}. Retrying in ${delay.toFixed(0)}ms...`); + await sleep(delay); + + console.log(`Retrying tool call (HTTP) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 2})`); + return await clientForTool.client.request( + { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, + CompatibilityCallToolResultSchema + ); + } catch (retryError: any) { + lastError = retryError; + console.error(`HTTP tool call retry attempt ${attempt + 1}/${maxRetries} for '${requestedExposedName}' failed:`, retryError.message); + if (attempt === maxRetries - 1) { + break; + } + } + } + const errorMessage = `Error calling HTTP tool '${requestedExposedName}' after ${maxRetries} retries (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${lastError.message || 'An unknown error occurred'}`; + console.error(errorMessage, lastError); + throw new Error(errorMessage); + + } else { + let reason = "Unknown reason for no retry."; + if (clientForTool.transportType === 'sse' && !shouldRetrySse) reason = "SSE retry disabled in config"; + else if (clientForTool.transportType === 'sse' && !isConnectionError(error)) reason = "Error not a connection error for SSE"; + else if (clientForTool.transportType === 'http' && (currentProxyConfig?.retryHttpToolCall === false)) reason = "HTTP retry disabled in config"; + else if (clientForTool.transportType === 'http' && !isConnectionError(error)) reason = "Error not a connection error for HTTP"; + else if (clientForTool.transportType !== 'sse' && clientForTool.transportType !== 'http') reason = `Unsupported transport type for retry: ${clientForTool.transportType}`; + + console.warn(`Not retrying tool call for '${requestedExposedName}'. Reason: ${reason}. Original error: ${error.message}`); + const errorMessage = `Error calling tool '${requestedExposedName}' (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${error.message || 'An unknown error occurred'}`; + console.error(errorMessage, error); + throw new Error(errorMessage); + } } }); @@ -306,9 +572,10 @@ export const createServer = async () => { console.log('Prompt result:', response); return response; - } catch (error) { - console.error(`Error getting prompt from ${clientForPrompt.name}:`, error); - throw error; + } catch (error: any) { + const errorMessage = `Error getting prompt '${name}' from backend server '${clientForPrompt.name}': ${error.message || 'An unknown error occurred'}`; + console.error(errorMessage, error); + throw new Error(errorMessage); } }); @@ -370,9 +637,10 @@ export const createServer = async () => { }, ReadResourceResultSchema ); - } catch (error) { - console.error(`Error reading resource from ${clientForResource.name}:`, error); - throw error; + } catch (error: any) { + const errorMessage = `Error reading resource '${uri}' from backend server '${clientForResource.name}': ${error.message || 'An unknown error occurred'}`; + console.error(errorMessage, error); + throw new Error(errorMessage); } }); @@ -410,7 +678,13 @@ export const createServer = async () => { if (isMethodNotFoundError) { console.warn(`Warning: Method 'resources/templates/list' not found on server ${connectedClient.name}. Proceeding without templates from this source.`); } else { - console.error(`Error fetching resource templates from ${connectedClient.name}:`, error?.message || error); + // Standardize error propagation for other errors + const errorMessage = `Error fetching resource templates from backend server '${connectedClient.name}': ${error.message || 'An unknown error occurred'}`; + console.error(errorMessage, error); // Log the detailed error + // We are in a loop, so we might not want to throw and stop the whole process. + // Instead, we log the error and continue to try fetching from other clients. + // If we needed to inform the client that partial data occurred, we'd need a different strategy. + // For now, just logging and continuing. If *all* sources fail, the client gets an empty list. } } } From 52a6977ae10b4b6ff609ac82c664a0a44a8dc0d9 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Thu, 29 May 2025 11:16:19 +0000 Subject: [PATCH 02/19] fix: Correct syntax error in mcp-proxy.ts Removes a duplicated and incomplete `createServer` function definition and a duplicated `isConnectionError` helper function that were causing a TypeScript build error (TS1005: '}' expected). This correction ensures `src/mcp-proxy.ts` is syntactically valid and should allow the project to build successfully. --- README_ZH.md.enhanced_reliability_section.md | 76 ++++++++++++++++++++ src/mcp-proxy.ts | 23 ------ 2 files changed, 76 insertions(+), 23 deletions(-) create mode 100644 README_ZH.md.enhanced_reliability_section.md diff --git a/README_ZH.md.enhanced_reliability_section.md b/README_ZH.md.enhanced_reliability_section.md new file mode 100644 index 0000000..0354f32 --- /dev/null +++ b/README_ZH.md.enhanced_reliability_section.md @@ -0,0 +1,76 @@ +## 增强的可靠性特性 + +MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后端 MCP 服务交互的可靠性，确保更平稳的操作和更一致的工具执行。 + +### 1. 错误传播 +代理服务器确保从后端 MCP 服务产生的错误能够一致地传播给请求客户端。这些错误被格式化为标准的 JSON-RPC 错误响应，使客户端更容易统一处理它们。 + +### 2. SSE 工具调用的连接重试 +当对基于 SSE 的后端服务器执行 `tools/call` 操作时，如果底层连接丢失或遇到错误，代理服务器将自动尝试： +1. 重新建立与 SSE 后端的连接。 +2. 如果重新连接成功，它将重试原始的 `tools/call` 请求**一次**。 + +此行为有助于缓解可能暂时中断 SSE 连接的瞬时网络问题。 + +**配置：** +此功能通过 `config/mcp_server.json` 文件中 `proxy` 对象内的 `retrySseToolCallOnDisconnect` 属性进行控制。 +- **`retrySseToolCallOnDisconnect`** (布尔型): + - 设置为 `true` (默认值) 以启用自动重新连接和重试。 + - 设置为 `false` 以禁用此功能。 + +**示例 (`config/mcp_server.json`):** +```json +{ + "mcpServers": { + "my-sse-server": { + "type": "sse", + "url": "http://example.com/sse-endpoint" + // ... 其他服务器配置 + } + }, + "proxy": { + "retrySseToolCallOnDisconnect": true + // ... 其他代理设置 + } +} +``` + +### 3. HTTP 工具调用的请求重试 +对于定向到基于 HTTP 的后端服务器的 `tools/call` 操作，代理服务器为连接错误（例如，“failed to fetch”、网络超时）实现了一套重试机制。 + +**重试机制：** +如果初始 HTTP 请求因连接错误而失败，代理将使用指数退避策略重试该请求。这意味着每次后续重试尝试之前的延迟会指数级增加，并加入少量抖动（随机性）以防止“惊群效应”。 + +**配置：** +这些设置在 `config/mcp_server.json` 文件的 `proxy` 对象内进行配置。 + +- **`retryHttpToolCall`** (布尔型): + - 设置为 `true` (默认值) 以启用 HTTP 工具调用的重试。 + - 设置为 `false` 以禁用此功能。 + +- **`httpToolCallMaxRetries`** (数字型): + - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `2`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 + - **默认值:** `2`。 + +- **`httpToolCallRetryDelayBaseMs`** (数字型): + - 用于指数退避计算的基础延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `httpToolCallRetryDelayBaseMs * (2^n) + jitter`。 + - **默认值:** `300` (毫秒)。 + +**示例 (`config/mcp_server.json`):** +```json +{ + "mcpServers": { + "my-http-server": { + "type": "http", + "url": "http://example.com/mcp-endpoint" + // ... 其他服务器配置 + } + }, + "proxy": { + "retryHttpToolCall": true, + "httpToolCallMaxRetries": 3, + "httpToolCallRetryDelayBaseMs": 500 + // ... 其他代理设置 + } +} +``` diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 368fb5e..830386d 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -300,29 +300,6 @@ export const getCurrentProxyState = () => { return { tools }; }; - -// --- Server Creation --- -export const createServer = async () => { - // Load initial config - const initialServerConfig = await loadConfig(); - const initialToolConfig = await loadToolConfig(); - - // Initialize currentActiveServersConfig from the initial load - const initialActiveServers: Record = {}; - for (const serverKey in initialServerConfig.mcpServers) { - if (Object.prototype.hasOwnProperty.call(initialServerConfig.mcpServers, serverKey)) { - const serverConf = initialServerConfig.mcpServers[serverKey]; - const isActive = !(serverConf.active === false || String(serverConf.active).toLowerCase() === 'false'); - if (isActive) { - initialActiveServers[serverKey] = serverConf; - } - } - } - currentActiveServersConfig = initialActiveServers; - - // Perform initial connection and map population - await updateBackendConnections(initialServerConfig, initialToolConfig); - // Helper function to identify connection errors const isConnectionError = (err: any): boolean => { if (err && err.message) { From a20a0c202957250851ddfe1fe4cc3f563f1505f1 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Thu, 29 May 2025 11:32:10 +0000 Subject: [PATCH 03/19] fix: Resolve TS18048 errors for currentProxyConfig Ensures `currentProxyConfig` in `src/mcp-proxy.ts` is always initialized with a complete set of default values and its type guarantees it is non-nullable (`Required>`). This addresses TypeScript errors TS18048 ("'currentProxyConfig' is possibly 'undefined'") that occurred during property access. Updates to `currentProxyConfig` in `createServer` and `updateBackendConnections` now also ensure all default settings are preserved. --- src/mcp-proxy.ts | 50 +++++++++++++++++++++++++++++++++--------------- 1 file changed, 35 insertions(+), 15 deletions(-) diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 830386d..1ce21ee 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -32,13 +32,25 @@ const resourceToClientMap = new Map(); const promptToClientMap = new Map(); let currentToolConfig: ToolConfig = { tools: {} }; // Store loaded tool config let currentActiveServersConfig: Record = {}; // Added for retry logic -let currentProxyConfig: Config['proxy'] = { retrySseToolCallOnDisconnect: true }; // Added for proxy settings + +// Define Global Default Proxy Settings +const defaultProxySettingsFull: Required> = { + retrySseToolCallOnDisconnect: true, + retryHttpToolCall: true, + httpToolCallMaxRetries: 2, + httpToolCallRetryDelayBaseMs: 300, +}; + +let currentProxyConfig: Required> = { ...defaultProxySettingsFull }; // Initialize with full defaults // --- Function to update backend connections and maps --- export const updateBackendConnections = async (newServerConfig: Config, newToolConfig: ToolConfig) => { console.log("Starting update of backend connections..."); currentToolConfig = newToolConfig; // Update stored tool config - currentProxyConfig = newServerConfig.proxy || { retrySseToolCallOnDisconnect: true }; // Store proxy settings + currentProxyConfig = { // Update currentProxyConfig using full defaults + ...defaultProxySettingsFull, + ...(newServerConfig.proxy || {}), + }; const activeServersConfigLocal: Record = {}; // Renamed to avoid conflict with module-level for (const serverKey in newServerConfig.mcpServers) { @@ -331,15 +343,21 @@ export const createServer = async () => { } } currentActiveServersConfig = initialActiveServers; - // Ensure all default proxy settings are applied if some are missing - const defaultProxySettings: Required = { - retrySseToolCallOnDisconnect: true, - retryHttpToolCall: true, - httpToolCallMaxRetries: 2, - httpToolCallRetryDelayBaseMs: 300, - }; + // Initialize currentActiveServersConfig AND currentProxyConfig from the initial load + const initialActiveServers: Record = {}; + for (const serverKey in initialServerConfig.mcpServers) { + if (Object.prototype.hasOwnProperty.call(initialServerConfig.mcpServers, serverKey)) { + const serverConf = initialServerConfig.mcpServers[serverKey]; + const isActive = !(serverConf.active === false || String(serverConf.active).toLowerCase() === 'false'); + if (isActive) { + initialActiveServers[serverKey] = serverConf; + } + } + } + currentActiveServersConfig = initialActiveServers; + // Update currentProxyConfig using initialServerConfig and global defaults currentProxyConfig = { - ...defaultProxySettings, + ...defaultProxySettingsFull, ...(initialServerConfig.proxy || {}), }; @@ -436,7 +454,8 @@ export const createServer = async () => { } catch (error: any) { console.warn(`Initial attempt to call tool '${requestedExposedName}' failed: ${error.message}`); - const shouldRetrySse = currentProxyConfig?.retrySseToolCallOnDisconnect !== false; + // Access currentProxyConfig directly as it's guaranteed to be defined + const shouldRetrySse = currentProxyConfig.retrySseToolCallOnDisconnect !== false; if (clientForTool.transportType === 'sse' && isConnectionError(error) && shouldRetrySse) { console.log(`SSE connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting reconnect and retry.`); @@ -474,11 +493,12 @@ export const createServer = async () => { } // HTTP Retry Logic else if (clientForTool.transportType === 'http' && - (currentProxyConfig?.retryHttpToolCall !== false) && // Retry enabled by default + (currentProxyConfig.retryHttpToolCall !== false) && // Retry enabled by default, access directly isConnectionError(error)) { - const maxRetries = currentProxyConfig.httpToolCallMaxRetries ?? 2; - const retryDelayBaseMs = currentProxyConfig.httpToolCallRetryDelayBaseMs ?? 300; + // Access properties directly. Defaults are assured by currentProxyConfig's initialization. + const maxRetries = currentProxyConfig.httpToolCallMaxRetries; + const retryDelayBaseMs = currentProxyConfig.httpToolCallRetryDelayBaseMs; let lastError: any = error; console.log(`HTTP connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting up to ${maxRetries} retries.`); @@ -510,7 +530,7 @@ export const createServer = async () => { let reason = "Unknown reason for no retry."; if (clientForTool.transportType === 'sse' && !shouldRetrySse) reason = "SSE retry disabled in config"; else if (clientForTool.transportType === 'sse' && !isConnectionError(error)) reason = "Error not a connection error for SSE"; - else if (clientForTool.transportType === 'http' && (currentProxyConfig?.retryHttpToolCall === false)) reason = "HTTP retry disabled in config"; + else if (clientForTool.transportType === 'http' && (currentProxyConfig.retryHttpToolCall === false)) reason = "HTTP retry disabled in config"; // Access directly else if (clientForTool.transportType === 'http' && !isConnectionError(error)) reason = "Error not a connection error for HTTP"; else if (clientForTool.transportType !== 'sse' && clientForTool.transportType !== 'http') reason = `Unsupported transport type for retry: ${clientForTool.transportType}`; From 8688f1ea0c569e59a86cac1258354d9e6cae5175 Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Thu, 29 May 2025 11:40:41 +0000 Subject: [PATCH 04/19] fix: Resolve TS2451 redeclaration error for initialActiveServers Removes a duplicated code block within the `createServer` function in `src/mcp-proxy.ts` that was causing a TS2451 error ("Cannot redeclare block-scoped variable 'initialActiveServers'"). This ensures `initialActiveServers` is declared and initialized only once, allowing the project to build successfully. --- src/mcp-proxy.ts | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 1ce21ee..18f77bc 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -331,18 +331,6 @@ export const createServer = async () => { const initialServerConfig = await loadConfig(); // This now includes proxy settings const initialToolConfig = await loadToolConfig(); - // Initialize currentActiveServersConfig AND currentProxyConfig from the initial load - const initialActiveServers: Record = {}; - for (const serverKey in initialServerConfig.mcpServers) { - if (Object.prototype.hasOwnProperty.call(initialServerConfig.mcpServers, serverKey)) { - const serverConf = initialServerConfig.mcpServers[serverKey]; - const isActive = !(serverConf.active === false || String(serverConf.active).toLowerCase() === 'false'); - if (isActive) { - initialActiveServers[serverKey] = serverConf; - } - } - } - currentActiveServersConfig = initialActiveServers; // Initialize currentActiveServersConfig AND currentProxyConfig from the initial load const initialActiveServers: Record = {}; for (const serverKey in initialServerConfig.mcpServers) { From dac76ea9fe216b02968a7125a32ff7220ec758cd Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Thu, 29 May 2025 12:58:52 +0000 Subject: [PATCH 05/19] feat: Configure proxy retry settings via environment variables I've modified the MCP Proxy Server so you can configure specific proxy retry/reliability settings using environment variables. These environment variable settings will now take priority over any values you've set in `mcp_server.json` for the same fields. The following settings are affected: - `retrySseToolCallOnDisconnect` (env: `RETRY_SSE_TOOL_CALL_ON_DISCONNECT`) - `retryHttpToolCall` (env: `RETRY_HTTP_TOOL_CALL`) - `httpToolCallMaxRetries` (env: `HTTP_TOOL_CALL_MAX_RETRIES`) - `httpToolCallRetryDelayBaseMs` (env: `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`) If you don't set the environment variables or if they are invalid, the system will use predefined default values for these settings. The changes I made include: - Updating `src/config.ts` to read and parse these environment variables. - Updating `README.md` to reflect the new configuration method and environment variable names. Please note that `README_ZH.md` will need to be updated manually with the translated documentation for these changes. --- README.md | 97 ++++++++++++++++----------------------- src/config.ts | 124 ++++++++++++++++++++++++++++++++++++++------------ 2 files changed, 134 insertions(+), 87 deletions(-) diff --git a/README.md b/README.md index bb46d3e..8d78be2 100644 --- a/README.md +++ b/README.md @@ -175,28 +175,28 @@ Example `config/tool_config.json`: ``` ### 4. Proxy Behavior Configuration (Error Handling & Retries) -These settings are configured within `config/mcp_server.json` under a top-level `proxy` object. +While some general proxy behaviors might be configured here in the future, the primary retry and error handling settings are now managed via **Environment Variables** for easier deployment-specific overrides. Values in `config/mcp_server.json` for these specific settings will be overridden by environment variables if set. -Example: +Example `config/mcp_server.json` showing other potential proxy settings: ```json { "mcpServers": { "...": "..." }, "proxy": { - "retrySseToolCallOnDisconnect": true, - "retryHttpToolCall": true, - "httpToolCallMaxRetries": 2, - "httpToolCallRetryDelayBaseMs": 300 + "someOtherProxySettingNotOverriddenByEnv": "example_value" + // Specific retry settings like retrySseToolCallOnDisconnect, retryHttpToolCall, + // httpToolCallMaxRetries, and httpToolCallRetryDelayBaseMs are now + // preferably set via environment variables (see below). } } ``` -See the "Enhanced Reliability Features" section for details on these options. +See the "Enhanced Reliability Features" and "Environment Variables" sections for details on these options. ## Enhanced Reliability Features -The MCP Proxy Server includes features to improve its resilience and the reliability of interactions with backend MCP services. +The MCP Proxy Server includes features to improve its resilience and the reliability of interactions with backend MCP services, ensuring smoother operations and more consistent tool execution. ### 1. Error Propagation The proxy server ensures that errors originating from backend MCP services are consistently propagated to the requesting client. These errors are formatted as standard JSON-RPC error responses, making it easier for clients to handle them uniformly. @@ -209,28 +209,18 @@ When a `tools/call` operation is made to an SSE-based backend server, and the un This behavior helps mitigate transient network issues that might temporarily disrupt SSE connections. **Configuration:** -This feature is controlled by the `retrySseToolCallOnDisconnect` property within the `proxy` object in your `config/mcp_server.json` file. -- **`retrySseToolCallOnDisconnect`** (boolean): - - Set to `true` to enable the automatic reconnect and retry. - - Set to `false` to disable this feature. - - **Default:** `true`. - -**Example (`config/mcp_server.json`):** -```json -{ - "mcpServers": { - "my-sse-server": { - "type": "sse", - "url": "http://example.com/sse-endpoint" - // ... other server config - } - }, - "proxy": { - "retrySseToolCallOnDisconnect": true - // ... other proxy settings - } -} +This feature is primarily controlled by the **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** environment variable. +- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (environment variable): + - Set to `"true"` to enable the automatic reconnect and retry. + - Set to `"false"` to disable this feature. + - **Default Behavior:** `true` (if the environment variable is not set, is empty, or is an invalid value). + - *Note: If this setting is also present in `config/mcp_server.json` under `proxy`, the environment variable takes precedence.* + +**Example (Environment Variable):** +```bash +export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" ``` +*(The JSON example for `mcp_server.json` under "Proxy Behavior Configuration" illustrates where other proxy settings might go, but this specific setting is best managed via its environment variable.)* ### 3. HTTP Request Retry for Tool Calls For `tools/call` operations directed to HTTP-based backend servers, the proxy implements a retry mechanism for connection errors (e.g., "failed to fetch", network timeouts). @@ -239,39 +229,32 @@ For `tools/call` operations directed to HTTP-based backend servers, the proxy im If an initial HTTP request fails due to a connection error, the proxy will retry the request using an exponential backoff strategy. This means the delay before each subsequent retry attempt increases exponentially, with a small amount of jitter (randomness) added to prevent thundering herd scenarios. **Configuration:** -These settings are configured within the `proxy` object in your `config/mcp_server.json` file. +These settings are primarily controlled by environment variables. Values in `config/mcp_server.json` under the `proxy` object for these specific keys will be overridden by environment variables if set. -- **`retryHttpToolCall`** (boolean): - - Set to `true` to enable retries for HTTP tool calls. - - Set to `false` to disable this feature. - - **Default:** `true`. +- **`RETRY_HTTP_TOOL_CALL`** (environment variable): + - Set to `"true"` to enable retries for HTTP tool calls. + - Set to `"false"` to disable this feature. + - **Default Behavior:** `true` (if the environment variable is not set, is empty, or is an invalid value). -- **`httpToolCallMaxRetries`** (number): - - Specifies the maximum number of retry attempts *after* the initial failed attempt. For example, if set to `2`, there will be one initial attempt and up to two retry attempts, totaling a maximum of three attempts. - - **Default:** `2`. +- **`HTTP_TOOL_CALL_MAX_RETRIES`** (environment variable): + - Specifies the maximum number of retry attempts *after* the initial failed attempt. For example, if set to `"2"`, there will be one initial attempt and up to two retry attempts, totaling a maximum of three attempts. + - **Default Behavior:** `2` (if the environment variable is not set, is empty, or is not a valid integer). -- **`httpToolCallRetryDelayBaseMs`** (number): - - The base delay in milliseconds used in the exponential backoff calculation. The delay before the *n*-th retry (0-indexed) is roughly `httpToolCallRetryDelayBaseMs * (2^n) + jitter`. - - **Default:** `300` (milliseconds). +- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`** (environment variable): + - The base delay in milliseconds used in the exponential backoff calculation. The delay before the *n*-th retry (0-indexed) is roughly `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`. + - **Default Behavior:** `300` (milliseconds) (if the environment variable is not set, is empty, or is not a valid integer). -**Example (`config/mcp_server.json`):** -```json -{ - "mcpServers": { - "my-http-server": { - "type": "http", - "url": "http://example.com/mcp-endpoint" - // ... other server config - } - }, - "proxy": { - "retryHttpToolCall": true, - "httpToolCallMaxRetries": 3, - "httpToolCallRetryDelayBaseMs": 500 - // ... other proxy settings - } -} +**General Notes on Environment Variable Parsing:** +- Boolean environment variables (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`) are considered `true` if their lowercase value is exactly `"true"`. Any other value (including empty or not set) results in the default being applied or `false` if the default is `false` (though for these specific variables, the default is `true`). +- Numeric environment variables (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`) are parsed as base-10 integers. If parsing fails (e.g., the value is not a number, or the variable is empty/not set), the default value is used. + +**Example (Environment Variables):** +```bash +export RETRY_HTTP_TOOL_CALL="true" +export HTTP_TOOL_CALL_MAX_RETRIES="3" +export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" ``` +*(The JSON example for `mcp_server.json` under "Proxy Behavior Configuration" illustrates where other, non-environment-overrideable proxy settings might go.)* ## Development diff --git a/src/config.ts b/src/config.ts index 3a30d77..9baae76 100644 --- a/src/config.ts +++ b/src/config.ts @@ -82,51 +82,115 @@ export const loadConfig = async (): Promise => { throw new Error('Invalid config format: mcpServers object not found.'); } - // Initialize proxy settings with defaults - const defaultProxySettings: Required = { + // Define standard defaults for specific environment-overrideable proxy settings + const defaultEnvProxySettings = { retrySseToolCallOnDisconnect: true, retryHttpToolCall: true, httpToolCallMaxRetries: 2, httpToolCallRetryDelayBaseMs: 300, }; - const configWithDefaults: Config = { - ...parsedConfig, - proxy: { - ...defaultProxySettings, - ...(parsedConfig.proxy || {}), // Spread any existing proxy settings to override defaults - } - }; + // Initialize proxy object on parsedConfig if it doesn't exist + // This ensures that other proxy settings from the file are preserved if they exist. + parsedConfig.proxy = parsedConfig.proxy || {}; + + // Override with environment variables or defaults for the four specific settings + // 1. RETRY_SSE_TOOL_CALL_ON_DISCONNECT + const sseRetryEnv = process.env.RETRY_SSE_TOOL_CALL_ON_DISCONNECT; + if (sseRetryEnv && sseRetryEnv.trim() !== '') { + parsedConfig.proxy.retrySseToolCallOnDisconnect = sseRetryEnv.toLowerCase() === 'true'; + } else { + parsedConfig.proxy.retrySseToolCallOnDisconnect = defaultEnvProxySettings.retrySseToolCallOnDisconnect; + } - // Ensure specific boolean and number types if they exist in parsedConfig.proxy - if (parsedConfig.proxy) { - if (typeof parsedConfig.proxy.retrySseToolCallOnDisconnect === 'boolean') { - configWithDefaults.proxy!.retrySseToolCallOnDisconnect = parsedConfig.proxy.retrySseToolCallOnDisconnect; - } - if (typeof parsedConfig.proxy.retryHttpToolCall === 'boolean') { - configWithDefaults.proxy!.retryHttpToolCall = parsedConfig.proxy.retryHttpToolCall; - } - if (typeof parsedConfig.proxy.httpToolCallMaxRetries === 'number') { - configWithDefaults.proxy!.httpToolCallMaxRetries = parsedConfig.proxy.httpToolCallMaxRetries; + // 2. RETRY_HTTP_TOOL_CALL + const httpRetryEnv = process.env.RETRY_HTTP_TOOL_CALL; + if (httpRetryEnv && httpRetryEnv.trim() !== '') { + parsedConfig.proxy.retryHttpToolCall = httpRetryEnv.toLowerCase() === 'true'; + } else { + parsedConfig.proxy.retryHttpToolCall = defaultEnvProxySettings.retryHttpToolCall; + } + + // 3. HTTP_TOOL_CALL_MAX_RETRIES + const maxRetriesEnv = process.env.HTTP_TOOL_CALL_MAX_RETRIES; + if (maxRetriesEnv && maxRetriesEnv.trim() !== '') { + const numVal = parseInt(maxRetriesEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.httpToolCallMaxRetries = numVal; + } else { + console.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnv}". Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); + parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; } - if (typeof parsedConfig.proxy.httpToolCallRetryDelayBaseMs === 'number') { - configWithDefaults.proxy!.httpToolCallRetryDelayBaseMs = parsedConfig.proxy.httpToolCallRetryDelayBaseMs; + } else { + parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; + } + + // 4. HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS + const delayBaseEnv = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (delayBaseEnv && delayBaseEnv.trim() !== '') { + const numVal = parseInt(delayBaseEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.httpToolCallRetryDelayBaseMs = numVal; + } else { + console.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnv}". Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); + parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; } + } else { + parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; } + + // The parsedConfig now has its proxy settings correctly reflecting env overrides for the specified fields. + // Other fields in parsedConfig.proxy loaded from the file remain untouched. + // Other parts of parsedConfig (like mcpServers) are also as loaded from the file. + + console.log("Loaded config with final proxy settings (after env overrides):", parsedConfig.proxy); + return parsedConfig; // Return the modified parsedConfig - console.log("Loaded config with proxy settings:", configWithDefaults.proxy); - return configWithDefaults; } catch (error) { console.error(`Error loading config/mcp_server.json:`, error); - // Return default structure in case of error + + // If file loading fails, initialize with environment variables or defaults for proxy settings + const proxySettingsFromEnvOrDefaults: ProxySettings = { + retrySseToolCallOnDisconnect: defaultEnvProxySettings.retrySseToolCallOnDisconnect, + retryHttpToolCall: defaultEnvProxySettings.retryHttpToolCall, + httpToolCallMaxRetries: defaultEnvProxySettings.httpToolCallMaxRetries, + httpToolCallRetryDelayBaseMs: defaultEnvProxySettings.httpToolCallRetryDelayBaseMs, + }; + + const sseRetryEnvCatch = process.env.RETRY_SSE_TOOL_CALL_ON_DISCONNECT; + if (sseRetryEnvCatch && sseRetryEnvCatch.trim() !== '') { + proxySettingsFromEnvOrDefaults.retrySseToolCallOnDisconnect = sseRetryEnvCatch.toLowerCase() === 'true'; + } + + const httpRetryEnvCatch = process.env.RETRY_HTTP_TOOL_CALL; + if (httpRetryEnvCatch && httpRetryEnvCatch.trim() !== '') { + proxySettingsFromEnvOrDefaults.retryHttpToolCall = httpRetryEnvCatch.toLowerCase() === 'true'; + } + + const maxRetriesEnvCatch = process.env.HTTP_TOOL_CALL_MAX_RETRIES; + if (maxRetriesEnvCatch && maxRetriesEnvCatch.trim() !== '') { + const numVal = parseInt(maxRetriesEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.httpToolCallMaxRetries = numVal; + } else { + console.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); + } + } + + const delayBaseEnvCatch = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (delayBaseEnvCatch && delayBaseEnvCatch.trim() !== '') { + const numVal = parseInt(delayBaseEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.httpToolCallRetryDelayBaseMs = numVal; + } else { + console.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); + } + } + + console.log("Using proxy settings from environment/defaults due to mcp_server.json load error:", proxySettingsFromEnvOrDefaults); return { mcpServers: {}, - proxy: { // Ensure all defaults are present here too - retrySseToolCallOnDisconnect: true, - retryHttpToolCall: true, - httpToolCallMaxRetries: 2, - httpToolCallRetryDelayBaseMs: 300, - } + proxy: proxySettingsFromEnvOrDefaults, }; } }; From 64c841b3d697ba3ed460ca7f01bd49f3f5e3894e Mon Sep 17 00:00:00 2001 From: "google-labs-jules[bot]" <161369871+google-labs-jules[bot]@users.noreply.github.com> Date: Thu, 29 May 2025 13:10:22 +0000 Subject: [PATCH 06/19] fix: Correct scope of defaultEnvProxySettings in config.ts Moves the definition of the `defaultEnvProxySettings` constant to the beginning of the `loadConfig` function. This ensures it is correctly scoped and accessible to both the `try` and `catch` blocks within the function. This resolves the TS2304 error ("Cannot find name 'defaultEnvProxySettings'") that occurred when trying to access this constant from the catch block. --- ..._ZH.md.delta_env_var_config_translation.md | 64 +++++++++++++++++++ README_ZH.md.delta_translation.md | 64 +++++++++++++++++++ ...md.extracted_env_var_changes_translated.md | 64 +++++++++++++++++++ src/config.ts | 17 ++--- 4 files changed, 201 insertions(+), 8 deletions(-) create mode 100644 README_ZH.md.delta_env_var_config_translation.md create mode 100644 README_ZH.md.delta_translation.md create mode 100644 README_ZH.md.extracted_env_var_changes_translated.md diff --git a/README_ZH.md.delta_env_var_config_translation.md b/README_ZH.md.delta_env_var_config_translation.md new file mode 100644 index 0000000..80bbadd --- /dev/null +++ b/README_ZH.md.delta_env_var_config_translation.md @@ -0,0 +1,64 @@ +### 4. 代理行为配置 (错误处理与重试) +虽然将来可能会在此处配置某些通用的代理行为，但主要的重试和错误处理设置现在通过**环境变量**进行管理，以便于针对特定部署进行覆盖。如果设置了相应的环境变量，`config/mcp_server.json` 中针对这些特定设置的值将被覆盖。 + +`config/mcp_server.json` 示例，展示其他可能的代理设置： +```json +{ + "mcpServers": { + "...": "..." + }, + "proxy": { + "someOtherProxySettingNotOverriddenByEnv": "example_value" + // 特定的重试设置，如 retrySseToolCallOnDisconnect, retryHttpToolCall, + // httpToolCallMaxRetries, 和 httpToolCallRetryDelayBaseMs 现在 + // 优先通过环境变量进行设置 (见下文)。 + } +} +``` +有关这些选项的详细信息，请参阅“增强的可靠性特性”和“环境变量”部分。 + +## 增强的可靠性特性 + +MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后端 MCP 服务交互的可靠性，确保更平稳的操作和更一致的工具执行。 + +**配置 (SSE 连接重试):** +此功能主要通过 **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** 环境变量进行控制。 +- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (环境变量): + - 设置为 `"true"` 以启用自动重新连接和重试。 + - 设置为 `"false"` 以禁用此功能。 + - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 + - *注意: 如果此设置也存在于 `config/mcp_server.json` 的 `proxy` 对象下，环境变量将优先。* + +**示例 (环境变量):** +```bash +export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" +``` +*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他代理设置可能的位置，但此特定设置最好通过其环境变量进行管理。)* + +**配置 (HTTP 请求重试):** +这些设置主要通过环境变量进行控制。如果设置了相应的环境变量，`config/mcp_server.json` 文件中 `proxy` 对象内这些特定键的值将被覆盖。 + +- **`RETRY_HTTP_TOOL_CALL`** (环境变量): + - 设置为 `"true"` 以启用 HTTP 工具调用的重试。 + - 设置为 `"false"` 以禁用此功能。 + - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 + +- **`HTTP_TOOL_CALL_MAX_RETRIES`** (环境变量): + - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `"2"`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 + - **默认行为:** `2` (如果环境变量未设置、为空或不是一个有效的整数)。 + +- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`** (环境变量): + - 用于指数退避计算的基础延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`。 + - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 + +**关于环境变量解析的通用说明:** +- 布尔型环境变量 (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`) 如果其小写值精确为 `"true"`，则被视为 `true`。任何其他值（包括空值或未设置）将导致应用默认值；如果默认值为 `false`，则解析为 `false`（尽管对于这些特定变量，默认值为 `true`）。 +- 数字型环境变量 (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`) 被解析为十进制整数。如果解析失败（例如，值不是一个数字，或变量为空/未设置），则使用默认值。 + +**示例 (环境变量):** +```bash +export RETRY_HTTP_TOOL_CALL="true" +export HTTP_TOOL_CALL_MAX_RETRIES="3" +export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" +``` +*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他不受环境变量覆盖的代理设置可能的位置。)* diff --git a/README_ZH.md.delta_translation.md b/README_ZH.md.delta_translation.md new file mode 100644 index 0000000..80bbadd --- /dev/null +++ b/README_ZH.md.delta_translation.md @@ -0,0 +1,64 @@ +### 4. 代理行为配置 (错误处理与重试) +虽然将来可能会在此处配置某些通用的代理行为，但主要的重试和错误处理设置现在通过**环境变量**进行管理，以便于针对特定部署进行覆盖。如果设置了相应的环境变量，`config/mcp_server.json` 中针对这些特定设置的值将被覆盖。 + +`config/mcp_server.json` 示例，展示其他可能的代理设置： +```json +{ + "mcpServers": { + "...": "..." + }, + "proxy": { + "someOtherProxySettingNotOverriddenByEnv": "example_value" + // 特定的重试设置，如 retrySseToolCallOnDisconnect, retryHttpToolCall, + // httpToolCallMaxRetries, 和 httpToolCallRetryDelayBaseMs 现在 + // 优先通过环境变量进行设置 (见下文)。 + } +} +``` +有关这些选项的详细信息，请参阅“增强的可靠性特性”和“环境变量”部分。 + +## 增强的可靠性特性 + +MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后端 MCP 服务交互的可靠性，确保更平稳的操作和更一致的工具执行。 + +**配置 (SSE 连接重试):** +此功能主要通过 **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** 环境变量进行控制。 +- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (环境变量): + - 设置为 `"true"` 以启用自动重新连接和重试。 + - 设置为 `"false"` 以禁用此功能。 + - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 + - *注意: 如果此设置也存在于 `config/mcp_server.json` 的 `proxy` 对象下，环境变量将优先。* + +**示例 (环境变量):** +```bash +export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" +``` +*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他代理设置可能的位置，但此特定设置最好通过其环境变量进行管理。)* + +**配置 (HTTP 请求重试):** +这些设置主要通过环境变量进行控制。如果设置了相应的环境变量，`config/mcp_server.json` 文件中 `proxy` 对象内这些特定键的值将被覆盖。 + +- **`RETRY_HTTP_TOOL_CALL`** (环境变量): + - 设置为 `"true"` 以启用 HTTP 工具调用的重试。 + - 设置为 `"false"` 以禁用此功能。 + - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 + +- **`HTTP_TOOL_CALL_MAX_RETRIES`** (环境变量): + - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `"2"`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 + - **默认行为:** `2` (如果环境变量未设置、为空或不是一个有效的整数)。 + +- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`** (环境变量): + - 用于指数退避计算的基础延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`。 + - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 + +**关于环境变量解析的通用说明:** +- 布尔型环境变量 (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`) 如果其小写值精确为 `"true"`，则被视为 `true`。任何其他值（包括空值或未设置）将导致应用默认值；如果默认值为 `false`，则解析为 `false`（尽管对于这些特定变量，默认值为 `true`）。 +- 数字型环境变量 (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`) 被解析为十进制整数。如果解析失败（例如，值不是一个数字，或变量为空/未设置），则使用默认值。 + +**示例 (环境变量):** +```bash +export RETRY_HTTP_TOOL_CALL="true" +export HTTP_TOOL_CALL_MAX_RETRIES="3" +export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" +``` +*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他不受环境变量覆盖的代理设置可能的位置。)* diff --git a/README_ZH.md.extracted_env_var_changes_translated.md b/README_ZH.md.extracted_env_var_changes_translated.md new file mode 100644 index 0000000..80bbadd --- /dev/null +++ b/README_ZH.md.extracted_env_var_changes_translated.md @@ -0,0 +1,64 @@ +### 4. 代理行为配置 (错误处理与重试) +虽然将来可能会在此处配置某些通用的代理行为，但主要的重试和错误处理设置现在通过**环境变量**进行管理，以便于针对特定部署进行覆盖。如果设置了相应的环境变量，`config/mcp_server.json` 中针对这些特定设置的值将被覆盖。 + +`config/mcp_server.json` 示例，展示其他可能的代理设置： +```json +{ + "mcpServers": { + "...": "..." + }, + "proxy": { + "someOtherProxySettingNotOverriddenByEnv": "example_value" + // 特定的重试设置，如 retrySseToolCallOnDisconnect, retryHttpToolCall, + // httpToolCallMaxRetries, 和 httpToolCallRetryDelayBaseMs 现在 + // 优先通过环境变量进行设置 (见下文)。 + } +} +``` +有关这些选项的详细信息，请参阅“增强的可靠性特性”和“环境变量”部分。 + +## 增强的可靠性特性 + +MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后端 MCP 服务交互的可靠性，确保更平稳的操作和更一致的工具执行。 + +**配置 (SSE 连接重试):** +此功能主要通过 **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** 环境变量进行控制。 +- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (环境变量): + - 设置为 `"true"` 以启用自动重新连接和重试。 + - 设置为 `"false"` 以禁用此功能。 + - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 + - *注意: 如果此设置也存在于 `config/mcp_server.json` 的 `proxy` 对象下，环境变量将优先。* + +**示例 (环境变量):** +```bash +export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" +``` +*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他代理设置可能的位置，但此特定设置最好通过其环境变量进行管理。)* + +**配置 (HTTP 请求重试):** +这些设置主要通过环境变量进行控制。如果设置了相应的环境变量，`config/mcp_server.json` 文件中 `proxy` 对象内这些特定键的值将被覆盖。 + +- **`RETRY_HTTP_TOOL_CALL`** (环境变量): + - 设置为 `"true"` 以启用 HTTP 工具调用的重试。 + - 设置为 `"false"` 以禁用此功能。 + - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 + +- **`HTTP_TOOL_CALL_MAX_RETRIES`** (环境变量): + - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `"2"`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 + - **默认行为:** `2` (如果环境变量未设置、为空或不是一个有效的整数)。 + +- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`** (环境变量): + - 用于指数退避计算的基础延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`。 + - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 + +**关于环境变量解析的通用说明:** +- 布尔型环境变量 (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`) 如果其小写值精确为 `"true"`，则被视为 `true`。任何其他值（包括空值或未设置）将导致应用默认值；如果默认值为 `false`，则解析为 `false`（尽管对于这些特定变量，默认值为 `true`）。 +- 数字型环境变量 (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`) 被解析为十进制整数。如果解析失败（例如，值不是一个数字，或变量为空/未设置），则使用默认值。 + +**示例 (环境变量):** +```bash +export RETRY_HTTP_TOOL_CALL="true" +export HTTP_TOOL_CALL_MAX_RETRIES="3" +export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" +``` +*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他不受环境变量覆盖的代理设置可能的位置。)* diff --git a/src/config.ts b/src/config.ts index 9baae76..346df41 100644 --- a/src/config.ts +++ b/src/config.ts @@ -72,6 +72,15 @@ export function isHttpConfig(config: TransportConfig): config is TransportConfig export const loadConfig = async (): Promise => { + // Define standard defaults for specific environment-overrideable proxy settings + // This is moved here to be in scope for both try and catch blocks. + const defaultEnvProxySettings = { + retrySseToolCallOnDisconnect: true, + retryHttpToolCall: true, + httpToolCallMaxRetries: 2, + httpToolCallRetryDelayBaseMs: 300, + }; + try { const configPath = resolve(process.cwd(), 'config', 'mcp_server.json'); console.log(`Attempting to load configuration from: ${configPath}`); @@ -82,14 +91,6 @@ export const loadConfig = async (): Promise => { throw new Error('Invalid config format: mcpServers object not found.'); } - // Define standard defaults for specific environment-overrideable proxy settings - const defaultEnvProxySettings = { - retrySseToolCallOnDisconnect: true, - retryHttpToolCall: true, - httpToolCallMaxRetries: 2, - httpToolCallRetryDelayBaseMs: 300, - }; - // Initialize proxy object on parsedConfig if it doesn't exist // This ensures that other proxy settings from the file are preserved if they exist. parsedConfig.proxy = parsedConfig.proxy || {}; From a2ae3618d83fab5c5d6e4aa9a437b85bf669c458 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Thu, 5 Jun 2025 19:33:22 +0800 Subject: [PATCH 07/19] refactor: change tool name seperator from -- to __ --- public/tools.js | 4 ++-- src/mcp-proxy.ts | 6 ++++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/public/tools.js b/public/tools.js index b365b4a..0aa1c6b 100644 --- a/public/tools.js +++ b/public/tools.js @@ -66,7 +66,7 @@ function renderTools() { // Render discovered tools first, merging with config discoveredTools.forEach(tool => { - const toolKey = `${tool.serverName}--${tool.name}`; // Unique key + const toolKey = `${tool.serverName}__${tool.name}`; // Unique key const config = currentToolConfig.tools[toolKey] || {}; // Get config or empty object // For discovered tools, their server is considered active by the proxy at connection time renderToolEntry(toolKey, tool, config, false, true); // isConfigOnly = false, isServerActive = true @@ -76,7 +76,7 @@ function renderTools() { // Render any remaining configured tools that were not discovered configuredToolKeys.forEach(toolKey => { const config = currentToolConfig.tools[toolKey]; - const serverKeyForConfigOnlyTool = toolKey.split('--')[0]; + const serverKeyForConfigOnlyTool = toolKey.split('__')[0]; let isServerActiveForConfigOnlyTool = true; // Default to true if server config not found or active flag is missing/true if (window.currentServerConfig && window.currentServerConfig.mcpServers && window.currentServerConfig.mcpServers[serverKeyForConfigOnlyTool]) { diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 18f77bc..a82dcb6 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -117,7 +117,7 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC const result = await connectedClient.client.request({ method: 'tools/list', params: {} }, ListToolsResultSchema); if (result.tools && result.tools.length > 0) { for (const tool of result.tools) { - const qualifiedName = `${connectedClient.name}--${tool.name}`; // Changed separator to -- + const qualifiedName = `${connectedClient.name}__${tool.name}`; // Changed separator to -- const toolSettings = currentToolConfig.tools[qualifiedName]; const isEnabled = !toolSettings || toolSettings.enabled !== false; if (isEnabled) { @@ -432,13 +432,15 @@ export const createServer = async () => { try { console.log(`Received tool call for exposed name '${requestedExposedName}' (original qualified name: '${originalQualifiedName}'). Forwarding to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt 1)`); - return await clientForTool.client.request( + const backendResponse = await clientForTool.client.request( { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, CompatibilityCallToolResultSchema ); + console.log(`[Tool Call] Backend response received for '${requestedExposedName}':'${backendResponse}' . Passing to SDK Server.`); + return backendResponse; } catch (error: any) { console.warn(`Initial attempt to call tool '${requestedExposedName}' failed: ${error.message}`); From 76109f89850ff750ddbe1721b7c77ccecf17ffa1 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Thu, 5 Jun 2025 20:41:05 +0800 Subject: [PATCH 08/19] perf: improve tool call logging --- src/mcp-proxy.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index a82dcb6..22cdecf 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -439,7 +439,7 @@ export const createServer = async () => { }, CompatibilityCallToolResultSchema ); - console.log(`[Tool Call] Backend response received for '${requestedExposedName}':'${backendResponse}' . Passing to SDK Server.`); + console.log(`[Tool Call] Backend response received for '${requestedExposedName}':'${JSON.stringify(backendResponse)}' . Passing to SDK Server.`); return backendResponse; } catch (error: any) { console.warn(`Initial attempt to call tool '${requestedExposedName}' failed: ${error.message}`); From d160e0ccae8f0bc2611a80e1932f193773f610ed Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Thu, 19 Jun 2025 13:09:03 +0800 Subject: [PATCH 09/19] fix: revert -- seperator change --- public/tools.js | 4 ++-- src/mcp-proxy.ts | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/public/tools.js b/public/tools.js index 0aa1c6b..b365b4a 100644 --- a/public/tools.js +++ b/public/tools.js @@ -66,7 +66,7 @@ function renderTools() { // Render discovered tools first, merging with config discoveredTools.forEach(tool => { - const toolKey = `${tool.serverName}__${tool.name}`; // Unique key + const toolKey = `${tool.serverName}--${tool.name}`; // Unique key const config = currentToolConfig.tools[toolKey] || {}; // Get config or empty object // For discovered tools, their server is considered active by the proxy at connection time renderToolEntry(toolKey, tool, config, false, true); // isConfigOnly = false, isServerActive = true @@ -76,7 +76,7 @@ function renderTools() { // Render any remaining configured tools that were not discovered configuredToolKeys.forEach(toolKey => { const config = currentToolConfig.tools[toolKey]; - const serverKeyForConfigOnlyTool = toolKey.split('__')[0]; + const serverKeyForConfigOnlyTool = toolKey.split('--')[0]; let isServerActiveForConfigOnlyTool = true; // Default to true if server config not found or active flag is missing/true if (window.currentServerConfig && window.currentServerConfig.mcpServers && window.currentServerConfig.mcpServers[serverKeyForConfigOnlyTool]) { diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 22cdecf..a7a45a4 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -117,7 +117,7 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC const result = await connectedClient.client.request({ method: 'tools/list', params: {} }, ListToolsResultSchema); if (result.tools && result.tools.length > 0) { for (const tool of result.tools) { - const qualifiedName = `${connectedClient.name}__${tool.name}`; // Changed separator to -- + const qualifiedName = `${connectedClient.name}--${tool.name}`; // Changed separator to -- const toolSettings = currentToolConfig.tools[qualifiedName]; const isEnabled = !toolSettings || toolSettings.enabled !== false; if (isEnabled) { From be4b869fcb96418f64abc30bdd1a9b40c8817d17 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Mon, 23 Jun 2025 16:06:26 +0800 Subject: [PATCH 10/19] feat: add stdio tool retry and improve readme --- README.md | 117 +++++++++++++++--- README_ZH.md | 103 +++++++++++++++ ..._ZH.md.delta_env_var_config_translation.md | 64 ---------- README_ZH.md.delta_translation.md | 64 ---------- README_ZH.md.enhanced_reliability_section.md | 76 ------------ ...md.extracted_env_var_changes_translated.md | 64 ---------- src/config.ts | 76 +++++++++++- src/mcp-proxy.ts | 54 +++++++- 8 files changed, 326 insertions(+), 292 deletions(-) delete mode 100644 README_ZH.md.delta_env_var_config_translation.md delete mode 100644 README_ZH.md.delta_translation.md delete mode 100644 README_ZH.md.enhanced_reliability_section.md delete mode 100644 README_ZH.md.extracted_env_var_changes_translated.md diff --git a/README.md b/README.md index 8d78be2..620fe0e 100644 --- a/README.md +++ b/README.md @@ -174,27 +174,110 @@ Example `config/tool_config.json`: export TOOLS_FOLDER=/srv/mcp_tools ``` -### 4. Proxy Behavior Configuration (Error Handling & Retries) -While some general proxy behaviors might be configured here in the future, the primary retry and error handling settings are now managed via **Environment Variables** for easier deployment-specific overrides. Values in `config/mcp_server.json` for these specific settings will be overridden by environment variables if set. +- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`**: (Optional) Controls whether to automatically reconnect and retry on SSE tool call failures. Set to `"true"` to enable, `"false"` to disable. Default: `true`. See the "Enhanced Reliability Features" section for details. + ```bash + export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" + ``` +- **`RETRY_HTTP_TOOL_CALL`**: (Optional) Controls whether to retry on HTTP tool call connection errors. Set to `"true"` to enable, `"false"` to disable. Default: `true`. See the "Enhanced Reliability Features" section for details. + ```bash + export RETRY_HTTP_TOOL_CALL="true" + ``` +- **`HTTP_TOOL_CALL_MAX_RETRIES`**: (Optional) Maximum number of retry attempts for HTTP tool calls (after the initial failure). Default: `2`. See the "Enhanced Reliability Features" section for details. + ```bash + export HTTP_TOOL_CALL_MAX_RETRIES="3" + ``` +- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`**: (Optional) Base delay in milliseconds for HTTP tool call retries, used in exponential backoff. Default: `300`. See the "Enhanced Reliability Features" section for details. + ```bash + export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" + ``` +- **`RETRY_STDIO_TOOL_CALL`**: (Optional) Controls whether to retry on Stdio tool call connection errors (attempts to restart the process). Set to `"true"` to enable, `"false"` to disable. Default: `true`. See the "Enhanced Reliability Features" section for details. + ```bash + export RETRY_STDIO_TOOL_CALL="true" + ``` +- **`STDIO_TOOL_CALL_MAX_RETRIES`**: (Optional) Maximum number of retry attempts for Stdio tool calls (after the initial failure). Default: `2`. See the "Enhanced Reliability Features" section for details. + ```bash + export STDIO_TOOL_CALL_MAX_RETRIES="5" + ``` +- **`STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`**: (Optional) Base delay in milliseconds for Stdio tool call retries, used in exponential backoff. Default: `300`. See the "Enhanced Reliability Features" section for details. + ```bash + export STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS="1000" + ``` -Example `config/mcp_server.json` showing other potential proxy settings: -```json -{ - "mcpServers": { - "...": "..." - }, - "proxy": { - "someOtherProxySettingNotOverriddenByEnv": "example_value" - // Specific retry settings like retrySseToolCallOnDisconnect, retryHttpToolCall, - // httpToolCallMaxRetries, and httpToolCallRetryDelayBaseMs are now - // preferably set via environment variables (see below). - } -} +## Enhanced Reliability Features + +The MCP Proxy Server includes features to improve its resilience and the reliability of interactions with backend MCP services, ensuring smoother operations and more consistent tool execution. + +### 1. Error Propagation +The proxy server ensures that errors originating from backend MCP services are consistently propagated to the requesting client. These errors are formatted as standard JSON-RPC error responses, making it easier for clients to handle them uniformly. + +### 2. SSE Connection Retry for Tool Calls +When a `tools/call` operation is made to an SSE-based backend server, and the underlying connection is lost or experiences an error, the proxy server will automatically attempt to: +1. Re-establish the connection to the SSE backend. +2. If reconnection is successful, it will retry the original `tools/call` request **once**. + +This behavior helps mitigate transient network issues that might temporarily disrupt SSE connections. + +**Configuration:** +This feature is primarily controlled by the **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** environment variable. +- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (environment variable): + - Set to `"true"` to enable the automatic reconnect and retry. + - Set to `"false"` to disable this feature. + - **Default Behavior:** `true` (if the environment variable is not set, is empty, or is an invalid value). + +**Example (Environment Variable):** +```bash +export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" ``` -See the "Enhanced Reliability Features" and "Environment Variables" sections for details on these options. +### 3. HTTP Request Retry for Tool Calls +For `tools/call` operations directed to HTTP-based backend servers, the proxy implements a retry mechanism for connection errors (e.g., "failed to fetch", network timeouts). + +**Retry Mechanism:** +If an initial HTTP request fails due to a connection error, the proxy will retry the request using an exponential backoff strategy. This means the delay before each subsequent retry attempt increases exponentially, with a small amount of jitter (randomness) added to prevent thundering herd scenarios. -## Enhanced Reliability Features +**Configuration:** +These settings are primarily controlled by environment variables. + +- **`RETRY_HTTP_TOOL_CALL`** (environment variable): + - Set to `"true"` to enable retries for HTTP tool calls. + - Set to `"false"` to disable this feature. + - **Default Behavior:** `true` (if the environment variable is not set, is empty, or is an invalid value). + +- **`HTTP_TOOL_CALL_MAX_RETRIES`** (environment variable): + - Specifies the maximum number of retry attempts *after* the initial failed attempt. For example, if set to `"2"`，there will be one initial attempt and up to two retry attempts, totaling a maximum of three attempts. + - **Default Behavior:** `2` (if the environment variable is not set, is empty, or is not a valid integer). + +- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`** (environment variable): + - The base delay in milliseconds used in the exponential backoff calculation. The delay before the *n*-th retry (0-indexed) is roughly `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`. + - **Default Behavior:** `300` (milliseconds) (if the environment variable is not set, is empty, or is not a valid integer). + +### 4. Stdio Connection Retry for Tool Calls +For `tools/call` operations directed to Stdio-based backend servers, the proxy implements a retry mechanism for connection errors (e.g., process crash or unresponsiveness). + +**Retry Mechanism:** +If an initial Stdio connection or tool call fails, the proxy will attempt to restart the Stdio process and retry the request. This mechanism follows an exponential backoff strategy similar to HTTP retries. + +**Configuration:** +These settings are primarily controlled by environment variables. + +- **`RETRY_STDIO_TOOL_CALL`** (environment variable): + - Set to `"true"` to enable Stdio tool call retries. + - Set to `"false"` to disable this feature. + - **Default Behavior:** `true` (if the environment variable is not set, is empty, or is an invalid value). + +- **`STDIO_TOOL_CALL_MAX_RETRIES`** (environment variable): + - Specifies the maximum number of retry attempts *after* the initial failed attempt. For example, if set to `"2"`，there will be one initial attempt and up to two retry attempts, totaling a maximum of three attempts. + - **Default Behavior:** `2` (if the environment variable is not set, is empty, or is not a valid integer). + +- **`STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`** (environment variable): + - The base delay in milliseconds used in the exponential backoff calculation. The delay before the *n*-th retry (0-indexed) is roughly `STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`. + - **Default Behavior:** `300` (milliseconds) (if the environment variable is not set, is empty, or is not a valid integer). + +**General Notes on Environment Variable Parsing:** +- Boolean environment variables (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`, `RETRY_STDIO_TOOL_CALL`) are considered `true` if their lowercase value is exactly `"true"`. Any other value (including empty or not set) results in the default being applied or `false` if the default is `false` (though for these specific variables, the default is `true`). +- Numeric environment variables (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`, `STDIO_TOOL_CALL_MAX_RETRIES`, `STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`) are parsed as base-10 integers. If parsing fails (e.g., the value is not a number, or the variable is empty/not set), the default value is used. + +## Development The MCP Proxy Server includes features to improve its resilience and the reliability of interactions with backend MCP services, ensuring smoother operations and more consistent tool execution. diff --git a/README_ZH.md b/README_ZH.md index dc829a9..119c091 100644 --- a/README_ZH.md +++ b/README_ZH.md @@ -175,6 +175,109 @@ export TOOLS_FOLDER=/srv/mcp_tools ``` +- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`**: (可选) 控制 SSE 工具调用失败时是否自动重连并重试。设置为 `"true"` 启用，`"false"` 禁用。默认: `true`。有关详细信息，请参阅“增强的可靠性特性”部分。 + ```bash + export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" + ``` +- **`RETRY_HTTP_TOOL_CALL`**: (可选) 控制 HTTP 工具调用连接错误时是否重试。设置为 `"true"` 启用，`"false"` 禁用。默认: `true`。有关详细信息，请参阅“增强的可靠性特性”部分。 + ```bash + export RETRY_HTTP_TOOL_CALL="true" + ``` +- **`HTTP_TOOL_CALL_MAX_RETRIES`**: (可选) HTTP 工具调用最大重试次数（在初始失败后）。默认: `2`。有关详细信息，请参阅“增强的可靠性特性”部分。 + ```bash + export HTTP_TOOL_CALL_MAX_RETRIES="3" + ``` +- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`**: (可选) HTTP 工具调用重试延迟基准（毫秒），用于指数退避。默认: `300`。有关详细信息，请参阅“增强的可靠性特性”部分。 + ```bash + export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" + ``` +- **`RETRY_STDIO_TOOL_CALL`**: (可选) 控制 Stdio 工具调用连接错误时是否重试（尝试重启进程）。设置为 `"true"` 启用，`"false"` 禁用。默认: `true`。有关详细信息，请参阅“增强的可靠性特性”部分。 + ```bash + export RETRY_STDIO_TOOL_CALL="true" + ``` +- **`STDIO_TOOL_CALL_MAX_RETRIES`**: (可选) Stdio 工具调用最大重试次数（在初始失败后）。默认: `2`。有关详细信息，请参阅“增强的可靠性特性”部分。 + ```bash + export STDIO_TOOL_CALL_MAX_RETRIES="5" + ``` +- **`STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`**: (可选) Stdio 工具调用重试延迟基准（毫秒），用于指数退避。默认: `300`。有关详细信息，请参阅“增强的可靠性特性”部分。 + ```bash + export STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS="1000" + ``` + +## 增强的可靠性特性 + +MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后端 MCP 服务交互的可靠性，确保更平稳的操作和更一致的工具执行。 + +### 1. 错误传播 +代理服务器确保从后端 MCP 服务产生的错误能够一致地传播给请求客户端。这些错误被格式化为标准的 JSON-RPC 错误响应，使客户端更容易统一处理它们。 + +### 2. SSE 工具调用的连接重试 +当对基于 SSE 的后端服务器执行 `tools/call` 操作时，如果底层连接丢失或遇到错误，代理服务器将自动尝试： +1. 重新建立与 SSE 后端的连接。 +2. 如果重新连接成功，它将重试原始的 `tools/call` 请求**一次**。 + +此行为有助于缓解可能暂时中断 SSE 连接的瞬时网络问题。 + +**配置:** +此功能主要通过 **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** 环境变量控制。 +- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (环境变量): + - 设置为 `"true"` 以启用自动重新连接和重试。 + - 设置为 `"false"` 以禁用此功能。 + - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 + +**示例 (环境变量):** +```bash +export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" +``` + +### 3. HTTP 工具调用的请求重试 +对于定向到基于 HTTP 的后端服务器的 `tools/call` 操作，代理服务器为连接错误（例如，“failed to fetch”、网络超时）实现了一套重试机制。 + +**重试机制：** +如果初始 HTTP 请求因连接错误而失败，代理将使用指数退避策略重试该请求。这意味着每次后续重试尝试之前的延迟会指数级增加，并加入少量抖动（随机性）以防止“惊群效应”。 + +**配置：** +这些设置主要通过环境变量控制。 + +- **`RETRY_HTTP_TOOL_CALL`** (环境变量): + - 设置为 `"true"` 以启用 HTTP 工具调用的重试。 + - 设置为 `"false"` 以禁用此功能。 + - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 + +- **`HTTP_TOOL_CALL_MAX_RETRIES`** (环境变量): + - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `"2"`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 + - **默认行为:** `2` (如果环境变量未设置、为空或不是一个有效的整数)。 + +- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`** (环境变量): + - 用于指数退避计算的基准延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + 抖动`。 + - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 + +### 4. Stdio 工具调用的连接重试 +对于指向基于 Stdio 的后端服务器的 `tools/call` 操作，代理实现了针对连接错误（例如，进程崩溃或无响应）的重试机制。 + +**重试机制:** +如果初始 Stdio 连接或工具调用失败，代理将尝试重新启动 Stdio 进程并重试请求。此机制类似于 HTTP 重试，使用指数退避策略。 + +**配置:** +这些设置主要由环境变量控制。 + +- **`RETRY_STDIO_TOOL_CALL`** (环境变量): + - 设置为 `"true"` 以启用 Stdio 工具调用重试。 + - 设置为 `"false"` 以禁用此功能。 + - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 + +- **`STDIO_TOOL_CALL_MAX_RETRIES`** (环境变量): + - 指定在初次失败尝试*之后*的最大重试尝试次数。例如，如果设置为 `"2"`，则将有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 + - **默认行为:** `2` (如果环境变量未设置、为空或不是一个有效的整数)。 + +- **`STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`** (环境变量): + - 用于指数退避计算的基准延迟（以毫秒为单位）。第 *n* 次重试（从 0 开始索引）之前的延迟大约是 `STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + 抖动`。 + - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 + +**环境变量解析通用说明:** +- 布尔环境变量（`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`，`RETRY_HTTP_TOOL_CALL`，`RETRY_STDIO_TOOL_CALL`）如果其小写值恰好是 `"true"`，则被视为 `true`。任何其他值（包括空或未设置）将应用默认值，或者如果默认值为 `false` 则为 `false`（尽管对于这些特定变量，默认值为 `true`）。 +- 数字环境变量（`HTTP_TOOL_CALL_MAX_RETRIES`，`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`，`STDIO_TOOL_CALL_MAX_RETRIES`，`STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`）被解析为十进制整数。如果解析失败（例如，值不是数字，或变量为空/未设置），则使用默认值。 + ## 开发 安装依赖: diff --git a/README_ZH.md.delta_env_var_config_translation.md b/README_ZH.md.delta_env_var_config_translation.md deleted file mode 100644 index 80bbadd..0000000 --- a/README_ZH.md.delta_env_var_config_translation.md +++ /dev/null @@ -1,64 +0,0 @@ -### 4. 代理行为配置 (错误处理与重试) -虽然将来可能会在此处配置某些通用的代理行为，但主要的重试和错误处理设置现在通过**环境变量**进行管理，以便于针对特定部署进行覆盖。如果设置了相应的环境变量，`config/mcp_server.json` 中针对这些特定设置的值将被覆盖。 - -`config/mcp_server.json` 示例，展示其他可能的代理设置： -```json -{ - "mcpServers": { - "...": "..." - }, - "proxy": { - "someOtherProxySettingNotOverriddenByEnv": "example_value" - // 特定的重试设置，如 retrySseToolCallOnDisconnect, retryHttpToolCall, - // httpToolCallMaxRetries, 和 httpToolCallRetryDelayBaseMs 现在 - // 优先通过环境变量进行设置 (见下文)。 - } -} -``` -有关这些选项的详细信息，请参阅“增强的可靠性特性”和“环境变量”部分。 - -## 增强的可靠性特性 - -MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后端 MCP 服务交互的可靠性，确保更平稳的操作和更一致的工具执行。 - -**配置 (SSE 连接重试):** -此功能主要通过 **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** 环境变量进行控制。 -- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (环境变量): - - 设置为 `"true"` 以启用自动重新连接和重试。 - - 设置为 `"false"` 以禁用此功能。 - - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 - - *注意: 如果此设置也存在于 `config/mcp_server.json` 的 `proxy` 对象下，环境变量将优先。* - -**示例 (环境变量):** -```bash -export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" -``` -*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他代理设置可能的位置，但此特定设置最好通过其环境变量进行管理。)* - -**配置 (HTTP 请求重试):** -这些设置主要通过环境变量进行控制。如果设置了相应的环境变量，`config/mcp_server.json` 文件中 `proxy` 对象内这些特定键的值将被覆盖。 - -- **`RETRY_HTTP_TOOL_CALL`** (环境变量): - - 设置为 `"true"` 以启用 HTTP 工具调用的重试。 - - 设置为 `"false"` 以禁用此功能。 - - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 - -- **`HTTP_TOOL_CALL_MAX_RETRIES`** (环境变量): - - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `"2"`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 - - **默认行为:** `2` (如果环境变量未设置、为空或不是一个有效的整数)。 - -- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`** (环境变量): - - 用于指数退避计算的基础延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`。 - - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 - -**关于环境变量解析的通用说明:** -- 布尔型环境变量 (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`) 如果其小写值精确为 `"true"`，则被视为 `true`。任何其他值（包括空值或未设置）将导致应用默认值；如果默认值为 `false`，则解析为 `false`（尽管对于这些特定变量，默认值为 `true`）。 -- 数字型环境变量 (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`) 被解析为十进制整数。如果解析失败（例如，值不是一个数字，或变量为空/未设置），则使用默认值。 - -**示例 (环境变量):** -```bash -export RETRY_HTTP_TOOL_CALL="true" -export HTTP_TOOL_CALL_MAX_RETRIES="3" -export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" -``` -*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他不受环境变量覆盖的代理设置可能的位置。)* diff --git a/README_ZH.md.delta_translation.md b/README_ZH.md.delta_translation.md deleted file mode 100644 index 80bbadd..0000000 --- a/README_ZH.md.delta_translation.md +++ /dev/null @@ -1,64 +0,0 @@ -### 4. 代理行为配置 (错误处理与重试) -虽然将来可能会在此处配置某些通用的代理行为，但主要的重试和错误处理设置现在通过**环境变量**进行管理，以便于针对特定部署进行覆盖。如果设置了相应的环境变量，`config/mcp_server.json` 中针对这些特定设置的值将被覆盖。 - -`config/mcp_server.json` 示例，展示其他可能的代理设置： -```json -{ - "mcpServers": { - "...": "..." - }, - "proxy": { - "someOtherProxySettingNotOverriddenByEnv": "example_value" - // 特定的重试设置，如 retrySseToolCallOnDisconnect, retryHttpToolCall, - // httpToolCallMaxRetries, 和 httpToolCallRetryDelayBaseMs 现在 - // 优先通过环境变量进行设置 (见下文)。 - } -} -``` -有关这些选项的详细信息，请参阅“增强的可靠性特性”和“环境变量”部分。 - -## 增强的可靠性特性 - -MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后端 MCP 服务交互的可靠性，确保更平稳的操作和更一致的工具执行。 - -**配置 (SSE 连接重试):** -此功能主要通过 **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** 环境变量进行控制。 -- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (环境变量): - - 设置为 `"true"` 以启用自动重新连接和重试。 - - 设置为 `"false"` 以禁用此功能。 - - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 - - *注意: 如果此设置也存在于 `config/mcp_server.json` 的 `proxy` 对象下，环境变量将优先。* - -**示例 (环境变量):** -```bash -export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" -``` -*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他代理设置可能的位置，但此特定设置最好通过其环境变量进行管理。)* - -**配置 (HTTP 请求重试):** -这些设置主要通过环境变量进行控制。如果设置了相应的环境变量，`config/mcp_server.json` 文件中 `proxy` 对象内这些特定键的值将被覆盖。 - -- **`RETRY_HTTP_TOOL_CALL`** (环境变量): - - 设置为 `"true"` 以启用 HTTP 工具调用的重试。 - - 设置为 `"false"` 以禁用此功能。 - - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 - -- **`HTTP_TOOL_CALL_MAX_RETRIES`** (环境变量): - - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `"2"`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 - - **默认行为:** `2` (如果环境变量未设置、为空或不是一个有效的整数)。 - -- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`** (环境变量): - - 用于指数退避计算的基础延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`。 - - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 - -**关于环境变量解析的通用说明:** -- 布尔型环境变量 (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`) 如果其小写值精确为 `"true"`，则被视为 `true`。任何其他值（包括空值或未设置）将导致应用默认值；如果默认值为 `false`，则解析为 `false`（尽管对于这些特定变量，默认值为 `true`）。 -- 数字型环境变量 (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`) 被解析为十进制整数。如果解析失败（例如，值不是一个数字，或变量为空/未设置），则使用默认值。 - -**示例 (环境变量):** -```bash -export RETRY_HTTP_TOOL_CALL="true" -export HTTP_TOOL_CALL_MAX_RETRIES="3" -export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" -``` -*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他不受环境变量覆盖的代理设置可能的位置。)* diff --git a/README_ZH.md.enhanced_reliability_section.md b/README_ZH.md.enhanced_reliability_section.md deleted file mode 100644 index 0354f32..0000000 --- a/README_ZH.md.enhanced_reliability_section.md +++ /dev/null @@ -1,76 +0,0 @@ -## 增强的可靠性特性 - -MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后端 MCP 服务交互的可靠性，确保更平稳的操作和更一致的工具执行。 - -### 1. 错误传播 -代理服务器确保从后端 MCP 服务产生的错误能够一致地传播给请求客户端。这些错误被格式化为标准的 JSON-RPC 错误响应，使客户端更容易统一处理它们。 - -### 2. SSE 工具调用的连接重试 -当对基于 SSE 的后端服务器执行 `tools/call` 操作时，如果底层连接丢失或遇到错误，代理服务器将自动尝试： -1. 重新建立与 SSE 后端的连接。 -2. 如果重新连接成功，它将重试原始的 `tools/call` 请求**一次**。 - -此行为有助于缓解可能暂时中断 SSE 连接的瞬时网络问题。 - -**配置：** -此功能通过 `config/mcp_server.json` 文件中 `proxy` 对象内的 `retrySseToolCallOnDisconnect` 属性进行控制。 -- **`retrySseToolCallOnDisconnect`** (布尔型): - - 设置为 `true` (默认值) 以启用自动重新连接和重试。 - - 设置为 `false` 以禁用此功能。 - -**示例 (`config/mcp_server.json`):** -```json -{ - "mcpServers": { - "my-sse-server": { - "type": "sse", - "url": "http://example.com/sse-endpoint" - // ... 其他服务器配置 - } - }, - "proxy": { - "retrySseToolCallOnDisconnect": true - // ... 其他代理设置 - } -} -``` - -### 3. HTTP 工具调用的请求重试 -对于定向到基于 HTTP 的后端服务器的 `tools/call` 操作，代理服务器为连接错误（例如，“failed to fetch”、网络超时）实现了一套重试机制。 - -**重试机制：** -如果初始 HTTP 请求因连接错误而失败，代理将使用指数退避策略重试该请求。这意味着每次后续重试尝试之前的延迟会指数级增加，并加入少量抖动（随机性）以防止“惊群效应”。 - -**配置：** -这些设置在 `config/mcp_server.json` 文件的 `proxy` 对象内进行配置。 - -- **`retryHttpToolCall`** (布尔型): - - 设置为 `true` (默认值) 以启用 HTTP 工具调用的重试。 - - 设置为 `false` 以禁用此功能。 - -- **`httpToolCallMaxRetries`** (数字型): - - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `2`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 - - **默认值:** `2`。 - -- **`httpToolCallRetryDelayBaseMs`** (数字型): - - 用于指数退避计算的基础延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `httpToolCallRetryDelayBaseMs * (2^n) + jitter`。 - - **默认值:** `300` (毫秒)。 - -**示例 (`config/mcp_server.json`):** -```json -{ - "mcpServers": { - "my-http-server": { - "type": "http", - "url": "http://example.com/mcp-endpoint" - // ... 其他服务器配置 - } - }, - "proxy": { - "retryHttpToolCall": true, - "httpToolCallMaxRetries": 3, - "httpToolCallRetryDelayBaseMs": 500 - // ... 其他代理设置 - } -} -``` diff --git a/README_ZH.md.extracted_env_var_changes_translated.md b/README_ZH.md.extracted_env_var_changes_translated.md deleted file mode 100644 index 80bbadd..0000000 --- a/README_ZH.md.extracted_env_var_changes_translated.md +++ /dev/null @@ -1,64 +0,0 @@ -### 4. 代理行为配置 (错误处理与重试) -虽然将来可能会在此处配置某些通用的代理行为，但主要的重试和错误处理设置现在通过**环境变量**进行管理，以便于针对特定部署进行覆盖。如果设置了相应的环境变量，`config/mcp_server.json` 中针对这些特定设置的值将被覆盖。 - -`config/mcp_server.json` 示例，展示其他可能的代理设置： -```json -{ - "mcpServers": { - "...": "..." - }, - "proxy": { - "someOtherProxySettingNotOverriddenByEnv": "example_value" - // 特定的重试设置，如 retrySseToolCallOnDisconnect, retryHttpToolCall, - // httpToolCallMaxRetries, 和 httpToolCallRetryDelayBaseMs 现在 - // 优先通过环境变量进行设置 (见下文)。 - } -} -``` -有关这些选项的详细信息，请参阅“增强的可靠性特性”和“环境变量”部分。 - -## 增强的可靠性特性 - -MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后端 MCP 服务交互的可靠性，确保更平稳的操作和更一致的工具执行。 - -**配置 (SSE 连接重试):** -此功能主要通过 **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** 环境变量进行控制。 -- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (环境变量): - - 设置为 `"true"` 以启用自动重新连接和重试。 - - 设置为 `"false"` 以禁用此功能。 - - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 - - *注意: 如果此设置也存在于 `config/mcp_server.json` 的 `proxy` 对象下，环境变量将优先。* - -**示例 (环境变量):** -```bash -export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" -``` -*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他代理设置可能的位置，但此特定设置最好通过其环境变量进行管理。)* - -**配置 (HTTP 请求重试):** -这些设置主要通过环境变量进行控制。如果设置了相应的环境变量，`config/mcp_server.json` 文件中 `proxy` 对象内这些特定键的值将被覆盖。 - -- **`RETRY_HTTP_TOOL_CALL`** (环境变量): - - 设置为 `"true"` 以启用 HTTP 工具调用的重试。 - - 设置为 `"false"` 以禁用此功能。 - - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 - -- **`HTTP_TOOL_CALL_MAX_RETRIES`** (环境变量): - - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `"2"`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 - - **默认行为:** `2` (如果环境变量未设置、为空或不是一个有效的整数)。 - -- **`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`** (环境变量): - - 用于指数退避计算的基础延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`。 - - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 - -**关于环境变量解析的通用说明:** -- 布尔型环境变量 (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`) 如果其小写值精确为 `"true"`，则被视为 `true`。任何其他值（包括空值或未设置）将导致应用默认值；如果默认值为 `false`，则解析为 `false`（尽管对于这些特定变量，默认值为 `true`）。 -- 数字型环境变量 (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`) 被解析为十进制整数。如果解析失败（例如，值不是一个数字，或变量为空/未设置），则使用默认值。 - -**示例 (环境变量):** -```bash -export RETRY_HTTP_TOOL_CALL="true" -export HTTP_TOOL_CALL_MAX_RETRIES="3" -export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" -``` -*(`config/mcp_server.json` 中“代理行为配置”下的 JSON 示例说明了其他不受环境变量覆盖的代理设置可能的位置。)* diff --git a/src/config.ts b/src/config.ts index 346df41..ed2b4ae 100644 --- a/src/config.ts +++ b/src/config.ts @@ -39,6 +39,9 @@ export interface ProxySettings { retryHttpToolCall?: boolean; httpToolCallMaxRetries?: number; httpToolCallRetryDelayBaseMs?: number; + retryStdioToolCall?: boolean; // Add stdio retry flag + stdioToolCallMaxRetries?: number; // Add stdio max retries + stdioToolCallRetryDelayBaseMs?: number; // Add stdio retry delay } export interface Config { @@ -79,6 +82,9 @@ export const loadConfig = async (): Promise => { retryHttpToolCall: true, httpToolCallMaxRetries: 2, httpToolCallRetryDelayBaseMs: 300, + retryStdioToolCall: true, // Default for stdio retry + stdioToolCallMaxRetries: 2, // Default for stdio max retries + stdioToolCallRetryDelayBaseMs: 300, // Default for stdio retry delay }; try { @@ -95,7 +101,7 @@ export const loadConfig = async (): Promise => { // This ensures that other proxy settings from the file are preserved if they exist. parsedConfig.proxy = parsedConfig.proxy || {}; - // Override with environment variables or defaults for the four specific settings + // Override with environment variables or defaults for the specific settings // 1. RETRY_SSE_TOOL_CALL_ON_DISCONNECT const sseRetryEnv = process.env.RETRY_SSE_TOOL_CALL_ON_DISCONNECT; if (sseRetryEnv && sseRetryEnv.trim() !== '') { @@ -139,7 +145,43 @@ export const loadConfig = async (): Promise => { } else { parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; } - + + // 5. RETRY_STDIO_TOOL_CALL + const stdioRetryEnv = process.env.RETRY_STDIO_TOOL_CALL; + if (stdioRetryEnv && stdioRetryEnv.trim() !== '') { + parsedConfig.proxy.retryStdioToolCall = stdioRetryEnv.toLowerCase() === 'true'; + } else { + parsedConfig.proxy.retryStdioToolCall = defaultEnvProxySettings.retryStdioToolCall; + } + + // 6. STDIO_TOOL_CALL_MAX_RETRIES + const stdioMaxRetriesEnv = process.env.STDIO_TOOL_CALL_MAX_RETRIES; + if (stdioMaxRetriesEnv && stdioMaxRetriesEnv.trim() !== '') { + const numVal = parseInt(stdioMaxRetriesEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.stdioToolCallMaxRetries = numVal; + } else { + console.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); + parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; + } + } else { + parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; + } + + // 7. STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS + const stdioDelayBaseEnv = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (stdioDelayBaseEnv && stdioDelayBaseEnv.trim() !== '') { + const numVal = parseInt(stdioDelayBaseEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = numVal; + } else { + console.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); + parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; + } + } else { + parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; + } + // The parsedConfig now has its proxy settings correctly reflecting env overrides for the specified fields. // Other fields in parsedConfig.proxy loaded from the file remain untouched. // Other parts of parsedConfig (like mcpServers) are also as loaded from the file. @@ -156,6 +198,9 @@ export const loadConfig = async (): Promise => { retryHttpToolCall: defaultEnvProxySettings.retryHttpToolCall, httpToolCallMaxRetries: defaultEnvProxySettings.httpToolCallMaxRetries, httpToolCallRetryDelayBaseMs: defaultEnvProxySettings.httpToolCallRetryDelayBaseMs, + retryStdioToolCall: defaultEnvProxySettings.retryStdioToolCall, // Default for stdio retry + stdioToolCallMaxRetries: defaultEnvProxySettings.stdioToolCallMaxRetries, // Default for stdio max retries + stdioToolCallRetryDelayBaseMs: defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs, // Default for stdio retry delay }; const sseRetryEnvCatch = process.env.RETRY_SSE_TOOL_CALL_ON_DISCONNECT; @@ -187,7 +232,32 @@ export const loadConfig = async (): Promise => { console.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); } } - + + const stdioRetryEnvCatch = process.env.RETRY_STDIO_TOOL_CALL; + if (stdioRetryEnvCatch && stdioRetryEnvCatch.trim() !== '') { + proxySettingsFromEnvOrDefaults.retryStdioToolCall = stdioRetryEnvCatch.toLowerCase() === 'true'; + } + + const stdioMaxRetriesEnvCatch = process.env.STDIO_TOOL_CALL_MAX_RETRIES; + if (stdioMaxRetriesEnvCatch && stdioMaxRetriesEnvCatch.trim() !== '') { + const numVal = parseInt(stdioMaxRetriesEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.stdioToolCallMaxRetries = numVal; + } else { + console.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); + } + } + + const stdioDelayBaseEnvCatch = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (stdioDelayBaseEnvCatch && stdioDelayBaseEnvCatch.trim() !== '') { + const numVal = parseInt(stdioDelayBaseEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.stdioToolCallRetryDelayBaseMs = numVal; + } else { + console.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); + } + } + console.log("Using proxy settings from environment/defaults due to mcp_server.json load error:", proxySettingsFromEnvOrDefaults); return { mcpServers: {}, diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index a7a45a4..00b5b39 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -39,6 +39,9 @@ const defaultProxySettingsFull: Required> = { retryHttpToolCall: true, httpToolCallMaxRetries: 2, httpToolCallRetryDelayBaseMs: 300, + retryStdioToolCall: true, // Default for stdio retry + stdioToolCallMaxRetries: 2, // Default for stdio max retries + stdioToolCallRetryDelayBaseMs: 300, // Default for stdio retry delay }; let currentProxyConfig: Required> = { ...defaultProxySettingsFull }; // Initialize with full defaults @@ -320,7 +323,11 @@ const isConnectionError = (err: any): boolean => { lowerMessage.includes("not connected") || lowerMessage.includes("connection closed") || lowerMessage.includes("transport is closed") || // SDK specific - lowerMessage.includes("failed to fetch"); // Network level + lowerMessage.includes("failed to fetch") || + lowerMessage.includes("not found") || //404 + lowerMessage.includes("EOF") || // Network level + lowerMessage.includes("TLS") || // TLS handshake + lowerMessage.includes("timeout"); } return false; }; @@ -480,9 +487,45 @@ export const createServer = async () => { console.error(errorMessage); throw new Error(errorMessage); } - } + } + // STDIO Retry Logic + else if (clientForTool.transportType === 'stdio' && + (currentProxyConfig.retryStdioToolCall !== false) && // Retry enabled by default, access directly + isConnectionError(error)) { + + // Access properties directly. Defaults are assured by currentProxyConfig's initialization. + const maxRetries = currentProxyConfig.stdioToolCallMaxRetries; + const retryDelayBaseMs = currentProxyConfig.stdioToolCallRetryDelayBaseMs; + let lastError: any = error; + + console.log(`STDIO connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting up to ${maxRetries} retries.`); + + for (let attempt = 0; attempt < maxRetries; attempt++) { + try { + const delay = retryDelayBaseMs * Math.pow(2, attempt) + (Math.random() * retryDelayBaseMs * 0.5); + console.log(`STDIO tool call failed for '${requestedExposedName}'. Attempt ${attempt + 1}/${maxRetries}. Retrying in ${delay.toFixed(0)}ms...`); + await sleep(delay); + + console.log(`Retrying tool call (STDIO) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 2})`); + return await clientForTool.client.request( + { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, + CompatibilityCallToolResultSchema + ); + } catch (retryError: any) { + lastError = retryError; + console.error(`STDIO tool call retry attempt ${attempt + 1}/${maxRetries} for '${requestedExposedName}' failed:`, retryError.message); + if (attempt === maxRetries - 1) { + break; + } + } + } + const errorMessage = `Error calling STDIO tool '${requestedExposedName}' after ${maxRetries} retries (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${lastError.message || 'An unknown error occurred'}`; + console.error(errorMessage, lastError); + throw new Error(errorMessage); + + } // HTTP Retry Logic - else if (clientForTool.transportType === 'http' && + else if (clientForTool.transportType === 'http' && (currentProxyConfig.retryHttpToolCall !== false) && // Retry enabled by default, access directly isConnectionError(error)) { @@ -518,11 +561,14 @@ export const createServer = async () => { } else { let reason = "Unknown reason for no retry."; + const shouldRetryStdio = currentProxyConfig.retryStdioToolCall !== false; // Access directly if (clientForTool.transportType === 'sse' && !shouldRetrySse) reason = "SSE retry disabled in config"; else if (clientForTool.transportType === 'sse' && !isConnectionError(error)) reason = "Error not a connection error for SSE"; + else if (clientForTool.transportType === 'stdio' && !shouldRetryStdio) reason = "STDIO retry disabled in config"; // Check stdio retry flag + else if (clientForTool.transportType === 'stdio' && !isConnectionError(error)) reason = "Error not a connection error for STDIO"; // Check stdio connection error else if (clientForTool.transportType === 'http' && (currentProxyConfig.retryHttpToolCall === false)) reason = "HTTP retry disabled in config"; // Access directly else if (clientForTool.transportType === 'http' && !isConnectionError(error)) reason = "Error not a connection error for HTTP"; - else if (clientForTool.transportType !== 'sse' && clientForTool.transportType !== 'http') reason = `Unsupported transport type for retry: ${clientForTool.transportType}`; + else if (clientForTool.transportType !== 'sse' && clientForTool.transportType !== 'http' && clientForTool.transportType !== 'stdio') reason = `Unsupported transport type for retry: ${clientForTool.transportType}`; // Add stdio to check console.warn(`Not retrying tool call for '${requestedExposedName}'. Reason: ${reason}. Original error: ${error.message}`); const errorMessage = `Error calling tool '${requestedExposedName}' (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${error.message || 'An unknown error occurred'}`; From 1cb290f154a2f58b834f9e98697e29a621014e98 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Mon, 23 Jun 2025 16:12:20 +0800 Subject: [PATCH 11/19] perf: improve connection error --- src/mcp-proxy.ts | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 00b5b39..e1f7e63 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -325,9 +325,10 @@ const isConnectionError = (err: any): boolean => { lowerMessage.includes("transport is closed") || // SDK specific lowerMessage.includes("failed to fetch") || lowerMessage.includes("not found") || //404 - lowerMessage.includes("EOF") || // Network level - lowerMessage.includes("TLS") || // TLS handshake - lowerMessage.includes("timeout"); + lowerMessage.includes("eof") || // Network level + lowerMessage.includes("tls") || // TLS handshake + lowerMessage.includes("timeout") || + lowerMessage.includes("timed out"); } return false; }; From 03094cd375560b9146a4286ccd754f1d62cc85f9 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Mon, 23 Jun 2025 17:36:47 +0800 Subject: [PATCH 12/19] feat: logger level --- src/client.ts | 167 +++++++++++++++--------------- src/config.ts | 87 ++++++++-------- src/index.ts | 3 +- src/logger.ts | 66 ++++++++++++ src/mcp-proxy.ts | 151 +++++++++++++-------------- src/sse.ts | 259 +++++++++++++++++++++++++---------------------- 6 files changed, 411 insertions(+), 322 deletions(-) create mode 100644 src/logger.ts diff --git a/src/client.ts b/src/client.ts index 0a47da6..bd21998 100644 --- a/src/client.ts +++ b/src/client.ts @@ -5,6 +5,7 @@ import { StreamableHTTPClientTransport, StreamableHTTPClientTransportOptions } f import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'; import { TransportConfig, isSSEConfig, isStdioConfig, isHttpConfig } from './config.js'; import { EventSource } from 'eventsource'; +import { logger } from './logger.js'; // Import logger functions const sleep = (time: number) => new Promise(resolve => setTimeout(() => resolve(), time)) export interface ConnectedClient { @@ -27,10 +28,10 @@ const createClient = (name: string, transportConfig: TransportConfig): { client: if (transportConfig.bearerToken) { customHeaders = { 'Authorization': `Bearer ${transportConfig.bearerToken}` }; - console.log(` Using Bearer Token for SSE connection to ${name}`); + logger.debug(` Using Bearer Token for SSE connection to ${name}`); // Changed to debug } else if (transportConfig.apiKey) { customHeaders = { 'X-Api-Key': transportConfig.apiKey }; - console.log(` Using X-Api-Key for SSE connection to ${name}`); + logger.debug(` Using X-Api-Key for SSE connection to ${name}`); // Changed to debug } if (customHeaders) { @@ -56,77 +57,77 @@ const createClient = (name: string, transportConfig: TransportConfig): { client: } transport = new SSEClientTransport(new URL(transportConfig.url), transportOptions); - } else if (isStdioConfig(transportConfig)) { - transportType = 'stdio'; - const mergedEnv = { - ...process.env, - ...transportConfig.env - }; - const filteredEnv: Record = {}; - for (const key in mergedEnv) { - if (Object.prototype.hasOwnProperty.call(mergedEnv, key) && mergedEnv[key] !== undefined) { - filteredEnv[key] = mergedEnv[key] as string; - } - } - transport = new StdioClientTransport({ - command: transportConfig.command, - args: transportConfig.args, - env: filteredEnv - }); - } else if (isHttpConfig(transportConfig)) { - transportType = 'http'; - const transportOptions: StreamableHTTPClientTransportOptions = {}; - let customHeaders: Record | undefined; - - if (transportConfig.bearerToken) { - customHeaders = { 'Authorization': `Bearer ${transportConfig.bearerToken}` }; - console.log(` Using Bearer Token for StreamableHTTP connection to ${name}`); - } else if (transportConfig.apiKey) { - customHeaders = { 'X-Api-Key': transportConfig.apiKey }; - console.log(` Using X-Api-Key for StreamableHTTP connection to ${name}`); - } - - if (customHeaders) { - transportOptions.requestInit = { headers: customHeaders }; - } - // Note: StreamableHTTPClientTransport handles session ID internally if configured. - // We might pass transportConfig.sessionId if we want to force a specific one. - transport = new StreamableHTTPClientTransport(new URL(transportConfig.url), transportOptions); - } else { - console.error(`Invalid or unknown transport type in configuration for server: ${name}`); - } - } catch (error) { - let transportType = 'unknown'; - if (isSSEConfig(transportConfig)) transportType = 'sse'; - else if (isStdioConfig(transportConfig)) transportType = 'stdio'; - else if (isHttpConfig(transportConfig)) transportType = 'http'; - console.error(`Failed to create transport ${transportType} to ${name}:`, error); - } - - if (!transport || !transportType) { // Also check transportType - console.warn(`Transport or transportType for ${name} not available.`); - return { transport: undefined, client: undefined, transportType: undefined }; - } - - const client = new Client({ - name: 'mcp-proxy-client', - version: '1.0.0', - }, { - capabilities: { - prompts: {}, - resources: { subscribe: true }, - tools: {} - } - }); + } else if (isStdioConfig(transportConfig)) { + transportType = 'stdio'; + const mergedEnv = { + ...process.env, + ...transportConfig.env + }; + const filteredEnv: Record = {}; + for (const key in mergedEnv) { + if (Object.prototype.hasOwnProperty.call(mergedEnv, key) && mergedEnv[key] !== undefined) { + filteredEnv[key] = mergedEnv[key] as string; + } + } + transport = new StdioClientTransport({ + command: transportConfig.command, + args: transportConfig.args, + env: filteredEnv + }); + } else if (isHttpConfig(transportConfig)) { + transportType = 'http'; + const transportOptions: StreamableHTTPClientTransportOptions = {}; + let customHeaders: Record | undefined; + + if (transportConfig.bearerToken) { + customHeaders = { 'Authorization': `Bearer ${transportConfig.bearerToken}` }; + logger.debug(` Using Bearer Token for StreamableHTTP connection to ${name}`); // Changed to debug + } else if (transportConfig.apiKey) { + customHeaders = { 'X-Api-Key': transportConfig.apiKey }; + logger.debug(` Using X-Api-Key for StreamableHTTP connection to ${name}`); // Changed to debug + } - return { client, transport, transportType } + if (customHeaders) { + transportOptions.requestInit = { headers: customHeaders }; + } + // Note: StreamableHTTPClientTransport handles session ID internally if configured. + // We might pass transportConfig.sessionId if we want to force a specific one. + transport = new StreamableHTTPClientTransport(new URL(transportConfig.url), transportOptions); + } else { + logger.error(`Invalid or unknown transport type in configuration for server: ${name}`); // Changed to error + } + } catch (error) { + let transportType = 'unknown'; + if (isSSEConfig(transportConfig)) transportType = 'sse'; + else if (isStdioConfig(transportConfig)) transportType = 'stdio'; + else if (isHttpConfig(transportConfig)) transportType = 'http'; + logger.error(`Failed to create transport ${transportType} to ${name}:`, error); // Changed to error + } + + if (!transport || !transportType) { // Also check transportType + logger.warn(`Transport or transportType for ${name} not available.`); // Changed to warn + return { transport: undefined, client: undefined, transportType: undefined }; + } + + const client = new Client({ + name: 'mcp-proxy-client', + version: '1.0.0', + }, { + capabilities: { + prompts: {}, + resources: { subscribe: true }, + tools: {} + } + }); + + return { client, transport, transportType } } export const createClients = async (mcpServers: Record): Promise => { const clients: ConnectedClient[] = []; for (const [name, transportConfig] of Object.entries(mcpServers)) { - console.log(`Connecting to server: ${name}`); + logger.log(`Connecting to server: ${name}`); // Changed to log const waitFor = 2500; const retries = 3; @@ -137,13 +138,13 @@ export const createClients = async (mcpServers: Record) const { client, transport, transportType } = createClient(name, transportConfig); // Capture transportType if (!client || !transport || !transportType) { // Check transportType - console.warn(`Skipping client ${name} due to failed client/transport creation.`); + logger.warn(`Skipping client ${name} due to failed client/transport creation.`); // Changed to warn break; } try { await client.connect(transport); - console.log(`Connected to server: ${name}`); + logger.log(`Connected to server: ${name}`); // Changed to log clients.push({ client, @@ -157,15 +158,15 @@ export const createClients = async (mcpServers: Record) break - } catch (error) { - console.error(`Failed to connect to ${name}:`, error); + } catch (error: any) { + logger.error(`Failed to connect to ${name}: ${error.message}`); // Log error message count++; retry = (count < retries); if (retry) { try { await client.close(); } catch { } - console.log(`Retry connection to ${name} in ${waitFor}ms (${count}/${retries})`); + logger.log(`Retry connection to ${name} in ${waitFor}ms (${count}/${retries})`); // Changed to log await sleep(waitFor); } } @@ -185,14 +186,14 @@ export async function reconnectSingleClient( transportConfig: TransportConfig, existingCleanup?: () => Promise ): Promise> { // Returns the parts needed to reconstruct a ConnectedClient - console.log(`Attempting to reconnect client: ${name}`); + logger.log(`Attempting to reconnect client: ${name}`); // Changed to log if (existingCleanup) { try { await existingCleanup(); - console.log(`Existing client ${name} cleaned up before reconnecting.`); + logger.log(`Existing client ${name} cleaned up before reconnecting.`); // Changed to log } catch (e: any) { - console.warn(`Error during cleanup of existing client ${name} before reconnect: ${e.message}`); + logger.warn(`Error during cleanup of existing client ${name} before reconnect: ${e.message}`); // Changed to warn } } @@ -206,10 +207,10 @@ export async function reconnectSingleClient( let customHeaders: Record | undefined; if (transportConfig.bearerToken) { customHeaders = { 'Authorization': `Bearer ${transportConfig.bearerToken}` }; - console.log(` Using Bearer Token for SSE connection to ${name} (reconnect)`); + logger.debug(` Using Bearer Token for SSE connection to ${name} (reconnect)`); // Changed to debug } else if (transportConfig.apiKey) { customHeaders = { 'X-Api-Key': transportConfig.apiKey }; - console.log(` Using X-Api-Key for SSE connection to ${name} (reconnect)`); + logger.debug(` Using X-Api-Key for SSE connection to ${name} (reconnect)`); // Changed to debug } if (customHeaders) { transportOptions.requestInit = { headers: customHeaders }; @@ -239,17 +240,17 @@ export async function reconnectSingleClient( args: transportConfig.args, env: filteredEnv }); - console.log(` Configured Stdio transport for ${name} (reconnect)`); + logger.debug(` Configured Stdio transport for ${name} (reconnect)`); // Changed to debug } else if (isHttpConfig(transportConfig)) { determinedTransportType = 'http'; const transportOptions: StreamableHTTPClientTransportOptions = {}; let customHeaders: Record | undefined; if (transportConfig.bearerToken) { customHeaders = { 'Authorization': `Bearer ${transportConfig.bearerToken}` }; - console.log(` Using Bearer Token for StreamableHTTP connection to ${name} (reconnect)`); + logger.debug(` Using Bearer Token for StreamableHTTP connection to ${name} (reconnect)`); // Changed to debug } else if (transportConfig.apiKey) { customHeaders = { 'X-Api-Key': transportConfig.apiKey }; - console.log(` Using X-Api-Key for StreamableHTTP connection to ${name} (reconnect)`); + logger.debug(` Using X-Api-Key for StreamableHTTP connection to ${name} (reconnect)`); // Changed to debug } if (customHeaders) { transportOptions.requestInit = { headers: customHeaders }; @@ -259,7 +260,7 @@ export async function reconnectSingleClient( throw new Error(`Invalid or unknown transport type in configuration for server: ${name}`); } } catch (error: any) { - console.error(`Failed to create transport for ${name} during reconnect: ${error.message}`); + logger.error(`Failed to create transport for ${name} during reconnect: ${error.message}`); // Changed to error throw error; } @@ -276,7 +277,7 @@ export async function reconnectSingleClient( try { await newSdkClient.connect(transport); - console.log(`Successfully reconnected to server: ${name}`); + logger.log(`Successfully reconnected to server: ${name}`); // Changed to log const finalTransport = transport; // Capture for closure return { client: newSdkClient, @@ -289,13 +290,13 @@ export async function reconnectSingleClient( } }; } catch (error: any) { - console.error(`Failed to connect to ${name} during reconnect attempt: ${error.message}`); + logger.error(`Failed to connect to ${name} during reconnect attempt: ${error.message}`); // Changed to error try { if (transport) { await transport.close(); } } catch (closeError: any) { - console.warn(`Failed to close transport for ${name} after reconnect failure: ${closeError.message}`); + logger.warn(`Failed to close transport for ${name} after reconnect failure: ${closeError.message}`); // Changed to warn } throw error; } diff --git a/src/config.ts b/src/config.ts index ed2b4ae..d2d86c3 100644 --- a/src/config.ts +++ b/src/config.ts @@ -1,5 +1,6 @@ import { readFile } from 'fs/promises'; import { resolve } from 'path'; +import { logger } from './logger.js'; export type TransportConfigStdio = { type: 'stdio'; @@ -125,7 +126,7 @@ export const loadConfig = async (): Promise => { if (!isNaN(numVal)) { parsedConfig.proxy.httpToolCallMaxRetries = numVal; } else { - console.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnv}". Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); + logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnv}". Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; } } else { @@ -139,7 +140,7 @@ export const loadConfig = async (): Promise => { if (!isNaN(numVal)) { parsedConfig.proxy.httpToolCallRetryDelayBaseMs = numVal; } else { - console.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnv}". Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); + logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnv}". Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; } } else { @@ -161,7 +162,7 @@ export const loadConfig = async (): Promise => { if (!isNaN(numVal)) { parsedConfig.proxy.stdioToolCallMaxRetries = numVal; } else { - console.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); + logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; } } else { @@ -175,7 +176,7 @@ export const loadConfig = async (): Promise => { if (!isNaN(numVal)) { parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = numVal; } else { - console.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); + logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; } } else { @@ -185,14 +186,14 @@ export const loadConfig = async (): Promise => { // The parsedConfig now has its proxy settings correctly reflecting env overrides for the specified fields. // Other fields in parsedConfig.proxy loaded from the file remain untouched. // Other parts of parsedConfig (like mcpServers) are also as loaded from the file. - - console.log("Loaded config with final proxy settings (after env overrides):", parsedConfig.proxy); - return parsedConfig; // Return the modified parsedConfig - - } catch (error) { - console.error(`Error loading config/mcp_server.json:`, error); - - // If file loading fails, initialize with environment variables or defaults for proxy settings + + logger.log("Loaded config with final proxy settings (after env overrides):", JSON.stringify(parsedConfig.proxy).slice(1, -1)); + return parsedConfig; // Return the modified parsedConfig + + } catch (error: any) { + logger.error(`Error loading config/mcp_server.json: ${error.message}`); + + // If file loading fails, initialize with environment variables or defaults for proxy settings const proxySettingsFromEnvOrDefaults: ProxySettings = { retrySseToolCallOnDisconnect: defaultEnvProxySettings.retrySseToolCallOnDisconnect, retryHttpToolCall: defaultEnvProxySettings.retryHttpToolCall, @@ -219,7 +220,7 @@ export const loadConfig = async (): Promise => { if (!isNaN(numVal)) { proxySettingsFromEnvOrDefaults.httpToolCallMaxRetries = numVal; } else { - console.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); + logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); } } @@ -229,7 +230,7 @@ export const loadConfig = async (): Promise => { if (!isNaN(numVal)) { proxySettingsFromEnvOrDefaults.httpToolCallRetryDelayBaseMs = numVal; } else { - console.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); + logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); } } @@ -244,7 +245,7 @@ export const loadConfig = async (): Promise => { if (!isNaN(numVal)) { proxySettingsFromEnvOrDefaults.stdioToolCallMaxRetries = numVal; } else { - console.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); + logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); } } @@ -254,11 +255,11 @@ export const loadConfig = async (): Promise => { if (!isNaN(numVal)) { proxySettingsFromEnvOrDefaults.stdioToolCallRetryDelayBaseMs = numVal; } else { - console.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); + logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); } } - console.log("Using proxy settings from environment/defaults due to mcp_server.json load error:", proxySettingsFromEnvOrDefaults); + logger.log("Using proxy settings from environment/defaults due to mcp_server.json load error:", proxySettingsFromEnvOrDefaults); return { mcpServers: {}, proxy: proxySettingsFromEnvOrDefaults, @@ -269,31 +270,31 @@ export const loadConfig = async (): Promise => { export const loadToolConfig = async (): Promise => { const defaultConfig: ToolConfig = { tools: {} }; - try { - const configPath = resolve(process.cwd(), 'config', 'tool_config.json'); - console.log(`Attempting to load tool configuration from: ${configPath}`); - const fileContents = await readFile(configPath, 'utf-8'); - const parsedConfig = JSON.parse(fileContents) as ToolConfig; - - if (typeof parsedConfig !== 'object' || parsedConfig === null || typeof parsedConfig.tools !== 'object') { - console.warn('Invalid tool_config.json format: "tools" object not found or invalid. Using default.'); - return defaultConfig; - } - for (const toolKey in parsedConfig.tools) { - if (typeof parsedConfig.tools[toolKey]?.enabled !== 'boolean') { - console.warn(`Invalid setting for tool "${toolKey}" in tool_config.json: 'enabled' is missing or not a boolean. Assuming enabled.`); - } - } - - console.log(`Successfully loaded tool configuration for ${Object.keys(parsedConfig.tools).length} tools.`); - return parsedConfig; - } catch (error: any) { - if (error.code === 'ENOENT') { - console.log('config/tool_config.json not found. Using default (all tools enabled).'); - } else { - console.error(`Error loading config/tool_config.json:`, error); - console.warn('Using default tool configuration (all tools enabled) due to error.'); - } - return defaultConfig; +try { + const configPath = resolve(process.cwd(), 'config', 'tool_config.json'); + logger.log(`Attempting to load tool configuration from: ${configPath}`); + const fileContents = await readFile(configPath, 'utf-8'); + const parsedConfig = JSON.parse(fileContents) as ToolConfig; + + if (typeof parsedConfig !== 'object' || parsedConfig === null || typeof parsedConfig.tools !== 'object') { + logger.warn('Invalid tool_config.json format: "tools" object not found or invalid. Using default.'); + return defaultConfig; } + for (const toolKey in parsedConfig.tools) { + if (typeof parsedConfig.tools[toolKey]?.enabled !== 'boolean') { + logger.warn(`Invalid setting for tool "${toolKey}" in tool_config.json: 'enabled' is missing or not a boolean. Assuming enabled.`); + } + } + + logger.log(`Successfully loaded tool configuration for ${Object.keys(parsedConfig.tools).length} tools.`); + return parsedConfig; +} catch (error: any) { + if (error.code === 'ENOENT') { + logger.log('config/tool_config.json not found. Using default (all tools enabled).'); + } else { + logger.error(`Error loading config/tool_config.json: ${error.message}`); + logger.warn('Using default tool configuration (all tools enabled) due to error.'); + } + return defaultConfig; +} }; \ No newline at end of file diff --git a/src/index.ts b/src/index.ts index baafe85..8bf9b3d 100644 --- a/src/index.ts +++ b/src/index.ts @@ -1,6 +1,7 @@ #!/usr/bin/env node import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; +import { logger } from './logger.js'; import { createServer } from "./mcp-proxy.js"; async function main() { @@ -17,6 +18,6 @@ async function main() { } main().catch((error) => { - console.error("Server error:", error); + logger.error("Server error:", error.message); process.exit(1); }); diff --git a/src/logger.ts b/src/logger.ts new file mode 100644 index 0000000..c9b51d8 --- /dev/null +++ b/src/logger.ts @@ -0,0 +1,66 @@ +function formatTimestamp(): string { + const now = new Date(); + const year = now.getFullYear(); + const month = (now.getMonth() + 1).toString().padStart(2, '0'); + const day = now.getDate().toString().padStart(2, '0'); + const hours = now.getHours().toString().padStart(2, '0'); + const minutes = now.getMinutes().toString().padStart(2, '0'); + const seconds = now.getSeconds().toString().padStart(2, '0'); + const milliseconds = now.getMilliseconds().toString().padStart(3, '0'); + return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`; +} + +enum LogLevel { + Error, + Warn, + Info, + Debug, +} + +function getLogLevel(envVar: string | undefined): LogLevel { + switch (envVar?.toLowerCase()) { + case 'debug': + return LogLevel.Debug; + case 'info': + return LogLevel.Info; + case 'warn': + return LogLevel.Warn; + case 'error': + return LogLevel.Error; + default: + return LogLevel.Info; // Default to Info level + } +} + +const currentLogLevel = getLogLevel(process.env.LOGGING); + +function log(...args: any[]): void { + if (currentLogLevel >= LogLevel.Info) { + console.log(`[${formatTimestamp()}] [INFO]`, ...args); + } +} + +function warn(...args: any[]): void { + if (currentLogLevel >= LogLevel.Warn) { + console.warn(`[${formatTimestamp()}] [WARN]`, ...args); + } +} + +function error(...args: any[]): void { + if (currentLogLevel >= LogLevel.Error) { + console.error(`[${formatTimestamp()}] [ERROR]`, ...args); + } +} + +function debug(...args: any[]): void { + if (currentLogLevel >= LogLevel.Debug) { + console.debug(`[${formatTimestamp()}] [DEBUG]`, ...args); + } +} + +export const logger = { + log, + warn, + error, + debug, +}; \ No newline at end of file diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index e1f7e63..740cdcd 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -18,6 +18,7 @@ import { GetPromptResultSchema } from "@modelcontextprotocol/sdk/types.js"; import { createClients, ConnectedClient, reconnectSingleClient } from './client.js'; +import { logger } from './logger.js'; import { Config, loadConfig, TransportConfig, isSSEConfig, isStdioConfig, isHttpConfig, ToolConfig, loadToolConfig } from './config.js'; import { z } from 'zod'; import * as eventsource from 'eventsource'; @@ -48,7 +49,7 @@ let currentProxyConfig: Required> = { ...defaultPro // --- Function to update backend connections and maps --- export const updateBackendConnections = async (newServerConfig: Config, newToolConfig: ToolConfig) => { - console.log("Starting update of backend connections..."); + logger.log("Starting update of backend connections..."); currentToolConfig = newToolConfig; // Update stored tool config currentProxyConfig = { // Update currentProxyConfig using full defaults ...defaultProxySettingsFull, @@ -64,7 +65,7 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC activeServersConfigLocal[serverKey] = serverConf; } else { const serverName = serverConf.name || (isSSEConfig(serverConf) ? serverConf.url : isStdioConfig(serverConf) ? serverConf.command : serverKey); - console.log(`Skipping inactive server during update: ${serverName}`); + logger.log(`Skipping inactive server during update: ${serverName}`); } } } @@ -77,19 +78,19 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC const clientsToKeep = currentConnectedClients.filter(c => newClientKeys.has(c.name)); const keysToAdd = Object.keys(activeServersConfigLocal).filter(key => !currentClientKeys.has(key)); - console.log(`Clients to remove: ${clientsToRemove.map(c => c.name).join(', ') || 'None'}`); - console.log(`Clients to keep: ${clientsToKeep.map(c => c.name).join(', ') || 'None'}`); - console.log(`Server keys to add: ${keysToAdd.join(', ') || 'None'}`); + logger.log(`Clients to remove: ${clientsToRemove.map(c => c.name).join(', ') || 'None'}`); + logger.log(`Clients to keep: ${clientsToKeep.map(c => c.name).join(', ') || 'None'}`); + logger.log(`Server keys to add: ${keysToAdd.join(', ') || 'None'}`); // 1. Cleanup removed clients if (clientsToRemove.length > 0) { - console.log(`Cleaning up ${clientsToRemove.length} removed clients...`); + logger.log(`Cleaning up ${clientsToRemove.length} removed clients...`); await Promise.all(clientsToRemove.map(async ({ name, cleanup }) => { try { await cleanup(); - console.log(` Cleaned up client: ${name}`); - } catch (error) { - console.error(` Error cleaning up client ${name}:`, error); + logger.log(` Cleaned up client: ${name}`); + } catch (error: any) { + logger.error(` Error cleaning up client ${name}: ${error.message}`); } })); } @@ -99,17 +100,17 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC if (keysToAdd.length > 0) { const configToAdd: Record = {}; keysToAdd.forEach(key => { configToAdd[key] = activeServersConfigLocal[key]; }); - console.log(`Connecting ${keysToAdd.length} new clients...`); + logger.log(`Connecting ${keysToAdd.length} new clients...`); newlyConnectedClients = await createClients(configToAdd); - console.log(`Successfully connected to ${newlyConnectedClients.length} out of ${keysToAdd.length} new clients.`); + logger.log(`Successfully connected to ${newlyConnectedClients.length} out of ${keysToAdd.length} new clients.`); } // 3. Update the main list currentConnectedClients = [...clientsToKeep, ...newlyConnectedClients]; - console.log(`Total active clients after update: ${currentConnectedClients.length}`); + logger.log(`Total active clients after update: ${currentConnectedClients.length}`); // 4. Clear and repopulate maps immediately (important for consistency) - console.log("Clearing and repopulating internal maps (tools, resources, prompts)..."); + logger.log("Clearing and repopulating internal maps (tools, resources, prompts)..."); toolToClientMap.clear(); resourceToClientMap.clear(); promptToClientMap.clear(); @@ -131,11 +132,11 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC } } catch (error: any) { if (!(error?.name === 'McpError' && error?.code === -32601)) { // Ignore 'Method not found' - console.error(`Error fetching tools from ${connectedClient.name} during map update:`, error?.message || error); + logger.error(`Error fetching tools from ${connectedClient.name} during map update:`, error?.message || error); } } } - console.log(` Updated tool map with ${toolToClientMap.size} enabled tools.`); + logger.log(` Updated tool map with ${toolToClientMap.size} enabled tools.`); // Repopulate Resources Map for (const connectedClient of currentConnectedClients) { @@ -146,11 +147,11 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC } } catch (error: any) { if (!(error?.name === 'McpError' && error?.code === -32601)) { // Ignore 'Method not found' - console.error(`Error fetching resources from ${connectedClient.name} during map update:`, error?.message || error); + logger.error(`Error fetching resources from ${connectedClient.name} during map update:`, error?.message || error); } } } - console.log(` Updated resource map with ${resourceToClientMap.size} resources.`); + logger.log(` Updated resource map with ${resourceToClientMap.size} resources.`); // Repopulate Prompts Map for (const connectedClient of currentConnectedClients) { @@ -161,16 +162,16 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC } } catch (error: any) { if (!(error?.name === 'McpError' && error?.code === -32601)) { // Ignore 'Method not found' - console.error(`Error fetching prompts from ${connectedClient.name} during map update:`, error?.message || error); + logger.error(`Error fetching prompts from ${connectedClient.name} during map update:`, error?.message || error); } } } - console.log(` Updated prompt map with ${promptToClientMap.size} prompts.`); - console.log("Backend connections update finished."); + logger.log(` Updated prompt map with ${promptToClientMap.size} prompts.`); + logger.log("Backend connections update finished."); }; async function refreshBackendConnection(serverKey: string, serverConfig: TransportConfig): Promise { - console.log(`Attempting to refresh backend connection for server: ${serverKey}`); + logger.log(`Attempting to refresh backend connection for server: ${serverKey}`); const existingClientIndex = currentConnectedClients.findIndex(c => c.name === serverKey); let oldCleanup: (() => Promise) | undefined = undefined; let existingConfig: TransportConfig | undefined = currentConnectedClients[existingClientIndex]?.config; @@ -184,7 +185,7 @@ async function refreshBackendConnection(serverKey: string, serverConfig: Transpo } if (!existingConfig) { - console.error(`Configuration for server ${serverKey} not found. Cannot refresh.`); + logger.error(`Configuration for server ${serverKey} not found. Cannot refresh.`); return false; } // Use the passed serverConfig if available (e.g. from initial load), otherwise fallback to existingConfig. @@ -203,10 +204,10 @@ async function refreshBackendConnection(serverKey: string, serverConfig: Transpo if (existingClientIndex !== -1) { currentConnectedClients[existingClientIndex] = newConnectedClientEntry; - console.log(`Updated existing client entry for ${serverKey} in currentConnectedClients.`); + logger.log(`Updated existing client entry for ${serverKey} in currentConnectedClients.`); } else { currentConnectedClients.push(newConnectedClientEntry); - console.log(`Added new client entry for ${serverKey} to currentConnectedClients (this path might be taken if client was previously removed due to error).`); + logger.log(`Added new client entry for ${serverKey} to currentConnectedClients (this path might be taken if client was previously removed due to error).`); } // Clear existing entries for this client @@ -227,7 +228,7 @@ async function refreshBackendConnection(serverKey: string, serverConfig: Transpo promptToClientMap.delete(key); } } - console.log(`Cleared map entries for ${serverKey}.`); + logger.log(`Cleared map entries for ${serverKey}.`); // Repopulate maps for the reconnected client const connectedClient = newConnectedClientEntry; @@ -245,7 +246,7 @@ async function refreshBackendConnection(serverKey: string, serverConfig: Transpo } } catch (error: any) { if (!(error?.name === 'McpError' && error?.code === -32601)) { - console.error(`Error fetching tools from ${connectedClient.name} during refresh:`, error?.message || error); + logger.error(`Error fetching tools from ${connectedClient.name} during refresh:`, error?.message || error); } } @@ -256,7 +257,7 @@ async function refreshBackendConnection(serverKey: string, serverConfig: Transpo } } catch (error: any) { if (!(error?.name === 'McpError' && error?.code === -32601)) { - console.error(`Error fetching resources from ${connectedClient.name} during refresh:`, error?.message || error); + logger.error(`Error fetching resources from ${connectedClient.name} during refresh:`, error?.message || error); } } @@ -267,14 +268,14 @@ async function refreshBackendConnection(serverKey: string, serverConfig: Transpo } } catch (error: any) { if (!(error?.name === 'McpError' && error?.code === -32601)) { - console.error(`Error fetching prompts from ${connectedClient.name} during refresh:`, error?.message || error); + logger.error(`Error fetching prompts from ${connectedClient.name} during refresh:`, error?.message || error); } } - console.log(`Repopulated maps for ${serverKey}.`); + logger.log(`Repopulated maps for ${serverKey}.`); return true; - } catch (error) { - console.error(`Failed to refresh backend connection for ${serverKey}:`, error); + } catch (error: any) { + logger.error(`Failed to refresh backend connection for ${serverKey}: ${error.message}`); // If refresh failed, we remove the client to prevent further attempts with a known bad state. // This also cleans up its entries from the maps. if (existingClientIndex !== -1) { @@ -290,7 +291,7 @@ async function refreshBackendConnection(serverKey: string, serverConfig: Transpo for (const [key, value] of promptToClientMap.entries()) { if (value.name === serverKey) promptToClientMap.delete(key); } - console.log(`Removed client ${serverKey} and its map entries after failed refresh.`); + logger.log(`Removed client ${serverKey} and its map entries after failed refresh.`); return false; } } @@ -383,7 +384,7 @@ export const createServer = async () => { // Note: InitializeRequest is handled by the SDK's Server default behavior. server.setRequestHandler(ListToolsRequestSchema, async (request) => { - console.log("Received tools/list request - applying overrides from config"); + logger.log("Received tools/list request - applying overrides from config"); const enabledTools: Tool[] = []; // Access the globally stored tool config which includes overrides const toolOverrides = currentToolConfig.tools || {}; @@ -403,7 +404,7 @@ export const createServer = async () => { inputSchema: toolInfo.inputSchema, // Schema is never overridden }); } - console.log(`Returning ${enabledTools.length} enabled tools with applied overrides.`); + logger.log(`Returning ${enabledTools.length} enabled tools with applied overrides.`); return { tools: enabledTools }; }); @@ -430,7 +431,7 @@ export const createServer = async () => { // If no entry was found after checking all enabled tools and their potential overrides if (!mapEntry || !originalQualifiedName) { - console.error(`Attempted to call tool with exposed name "${requestedExposedName}", but no corresponding enabled tool or override configuration found.`); + logger.error(`Attempted to call tool with exposed name "${requestedExposedName}", but no corresponding enabled tool or override configuration found.`); throw new Error(`Unknown or disabled tool: ${requestedExposedName}`); } @@ -439,7 +440,7 @@ export const createServer = async () => { const originalToolNameForBackend = toolInfo.name; // The actual name the backend server expects (from the original toolInfo) try { - console.log(`Received tool call for exposed name '${requestedExposedName}' (original qualified name: '${originalQualifiedName}'). Forwarding to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt 1)`); + logger.log(`Received tool call for exposed name '${requestedExposedName}' (original qualified name: '${originalQualifiedName}'). Forwarding to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt 1)`); const backendResponse = await clientForTool.client.request( { method: 'tools/call', @@ -447,45 +448,45 @@ export const createServer = async () => { }, CompatibilityCallToolResultSchema ); - console.log(`[Tool Call] Backend response received for '${requestedExposedName}':'${JSON.stringify(backendResponse)}' . Passing to SDK Server.`); + logger.log(`[Tool Call] Backend response received for '${requestedExposedName}':'${JSON.stringify(backendResponse)}' . Passing to SDK Server.`); return backendResponse; } catch (error: any) { - console.warn(`Initial attempt to call tool '${requestedExposedName}' failed: ${error.message}`); + logger.warn(`Initial attempt to call tool '${requestedExposedName}' failed: ${error.message}`); // Access currentProxyConfig directly as it's guaranteed to be defined const shouldRetrySse = currentProxyConfig.retrySseToolCallOnDisconnect !== false; if (clientForTool.transportType === 'sse' && isConnectionError(error) && shouldRetrySse) { - console.log(`SSE connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting reconnect and retry.`); + logger.log(`SSE connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting reconnect and retry.`); const clientTransportConfig = currentActiveServersConfig[clientForTool.name]; if (!clientTransportConfig) { - console.error(`Cannot retry SSE: TransportConfig for server '${clientForTool.name}' not found.`); + logger.error(`Cannot retry SSE: TransportConfig for server '${clientForTool.name}' not found.`); throw new Error(`Error calling tool '${requestedExposedName}': Original error: ${error.message}. SSE Retry failed: server configuration not found.`); } const refreshed = await refreshBackendConnection(clientForTool.name, clientTransportConfig); if (refreshed) { - console.log(`Successfully reconnected to server '${clientForTool.name}' via SSE. Retrying tool call for '${requestedExposedName}'.`); + logger.log(`Successfully reconnected to server '${clientForTool.name}' via SSE. Retrying tool call for '${requestedExposedName}'.`); const newMapEntry = toolToClientMap.get(originalQualifiedName); if (!newMapEntry) { - console.error(`Tool '${originalQualifiedName}' not found in map after successful SSE refresh for server '${clientForTool.name}'.`); + logger.error(`Tool '${originalQualifiedName}' not found in map after successful SSE refresh for server '${clientForTool.name}'.`); throw new Error(`Error calling tool '${requestedExposedName}': Original error: ${error.message}. SSE Retry failed: tool not found in map after refresh.`); } clientForTool = newMapEntry.client; toolInfo = newMapEntry.toolInfo; try { - console.log(`Retrying tool call (SSE) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt 2)`); + logger.log(`Retrying tool call (SSE) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt 2)`); return await clientForTool.client.request( { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, CompatibilityCallToolResultSchema ); } catch (retryError: any) { const errorMessage = `Error calling tool '${requestedExposedName}' (on backend '${clientForTool.name}') after SSE retry: ${retryError.message || 'An unknown error occurred during retry'}`; - console.error(errorMessage, retryError); + logger.error(errorMessage, retryError); throw new Error(errorMessage); } } else { const errorMessage = `Error calling tool '${requestedExposedName}': SSE Reconnection to server '${clientForTool.name}' failed. Original error: ${error.message || 'An unknown error occurred'}`; - console.error(errorMessage); + logger.error(errorMessage); throw new Error(errorMessage); } } @@ -499,29 +500,29 @@ export const createServer = async () => { const retryDelayBaseMs = currentProxyConfig.stdioToolCallRetryDelayBaseMs; let lastError: any = error; - console.log(`STDIO connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting up to ${maxRetries} retries.`); + logger.log(`STDIO connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting up to ${maxRetries} retries.`); for (let attempt = 0; attempt < maxRetries; attempt++) { try { const delay = retryDelayBaseMs * Math.pow(2, attempt) + (Math.random() * retryDelayBaseMs * 0.5); - console.log(`STDIO tool call failed for '${requestedExposedName}'. Attempt ${attempt + 1}/${maxRetries}. Retrying in ${delay.toFixed(0)}ms...`); + logger.log(`STDIO tool call failed for '${requestedExposedName}'. Attempt ${attempt + 1}/${maxRetries}. Retrying in ${delay.toFixed(0)}ms...`); await sleep(delay); - console.log(`Retrying tool call (STDIO) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 2})`); + logger.log(`Retrying tool call (STDIO) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 2})`); return await clientForTool.client.request( { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, CompatibilityCallToolResultSchema ); } catch (retryError: any) { lastError = retryError; - console.error(`STDIO tool call retry attempt ${attempt + 1}/${maxRetries} for '${requestedExposedName}' failed:`, retryError.message); + logger.error(`STDIO tool call retry attempt ${attempt + 1}/${maxRetries} for '${requestedExposedName}' failed:`, retryError.message); if (attempt === maxRetries - 1) { break; } } } const errorMessage = `Error calling STDIO tool '${requestedExposedName}' after ${maxRetries} retries (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${lastError.message || 'An unknown error occurred'}`; - console.error(errorMessage, lastError); + logger.error(errorMessage, lastError); throw new Error(errorMessage); } @@ -535,29 +536,29 @@ export const createServer = async () => { const retryDelayBaseMs = currentProxyConfig.httpToolCallRetryDelayBaseMs; let lastError: any = error; - console.log(`HTTP connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting up to ${maxRetries} retries.`); + logger.log(`HTTP connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting up to ${maxRetries} retries.`); for (let attempt = 0; attempt < maxRetries; attempt++) { try { const delay = retryDelayBaseMs * Math.pow(2, attempt) + (Math.random() * retryDelayBaseMs * 0.5); - console.log(`HTTP tool call failed for '${requestedExposedName}'. Attempt ${attempt + 1}/${maxRetries}. Retrying in ${delay.toFixed(0)}ms...`); + logger.log(`HTTP tool call failed for '${requestedExposedName}'. Attempt ${attempt + 1}/${maxRetries}. Retrying in ${delay.toFixed(0)}ms...`); await sleep(delay); - console.log(`Retrying tool call (HTTP) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 2})`); + logger.log(`Retrying tool call (HTTP) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 2})`); return await clientForTool.client.request( { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, CompatibilityCallToolResultSchema ); } catch (retryError: any) { lastError = retryError; - console.error(`HTTP tool call retry attempt ${attempt + 1}/${maxRetries} for '${requestedExposedName}' failed:`, retryError.message); + logger.error(`HTTP tool call retry attempt ${attempt + 1}/${maxRetries} for '${requestedExposedName}' failed:`, retryError.message); if (attempt === maxRetries - 1) { - break; + break; } } } const errorMessage = `Error calling HTTP tool '${requestedExposedName}' after ${maxRetries} retries (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${lastError.message || 'An unknown error occurred'}`; - console.error(errorMessage, lastError); + logger.error(errorMessage, lastError); throw new Error(errorMessage); } else { @@ -571,9 +572,9 @@ export const createServer = async () => { else if (clientForTool.transportType === 'http' && !isConnectionError(error)) reason = "Error not a connection error for HTTP"; else if (clientForTool.transportType !== 'sse' && clientForTool.transportType !== 'http' && clientForTool.transportType !== 'stdio') reason = `Unsupported transport type for retry: ${clientForTool.transportType}`; // Add stdio to check - console.warn(`Not retrying tool call for '${requestedExposedName}'. Reason: ${reason}. Original error: ${error.message}`); + logger.warn(`Not retrying tool call for '${requestedExposedName}'. Reason: ${reason}. Original error: ${error.message}`); const errorMessage = `Error calling tool '${requestedExposedName}' (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${error.message || 'An unknown error occurred'}`; - console.error(errorMessage, error); + logger.error(errorMessage, error); throw new Error(errorMessage); } } @@ -588,7 +589,7 @@ export const createServer = async () => { } try { - console.log('Forwarding prompt request:', name); + logger.log('Forwarding prompt request:', name); const response = await clientForPrompt.client.request( { @@ -604,17 +605,17 @@ export const createServer = async () => { GetPromptResultSchema ); - console.log('Prompt result:', response); + logger.log('Prompt result:', response); return response; } catch (error: any) { const errorMessage = `Error getting prompt '${name}' from backend server '${clientForPrompt.name}': ${error.message || 'An unknown error occurred'}`; - console.error(errorMessage, error); + logger.error(errorMessage, error); throw new Error(errorMessage); } }); server.setRequestHandler(ListPromptsRequestSchema, async (request) => { - console.log("Received prompts/list request - returning from cached map"); + logger.log("Received prompts/list request - returning from cached map"); // Directly use the pre-populated map const allPrompts: z.infer['prompts'] = []; for (const [name, connectedClient] of promptToClientMap.entries()) { @@ -624,16 +625,16 @@ export const createServer = async () => { description: `[${connectedClient.name}] Prompt (details omitted in list)`, inputSchema: {}, }); - } - console.log(`Returning ${allPrompts.length} prompts from map.`); - return { - prompts: allPrompts, + } + logger.log(`Returning ${allPrompts.length} prompts from map.`); + return { + prompts: allPrompts, nextCursor: undefined // Caching doesn't support pagination easily here }; }); server.setRequestHandler(ListResourcesRequestSchema, async (request) => { - console.log("Received resources/list request - returning from cached map"); + logger.log("Received resources/list request - returning from cached map"); const allResources: z.infer['resources'] = []; for (const [uri, connectedClient] of resourceToClientMap.entries()) { // Simplified response @@ -644,7 +645,7 @@ export const createServer = async () => { methods: [], // Cannot know methods without asking client }); } - console.log(`Returning ${allResources.length} resources from map.`); + logger.log(`Returning ${allResources.length} resources from map.`); return { resources: allResources, nextCursor: undefined // Caching doesn't support pagination easily here @@ -673,7 +674,7 @@ export const createServer = async () => { ); } catch (error: any) { const errorMessage = `Error reading resource '${uri}' from backend server '${clientForResource.name}': ${error.message || 'An unknown error occurred'}`; - console.error(errorMessage, error); + logger.error(errorMessage, error); throw new Error(errorMessage); } }); @@ -710,11 +711,11 @@ export const createServer = async () => { const isMethodNotFoundError = error?.name === 'McpError' && error?.code === -32601; if (isMethodNotFoundError) { - console.warn(`Warning: Method 'resources/templates/list' not found on server ${connectedClient.name}. Proceeding without templates from this source.`); + logger.warn(`Warning: Method 'resources/templates/list' not found on server ${connectedClient.name}. Proceeding without templates from this source.`); } else { // Standardize error propagation for other errors const errorMessage = `Error fetching resource templates from backend server '${connectedClient.name}': ${error.message || 'An unknown error occurred'}`; - console.error(errorMessage, error); // Log the detailed error + logger.error(errorMessage, error); // Log the detailed error // We are in a loop, so we might not want to throw and stop the whole process. // Instead, we log the error and continue to try fetching from other clients. // If we needed to inform the client that partial data occurred, we'd need a different strategy. @@ -731,13 +732,13 @@ export const createServer = async () => { // Cleanup function needs to handle the *current* list of clients const cleanup = async () => { - console.log(`Cleaning up ${currentConnectedClients.length} connected clients...`); + logger.log(`Cleaning up ${currentConnectedClients.length} connected clients...`); await Promise.all(currentConnectedClients.map(async ({ name, cleanup: clientCleanup }) => { try { await clientCleanup(); - console.log(` Cleaned up client: ${name}`); - } catch(error) { - console.error(` Error cleaning up client ${name}:`, error); + logger.log(` Cleaned up client: ${name}`); + } catch(error: any) { + logger.error(` Error cleaning up client ${name}: ${error.message}`); } })); currentConnectedClients = []; // Clear the list after cleanup diff --git a/src/sse.ts b/src/sse.ts index e1508bf..6cefc94 100644 --- a/src/sse.ts +++ b/src/sse.ts @@ -16,6 +16,7 @@ import { fileURLToPath } from 'url'; import { Tool, ListToolsResultSchema, JSONRPCMessage, JSONRPCError } from "@modelcontextprotocol/sdk/types.js"; // Import loadToolConfig as well import { Config, loadConfig, isStdioConfig, loadToolConfig } from './config.js'; +import { logger } from './logger.js'; // Import terminal router and related types/variables for shutdown import { terminalRouter, activeTerminals, TERMINAL_OUTPUT_SSE_CONNECTIONS, ActiveTerminal } from './terminal.js'; @@ -54,14 +55,14 @@ const allowedTokensRaw = process.env.ALLOWED_TOKENS || ""; // Renamed const allowedTokens = new Set(allowedTokensRaw.split(',').map(t => t.trim()).filter(t => t.length > 0)); const authEnabled = allowedKeys.size > 0 || allowedTokens.size > 0; -console.log(`MCP Endpoint Authentication: ${authEnabled ? `Enabled. ${allowedKeys.size} key(s) and ${allowedTokens.size} token(s) configured.` : 'Disabled.'}`); +logger.log(`MCP Endpoint Authentication: ${authEnabled ? `Enabled. ${allowedKeys.size} key(s) and ${allowedTokens.size} token(s) configured.` : 'Disabled.'}`); const ADMIN_USERNAME = process.env.ADMIN_USERNAME || 'admin'; const ADMIN_PASSWORD = process.env.ADMIN_PASSWORD || 'password'; const SESSION_SECRET_ENV = process.env.SESSION_SECRET; // Read from env if (ADMIN_PASSWORD === 'password') { - console.warn("WARNING: Using default admin password. Set ADMIN_PASSWORD environment variable for security."); + logger.warn("WARNING: Using default admin password. Set ADMIN_PASSWORD environment variable for security."); } // SESSION_SECRET warning is handled in getSessionSecret @@ -73,7 +74,7 @@ const enableAdminUI = typeof rawEnableAdminUI === 'string' && (rawEnableAdminUI. async function getSessionSecret(): Promise { if (SESSION_SECRET_ENV && SESSION_SECRET_ENV !== 'unsafe-default-secret' && SESSION_SECRET_ENV.trim() !== '') { - console.log("Using session secret from SESSION_SECRET environment variable."); + logger.log("Using session secret from SESSION_SECRET environment variable."); return SESSION_SECRET_ENV; } @@ -81,18 +82,18 @@ async function getSessionSecret(): Promise { await access(SECRET_FILE_PATH); const secretFromFile = await readFile(SECRET_FILE_PATH, 'utf-8'); if (secretFromFile.trim() !== '') { - console.log("Read existing session secret from file."); + logger.log("Read existing session secret from file."); return secretFromFile.trim(); } // If file exists but is empty, proceed to generate a new one. - console.log("Session secret file exists but is empty. Generating a new one..."); + logger.log("Session secret file exists but is empty. Generating a new one..."); } catch (error: any) { if (error.code !== 'ENOENT') { - console.error("Error accessing session secret file, attempting to generate new:", error); + logger.error("Error accessing session secret file, attempting to generate new:", error); // Proceed to generate new one if access failed for other reasons than not found } else { // File does not exist, normal path to generate new. - console.log("Session secret file not found. Generating a new one..."); + logger.log("Session secret file not found. Generating a new one..."); } } @@ -101,11 +102,11 @@ async function getSessionSecret(): Promise { try { await mkdir(path.dirname(SECRET_FILE_PATH), { recursive: true }); await writeFile(SECRET_FILE_PATH, newSecret, { encoding: 'utf-8', mode: 0o600 }); - console.log(`New session secret generated and saved to ${SECRET_FILE_PATH}. It's recommended to set this value in the SESSION_SECRET environment variable for persistence across container restarts or deployments.`); + logger.log(`New session secret generated and saved to ${SECRET_FILE_PATH}. It's recommended to set this value in the SESSION_SECRET environment variable for persistence across container restarts or deployments.`); return newSecret; } catch (writeError) { - console.error("FATAL: Could not write new session secret file:", writeError); - console.warn("WARNING: Falling back to a temporary, insecure session secret. Admin UI sessions will not persist."); + logger.error("FATAL: Could not write new session secret file:", writeError); + logger.warn("WARNING: Falling back to a temporary, insecure session secret. Admin UI sessions will not persist."); return 'temporary-insecure-secret-' + crypto.randomBytes(16).toString('hex'); // Fallback, but not ideal } } @@ -115,11 +116,11 @@ async function getSessionSecret(): Promise { const adminSseConnections = new Map(); if (enableAdminUI) { - console.log("Admin UI is ENABLED."); + logger.log("Admin UI is ENABLED."); // Use global ADMIN_USERNAME and ADMIN_PASSWORD defined earlier. if (ADMIN_PASSWORD === 'password') { // Use global ADMIN_PASSWORD - console.warn("WARNING: Using default admin password. Set ADMIN_USERNAME and ADMIN_PASSWORD environment variables for security."); + logger.warn("WARNING: Using default admin password. Set ADMIN_USERNAME and ADMIN_PASSWORD environment variables for security."); } const sessionSecret = await getSessionSecret(); @@ -148,10 +149,10 @@ if (enableAdminUI) { const { username, password } = req.body; if (username === ADMIN_USERNAME && password === ADMIN_PASSWORD) { req.session.user = { username: username }; - console.log(`Admin user '${username}' logged in.`); + logger.log(`Admin user '${username}' logged in.`); res.json({ success: true }); } else { - console.warn(`Failed admin login attempt for username: '${username}'`); + logger.warn(`Failed admin login attempt for username: '${username}'`); res.status(401).json({ success: false, error: 'Invalid credentials' }); } }); @@ -160,10 +161,10 @@ if (enableAdminUI) { const username = req.session.user?.username; req.session.destroy((err) => { if (err) { - console.error("Error destroying session:", err); + logger.error("Error destroying session:", err); return res.status(500).json({ success: false, error: 'Failed to logout' }); } - console.log(`Admin user '${username}' logged out.`); + logger.log(`Admin user '${username}' logged out.`); res.clearCookie('connect.sid'); res.json({ success: true }); }); @@ -171,12 +172,12 @@ if (enableAdminUI) { app.get('/admin/config', isAuthenticated, async (req, res) => { try { - console.log("Admin request: GET /admin/config"); + logger.log("Admin request: GET /admin/config"); const configData = await readFile(CONFIG_PATH, 'utf-8'); res.setHeader('Content-Type', 'application/json'); res.send(configData); } catch (error: any) { - console.error(`Error reading config file at ${CONFIG_PATH}:`, error); + logger.error(`Error reading config file at ${CONFIG_PATH}:`, error); if (error.code === 'ENOENT') { res.status(404).json({ error: 'Configuration file not found.' }); } else { @@ -187,7 +188,7 @@ if (enableAdminUI) { app.post('/admin/config', isAuthenticated, async (req, res) => { try { - console.log("Admin request: POST /admin/config"); + logger.log("Admin request: POST /admin/config"); const newConfigData = req.body; if (typeof newConfigData !== 'object' || newConfigData === null) { @@ -196,10 +197,10 @@ if (enableAdminUI) { const configString = JSON.stringify(newConfigData, null, 2); await writeFile(CONFIG_PATH, configString, 'utf-8'); - console.log(`Configuration file updated successfully by admin '${req.session.user?.username}'.`); + logger.log(`Configuration file updated successfully by admin '${req.session.user?.username}'.`); res.json({ success: true }); } catch (error) { - console.error(`Error writing config file at ${CONFIG_PATH}:`, error); + logger.error(`Error writing config file at ${CONFIG_PATH}:`, error); res.status(500).json({ error: 'Failed to write configuration file.' }); } }); @@ -207,31 +208,31 @@ if (enableAdminUI) { // Updated to use getCurrentProxyState app.get('/admin/tools/list', isAuthenticated, async (req, res) => { - console.log("Admin request: GET /admin/tools/list"); + logger.log("Admin request: GET /admin/tools/list"); try { // Get the current tool state from the proxy module const { tools } = getCurrentProxyState(); // The tools returned are already simplified for the UI - console.log(`Admin tools/list: Returning ${tools.length} discovered tools from proxy state.`); + logger.log(`Admin tools/list: Returning ${tools.length} discovered tools from proxy state.`); res.json({ tools }); // Return the simplified list directly } catch (error: any) { - console.error(`Admin tools/list: Error getting proxy state:`, error?.message || error); + logger.error(`Admin tools/list: Error getting proxy state:`, error?.message || error); res.status(500).json({ error: 'Failed to retrieve tool list from proxy state.' }); } }); app.get('/admin/tools/config', isAuthenticated, async (req, res) => { try { - console.log("Admin request: GET /admin/tools/config"); + logger.log("Admin request: GET /admin/tools/config"); const toolConfigData = await readFile(TOOL_CONFIG_PATH, 'utf-8'); res.setHeader('Content-Type', 'application/json'); res.send(toolConfigData); } catch (error: any) { if (error.code === 'ENOENT') { - console.log(`Tool config file ${TOOL_CONFIG_PATH} not found, returning empty config.`); + logger.log(`Tool config file ${TOOL_CONFIG_PATH} not found, returning empty config.`); res.json({ tools: {} }); } else { - console.error(`Error reading tool config file at ${TOOL_CONFIG_PATH}:`, error); + logger.error(`Error reading tool config file at ${TOOL_CONFIG_PATH}:`, error); res.status(500).json({ error: 'Failed to read tool configuration file.' }); } } @@ -239,7 +240,7 @@ if (enableAdminUI) { app.post('/admin/tools/config', isAuthenticated, async (req, res) => { try { - console.log("Admin request: POST /admin/tools/config"); + logger.log("Admin request: POST /admin/tools/config"); const newToolConfigData = req.body; if (typeof newToolConfigData !== 'object' || newToolConfigData === null || typeof newToolConfigData.tools !== 'object') { @@ -248,16 +249,16 @@ if (enableAdminUI) { const configString = JSON.stringify(newToolConfigData, null, 2); await writeFile(TOOL_CONFIG_PATH, configString, 'utf-8'); - console.log(`Tool configuration file updated successfully by admin '${req.session.user?.username}'.`); + logger.log(`Tool configuration file updated successfully by admin '${req.session.user?.username}'.`); res.json({ success: true, message: "Configuration saved. Restart proxy server to apply changes." }); } catch (error) { - console.error(`Error writing tool config file at ${TOOL_CONFIG_PATH}:`, error); + logger.error(`Error writing tool config file at ${TOOL_CONFIG_PATH}:`, error); res.status(500).json({ error: 'Failed to write tool configuration file.' }); } }); // Renamed endpoint and updated logic for in-process reload app.post('/admin/server/reload', isAuthenticated, async (req, res) => { - console.log(`Admin request: POST /admin/server/reload by user '${req.session.user?.username}'`); + logger.log(`Admin request: POST /admin/server/reload by user '${req.session.user?.username}'`); try { // Load the latest configurations const latestServerConfig = await loadConfig(); @@ -266,11 +267,11 @@ if (enableAdminUI) { // Trigger the update process in mcp-proxy await updateBackendConnections(latestServerConfig, latestToolConfig); - console.log("Configuration reload completed successfully."); + logger.log("Configuration reload completed successfully."); res.json({ success: true, message: 'Server configuration reloaded successfully.' }); } catch (error: any) { - console.error("Error during configuration reload:", error); + logger.error("Error during configuration reload:", error); res.status(500).json({ success: false, error: 'Failed to reload server configuration.', details: error.message }); } }); @@ -289,8 +290,8 @@ if (enableAdminUI) { const adminSessionId = req.session.id; // Get current admin's session ID const clientId = req.ip || `admin-${Date.now()}`; // For logging - console.log(`[${clientId}] Admin request: POST /admin/server/install/${serverKey} for session ${adminSessionId}`); - console.warn(`[${clientId}] SECURITY WARNING: Attempting to execute installation commands for server '${serverKey}'.`); + logger.log(`[${clientId}] Admin request: POST /admin/server/install/${serverKey} for session ${adminSessionId}`); + logger.warn(`[${clientId}] SECURITY WARNING: Attempting to execute installation commands for server '${serverKey}'.`); // Immediately respond to the HTTP request res.json({ success: true, message: `Installation process for '${serverKey}' started. Check for live updates.` }); @@ -306,10 +307,10 @@ if (enableAdminUI) { // Ensure data is stringified to handle objects and special characters adminRes.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`); } catch (e) { - console.error(`[${clientId}] Failed to send admin SSE event ${event} for session ${adminSessionId}:`, e); + logger.error(`[${clientId}] Failed to send admin SSE event ${event} for session ${adminSessionId}:`, e); } } else if (adminSessionId) { // Log warning only if we expected a connection - console.warn(`[${clientId}] No active admin SSE connection found for session ${adminSessionId} to send event ${event}.`); + logger.warn(`[${clientId}] No active admin SSE connection found for session ${adminSessionId} to send event ${event}.`); } }; @@ -318,10 +319,12 @@ if (enableAdminUI) { const serverConfig = config.mcpServers[serverKey]; if (!serverConfig) { + logger.error(`Server configuration not found for key: ${serverKey}`); sendAdminSseEvent('install_error', { serverKey, error: `Server configuration not found for key: ${serverKey}` }); return; } if (!isStdioConfig(serverConfig)) { + logger.error(`Installation commands only supported for stdio servers.`); sendAdminSseEvent('install_error', { serverKey, error: `Installation commands only supported for stdio servers.` }); return; } @@ -331,19 +334,22 @@ if (enableAdminUI) { if (installDirectory) { // 1. From mcp_server.json absoluteInstallDir = path.resolve(installDirectory); // path.resolve handles both absolute and relative (to cwd) + logger.log(`Using 'installDirectory' from config: ${absoluteInstallDir}`); sendAdminSseEvent('install_info', { serverKey, message: `Using 'installDirectory' from config: ${absoluteInstallDir}` }); } else if (process.env.TOOLS_FOLDER && process.env.TOOLS_FOLDER.trim() !== '') { // 2. From TOOLS_FOLDER env var absoluteInstallDir = path.resolve(process.env.TOOLS_FOLDER.trim(), serverKey); + logger.log(`Using 'TOOLS_FOLDER' env var ('${process.env.TOOLS_FOLDER.trim()}'). Target server directory: ${absoluteInstallDir}`); sendAdminSseEvent('install_info', { serverKey, message: `Using 'TOOLS_FOLDER' env var ('${process.env.TOOLS_FOLDER.trim()}'). Target server directory: ${absoluteInstallDir}` }); } else { // 3. Default to a 'tools' subfolder in the project's current working directory absoluteInstallDir = path.resolve(process.cwd(), 'tools', serverKey); + logger.log(`No 'installDirectory' in config or 'TOOLS_FOLDER' env var. Defaulting to project's 'tools' subfolder. Target server directory: ${absoluteInstallDir}`); sendAdminSseEvent('install_info', { serverKey, message: `No 'installDirectory' in config or 'TOOLS_FOLDER' env var. Defaulting to project's 'tools' subfolder. Target server directory: ${absoluteInstallDir}` }); } // Commands should be executed in the parent directory of the server's specific folder const executionCwd = path.dirname(absoluteInstallDir); - console.log(`[${clientId}] Target server installation directory for ${serverKey}: ${absoluteInstallDir}`); - console.log(`[${clientId}] Execution CWD for install commands of ${serverKey}: ${executionCwd}`); + logger.log(`[${clientId}] Target server installation directory for ${serverKey}: ${absoluteInstallDir}`); + logger.log(`[${clientId}] Execution CWD for install commands of ${serverKey}: ${executionCwd}`); sendAdminSseEvent('install_info', { serverKey, message: `Install commands will be executed in: ${executionCwd}` }); // Ensure executionCwd (parent directory for installation) exists @@ -351,6 +357,7 @@ if (enableAdminUI) { await mkdir(executionCwd, { recursive: true }); sendAdminSseEvent('install_info', { serverKey, message: `Ensured execution directory exists: ${executionCwd}` }); } catch (mkdirError: any) { + logger.error(`Failed to create execution directory '${executionCwd}': ${mkdirError.message}`); sendAdminSseEvent('install_error', { serverKey, error: `Failed to create execution directory '${executionCwd}': ${mkdirError.message}` }); throw mkdirError; } @@ -358,22 +365,27 @@ if (enableAdminUI) { // 1. Check if the specific server directory (absoluteInstallDir) already exists try { await access(absoluteInstallDir); + logger.log(`Target server directory '${absoluteInstallDir}' already exists. Installation skipped.`); sendAdminSseEvent('install_info', { serverKey, message: `Target server directory '${absoluteInstallDir}' already exists. Installation skipped.` }); sendAdminSseEvent('install_complete', { serverKey, code: 0, message: "Already installed." }); return; // Stop if already installed } catch (error: any) { if (error.code !== 'ENOENT') { + logger.error(`Error checking target server directory '${absoluteInstallDir}': ${error.message}`); sendAdminSseEvent('install_error', { serverKey, error: `Error checking target server directory '${absoluteInstallDir}': ${error.message}` }); throw error; // Rethrow unexpected errors } + logger.log(`Target server directory '${absoluteInstallDir}' does not exist. Proceeding with installation commands...`); sendAdminSseEvent('install_info', { serverKey, message: `Target server directory '${absoluteInstallDir}' does not exist. Proceeding with installation commands...` }); } // 2. Execute install commands using spawn for live output const commandsToRun = installCommands && Array.isArray(installCommands) ? installCommands : []; if (commandsToRun.length > 0) { + logger.log(`Executing ${commandsToRun.length} installation command(s) in ${executionCwd}...`); sendAdminSseEvent('install_info', { serverKey, message: `Executing ${commandsToRun.length} installation command(s) in ${executionCwd}...` }); for (const command of commandsToRun) { + logger.log(`Executing: ${command}`); sendAdminSseEvent('install_info', { serverKey, message: `Executing: ${command}` }); const commandParts = command.split(' '); @@ -389,14 +401,14 @@ if (enableAdminUI) { // Stream stdout child.stdout.on('data', (data) => { const output = data.toString(); - console.log(`[${clientId}] Install stdout (${serverKey}): ${output.trim()}`); + logger.log(`[${clientId}] Install stdout (${serverKey}): ${output.trim()}`); sendAdminSseEvent('install_stdout', { serverKey, output }); }); // Stream stderr child.stderr.on('data', (data) => { const output = data.toString(); - console.error(`[${clientId}] Install stderr (${serverKey}): ${output.trim()}`); + logger.error(`[${clientId}] Install stderr (${serverKey}): ${output.trim()}`); sendAdminSseEvent('install_stderr', { serverKey, output }); }); @@ -404,7 +416,7 @@ if (enableAdminUI) { const exitCode = await new Promise((resolve, reject) => { child.on('close', resolve); child.on('error', (err) => { - console.error(`[${clientId}] Failed to start command "${command}":`, err); + logger.error(`[${clientId}] Failed to start command "${command}":`, err); reject(err); }); }); @@ -414,10 +426,13 @@ if (enableAdminUI) { sendAdminSseEvent('install_error', { serverKey, error: errorMsg, command, exitCode }); throw new Error(errorMsg); } + logger.log(`Command "${command}" completed successfully.`); sendAdminSseEvent('install_info', { serverKey, message: `Command "${command}" completed successfully.` }); } + logger.log(`All installation commands executed successfully.`); sendAdminSseEvent('install_info', { serverKey, message: `All installation commands executed successfully.` }); } else { + logger.log(`No installation commands provided.`); sendAdminSseEvent('install_info', { serverKey, message: `No installation commands provided.` }); } @@ -425,13 +440,17 @@ if (enableAdminUI) { // This is important if installCommands were supposed to create it (e.g., git clone serverKey). try { await access(absoluteInstallDir); + logger.log(`Confirmed target server directory exists: ${absoluteInstallDir}`); sendAdminSseEvent('install_info', { serverKey, message: `Confirmed target server directory exists: ${absoluteInstallDir}` }); } catch (error: any) { if (error.code === 'ENOENT') { // If it still doesn't exist (e.g. no commands, or commands didn't create it) + logger.log(`Target server directory ${absoluteInstallDir} not found after commands. If commands were expected to create it, check them. Creating directory now.`); sendAdminSseEvent('install_info', { serverKey, message: `Target server directory ${absoluteInstallDir} not found after commands. If commands were expected to create it, check them. Creating directory now.` }); await mkdir(absoluteInstallDir, { recursive: true }); // Create it as a fallback. + logger.log(`Successfully created target server directory ${absoluteInstallDir}.`); sendAdminSseEvent('install_info', { serverKey, message: `Successfully created target server directory ${absoluteInstallDir}.` }); } else { // Other access error + logger.error(`Error after commands, verifying/creating directory '${absoluteInstallDir}': ${error.message}`); sendAdminSseEvent('install_error', { serverKey, error: `Error after commands, verifying/creating directory '${absoluteInstallDir}': ${error.message}` }); throw error; } @@ -441,7 +460,7 @@ if (enableAdminUI) { sendAdminSseEvent('install_complete', { serverKey, code: 0, message: "Installation process completed successfully." }); } catch (error: any) { - console.error(`[${clientId}] Error during server installation process for '${serverKey}':`, error); + logger.error(`[${clientId}] Error during server installation process for '${serverKey}':`, error); if (!error.message?.includes('failed with exit code') && !error.message?.includes('Failed to create execution directory') && !error.message?.includes('Failed to create installation directory') && @@ -461,7 +480,7 @@ if (enableAdminUI) { return; } - console.log(`[Admin SSE] Connection received for session: ${sessionId}`); + logger.log(`[Admin SSE] Connection received for session: ${sessionId}`); // Set SSE headers res.writeHead(200, { @@ -475,12 +494,12 @@ if (enableAdminUI) { // Store connection adminSseConnections.set(sessionId, res); - console.log(`[Admin SSE] Connection stored for session ${sessionId}. Total admin connections: ${adminSseConnections.size}`); + logger.log(`[Admin SSE] Connection stored for session ${sessionId}. Total admin connections: ${adminSseConnections.size}`); // Remove connection on close req.on('close', () => { adminSseConnections.delete(sessionId); - console.log(`[Admin SSE] Connection closed for session ${sessionId}. Total admin connections: ${adminSseConnections.size}`); + logger.log(`[Admin SSE] Connection closed for session ${sessionId}. Total admin connections: ${adminSseConnections.size}`); }); }); @@ -489,7 +508,7 @@ if (enableAdminUI) { // Static file serving for admin UI should also be inside the if block - console.log(`Serving static admin files from: ${publicPath}`); + logger.log(`Serving static admin files from: ${publicPath}`); app.use('/admin', express.static(publicPath)); app.get('/admin', (req, res) => { @@ -506,7 +525,7 @@ if (enableAdminUI) { app.get("/sse", async (req, res) => { const clientId = req.ip || `client-${Date.now()}`; - console.log(`[${clientId}] SSE connection received`); + logger.log(`[${clientId}] SSE connection received`); if (authEnabled) { let authenticated = false; @@ -516,10 +535,10 @@ app.get("/sse", async (req, res) => { if (authHeader && authHeader.startsWith('Bearer ')) { const token = authHeader.substring('Bearer '.length).trim(); if (allowedTokens.has(token)) { - console.log(`[${clientId}] Authorized SSE connection using Bearer Token.`); + logger.log(`[${clientId}] Authorized SSE connection using Bearer Token.`); authenticated = true; } else { - console.warn(`[${clientId}] Unauthorized SSE connection attempt. Invalid Bearer Token.`); + logger.warn(`[${clientId}] Unauthorized SSE connection attempt. Invalid Bearer Token.`); } } @@ -530,16 +549,16 @@ app.get("/sse", async (req, res) => { const providedKey = headerKey || queryKey; if (providedKey && allowedKeys.has(providedKey)) { - console.log(`[${clientId}] Authorized SSE connection using ${headerKey ? 'header' : 'query'} API Key.`); + logger.log(`[${clientId}] Authorized SSE connection using ${headerKey ? 'header' : 'query'} API Key.`); authenticated = true; } else if (providedKey) { - console.warn(`[${clientId}] Unauthorized SSE connection attempt. Invalid API Key.`); + logger.warn(`[${clientId}] Unauthorized SSE connection attempt. Invalid API Key.`); } } // If authentication is enabled but no valid credentials were provided if (!authenticated) { - console.warn(`[${clientId}] Unauthorized SSE connection attempt. No valid credentials provided.`); + logger.warn(`[${clientId}] Unauthorized SSE connection attempt. No valid credentials provided.`); res.status(401).send('Unauthorized'); return; } @@ -554,23 +573,23 @@ app.get("/sse", async (req, res) => { // If client provides a session_id in query, and it exists on the server, // it implies an attempt to reconnect or a stale client. Clean up the old one. if (sessionIdFromClientQuery && sseTransports.has(sessionIdFromClientQuery)) { - console.log(`[${clientId}] Client provided existing session ID: ${sessionIdFromClientQuery}. Closing and removing old transport.`); + logger.log(`[${clientId}] Client provided existing session ID: ${sessionIdFromClientQuery}. Closing and removing old transport.`); const existingTransport = sseTransports.get(sessionIdFromClientQuery)!; sseTransports.delete(sessionIdFromClientQuery); // Remove old one from map if (typeof existingTransport.close === 'function') { existingTransport.close().catch(err => - console.warn(`[${clientId}] Non-critical error closing existing transport for session ${sessionIdFromClientQuery}:`, err) + logger.warn(`[${clientId}] Non-critical error closing existing transport for session ${sessionIdFromClientQuery}:`, err) ); } - console.log(`[${clientId}] Old transport for session ${sessionIdFromClientQuery} removed. Active sessions: ${sseTransports.size}`); + logger.log(`[${clientId}] Old transport for session ${sessionIdFromClientQuery} removed. Active sessions: ${sseTransports.size}`); } else if (sessionIdFromClientQuery) { - console.log(`[${clientId}] Client provided session ID ${sessionIdFromClientQuery}, but no active session found for it. A new session will be created.`); + logger.log(`[${clientId}] Client provided session ID ${sessionIdFromClientQuery}, but no active session found for it. A new session will be created.`); } // Always create a new SSEServerTransport. // It will generate its own internal sessionId, which will be sent to the client via the 'endpoint' event. // The client is expected to use this server-provided sessionId for subsequent POST /message requests. - console.log(`[${clientId}] Creating new SSEServerTransport...`); + logger.log(`[${clientId}] Creating new SSEServerTransport...`); clientTransport = new SSEServerTransport("/message", res); actualTransportSessionId = clientTransport.sessionId; // Get the ID generated by the transport itself @@ -579,43 +598,43 @@ app.get("/sse", async (req, res) => { } sseTransports.set(actualTransportSessionId, clientTransport); // Store the new transport with its own generated ID - console.log(`[${clientId}] New SSE transport created. Actual Session ID for this connection: ${actualTransportSessionId}. Client initially provided: ${sessionIdFromClientQuery || 'none'}. Active sessions: ${sseTransports.size}`); + logger.log(`[${clientId}] New SSE transport created. Actual Session ID for this connection: ${actualTransportSessionId}. Client initially provided: ${sessionIdFromClientQuery || 'none'}. Active sessions: ${sseTransports.size}`); const currentTransport = clientTransport; // To use in closures for onclose/onerror const currentSessionId = actualTransportSessionId; // To use in closures currentTransport.onerror = (err: any) => { - console.error(`[${clientId}] SSE transport error for session ${currentSessionId}: ${err?.stack || err?.message || err}`); + logger.error(`[${clientId}] SSE transport error for session ${currentSessionId}: ${err?.stack || err?.message || err}`); if (sseTransports.has(currentSessionId)) { sseTransports.delete(currentSessionId); - console.log(`[${clientId}] Transport for session ${currentSessionId} removed due to error. Active sessions: ${sseTransports.size}`); + logger.log(`[${clientId}] Transport for session ${currentSessionId} removed due to error. Active sessions: ${sseTransports.size}`); } }; currentTransport.onclose = () => { - console.log(`[${clientId}] SSE client disconnected for session ${currentSessionId}.`); + logger.log(`[${clientId}] SSE client disconnected for session ${currentSessionId}.`); if (sseTransports.has(currentSessionId)) { sseTransports.delete(currentSessionId); - console.log(`[${clientId}] Transport for session ${currentSessionId} removed on close. Active sessions: ${sseTransports.size}`); + logger.log(`[${clientId}] Transport for session ${currentSessionId} removed on close. Active sessions: ${sseTransports.size}`); } }; - console.log(`[${clientId}] Attempting server.connect for new transport with session ${currentSessionId}...`); + logger.log(`[${clientId}] Attempting server.connect for new transport with session ${currentSessionId}...`); await server.connect(currentTransport); - console.log(`[${clientId}] SSE client connected successfully via server.connect for session ${currentSessionId}.`); + logger.log(`[${clientId}] SSE client connected successfully via server.connect for session ${currentSessionId}.`); } catch (error: any) { const logSessionIdOnError = actualTransportSessionId || sessionIdFromClientQuery || "unknown_during_error_handling"; - console.error(`[${clientId}] Failed during SSE setup or connection for session attempt related to ${logSessionIdOnError}:`, error); + logger.error(`[${clientId}] Failed during SSE setup or connection for session attempt related to ${logSessionIdOnError}:`, error); // If a transport was created and added to the map, ensure it's cleaned up on error. if (actualTransportSessionId && sseTransports.has(actualTransportSessionId)) { sseTransports.delete(actualTransportSessionId); - console.log(`[${clientId}] Transport for session ${actualTransportSessionId} removed due to setup/connection error. Active sessions: ${sseTransports.size}`); + logger.log(`[${clientId}] Transport for session ${actualTransportSessionId} removed due to setup/connection error. Active sessions: ${sseTransports.size}`); } // Ensure clientTransport (if partially created) is closed on error. if (clientTransport && typeof clientTransport.close === 'function') { - clientTransport.close().catch((e: any) => console.error(`[${clientId}] Error closing transport for session ${logSessionIdOnError} after connection failure:`, e)); + clientTransport.close().catch((e: any) => logger.error(`[${clientId}] Error closing transport for session ${logSessionIdOnError} after connection failure:`, e)); } if (!res.headersSent) { res.status(500).send('Failed to establish SSE connection'); @@ -628,7 +647,7 @@ app.get("/sse", async (req, res) => { app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SSE and POST for messages const clientId = req.ip || `client-http-${Date.now()}`; - console.log(`[${clientId}] Received ${req.method} request on /mcp`); + logger.log(`[${clientId}] Received ${req.method} request on /mcp`); // Authentication check (similar to /sse) if (authEnabled) { @@ -637,10 +656,10 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS if (authHeader && authHeader.startsWith('Bearer ')) { const token = authHeader.substring('Bearer '.length).trim(); if (allowedTokens.has(token)) { - console.log(`[${clientId}] Authorized /mcp connection using Bearer Token.`); + logger.log(`[${clientId}] Authorized /mcp connection using Bearer Token.`); authenticated = true; } else { - console.warn(`[${clientId}] Unauthorized /mcp (Bearer) for ${req.method}. Invalid Token.`); + logger.warn(`[${clientId}] Unauthorized /mcp (Bearer) for ${req.method}. Invalid Token.`); } } if (!authenticated && allowedKeys.size > 0) { @@ -648,14 +667,14 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS const queryKey = req.query.key as string | undefined; const providedKey = headerKey || queryKey; if (providedKey && allowedKeys.has(providedKey)) { - console.log(`[${clientId}] Authorized /mcp connection using ${headerKey ? 'header' : 'query'} API Key.`); + logger.log(`[${clientId}] Authorized /mcp connection using ${headerKey ? 'header' : 'query'} API Key.`); authenticated = true; } else if (providedKey) { - console.warn(`[${clientId}] Unauthorized /mcp (API Key) for ${req.method}. Invalid Key.`); + logger.warn(`[${clientId}] Unauthorized /mcp (API Key) for ${req.method}. Invalid Key.`); } } if (!authenticated) { - console.warn(`[${clientId}] Unauthorized /mcp for ${req.method}. No valid credentials.`); + logger.warn(`[${clientId}] Unauthorized /mcp for ${req.method}. No valid credentials.`); res.status(401).send('Unauthorized'); return; } @@ -668,7 +687,7 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS if (clientProvidedSessionId) { httpTransport = streamableHttpTransports.get(clientProvidedSessionId); if (!httpTransport) { - console.warn(`[${clientId}] /mcp: Client provided Mcp-Session-Id '${clientProvidedSessionId}', but no active transport found. Responding 404.`); + logger.warn(`[${clientId}] /mcp: Client provided Mcp-Session-Id '${clientProvidedSessionId}', but no active transport found. Responding 404.`); if (!res.headersSent) { res.status(404).json({ jsonrpc: "2.0", @@ -678,11 +697,11 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS } return; } - console.log(`[${clientId}] /mcp: Using existing transport for Mcp-Session-Id: ${clientProvidedSessionId}`); + logger.log(`[${clientId}] /mcp: Using existing transport for Mcp-Session-Id: ${clientProvidedSessionId}`); } else { // No Mcp-Session-Id from client, or it's an InitializeRequest that might not have one yet. // Create a new transport. The transport itself will generate a session ID. - console.log(`[${clientId}] /mcp: No Mcp-Session-Id from client, or new session. Creating new StreamableHTTPServerTransport.`); + logger.log(`[${clientId}] /mcp: No Mcp-Session-Id from client, or new session. Creating new StreamableHTTPServerTransport.`); const tempGeneratedIdForEarlyMap = `pending-${crypto.randomBytes(8).toString('hex')}`; let capturedHttpTransportInstance: StreamableHTTPServerTransport | null = null; // To ensure closure captures the correct instance @@ -690,12 +709,12 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS sessionIdGenerator: () => crypto.randomUUID(), // Use crypto.randomUUID for session ID generation enableJsonResponse: false, onsessioninitialized: (sdkGeneratedSessionId: string) => { - console.log(`[${clientId}] /mcp: SDK 'onsessioninitialized' called. SDK Session ID: ${sdkGeneratedSessionId}`); + logger.log(`[${clientId}] /mcp: SDK 'onsessioninitialized' called. SDK Session ID: ${sdkGeneratedSessionId}`); if (capturedHttpTransportInstance) { // The SDK has now initialized the session and `capturedHttpTransportInstance.sessionId` should be set. // Verify it matches sdkGeneratedSessionId for sanity. if (capturedHttpTransportInstance.sessionId !== sdkGeneratedSessionId) { - console.warn(`[${clientId}] /mcp: Discrepancy! sdkGeneratedSessionId (${sdkGeneratedSessionId}) vs transport.sessionId (${capturedHttpTransportInstance.sessionId}). Using sdkGeneratedSessionId.`); + logger.warn(`[${clientId}] /mcp: Discrepancy! sdkGeneratedSessionId (${sdkGeneratedSessionId}) vs transport.sessionId (${capturedHttpTransportInstance.sessionId}). Using sdkGeneratedSessionId.`); } const finalSessionId = sdkGeneratedSessionId; // Use the ID from the callback @@ -707,12 +726,12 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS if (transportSessionIdToUse === tempGeneratedIdForEarlyMap) { transportSessionIdToUse = finalSessionId; } - console.log(`[${clientId}] /mcp: Transport map updated. Temp ID '${tempGeneratedIdForEarlyMap}' replaced with final '${finalSessionId}'. Active: ${streamableHttpTransports.size}`); + logger.log(`[${clientId}] /mcp: Transport map updated. Temp ID '${tempGeneratedIdForEarlyMap}' replaced with final '${finalSessionId}'. Active: ${streamableHttpTransports.size}`); } else { - console.error(`[${clientId}] /mcp: Mismatch during onsessioninitialized! Temp ID ${tempGeneratedIdForEarlyMap} found but instance differs.`); + logger.error(`[${clientId}] /mcp: Mismatch during onsessioninitialized! Temp ID ${tempGeneratedIdForEarlyMap} found but instance differs.`); if (!streamableHttpTransports.has(finalSessionId) || streamableHttpTransports.get(finalSessionId) !== capturedHttpTransportInstance) { streamableHttpTransports.set(finalSessionId, capturedHttpTransportInstance); - console.warn(`[${clientId}] /mcp: Force-mapped transport with final ID '${finalSessionId}' due to instance mismatch.`); + logger.warn(`[${clientId}] /mcp: Force-mapped transport with final ID '${finalSessionId}' due to instance mismatch.`); } } } else { @@ -721,11 +740,11 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS if (transportSessionIdToUse === tempGeneratedIdForEarlyMap) { transportSessionIdToUse = finalSessionId; } - console.log(`[${clientId}] /mcp: Transport (re)added to map with final ID '${finalSessionId}' (temp not found or instance check). Active: ${streamableHttpTransports.size}`); + logger.log(`[${clientId}] /mcp: Transport (re)added to map with final ID '${finalSessionId}' (temp not found or instance check). Active: ${streamableHttpTransports.size}`); } } } else { - console.error(`[${clientId}] /mcp: onsessioninitialized called but capturedHttpTransportInstance is null. SDK SessionId: ${sdkGeneratedSessionId}`); + logger.error(`[${clientId}] /mcp: onsessioninitialized called but capturedHttpTransportInstance is null. SDK SessionId: ${sdkGeneratedSessionId}`); } }, }; @@ -736,14 +755,14 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS // Store with a temporary ID. This will be updated by onsessioninitialized when the SDK provides the actual session ID. transportSessionIdToUse = tempGeneratedIdForEarlyMap; streamableHttpTransports.set(tempGeneratedIdForEarlyMap, httpTransport); - console.log(`[${clientId}] /mcp: New transport created. Stored with temp ID: ${tempGeneratedIdForEarlyMap}. Active transports: ${streamableHttpTransports.size}`); + logger.log(`[${clientId}] /mcp: New transport created. Stored with temp ID: ${tempGeneratedIdForEarlyMap}. Active transports: ${streamableHttpTransports.size}`); const currentTransportForHandlers = httpTransport; // Use this specific instance in handlers currentTransportForHandlers.onerror = (error: Error) => { // Use currentTransportForHandlers.sessionId if available, otherwise fallback to transportSessionIdToUse (which might be temp or final) const idToClean = currentTransportForHandlers.sessionId || transportSessionIdToUse; - console.error(`[${clientId}] /mcp: StreamableHTTPServerTransport error for session related to ${idToClean}:`, error); + logger.error(`[${clientId}] /mcp: StreamableHTTPServerTransport error for session related to ${idToClean}:`, error); if (streamableHttpTransports.get(tempGeneratedIdForEarlyMap) === currentTransportForHandlers) { streamableHttpTransports.delete(tempGeneratedIdForEarlyMap); @@ -751,26 +770,26 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS if (currentTransportForHandlers.sessionId && streamableHttpTransports.get(currentTransportForHandlers.sessionId) === currentTransportForHandlers) { streamableHttpTransports.delete(currentTransportForHandlers.sessionId); } - console.log(`[${clientId}] /mcp: Transport for session related to ${idToClean} removed due to error. Active: ${streamableHttpTransports.size}`); + logger.log(`[${clientId}] /mcp: Transport for session related to ${idToClean} removed due to error. Active: ${streamableHttpTransports.size}`); }; currentTransportForHandlers.onclose = () => { const idToClean = currentTransportForHandlers.sessionId || transportSessionIdToUse; - console.log(`[${clientId}] /mcp: StreamableHTTPServerTransport closed for session related to ${idToClean}.`); + logger.log(`[${clientId}] /mcp: StreamableHTTPServerTransport closed for session related to ${idToClean}.`); if (streamableHttpTransports.get(tempGeneratedIdForEarlyMap) === currentTransportForHandlers) { streamableHttpTransports.delete(tempGeneratedIdForEarlyMap); } if (currentTransportForHandlers.sessionId && streamableHttpTransports.get(currentTransportForHandlers.sessionId) === currentTransportForHandlers) { streamableHttpTransports.delete(currentTransportForHandlers.sessionId); } - console.log(`[${clientId}] /mcp: Transport for session related to ${idToClean} removed on close. Active: ${streamableHttpTransports.size}`); + logger.log(`[${clientId}] /mcp: Transport for session related to ${idToClean} removed on close. Active: ${streamableHttpTransports.size}`); }; try { await server.connect(currentTransportForHandlers); - console.log(`[${clientId}] /mcp: New transport (temp ID: ${transportSessionIdToUse}, awaiting final SDK sessionId) connected to server.`); + logger.log(`[${clientId}] /mcp: New transport (temp ID: ${transportSessionIdToUse}, awaiting final SDK sessionId) connected to server.`); } catch (connectError: any) { - console.error(`[${clientId}] /mcp: Failed to connect new transport to server:`, connectError); + logger.error(`[${clientId}] /mcp: Failed to connect new transport to server:`, connectError); streamableHttpTransports.delete(tempGeneratedIdForEarlyMap); // Clean up temp entry if (!res.headersSent) { res.status(500).json({ @@ -786,7 +805,7 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS if (!httpTransport) { // This case should ideally be caught earlier if clientProvidedSessionId was present but not found. // If it's a new session and httpTransport somehow didn't get created. - console.error(`[${clientId}] /mcp: Transport is unexpectedly undefined before handling request.`); + logger.error(`[${clientId}] /mcp: Transport is unexpectedly undefined before handling request.`); if (!res.headersSent) { res.status(500).json({ jsonrpc: "2.0", @@ -797,7 +816,7 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS return; } - console.log(`[${clientId}] /mcp: About to call transport.handleRequest for session ${transportSessionIdToUse || httpTransport.sessionId} - Method: ${req.method}`); + logger.log(`[${clientId}] /mcp: About to call transport.handleRequest for session ${transportSessionIdToUse || httpTransport.sessionId} - Method: ${req.method}`); try { // The SDK's StreamableHTTPServerTransport.handleRequest should: // - For new sessions (e.g., on InitializeRequest), establish the session, @@ -805,10 +824,10 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS // - For existing sessions, use the provided Mcp-Session-Id. // - Handle both POST (for client messages) and GET (for server-initiated SSE streams). await httpTransport.handleRequest(req, res, req.body); - console.log(`[${clientId}] /mcp: transport.handleRequest completed for session ${transportSessionIdToUse || httpTransport.sessionId}. Response stream managed by transport.`); + logger.log(`[${clientId}] /mcp: transport.handleRequest completed for session ${transportSessionIdToUse || httpTransport.sessionId}. Response stream managed by transport.`); } catch (error: any) { const idToLog = transportSessionIdToUse || httpTransport.sessionId; - console.error(`[${clientId}] /mcp: Error during transport.handleRequest for session ${idToLog}:`, error); + logger.error(`[${clientId}] /mcp: Error during transport.handleRequest for session ${idToLog}:`, error); if (!res.headersSent) { res.writeHead(500, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ @@ -823,26 +842,26 @@ app.all("/mcp", async (req, res) => { // Changed to app.all to handle GET for SS }); app.post("/message", async (req, res) => { const sessionId = req.query.sessionId as string; - console.log(`Received POST /message for Session ID: ${sessionId}`); + logger.log(`Received POST /message for Session ID: ${sessionId}`); if (!sessionId) { - console.error("POST /message error: Missing sessionId query parameter."); + logger.error("POST /message error: Missing sessionId query parameter."); return res.status(400).send({ error: "Missing sessionId query parameter" }); } const transport = sseTransports.get(sessionId); if (!transport) { - console.error(`POST /message error: No active transport found for Session ID: ${sessionId}`); + logger.error(`POST /message error: No active transport found for Session ID: ${sessionId}`); return res.status(404).send({ error: `No active session found for ID ${sessionId}` }); } - console.log(`Found transport for session ${sessionId}. Handling POST message...`); + logger.log(`Found transport for session ${sessionId}. Handling POST message...`); try { await transport.handlePostMessage(req, res, req.body); - console.log(`Successfully handled POST for session ${sessionId}`); + logger.log(`Successfully handled POST for session ${sessionId}`); } catch (error: any) { - console.error(`Error in transport.handlePostMessage for session ${sessionId}:`, error); + logger.error(`Error in transport.handlePostMessage for session ${sessionId}:`, error); if (!res.headersSent) { res.status(500).send({ error: "Failed to process message via transport" }); } @@ -854,62 +873,62 @@ const PORT = process.env.PORT || 3663; expressServer.listen(PORT, () => { const baseUrl = `http://localhost:${PORT}`; - console.log(`MCP Proxy Server is running.`); - console.log(`SSE endpoint: ${baseUrl}/sse`); - console.log(`Streamable HTTP (MCP) endpoint: ${baseUrl}/mcp`); + logger.log(`MCP Proxy Server is running.`); + logger.log(`SSE endpoint: ${baseUrl}/sse`); + logger.log(`Streamable HTTP (MCP) endpoint: ${baseUrl}/mcp`); if (authEnabled && allowedKeys.size > 0) { const firstKey = allowedKeys.values().next().value; - console.log(`Example authenticated SSE endpoint: ${baseUrl}/sse?key=${firstKey}`); - console.log(`Example authenticated MCP endpoint: ${baseUrl}/mcp?key=${firstKey} (or use X-Api-Key header)`); + logger.log(`Example authenticated SSE endpoint: ${baseUrl}/sse?key=${firstKey}`); + logger.log(`Example authenticated MCP endpoint: ${baseUrl}/mcp?key=${firstKey} (or use X-Api-Key header)`); } if (enableAdminUI) { - console.log(`Admin UI available at ${baseUrl}/admin`); + logger.log(`Admin UI available at ${baseUrl}/admin`); } }); const shutdown = async (signal: string) => { - console.log(`\nReceived ${signal}. Shutting down gracefully...`); + logger.log(`\nReceived ${signal}. Shutting down gracefully...`); try { - console.log("Closing MCP Server (disconnecting transports)..."); + logger.log("Closing MCP Server (disconnecting transports)..."); await server.close(); - console.log("MCP Server closed."); + logger.log("MCP Server closed."); - console.log("Cleaning up backend clients..."); + logger.log("Cleaning up backend clients..."); await cleanup(); - console.log("Backend clients cleaned up."); + logger.log("Backend clients cleaned up."); // Kill any active terminal processes - console.log("Killing active terminal sessions..."); + logger.log("Killing active terminal sessions..."); // Add type annotations for the forEach callback parameters activeTerminals.forEach((term: ActiveTerminal, id: string) => { - console.log(`Killing terminal ${id} (PID: ${term.ptyProcess.pid})`); + logger.log(`Killing terminal ${id} (PID: ${term.ptyProcess.pid})`); term.ptyProcess.kill(); }); activeTerminals.clear(); TERMINAL_OUTPUT_SSE_CONNECTIONS.clear(); // Also clear SSE connections for terminals - console.log("Active terminal sessions killed."); + logger.log("Active terminal sessions killed."); - console.log("Closing HTTP server..."); + logger.log("Closing HTTP server..."); expressServer.close((err) => { if (err) { - console.error("Error closing HTTP server:", err); + logger.error("Error closing HTTP server:", err); process.exit(1); } else { - console.log("HTTP server closed."); + logger.log("HTTP server closed."); process.exit(0); } }); setTimeout(() => { - console.error("Graceful shutdown timed out. Forcing exit."); + logger.error("Graceful shutdown timed out. Forcing exit."); process.exit(1); }, 10000); // Increased timeout slightly } catch (error) { - console.error("Error during graceful shutdown:", error); + logger.error("Error during graceful shutdown:", error); process.exit(1); } }; From 3566805a00cf9c131b4b21cb1955b9d7743ae3f7 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Mon, 23 Jun 2025 17:38:24 +0800 Subject: [PATCH 13/19] doc: improve readme for logger level --- README.md | 8 ++++++++ README_ZH.md | 8 ++++++++ 2 files changed, 16 insertions(+) diff --git a/README.md b/README.md index 620fe0e..1736f7e 100644 --- a/README.md +++ b/README.md @@ -174,6 +174,14 @@ Example `config/tool_config.json`: export TOOLS_FOLDER=/srv/mcp_tools ``` +- **`LOGGING`**: (Optional) Controls the minimum log level output by the server. + - Possible values (case-insensitive): `error`, `warn`, `info`, `debug`. + - Logs at the specified level and all levels above it will be shown. + - Default: `info`. + ```bash + export LOGGING="debug" + ``` + - **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`**: (Optional) Controls whether to automatically reconnect and retry on SSE tool call failures. Set to `"true"` to enable, `"false"` to disable. Default: `true`. See the "Enhanced Reliability Features" section for details. ```bash export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" diff --git a/README_ZH.md b/README_ZH.md index 119c091..040586c 100644 --- a/README_ZH.md +++ b/README_ZH.md @@ -175,6 +175,14 @@ export TOOLS_FOLDER=/srv/mcp_tools ``` +- **`LOGGING`**: (可选) 控制服务器输出的最低日志级别。 + - 可能的值（不区分大小写）：`error`, `warn`, `info`, `debug`。 + - 将显示指定级别及以上的所有日志。 + - 默认值：`info`。 + ```bash + export LOGGING="debug" + ``` + - **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`**: (可选) 控制 SSE 工具调用失败时是否自动重连并重试。设置为 `"true"` 启用，`"false"` 禁用。默认: `true`。有关详细信息，请参阅“增强的可靠性特性”部分。 ```bash export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" From 0bb1f66105bc15c81512d030a321ebac4d9ce180 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Wed, 25 Jun 2025 00:29:28 +0800 Subject: [PATCH 14/19] perf(logging): improve inactive logging --- src/mcp-proxy.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 740cdcd..0a07b8c 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -64,7 +64,7 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC if (isActive) { activeServersConfigLocal[serverKey] = serverConf; } else { - const serverName = serverConf.name || (isSSEConfig(serverConf) ? serverConf.url : isStdioConfig(serverConf) ? serverConf.command : serverKey); + const serverName = serverKey; logger.log(`Skipping inactive server during update: ${serverName}`); } } From 5284c4d824b67e951b2b918d7a95d1068e300283 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Fri, 27 Jun 2025 20:54:40 +0800 Subject: [PATCH 15/19] refactor: improve retry loggic --- README.md | 77 ++++++-- README_ZH.md | 42 +++-- src/config.ts | 480 ++++++++++++++++++++++++++--------------------- src/mcp-proxy.ts | 228 +++++++++------------- 4 files changed, 447 insertions(+), 380 deletions(-) diff --git a/README.md b/README.md index 1736f7e..7394e44 100644 --- a/README.md +++ b/README.md @@ -182,9 +182,17 @@ Example `config/tool_config.json`: export LOGGING="debug" ``` -- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`**: (Optional) Controls whether to automatically reconnect and retry on SSE tool call failures. Set to `"true"` to enable, `"false"` to disable. Default: `true`. See the "Enhanced Reliability Features" section for details. +- **`RETRY_SSE_TOOL_CALL`**: (Optional) Controls whether to enable retries for SSE tool calls. Set to `"true"` to enable, `"false"` to disable. Default: `true`. See the "Enhanced Reliability Features" section for details. ```bash - export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" + export RETRY_SSE_TOOL_CALL="true" + ``` +- **`SSE_TOOL_CALL_MAX_RETRIES`**: (Optional) Maximum number of retry attempts for SSE tool calls (after the initial failure). Default: `2`. See the "Enhanced Reliability Features" section for details. + ```bash + export SSE_TOOL_CALL_MAX_RETRIES="2" + ``` +- **`SSE_TOOL_CALL_RETRY_DELAY_BASE_MS`**: (Optional) Base delay in milliseconds for SSE tool call retries, used in exponential backoff. Default: `300`. See the "Enhanced Reliability Features" section for details. + ```bash + export SSE_TOOL_CALL_RETRY_DELAY_BASE_MS="300" ``` - **`RETRY_HTTP_TOOL_CALL`**: (Optional) Controls whether to retry on HTTP tool call connection errors. Set to `"true"` to enable, `"false"` to disable. Default: `true`. See the "Enhanced Reliability Features" section for details. ```bash @@ -218,23 +226,33 @@ The MCP Proxy Server includes features to improve its resilience and the reliabi ### 1. Error Propagation The proxy server ensures that errors originating from backend MCP services are consistently propagated to the requesting client. These errors are formatted as standard JSON-RPC error responses, making it easier for clients to handle them uniformly. -### 2. SSE Connection Retry for Tool Calls -When a `tools/call` operation is made to an SSE-based backend server, and the underlying connection is lost or experiences an error, the proxy server will automatically attempt to: -1. Re-establish the connection to the SSE backend. -2. If reconnection is successful, it will retry the original `tools/call` request **once**. +### 2. SSE Tool Call Retry +When a `tools/call` operation is made to an SSE-based backend server, and the underlying connection is lost or experiences an error (including timeouts), the proxy server implements a retry mechanism. -This behavior helps mitigate transient network issues that might temporarily disrupt SSE connections. +**Retry Mechanism:** +If an initial SSE tool call fails due to a connection error or timeout, the proxy will attempt to re-establish the connection to the SSE backend. If reconnection is successful, it will then retry the original `tools/call` request using an exponential backoff strategy, similar to HTTP and Stdio retries. This means the delay before each subsequent retry attempt increases exponentially, with a small amount of jitter (randomness) added. **Configuration:** -This feature is primarily controlled by the **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** environment variable. -- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (environment variable): - - Set to `"true"` to enable the automatic reconnect and retry. +These settings are primarily controlled by environment variables. Values in `config/mcp_server.json` under the `proxy` object for these specific keys will be overridden by environment variables if set. + +- **`RETRY_SSE_TOOL_CALL`** (environment variable): + - Set to `"true"` to enable retries for SSE tool calls. - Set to `"false"` to disable this feature. - **Default Behavior:** `true` (if the environment variable is not set, is empty, or is an invalid value). -**Example (Environment Variable):** +- **`SSE_TOOL_CALL_MAX_RETRIES`** (environment variable): + - Specifies the maximum number of retry attempts *after* the initial failed attempt. For example, if set to `"2"`, there will be one initial attempt and up to two retry attempts, totaling a maximum of three attempts. + - **Default Behavior:** `2` (if the environment variable is not set, is empty, or is not a valid integer). + +- **`SSE_TOOL_CALL_RETRY_DELAY_BASE_MS`** (environment variable): + - The base delay in milliseconds used in the exponential backoff calculation. The delay before the *n*-th retry (0-indexed) is roughly `SSE_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`. + - **Default Behavior:** `300` (milliseconds) (if the environment variable is not set, is empty, or is not a valid integer). + +**Example (Environment Variables):** ```bash -export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" +export RETRY_SSE_TOOL_CALL="true" +export SSE_TOOL_CALL_MAX_RETRIES="3" +export SSE_TOOL_CALL_RETRY_DELAY_BASE_MS="500" ``` ### 3. HTTP Request Retry for Tool Calls @@ -282,8 +300,8 @@ These settings are primarily controlled by environment variables. - **Default Behavior:** `300` (milliseconds) (if the environment variable is not set, is empty, or is not a valid integer). **General Notes on Environment Variable Parsing:** -- Boolean environment variables (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`, `RETRY_STDIO_TOOL_CALL`) are considered `true` if their lowercase value is exactly `"true"`. Any other value (including empty or not set) results in the default being applied or `false` if the default is `false` (though for these specific variables, the default is `true`). -- Numeric environment variables (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`, `STDIO_TOOL_CALL_MAX_RETRIES`, `STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`) are parsed as base-10 integers. If parsing fails (e.g., the value is not a number, or the variable is empty/not set), the default value is used. +- Boolean environment variables (`RETRY_SSE_TOOL_CALL`, `RETRY_HTTP_TOOL_CALL`, `RETRY_STDIO_TOOL_CALL`) are considered `true` if their lowercase value is exactly `"true"`. Any other value (including empty or not set) results in the default being applied or `false` if the default is `false` (though for these specific variables, the default is `true`)。 +- Numeric environment variables (`SSE_TOOL_CALL_MAX_RETRIES`, `SSE_TOOL_CALL_RETRY_DELAY_BASE_MS`, `HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`, `STDIO_TOOL_CALL_MAX_RETRIES`, `STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`) are parsed as base-10 integers. If parsing fails (e.g., the value is not a number, or the variable is empty/not set), the default value is used。 ## Development @@ -336,8 +354,8 @@ These settings are primarily controlled by environment variables. Values in `con - **Default Behavior:** `300` (milliseconds) (if the environment variable is not set, is empty, or is not a valid integer). **General Notes on Environment Variable Parsing:** -- Boolean environment variables (`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`, `RETRY_HTTP_TOOL_CALL`) are considered `true` if their lowercase value is exactly `"true"`. Any other value (including empty or not set) results in the default being applied or `false` if the default is `false` (though for these specific variables, the default is `true`). -- Numeric environment variables (`HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`) are parsed as base-10 integers. If parsing fails (e.g., the value is not a number, or the variable is empty/not set), the default value is used. +- Boolean environment variables (`RETRY_SSE_TOOL_CALL`, `RETRY_HTTP_TOOL_CALL`, `RETRY_STDIO_TOOL_CALL`) are considered `true` if their lowercase value is exactly `"true"`. Any other value (including empty or not set) results in the default being applied or `false` if the default is `false` (though for these specific variables, the default is `true`). +- Numeric environment variables (`SSE_TOOL_CALL_MAX_RETRIES`, `SSE_TOOL_CALL_RETRY_DELAY_BASE_MS`, `HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`, `STDIO_TOOL_CALL_MAX_RETRIES`, `STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`) are parsed as base-10 integers. If parsing fails (e.g., the value is not a number, or the variable is empty/not set), the default value is used. **Example (Environment Variables):** ```bash @@ -345,7 +363,32 @@ export RETRY_HTTP_TOOL_CALL="true" export HTTP_TOOL_CALL_MAX_RETRIES="3" export HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS="500" ``` -*(The JSON example for `mcp_server.json` under "Proxy Behavior Configuration" illustrates where other, non-environment-overrideable proxy settings might go.)* + +### 4. Stdio Connection Retry for Tool Calls +For `tools/call` operations directed to Stdio-based backend servers, the proxy implements a retry mechanism for connection errors (e.g., process crash or unresponsiveness). + +**Retry Mechanism:** +If an initial Stdio connection or tool call fails, the proxy will attempt to restart the Stdio process and retry the request. This mechanism follows an exponential backoff strategy similar to HTTP retries. + +**Configuration:** +These settings are primarily controlled by environment variables. + +- **`RETRY_STDIO_TOOL_CALL`** (environment variable): + - Set to `"true"` to enable Stdio tool call retries. + - Set to `"false"` to disable this feature. + - **Default Behavior:** `true` (if the environment variable is not set, is empty, or is an invalid value). + +- **`STDIO_TOOL_CALL_MAX_RETRIES`** (environment variable): + - Specifies the maximum number of retry attempts *after* the initial failed attempt. For example, if set to `"2"`, there will be one initial attempt and up to two retry attempts, totaling a maximum of three attempts. + - **Default Behavior:** `2` (if the environment variable is not set, is empty, or is not a valid integer). + +- **`STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`** (environment variable): + - The base delay in milliseconds used in the exponential backoff calculation. The delay before the *n*-th retry (0-indexed) is roughly `STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + jitter`. + - **Default Behavior:** `300` (milliseconds) (if the environment variable is not set, is empty, or is not a valid integer). + +**General Notes on Environment Variable Parsing:** +- Boolean environment variables (`RETRY_SSE_TOOL_CALL`, `RETRY_HTTP_TOOL_CALL`, `RETRY_STDIO_TOOL_CALL`) are considered `true` if their lowercase value is exactly `"true"`. Any other value (including empty or not set) results in the default being applied or `false` if the default is `false` (though for these specific variables, the default is `true`)。 +- Numeric environment variables (`SSE_TOOL_CALL_MAX_RETRIES`, `SSE_TOOL_CALL_RETRY_DELAY_BASE_MS`, `HTTP_TOOL_CALL_MAX_RETRIES`, `HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`, `STDIO_TOOL_CALL_MAX_RETRIES`, `STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`) are parsed as base-10 integers. If parsing fails (e.g., the value is not a number, or the variable is empty/not set), the default value is used. ## Development diff --git a/README_ZH.md b/README_ZH.md index 040586c..ee66d89 100644 --- a/README_ZH.md +++ b/README_ZH.md @@ -183,9 +183,17 @@ export LOGGING="debug" ``` -- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`**: (可选) 控制 SSE 工具调用失败时是否自动重连并重试。设置为 `"true"` 启用，`"false"` 禁用。默认: `true`。有关详细信息，请参阅“增强的可靠性特性”部分。 +- **`RETRY_SSE_TOOL_CALL`**: (可选) 控制 SSE 工具调用失败时是否自动重连并重试。设置为 `"true"` 启用，`"false"` 禁用。默认: `true`。有关详细信息，请参阅“增强的可靠性特性”部分。 ```bash - export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" + export RETRY_SSE_TOOL_CALL="true" + ``` +- **`SSE_TOOL_CALL_MAX_RETRIES`**: (可选) SSE 工具调用最大重试次数（在初始失败后）。默认: `2`。有关详细信息，请参阅“增强的可靠性特性”部分。 + ```bash + export SSE_TOOL_CALL_MAX_RETRIES="2" + ``` +- **`SSE_TOOL_CALL_RETRY_DELAY_BASE_MS`**: (可选) SSE 工具调用重试延迟基准（毫秒），用于指数退避。默认: `300`。有关详细信息，请参阅“增强的可靠性特性”部分。 + ```bash + export SSE_TOOL_CALL_RETRY_DELAY_BASE_MS="300" ``` - **`RETRY_HTTP_TOOL_CALL`**: (可选) 控制 HTTP 工具调用连接错误时是否重试。设置为 `"true"` 启用，`"false"` 禁用。默认: `true`。有关详细信息，请参阅“增强的可靠性特性”部分。 ```bash @@ -220,22 +228,32 @@ MCP 代理服务器包含多项特性，用以提升其自身弹性以及与后 代理服务器确保从后端 MCP 服务产生的错误能够一致地传播给请求客户端。这些错误被格式化为标准的 JSON-RPC 错误响应，使客户端更容易统一处理它们。 ### 2. SSE 工具调用的连接重试 -当对基于 SSE 的后端服务器执行 `tools/call` 操作时，如果底层连接丢失或遇到错误，代理服务器将自动尝试： -1. 重新建立与 SSE 后端的连接。 -2. 如果重新连接成功，它将重试原始的 `tools/call` 请求**一次**。 +当对基于 SSE 的后端服务器执行 `tools/call` 操作时，如果底层连接丢失或遇到错误（包括超时），代理服务器将实现重试机制。 -此行为有助于缓解可能暂时中断 SSE 连接的瞬时网络问题。 +**重试机制：** +如果初始 SSE 工具调用因连接错误或超时而失败，代理将尝试重新建立与 SSE 后端的连接。如果重新连接成功，它将使用指数退避策略重试原始的 `tools/call` 请求，类似于 HTTP 和 Stdio 重试。这意味着每次后续重试尝试之前的延迟会指数级增加，并加入少量抖动（随机性）。 **配置:** -此功能主要通过 **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** 环境变量控制。 -- **`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`** (环境变量): - - 设置为 `"true"` 以启用自动重新连接和重试。 +这些设置主要通过环境变量控制。如果 `config/mcp_server.json` 中 `proxy` 对象下存在这些特定键的值，它们将被环境变量覆盖。 + +- **`RETRY_SSE_TOOL_CALL`** (环境变量): + - 设置为 `"true"` 以启用 SSE 工具调用的重试。 - 设置为 `"false"` 以禁用此功能。 - **默认行为:** `true` (如果环境变量未设置、为空或为无效值)。 +- **`SSE_TOOL_CALL_MAX_RETRIES`** (环境变量): + - 指定在初次失败尝试*之后*的最大重试次数。例如，如果设置为 `"2"`，则会有一次初始尝试和最多两次重试尝试，总共最多三次尝试。 + - **默认行为:** `2` (如果环境变量未设置、为空或不是一个有效的整数)。 + +- **`SSE_TOOL_CALL_RETRY_DELAY_BASE_MS`** (环境变量): + - 用于指数退避计算的基准延迟（以毫秒为单位）。第 *n* 次重试（0索引）之前的延迟大约是 `SSE_TOOL_CALL_RETRY_DELAY_BASE_MS * (2^n) + 抖动`。 + - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 + **示例 (环境变量):** ```bash -export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" +export RETRY_SSE_TOOL_CALL="true" +export SSE_TOOL_CALL_MAX_RETRIES="3" +export SSE_TOOL_CALL_RETRY_DELAY_BASE_MS="500" ``` ### 3. HTTP 工具调用的请求重试 @@ -283,8 +301,8 @@ export RETRY_SSE_TOOL_CALL_ON_DISCONNECT="true" - **默认行为:** `300` (毫秒) (如果环境变量未设置、为空或不是一个有效的整数)。 **环境变量解析通用说明:** -- 布尔环境变量（`RETRY_SSE_TOOL_CALL_ON_DISCONNECT`，`RETRY_HTTP_TOOL_CALL`，`RETRY_STDIO_TOOL_CALL`）如果其小写值恰好是 `"true"`，则被视为 `true`。任何其他值（包括空或未设置）将应用默认值，或者如果默认值为 `false` 则为 `false`（尽管对于这些特定变量，默认值为 `true`）。 -- 数字环境变量（`HTTP_TOOL_CALL_MAX_RETRIES`，`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`，`STDIO_TOOL_CALL_MAX_RETRIES`，`STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`）被解析为十进制整数。如果解析失败（例如，值不是数字，或变量为空/未设置），则使用默认值。 +- 布尔环境变量（`RETRY_SSE_TOOL_CALL`，`RETRY_HTTP_TOOL_CALL`，`RETRY_STDIO_TOOL_CALL`）如果其小写值恰好是 `"true"`，则被视为 `true`。任何其他值（包括空或未设置）将应用默认值，或者如果默认值为 `false` 则为 `false`（尽管对于这些特定变量，默认值为 `true`）。 +- 数字环境变量（`SSE_TOOL_CALL_MAX_RETRIES`，`SSE_TOOL_CALL_RETRY_DELAY_BASE_MS`，`HTTP_TOOL_CALL_MAX_RETRIES`，`HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS`，`STDIO_TOOL_CALL_MAX_RETRIES`，`STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS`）被解析为十进制整数。如果解析失败（例如，值不是数字，或变量为空/未设置），则使用默认值。 ## 开发 diff --git a/src/config.ts b/src/config.ts index d2d86c3..a0badae 100644 --- a/src/config.ts +++ b/src/config.ts @@ -36,13 +36,15 @@ export type TransportConfigHTTP = { export type TransportConfig = (TransportConfigStdio | TransportConfigSSE | TransportConfigHTTP) & { name?: string, active?: boolean, type: 'stdio' | 'sse' | 'http' }; export interface ProxySettings { - retrySseToolCallOnDisconnect?: boolean; + retrySseToolCall?: boolean; // Renamed from retrySseToolCallOnDisconnect + sseToolCallMaxRetries?: number; + sseToolCallRetryDelayBaseMs?: number; retryHttpToolCall?: boolean; httpToolCallMaxRetries?: number; httpToolCallRetryDelayBaseMs?: number; - retryStdioToolCall?: boolean; // Add stdio retry flag - stdioToolCallMaxRetries?: number; // Add stdio max retries - stdioToolCallRetryDelayBaseMs?: number; // Add stdio retry delay + retryStdioToolCall?: boolean; + stdioToolCallMaxRetries?: number; + stdioToolCallRetryDelayBaseMs?: number; } export interface Config { @@ -78,223 +80,269 @@ export function isHttpConfig(config: TransportConfig): config is TransportConfig export const loadConfig = async (): Promise => { // Define standard defaults for specific environment-overrideable proxy settings // This is moved here to be in scope for both try and catch blocks. - const defaultEnvProxySettings = { - retrySseToolCallOnDisconnect: true, - retryHttpToolCall: true, - httpToolCallMaxRetries: 2, - httpToolCallRetryDelayBaseMs: 300, - retryStdioToolCall: true, // Default for stdio retry - stdioToolCallMaxRetries: 2, // Default for stdio max retries - stdioToolCallRetryDelayBaseMs: 300, // Default for stdio retry delay - }; - - try { - const configPath = resolve(process.cwd(), 'config', 'mcp_server.json'); - console.log(`Attempting to load configuration from: ${configPath}`); - const fileContents = await readFile(configPath, 'utf-8'); - const parsedConfig = JSON.parse(fileContents) as Config; - - if (typeof parsedConfig !== 'object' || parsedConfig === null || typeof parsedConfig.mcpServers !== 'object') { - throw new Error('Invalid config format: mcpServers object not found.'); - } - - // Initialize proxy object on parsedConfig if it doesn't exist - // This ensures that other proxy settings from the file are preserved if they exist. - parsedConfig.proxy = parsedConfig.proxy || {}; - - // Override with environment variables or defaults for the specific settings - // 1. RETRY_SSE_TOOL_CALL_ON_DISCONNECT - const sseRetryEnv = process.env.RETRY_SSE_TOOL_CALL_ON_DISCONNECT; - if (sseRetryEnv && sseRetryEnv.trim() !== '') { - parsedConfig.proxy.retrySseToolCallOnDisconnect = sseRetryEnv.toLowerCase() === 'true'; - } else { - parsedConfig.proxy.retrySseToolCallOnDisconnect = defaultEnvProxySettings.retrySseToolCallOnDisconnect; - } - - // 2. RETRY_HTTP_TOOL_CALL - const httpRetryEnv = process.env.RETRY_HTTP_TOOL_CALL; - if (httpRetryEnv && httpRetryEnv.trim() !== '') { - parsedConfig.proxy.retryHttpToolCall = httpRetryEnv.toLowerCase() === 'true'; - } else { - parsedConfig.proxy.retryHttpToolCall = defaultEnvProxySettings.retryHttpToolCall; - } - - // 3. HTTP_TOOL_CALL_MAX_RETRIES - const maxRetriesEnv = process.env.HTTP_TOOL_CALL_MAX_RETRIES; - if (maxRetriesEnv && maxRetriesEnv.trim() !== '') { - const numVal = parseInt(maxRetriesEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.httpToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnv}". Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); - parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; - } - } else { - parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; - } - - // 4. HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS - const delayBaseEnv = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (delayBaseEnv && delayBaseEnv.trim() !== '') { - const numVal = parseInt(delayBaseEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.httpToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnv}". Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); - parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; - } - } else { - parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; - } - - // 5. RETRY_STDIO_TOOL_CALL - const stdioRetryEnv = process.env.RETRY_STDIO_TOOL_CALL; - if (stdioRetryEnv && stdioRetryEnv.trim() !== '') { - parsedConfig.proxy.retryStdioToolCall = stdioRetryEnv.toLowerCase() === 'true'; - } else { - parsedConfig.proxy.retryStdioToolCall = defaultEnvProxySettings.retryStdioToolCall; - } - - // 6. STDIO_TOOL_CALL_MAX_RETRIES - const stdioMaxRetriesEnv = process.env.STDIO_TOOL_CALL_MAX_RETRIES; - if (stdioMaxRetriesEnv && stdioMaxRetriesEnv.trim() !== '') { - const numVal = parseInt(stdioMaxRetriesEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.stdioToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); - parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; - } - } else { - parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; - } - - // 7. STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS - const stdioDelayBaseEnv = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (stdioDelayBaseEnv && stdioDelayBaseEnv.trim() !== '') { - const numVal = parseInt(stdioDelayBaseEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); - parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; - } - } else { - parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; - } - - // The parsedConfig now has its proxy settings correctly reflecting env overrides for the specified fields. - // Other fields in parsedConfig.proxy loaded from the file remain untouched. - // Other parts of parsedConfig (like mcpServers) are also as loaded from the file. - - logger.log("Loaded config with final proxy settings (after env overrides):", JSON.stringify(parsedConfig.proxy).slice(1, -1)); - return parsedConfig; // Return the modified parsedConfig - - } catch (error: any) { - logger.error(`Error loading config/mcp_server.json: ${error.message}`); - - // If file loading fails, initialize with environment variables or defaults for proxy settings - const proxySettingsFromEnvOrDefaults: ProxySettings = { - retrySseToolCallOnDisconnect: defaultEnvProxySettings.retrySseToolCallOnDisconnect, - retryHttpToolCall: defaultEnvProxySettings.retryHttpToolCall, - httpToolCallMaxRetries: defaultEnvProxySettings.httpToolCallMaxRetries, - httpToolCallRetryDelayBaseMs: defaultEnvProxySettings.httpToolCallRetryDelayBaseMs, - retryStdioToolCall: defaultEnvProxySettings.retryStdioToolCall, // Default for stdio retry - stdioToolCallMaxRetries: defaultEnvProxySettings.stdioToolCallMaxRetries, // Default for stdio max retries - stdioToolCallRetryDelayBaseMs: defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs, // Default for stdio retry delay - }; - - const sseRetryEnvCatch = process.env.RETRY_SSE_TOOL_CALL_ON_DISCONNECT; - if (sseRetryEnvCatch && sseRetryEnvCatch.trim() !== '') { - proxySettingsFromEnvOrDefaults.retrySseToolCallOnDisconnect = sseRetryEnvCatch.toLowerCase() === 'true'; - } - - const httpRetryEnvCatch = process.env.RETRY_HTTP_TOOL_CALL; - if (httpRetryEnvCatch && httpRetryEnvCatch.trim() !== '') { - proxySettingsFromEnvOrDefaults.retryHttpToolCall = httpRetryEnvCatch.toLowerCase() === 'true'; - } - - const maxRetriesEnvCatch = process.env.HTTP_TOOL_CALL_MAX_RETRIES; - if (maxRetriesEnvCatch && maxRetriesEnvCatch.trim() !== '') { - const numVal = parseInt(maxRetriesEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.httpToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); - } - } - - const delayBaseEnvCatch = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (delayBaseEnvCatch && delayBaseEnvCatch.trim() !== '') { - const numVal = parseInt(delayBaseEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.httpToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); - } - } - - const stdioRetryEnvCatch = process.env.RETRY_STDIO_TOOL_CALL; - if (stdioRetryEnvCatch && stdioRetryEnvCatch.trim() !== '') { - proxySettingsFromEnvOrDefaults.retryStdioToolCall = stdioRetryEnvCatch.toLowerCase() === 'true'; - } - - const stdioMaxRetriesEnvCatch = process.env.STDIO_TOOL_CALL_MAX_RETRIES; - if (stdioMaxRetriesEnvCatch && stdioMaxRetriesEnvCatch.trim() !== '') { - const numVal = parseInt(stdioMaxRetriesEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.stdioToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); - } - } - - const stdioDelayBaseEnvCatch = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (stdioDelayBaseEnvCatch && stdioDelayBaseEnvCatch.trim() !== '') { - const numVal = parseInt(stdioDelayBaseEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.stdioToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); - } - } - - logger.log("Using proxy settings from environment/defaults due to mcp_server.json load error:", proxySettingsFromEnvOrDefaults); - return { - mcpServers: {}, - proxy: proxySettingsFromEnvOrDefaults, - }; - } + const defaultEnvProxySettings = { + retrySseToolCall: true, // Renamed from retrySseToolCallOnDisconnect + sseToolCallMaxRetries: 2, + sseToolCallRetryDelayBaseMs: 300, + retryHttpToolCall: true, + httpToolCallMaxRetries: 2, + httpToolCallRetryDelayBaseMs: 300, + retryStdioToolCall: true, + stdioToolCallMaxRetries: 2, + stdioToolCallRetryDelayBaseMs: 300, + }; + + try { + const configPath = resolve(process.cwd(), 'config', 'mcp_server.json'); + console.log(`Attempting to load configuration from: ${configPath}`); + const fileContents = await readFile(configPath, 'utf-8'); + const parsedConfig = JSON.parse(fileContents) as Config; + + if (typeof parsedConfig !== 'object' || parsedConfig === null || typeof parsedConfig.mcpServers !== 'object') { + throw new Error('Invalid config format: mcpServers object not found.'); + } + + // Initialize proxy object on parsedConfig if it doesn't exist + parsedConfig.proxy = parsedConfig.proxy || {}; + + // Override with environment variables or defaults for the specific settings + + // SSE Retry Settings + const sseRetryEnv = process.env.RETRY_SSE_TOOL_CALL; // Changed env var name + if (sseRetryEnv && sseRetryEnv.trim() !== '') { + parsedConfig.proxy.retrySseToolCall = sseRetryEnv.toLowerCase() === 'true'; // Changed property name + } else { + parsedConfig.proxy.retrySseToolCall = defaultEnvProxySettings.retrySseToolCall; // Changed property name + } + + const sseMaxRetriesEnv = process.env.SSE_TOOL_CALL_MAX_RETRIES; + if (sseMaxRetriesEnv && sseMaxRetriesEnv.trim() !== '') { + const numVal = parseInt(sseMaxRetriesEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.sseToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for SSE_TOOL_CALL_MAX_RETRIES: "${sseMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.sseToolCallMaxRetries}.`); + parsedConfig.proxy.sseToolCallMaxRetries = defaultEnvProxySettings.sseToolCallMaxRetries; + } + } else { + parsedConfig.proxy.sseToolCallMaxRetries = defaultEnvProxySettings.sseToolCallMaxRetries; + } + + const sseDelayBaseEnv = process.env.SSE_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (sseDelayBaseEnv && sseDelayBaseEnv.trim() !== '') { + const numVal = parseInt(sseDelayBaseEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.sseToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for SSE_TOOL_CALL_RETRY_DELAY_BASE_MS: "${sseDelayBaseEnv}". Using default: ${defaultEnvProxySettings.sseToolCallRetryDelayBaseMs}.`); + parsedConfig.proxy.sseToolCallRetryDelayBaseMs = defaultEnvProxySettings.sseToolCallRetryDelayBaseMs; + } + } else { + parsedConfig.proxy.sseToolCallRetryDelayBaseMs = defaultEnvProxySettings.sseToolCallRetryDelayBaseMs; + } + + + // HTTP Retry Settings + const httpRetryEnv = process.env.RETRY_HTTP_TOOL_CALL; + if (httpRetryEnv && httpRetryEnv.trim() !== '') { + parsedConfig.proxy.retryHttpToolCall = httpRetryEnv.toLowerCase() === 'true'; + } else { + parsedConfig.proxy.retryHttpToolCall = defaultEnvProxySettings.retryHttpToolCall; + } + + const maxRetriesEnv = process.env.HTTP_TOOL_CALL_MAX_RETRIES; + if (maxRetriesEnv && maxRetriesEnv.trim() !== '') { + const numVal = parseInt(maxRetriesEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.httpToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnv}". Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); + parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; + } + } else { + parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; + } + + const delayBaseEnv = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (delayBaseEnv && delayBaseEnv.trim() !== '') { + const numVal = parseInt(delayBaseEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.httpToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnv}". Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); + parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; + } + } else { + parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; + } + + // STDIO Retry Settings + const stdioRetryEnv = process.env.RETRY_STDIO_TOOL_CALL; + if (stdioRetryEnv && stdioRetryEnv.trim() !== '') { + parsedConfig.proxy.retryStdioToolCall = stdioRetryEnv.toLowerCase() === 'true'; + } else { + parsedConfig.proxy.retryStdioToolCall = defaultEnvProxySettings.retryStdioToolCall; + } + + const stdioMaxRetriesEnv = process.env.STDIO_TOOL_CALL_MAX_RETRIES; + if (stdioMaxRetriesEnv && stdioMaxRetriesEnv.trim() !== '') { + const numVal = parseInt(stdioMaxRetriesEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.stdioToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); + parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; + } + } else { + parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; + } + + const stdioDelayBaseEnv = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (stdioDelayBaseEnv && stdioDelayBaseEnv.trim() !== '') { + const numVal = parseInt(stdioDelayBaseEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); + parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; + } + } else { + parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; + } + + logger.log("Loaded config with final proxy settings (after env overrides):", JSON.stringify(parsedConfig.proxy).slice(1, -1)); + return parsedConfig; + + } catch (error: any) { + logger.error(`Error loading config/mcp_server.json: ${error.message}`); + + // If file loading fails, initialize with environment variables or defaults for proxy settings + const proxySettingsFromEnvOrDefaults: ProxySettings = { + retrySseToolCall: defaultEnvProxySettings.retrySseToolCall, + sseToolCallMaxRetries: defaultEnvProxySettings.sseToolCallMaxRetries, // Default for SSE max retries + sseToolCallRetryDelayBaseMs: defaultEnvProxySettings.sseToolCallRetryDelayBaseMs, // Default for SSE retry delay + retryHttpToolCall: defaultEnvProxySettings.retryHttpToolCall, + httpToolCallMaxRetries: defaultEnvProxySettings.httpToolCallMaxRetries, + httpToolCallRetryDelayBaseMs: defaultEnvProxySettings.httpToolCallRetryDelayBaseMs, + retryStdioToolCall: defaultEnvProxySettings.retryStdioToolCall, + stdioToolCallMaxRetries: defaultEnvProxySettings.stdioToolCallMaxRetries, + stdioToolCallRetryDelayBaseMs: defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs, + }; + + // SSE Retry Settings (during error handling) + const sseRetryEnvCatch = process.env.RETRY_SSE_TOOL_CALL; // Changed env var name + if (sseRetryEnvCatch && sseRetryEnvCatch.trim() !== '') { + proxySettingsFromEnvOrDefaults.retrySseToolCall = sseRetryEnvCatch.toLowerCase() === 'true'; // Changed property name + } + + const sseMaxRetriesEnvCatch = process.env.SSE_TOOL_CALL_MAX_RETRIES; + if (sseMaxRetriesEnvCatch && sseMaxRetriesEnvCatch.trim() !== '') { + const numVal = parseInt(sseMaxRetriesEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.sseToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for SSE_TOOL_CALL_MAX_RETRIES: "${sseMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.sseToolCallMaxRetries}.`); + } + } + + const sseDelayBaseEnvCatch = process.env.SSE_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (sseDelayBaseEnvCatch && sseDelayBaseEnvCatch.trim() !== '') { + const numVal = parseInt(sseDelayBaseEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.sseToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for SSE_TOOL_CALL_RETRY_DELAY_BASE_MS: "${sseDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.sseToolCallRetryDelayBaseMs}.`); + } + } + + // HTTP Retry Settings (during error handling) + const httpRetryEnvCatch = process.env.RETRY_HTTP_TOOL_CALL; + if (httpRetryEnvCatch && httpRetryEnvCatch.trim() !== '') { + proxySettingsFromEnvOrDefaults.retryHttpToolCall = httpRetryEnvCatch.toLowerCase() === 'true'; + } + + const maxRetriesEnvCatch = process.env.HTTP_TOOL_CALL_MAX_RETRIES; + if (maxRetriesEnvCatch && maxRetriesEnvCatch.trim() !== '') { + const numVal = parseInt(maxRetriesEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.httpToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); + } + } + + const delayBaseEnvCatch = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (delayBaseEnvCatch && delayBaseEnvCatch.trim() !== '') { + const numVal = parseInt(delayBaseEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.httpToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); + } + } + + // STDIO Retry Settings (during error handling) + const stdioRetryEnvCatch = process.env.RETRY_STDIO_TOOL_CALL; + if (stdioRetryEnvCatch && stdioRetryEnvCatch.trim() !== '') { + proxySettingsFromEnvOrDefaults.retryStdioToolCall = stdioRetryEnvCatch.toLowerCase() === 'true'; + } + + const stdioMaxRetriesEnvCatch = process.env.STDIO_TOOL_CALL_MAX_RETRIES; + if (stdioMaxRetriesEnvCatch && stdioMaxRetriesEnvCatch.trim() !== '') { + const numVal = parseInt(stdioMaxRetriesEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.stdioToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); + } + } + + const stdioDelayBaseEnvCatch = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (stdioDelayBaseEnvCatch && stdioDelayBaseEnvCatch.trim() !== '') { + const numVal = parseInt(stdioDelayBaseEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.stdioToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); + } + } + + logger.log("Using proxy settings from environment/defaults due to mcp_server.json load error:", proxySettingsFromEnvOrDefaults); + return { + mcpServers: {}, + proxy: proxySettingsFromEnvOrDefaults, + }; + } }; export const loadToolConfig = async (): Promise => { - const defaultConfig: ToolConfig = { tools: {} }; + const defaultConfig: ToolConfig = { tools: {} }; try { - const configPath = resolve(process.cwd(), 'config', 'tool_config.json'); - logger.log(`Attempting to load tool configuration from: ${configPath}`); - const fileContents = await readFile(configPath, 'utf-8'); - const parsedConfig = JSON.parse(fileContents) as ToolConfig; - - if (typeof parsedConfig !== 'object' || parsedConfig === null || typeof parsedConfig.tools !== 'object') { - logger.warn('Invalid tool_config.json format: "tools" object not found or invalid. Using default.'); - return defaultConfig; - } - for (const toolKey in parsedConfig.tools) { - if (typeof parsedConfig.tools[toolKey]?.enabled !== 'boolean') { - logger.warn(`Invalid setting for tool "${toolKey}" in tool_config.json: 'enabled' is missing or not a boolean. Assuming enabled.`); - } - } - - logger.log(`Successfully loaded tool configuration for ${Object.keys(parsedConfig.tools).length} tools.`); - return parsedConfig; + const configPath = resolve(process.cwd(), 'config', 'tool_config.json'); + logger.log(`Attempting to load tool configuration from: ${configPath}`); + const fileContents = await readFile(configPath, 'utf-8'); + const parsedConfig = JSON.parse(fileContents) as ToolConfig; + + if (typeof parsedConfig !== 'object' || parsedConfig === null || typeof parsedConfig.tools !== 'object') { + logger.warn('Invalid tool_config.json format: "tools" object not found or invalid. Using default.'); + return defaultConfig; + } + for (const toolKey in parsedConfig.tools) { + if (typeof parsedConfig.tools[toolKey]?.enabled !== 'boolean') { + logger.warn(`Invalid setting for tool "${toolKey}" in tool_config.json: 'enabled' is missing or not a boolean. Assuming enabled.`); + } + } + + logger.log(`Successfully loaded tool configuration for ${Object.keys(parsedConfig.tools).length} tools.`); + return parsedConfig; } catch (error: any) { - if (error.code === 'ENOENT') { - logger.log('config/tool_config.json not found. Using default (all tools enabled).'); - } else { - logger.error(`Error loading config/tool_config.json: ${error.message}`); - logger.warn('Using default tool configuration (all tools enabled) due to error.'); - } - return defaultConfig; + if (error.code === 'ENOENT') { + logger.log('config/tool_config.json not found. Using default (all tools enabled).'); + } else { + logger.error(`Error loading config/tool_config.json: ${error.message}`); + logger.warn('Using default tool configuration (all tools enabled) due to error.'); + } + return defaultConfig; } }; \ No newline at end of file diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 0a07b8c..a2f85cf 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -1,4 +1,5 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js"; +import { DEFAULT_REQUEST_TIMEOUT_MSEC } from "@modelcontextprotocol/sdk/shared/protocol.js"; // Import the constant import { CallToolRequestSchema, GetPromptRequestSchema, @@ -36,13 +37,15 @@ let currentActiveServersConfig: Record = {}; // Added f // Define Global Default Proxy Settings const defaultProxySettingsFull: Required> = { - retrySseToolCallOnDisconnect: true, + retrySseToolCall: true, // Renamed from retrySseToolCallOnDisconnect + sseToolCallMaxRetries: 2, + sseToolCallRetryDelayBaseMs: 300, retryHttpToolCall: true, httpToolCallMaxRetries: 2, httpToolCallRetryDelayBaseMs: 300, - retryStdioToolCall: true, // Default for stdio retry - stdioToolCallMaxRetries: 2, // Default for stdio max retries - stdioToolCallRetryDelayBaseMs: 300, // Default for stdio retry delay + retryStdioToolCall: true, + stdioToolCallMaxRetries: 2, + stdioToolCallRetryDelayBaseMs: 300, }; let currentProxyConfig: Required> = { ...defaultProxySettingsFull }; // Initialize with full defaults @@ -439,146 +442,101 @@ export const createServer = async () => { let { client: clientForTool, toolInfo } = mapEntry; // toolInfo here is the correct one from the found mapEntry const originalToolNameForBackend = toolInfo.name; // The actual name the backend server expects (from the original toolInfo) - try { - logger.log(`Received tool call for exposed name '${requestedExposedName}' (original qualified name: '${originalQualifiedName}'). Forwarding to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt 1)`); - const backendResponse = await clientForTool.client.request( - { - method: 'tools/call', - params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } - }, - CompatibilityCallToolResultSchema - ); - logger.log(`[Tool Call] Backend response received for '${requestedExposedName}':'${JSON.stringify(backendResponse)}' . Passing to SDK Server.`); - return backendResponse; - } catch (error: any) { - logger.warn(`Initial attempt to call tool '${requestedExposedName}' failed: ${error.message}`); - - // Access currentProxyConfig directly as it's guaranteed to be defined - const shouldRetrySse = currentProxyConfig.retrySseToolCallOnDisconnect !== false; - - if (clientForTool.transportType === 'sse' && isConnectionError(error) && shouldRetrySse) { - logger.log(`SSE connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting reconnect and retry.`); - const clientTransportConfig = currentActiveServersConfig[clientForTool.name]; - if (!clientTransportConfig) { - logger.error(`Cannot retry SSE: TransportConfig for server '${clientForTool.name}' not found.`); - throw new Error(`Error calling tool '${requestedExposedName}': Original error: ${error.message}. SSE Retry failed: server configuration not found.`); - } - const refreshed = await refreshBackendConnection(clientForTool.name, clientTransportConfig); - if (refreshed) { - logger.log(`Successfully reconnected to server '${clientForTool.name}' via SSE. Retrying tool call for '${requestedExposedName}'.`); - const newMapEntry = toolToClientMap.get(originalQualifiedName); - if (!newMapEntry) { - logger.error(`Tool '${originalQualifiedName}' not found in map after successful SSE refresh for server '${clientForTool.name}'.`); - throw new Error(`Error calling tool '${requestedExposedName}': Original error: ${error.message}. SSE Retry failed: tool not found in map after refresh.`); - } - clientForTool = newMapEntry.client; - toolInfo = newMapEntry.toolInfo; - try { - logger.log(`Retrying tool call (SSE) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt 2)`); - return await clientForTool.client.request( - { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, - CompatibilityCallToolResultSchema - ); - } catch (retryError: any) { - const errorMessage = `Error calling tool '${requestedExposedName}' (on backend '${clientForTool.name}') after SSE retry: ${retryError.message || 'An unknown error occurred during retry'}`; - logger.error(errorMessage, retryError); - throw new Error(errorMessage); - } - } else { - const errorMessage = `Error calling tool '${requestedExposedName}': SSE Reconnection to server '${clientForTool.name}' failed. Original error: ${error.message || 'An unknown error occurred'}`; - logger.error(errorMessage); - throw new Error(errorMessage); - } - } - // STDIO Retry Logic - else if (clientForTool.transportType === 'stdio' && - (currentProxyConfig.retryStdioToolCall !== false) && // Retry enabled by default, access directly - isConnectionError(error)) { - - // Access properties directly. Defaults are assured by currentProxyConfig's initialization. - const maxRetries = currentProxyConfig.stdioToolCallMaxRetries; - const retryDelayBaseMs = currentProxyConfig.stdioToolCallRetryDelayBaseMs; - let lastError: any = error; - - logger.log(`STDIO connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting up to ${maxRetries} retries.`); - - for (let attempt = 0; attempt < maxRetries; attempt++) { - try { - const delay = retryDelayBaseMs * Math.pow(2, attempt) + (Math.random() * retryDelayBaseMs * 0.5); - logger.log(`STDIO tool call failed for '${requestedExposedName}'. Attempt ${attempt + 1}/${maxRetries}. Retrying in ${delay.toFixed(0)}ms...`); + // --- Retry Logic --- + // Use HTTP retry settings for SSE as a fallback for retry count and delay + const maxRetries = clientForTool.transportType === 'sse' ? (currentProxyConfig.retrySseToolCall ? currentProxyConfig.sseToolCallMaxRetries : 0) : // Use SSE specific max retries, check retrySseToolCall + clientForTool.transportType === 'stdio' ? (currentProxyConfig.retryStdioToolCall ? currentProxyConfig.stdioToolCallMaxRetries : 0) : + clientForTool.transportType === 'http' ? (currentProxyConfig.retryHttpToolCall ? currentProxyConfig.httpToolCallMaxRetries : 0) : 0; + const retryDelayBaseMs = clientForTool.transportType === 'sse' ? currentProxyConfig.sseToolCallRetryDelayBaseMs : // Use SSE specific retry delay + clientForTool.transportType === 'stdio' ? (currentProxyConfig.retryStdioToolCall ? currentProxyConfig.stdioToolCallRetryDelayBaseMs : 0) : // Added check for stdio retry enabled + clientForTool.transportType === 'http' ? (currentProxyConfig.retryHttpToolCall ? currentProxyConfig.httpToolCallRetryDelayBaseMs : 0) : 0; // Added check for http retry enabled + + let lastError: any = null; + + // Loop includes the initial attempt (attempt 0) plus maxRetries + for (let attempt = 0; attempt <= maxRetries; attempt++) { + if (attempt > 0) { + const delay = retryDelayBaseMs * Math.pow(2, attempt - 1) + (Math.random() * retryDelayBaseMs * 0.5); + logger.log(`Tool call failed for '${requestedExposedName}'. Attempt ${attempt}/${maxRetries}. Retrying in ${delay.toFixed(0)}ms...`); await sleep(delay); - logger.log(`Retrying tool call (STDIO) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 2})`); - return await clientForTool.client.request( - { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, - CompatibilityCallToolResultSchema - ); - } catch (retryError: any) { - lastError = retryError; - logger.error(`STDIO tool call retry attempt ${attempt + 1}/${maxRetries} for '${requestedExposedName}' failed:`, retryError.message); - if (attempt === maxRetries - 1) { - break; + // For SSE, attempt reconnect before retrying the call if the last error was a connection error + if (clientForTool.transportType === 'sse' && isConnectionError(lastError)) { + logger.log(`SSE connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting reconnect before retry.`); + const clientTransportConfig = currentActiveServersConfig[clientForTool.name]; + if (!clientTransportConfig) { + logger.error(`Cannot retry SSE: TransportConfig for server '${clientForTool.name}' not found.`); + // If config is missing, we can't reconnect, so break retry loop + break; + } + const refreshed = await refreshBackendConnection(clientForTool.name, clientTransportConfig); + if (refreshed) { + logger.log(`Successfully reconnected to server '${clientForTool.name}' via SSE.`); + // Update clientForTool and toolInfo references after refresh + const newMapEntry = toolToClientMap.get(originalQualifiedName); + if (!newMapEntry) { + logger.error(`Tool '${originalQualifiedName}' not found in map after successful SSE refresh for server '${clientForTool.name}'.`); + // If tool disappears after refresh, something is wrong, break retry loop + break; + } + clientForTool = newMapEntry.client; + toolInfo = newMapEntry.toolInfo; + } else { + logger.error(`SSE Reconnection to server '${clientForTool.name}' failed.`); + // If reconnect fails, break retry loop + break; + } } - } } - const errorMessage = `Error calling STDIO tool '${requestedExposedName}' after ${maxRetries} retries (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${lastError.message || 'An unknown error occurred'}`; - logger.error(errorMessage, lastError); - throw new Error(errorMessage); - } - // HTTP Retry Logic - else if (clientForTool.transportType === 'http' && - (currentProxyConfig.retryHttpToolCall !== false) && // Retry enabled by default, access directly - isConnectionError(error)) { - - // Access properties directly. Defaults are assured by currentProxyConfig's initialization. - const maxRetries = currentProxyConfig.httpToolCallMaxRetries; - const retryDelayBaseMs = currentProxyConfig.httpToolCallRetryDelayBaseMs; - let lastError: any = error; - - logger.log(`HTTP connection error for tool '${requestedExposedName}' on server '${clientForTool.name}'. Attempting up to ${maxRetries} retries.`); - - for (let attempt = 0; attempt < maxRetries; attempt++) { - try { - const delay = retryDelayBaseMs * Math.pow(2, attempt) + (Math.random() * retryDelayBaseMs * 0.5); - logger.log(`HTTP tool call failed for '${requestedExposedName}'. Attempt ${attempt + 1}/${maxRetries}. Retrying in ${delay.toFixed(0)}ms...`); - await sleep(delay); - - logger.log(`Retrying tool call (HTTP) for '${requestedExposedName}' to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 2})`); - return await clientForTool.client.request( - { method: 'tools/call', params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } }, - CompatibilityCallToolResultSchema + try { + logger.log(`Forwarding tool call for exposed name '${requestedExposedName}' (original qualified name: '${originalQualifiedName}'). Forwarding to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 1})`); + // Explicitly set a timeout for the request using SDK's RequestOptions + const backendResponse = await clientForTool.client.request( + { + method: 'tools/call', + params: { name: originalToolNameForBackend, arguments: args || {}, _meta: { progressToken: request.params._meta?.progressToken } } + }, + CompatibilityCallToolResultSchema, + { timeout: DEFAULT_REQUEST_TIMEOUT_MSEC } // Set timeout explicitly ); - } catch (retryError: any) { - lastError = retryError; - logger.error(`HTTP tool call retry attempt ${attempt + 1}/${maxRetries} for '${requestedExposedName}' failed:`, retryError.message); - if (attempt === maxRetries - 1) { - break; + logger.log(`[Tool Call] Backend response received for '${requestedExposedName}'. Passing to SDK Server.`); + return backendResponse; // Success! Return the response. + } catch (error: any) { + lastError = error; + logger.warn(`Attempt ${attempt + 1} to call tool '${requestedExposedName}' failed: ${error.message}`); + + // Check if this error warrants a retry based on type and configuration + const isRetryableError = isConnectionError(error) || (error?.name === 'McpError' && error?.code === -32001); // Consider timeout as retryable + const shouldRetry = (clientForTool.transportType === 'sse' && currentProxyConfig.retrySseToolCall && isRetryableError) || // Check retrySseToolCall + (clientForTool.transportType === 'stdio' && currentProxyConfig.retryStdioToolCall && isRetryableError) || + (clientForTool.transportType === 'http' && currentProxyConfig.retryHttpToolCall && isRetryableError); + + + if (!shouldRetry && attempt === 0) { + // If it's the first attempt and not a retryable error type, re-throw immediately + logger.error(`Tool call for '${requestedExposedName}' failed with non-retryable error on first attempt: ${error.message}`, error); + throw error; } - } + + if (!shouldRetry && attempt > 0) { + // If it's a subsequent attempt and the error is no longer retryable (e.g., backend returned a specific error after reconnect) + logger.error(`Tool call for '${requestedExposedName}' failed with non-retryable error after retries: ${error.message}`, error); + throw error; + } + + // If it's a retryable error and we are within maxRetries, the loop continues. + // If it's a retryable error but we are at maxRetries, the loop will exit after this iteration. } - const errorMessage = `Error calling HTTP tool '${requestedExposedName}' after ${maxRetries} retries (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${lastError.message || 'An unknown error occurred'}`; - logger.error(errorMessage, lastError); - throw new Error(errorMessage); - - } else { - let reason = "Unknown reason for no retry."; - const shouldRetryStdio = currentProxyConfig.retryStdioToolCall !== false; // Access directly - if (clientForTool.transportType === 'sse' && !shouldRetrySse) reason = "SSE retry disabled in config"; - else if (clientForTool.transportType === 'sse' && !isConnectionError(error)) reason = "Error not a connection error for SSE"; - else if (clientForTool.transportType === 'stdio' && !shouldRetryStdio) reason = "STDIO retry disabled in config"; // Check stdio retry flag - else if (clientForTool.transportType === 'stdio' && !isConnectionError(error)) reason = "Error not a connection error for STDIO"; // Check stdio connection error - else if (clientForTool.transportType === 'http' && (currentProxyConfig.retryHttpToolCall === false)) reason = "HTTP retry disabled in config"; // Access directly - else if (clientForTool.transportType === 'http' && !isConnectionError(error)) reason = "Error not a connection error for HTTP"; - else if (clientForTool.transportType !== 'sse' && clientForTool.transportType !== 'http' && clientForTool.transportType !== 'stdio') reason = `Unsupported transport type for retry: ${clientForTool.transportType}`; // Add stdio to check - - logger.warn(`Not retrying tool call for '${requestedExposedName}'. Reason: ${reason}. Original error: ${error.message}`); - const errorMessage = `Error calling tool '${requestedExposedName}' (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${error.message || 'An unknown error occurred'}`; - logger.error(errorMessage, error); - throw new Error(errorMessage); - } } - }); + + // If the loop finishes without returning, it means all retries failed. + const errorMessage = `Error calling tool '${requestedExposedName}' after ${maxRetries} retries (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${lastError?.message || 'An unknown error occurred'}`; + logger.error(errorMessage, lastError); + throw new Error(errorMessage); +}); + +// ... rest of the file ... server.setRequestHandler(GetPromptRequestSchema, async (request) => { const { name } = request.params; From d2d7d7d3f45ace69523c3ddff7412f7da0c94c0d Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Fri, 27 Jun 2025 23:52:07 +0800 Subject: [PATCH 16/19] feat: Make server-tool name separator configurable SERVER_TOOLNAME_SEPERATOR --- README.md | 8 + README_ZH.md | 8 + public/tools.js | 19 +- src/config.ts | 494 +++++++++++++++++++++++++---------------------- src/mcp-proxy.ts | 13 +- src/sse.ts | 16 +- 6 files changed, 311 insertions(+), 247 deletions(-) diff --git a/README.md b/README.md index 7394e44..a24b688 100644 --- a/README.md +++ b/README.md @@ -174,6 +174,14 @@ Example `config/tool_config.json`: export TOOLS_FOLDER=/srv/mcp_tools ``` +- **`SERVER_TOOLNAME_SEPERATOR`**: (Optional) Defines the separator used to combine the server name and tool name when generating the unique key for tools (e.g., `server-key--tool-name`). This key is used internally and in the `tool_config.json` file. + - Default: `--`. + - Must be at least 2 characters long and contain only letters (a-z, A-Z), numbers (0-9), hyphens (`-`), and underscores (`_`). + - If the provided value is invalid, the default (`--`) will be used, and a warning will be logged. + ```bash + export SERVER_TOOLNAME_SEPERATOR="___" # Example: using triple underscore + ``` + - **`LOGGING`**: (Optional) Controls the minimum log level output by the server. - Possible values (case-insensitive): `error`, `warn`, `info`, `debug`. - Logs at the specified level and all levels above it will be shown. diff --git a/README_ZH.md b/README_ZH.md index ee66d89..def7611 100644 --- a/README_ZH.md +++ b/README_ZH.md @@ -175,6 +175,14 @@ export TOOLS_FOLDER=/srv/mcp_tools ``` +- **`SERVER_TOOLNAME_SEPERATOR`**: (可选) 定义用于组合服务器名称和工具名称以生成工具唯一键的分隔符（例如 `server-key--tool-name`）。此键在内部和 `tool_config.json` 文件中使用。 + - 默认值：`--`。 + - 必须至少包含 2 个字符，且只能包含字母（a-z, A-Z）、数字（0-9）、连字符（`-`）和下划线（`_`）。 + - 如果提供的值无效，将使用默认值（`--`）并记录警告。 + ```bash + export SERVER_TOOLNAME_SEPERATOR="___" # 示例：使用三个下划线 + ``` + - **`LOGGING`**: (可选) 控制服务器输出的最低日志级别。 - 可能的值（不区分大小写）：`error`, `warn`, `info`, `debug`。 - 将显示指定级别及以上的所有日志。 diff --git a/public/tools.js b/public/tools.js index b365b4a..8a75c55 100644 --- a/public/tools.js +++ b/public/tools.js @@ -4,6 +4,7 @@ const saveToolConfigButton = document.getElementById('save-tool-config-button'); // const saveToolStatus = document.getElementById('save-tool-status'); // Removed: Declared in script.js // Note: Assumes currentToolConfig and discoveredTools variables are globally accessible from script.js or passed. // Note: Assumes triggerReload function is globally accessible from script.js or passed. +let serverToolnameSeparator = '--'; // Default separator // --- Tool Configuration Management --- async function loadToolData() { @@ -11,14 +12,16 @@ async function loadToolData() { saveToolStatus.textContent = 'Loading tool data...'; window.toolDataLoaded = false; // Reset flag during load attempt (use global flag) try { - // Fetch both discovered tools and tool config concurrently - const [toolsResponse, configResponse] = await Promise.all([ + // Fetch discovered tools, tool config, and environment info concurrently + const [toolsResponse, configResponse, envResponse] = await Promise.all([ fetch('/admin/tools/list'), - fetch('/admin/tools/config') + fetch('/admin/tools/config'), + fetch('/admin/environment') // Fetch environment info ]); if (!toolsResponse.ok) throw new Error(`Failed to fetch discovered tools: ${toolsResponse.statusText}`); if (!configResponse.ok) throw new Error(`Failed to fetch tool config: ${configResponse.statusText}`); + if (!envResponse.ok) throw new Error(`Failed to fetch environment info: ${envResponse.statusText}`); // Check env response const toolsResult = await toolsResponse.json(); window.discoveredTools = toolsResult.tools || []; // Expecting { tools: [...] } (use global var) @@ -26,9 +29,12 @@ async function loadToolData() { window.currentToolConfig = await configResponse.json(); // Use global var if (!window.currentToolConfig || typeof window.currentToolConfig !== 'object' || !window.currentToolConfig.tools) { console.warn("Received invalid tool configuration format, initializing empty.", window.currentToolConfig); - window.currentToolConfig = { tools: {} }; // Initialize if invalid or empty + window.currentToolConfig = { tools: {} }; // Initialize if invalid or empty } + const envResult = await envResponse.json(); // Parse environment info + serverToolnameSeparator = envResult.serverToolnameSeparator || '--'; // Update separator + console.log(`Using server toolname separator from backend: "${serverToolnameSeparator}"`); renderTools(); // Render using both discovered and configured data window.toolDataLoaded = true; // Set global flag only after successful load and render @@ -66,7 +72,7 @@ function renderTools() { // Render discovered tools first, merging with config discoveredTools.forEach(tool => { - const toolKey = `${tool.serverName}--${tool.name}`; // Unique key + const toolKey = `${tool.serverName}${serverToolnameSeparator}${tool.name}`; // Use the fetched separator const config = currentToolConfig.tools[toolKey] || {}; // Get config or empty object // For discovered tools, their server is considered active by the proxy at connection time renderToolEntry(toolKey, tool, config, false, true); // isConfigOnly = false, isServerActive = true @@ -76,7 +82,8 @@ function renderTools() { // Render any remaining configured tools that were not discovered configuredToolKeys.forEach(toolKey => { const config = currentToolConfig.tools[toolKey]; - const serverKeyForConfigOnlyTool = toolKey.split('--')[0]; + // Use the fetched separator for splitting + const serverKeyForConfigOnlyTool = toolKey.split(serverToolnameSeparator)[0]; let isServerActiveForConfigOnlyTool = true; // Default to true if server config not found or active flag is missing/true if (window.currentServerConfig && window.currentServerConfig.mcpServers && window.currentServerConfig.mcpServers[serverKeyForConfigOnlyTool]) { diff --git a/src/config.ts b/src/config.ts index a0badae..680b911 100644 --- a/src/config.ts +++ b/src/config.ts @@ -47,9 +47,13 @@ export interface ProxySettings { stdioToolCallRetryDelayBaseMs?: number; } +export const DEFAULT_SERVER_TOOLNAME_SEPERATOR = '--'; +export const SERVER_TOOLNAME_SEPERATOR_ENV_VAR = 'SERVER_TOOLNAME_SEPERATOR'; + export interface Config { mcpServers: Record; proxy?: ProxySettings; + serverToolnameSeparator?: string; // Added for the separator } @@ -80,239 +84,263 @@ export function isHttpConfig(config: TransportConfig): config is TransportConfig export const loadConfig = async (): Promise => { // Define standard defaults for specific environment-overrideable proxy settings // This is moved here to be in scope for both try and catch blocks. - const defaultEnvProxySettings = { - retrySseToolCall: true, // Renamed from retrySseToolCallOnDisconnect - sseToolCallMaxRetries: 2, - sseToolCallRetryDelayBaseMs: 300, - retryHttpToolCall: true, - httpToolCallMaxRetries: 2, - httpToolCallRetryDelayBaseMs: 300, - retryStdioToolCall: true, - stdioToolCallMaxRetries: 2, - stdioToolCallRetryDelayBaseMs: 300, - }; - - try { - const configPath = resolve(process.cwd(), 'config', 'mcp_server.json'); - console.log(`Attempting to load configuration from: ${configPath}`); - const fileContents = await readFile(configPath, 'utf-8'); - const parsedConfig = JSON.parse(fileContents) as Config; - - if (typeof parsedConfig !== 'object' || parsedConfig === null || typeof parsedConfig.mcpServers !== 'object') { - throw new Error('Invalid config format: mcpServers object not found.'); - } - - // Initialize proxy object on parsedConfig if it doesn't exist - parsedConfig.proxy = parsedConfig.proxy || {}; - - // Override with environment variables or defaults for the specific settings - - // SSE Retry Settings - const sseRetryEnv = process.env.RETRY_SSE_TOOL_CALL; // Changed env var name - if (sseRetryEnv && sseRetryEnv.trim() !== '') { - parsedConfig.proxy.retrySseToolCall = sseRetryEnv.toLowerCase() === 'true'; // Changed property name - } else { - parsedConfig.proxy.retrySseToolCall = defaultEnvProxySettings.retrySseToolCall; // Changed property name - } - - const sseMaxRetriesEnv = process.env.SSE_TOOL_CALL_MAX_RETRIES; - if (sseMaxRetriesEnv && sseMaxRetriesEnv.trim() !== '') { - const numVal = parseInt(sseMaxRetriesEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.sseToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for SSE_TOOL_CALL_MAX_RETRIES: "${sseMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.sseToolCallMaxRetries}.`); - parsedConfig.proxy.sseToolCallMaxRetries = defaultEnvProxySettings.sseToolCallMaxRetries; - } - } else { - parsedConfig.proxy.sseToolCallMaxRetries = defaultEnvProxySettings.sseToolCallMaxRetries; - } - - const sseDelayBaseEnv = process.env.SSE_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (sseDelayBaseEnv && sseDelayBaseEnv.trim() !== '') { - const numVal = parseInt(sseDelayBaseEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.sseToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for SSE_TOOL_CALL_RETRY_DELAY_BASE_MS: "${sseDelayBaseEnv}". Using default: ${defaultEnvProxySettings.sseToolCallRetryDelayBaseMs}.`); - parsedConfig.proxy.sseToolCallRetryDelayBaseMs = defaultEnvProxySettings.sseToolCallRetryDelayBaseMs; - } - } else { - parsedConfig.proxy.sseToolCallRetryDelayBaseMs = defaultEnvProxySettings.sseToolCallRetryDelayBaseMs; - } - - - // HTTP Retry Settings - const httpRetryEnv = process.env.RETRY_HTTP_TOOL_CALL; - if (httpRetryEnv && httpRetryEnv.trim() !== '') { - parsedConfig.proxy.retryHttpToolCall = httpRetryEnv.toLowerCase() === 'true'; - } else { - parsedConfig.proxy.retryHttpToolCall = defaultEnvProxySettings.retryHttpToolCall; - } - - const maxRetriesEnv = process.env.HTTP_TOOL_CALL_MAX_RETRIES; - if (maxRetriesEnv && maxRetriesEnv.trim() !== '') { - const numVal = parseInt(maxRetriesEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.httpToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnv}". Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); - parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; - } - } else { - parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; - } - - const delayBaseEnv = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (delayBaseEnv && delayBaseEnv.trim() !== '') { - const numVal = parseInt(delayBaseEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.httpToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnv}". Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); - parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; - } - } else { - parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; - } - - // STDIO Retry Settings - const stdioRetryEnv = process.env.RETRY_STDIO_TOOL_CALL; - if (stdioRetryEnv && stdioRetryEnv.trim() !== '') { - parsedConfig.proxy.retryStdioToolCall = stdioRetryEnv.toLowerCase() === 'true'; - } else { - parsedConfig.proxy.retryStdioToolCall = defaultEnvProxySettings.retryStdioToolCall; - } - - const stdioMaxRetriesEnv = process.env.STDIO_TOOL_CALL_MAX_RETRIES; - if (stdioMaxRetriesEnv && stdioMaxRetriesEnv.trim() !== '') { - const numVal = parseInt(stdioMaxRetriesEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.stdioToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); - parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; - } - } else { - parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; - } - - const stdioDelayBaseEnv = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (stdioDelayBaseEnv && stdioDelayBaseEnv.trim() !== '') { - const numVal = parseInt(stdioDelayBaseEnv, 10); - if (!isNaN(numVal)) { - parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); - parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; - } - } else { - parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; - } - - logger.log("Loaded config with final proxy settings (after env overrides):", JSON.stringify(parsedConfig.proxy).slice(1, -1)); - return parsedConfig; - - } catch (error: any) { - logger.error(`Error loading config/mcp_server.json: ${error.message}`); - - // If file loading fails, initialize with environment variables or defaults for proxy settings - const proxySettingsFromEnvOrDefaults: ProxySettings = { - retrySseToolCall: defaultEnvProxySettings.retrySseToolCall, - sseToolCallMaxRetries: defaultEnvProxySettings.sseToolCallMaxRetries, // Default for SSE max retries - sseToolCallRetryDelayBaseMs: defaultEnvProxySettings.sseToolCallRetryDelayBaseMs, // Default for SSE retry delay - retryHttpToolCall: defaultEnvProxySettings.retryHttpToolCall, - httpToolCallMaxRetries: defaultEnvProxySettings.httpToolCallMaxRetries, - httpToolCallRetryDelayBaseMs: defaultEnvProxySettings.httpToolCallRetryDelayBaseMs, - retryStdioToolCall: defaultEnvProxySettings.retryStdioToolCall, - stdioToolCallMaxRetries: defaultEnvProxySettings.stdioToolCallMaxRetries, - stdioToolCallRetryDelayBaseMs: defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs, - }; - - // SSE Retry Settings (during error handling) - const sseRetryEnvCatch = process.env.RETRY_SSE_TOOL_CALL; // Changed env var name - if (sseRetryEnvCatch && sseRetryEnvCatch.trim() !== '') { - proxySettingsFromEnvOrDefaults.retrySseToolCall = sseRetryEnvCatch.toLowerCase() === 'true'; // Changed property name - } - - const sseMaxRetriesEnvCatch = process.env.SSE_TOOL_CALL_MAX_RETRIES; - if (sseMaxRetriesEnvCatch && sseMaxRetriesEnvCatch.trim() !== '') { - const numVal = parseInt(sseMaxRetriesEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.sseToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for SSE_TOOL_CALL_MAX_RETRIES: "${sseMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.sseToolCallMaxRetries}.`); - } - } - - const sseDelayBaseEnvCatch = process.env.SSE_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (sseDelayBaseEnvCatch && sseDelayBaseEnvCatch.trim() !== '') { - const numVal = parseInt(sseDelayBaseEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.sseToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for SSE_TOOL_CALL_RETRY_DELAY_BASE_MS: "${sseDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.sseToolCallRetryDelayBaseMs}.`); - } - } - - // HTTP Retry Settings (during error handling) - const httpRetryEnvCatch = process.env.RETRY_HTTP_TOOL_CALL; - if (httpRetryEnvCatch && httpRetryEnvCatch.trim() !== '') { - proxySettingsFromEnvOrDefaults.retryHttpToolCall = httpRetryEnvCatch.toLowerCase() === 'true'; - } - - const maxRetriesEnvCatch = process.env.HTTP_TOOL_CALL_MAX_RETRIES; - if (maxRetriesEnvCatch && maxRetriesEnvCatch.trim() !== '') { - const numVal = parseInt(maxRetriesEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.httpToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); - } - } - - const delayBaseEnvCatch = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (delayBaseEnvCatch && delayBaseEnvCatch.trim() !== '') { - const numVal = parseInt(delayBaseEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.httpToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); - } - } - - // STDIO Retry Settings (during error handling) - const stdioRetryEnvCatch = process.env.RETRY_STDIO_TOOL_CALL; - if (stdioRetryEnvCatch && stdioRetryEnvCatch.trim() !== '') { - proxySettingsFromEnvOrDefaults.retryStdioToolCall = stdioRetryEnvCatch.toLowerCase() === 'true'; - } - - const stdioMaxRetriesEnvCatch = process.env.STDIO_TOOL_CALL_MAX_RETRIES; - if (stdioMaxRetriesEnvCatch && stdioMaxRetriesEnvCatch.trim() !== '') { - const numVal = parseInt(stdioMaxRetriesEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.stdioToolCallMaxRetries = numVal; - } else { - logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); - } - } - - const stdioDelayBaseEnvCatch = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; - if (stdioDelayBaseEnvCatch && stdioDelayBaseEnvCatch.trim() !== '') { - const numVal = parseInt(stdioDelayBaseEnvCatch, 10); - if (!isNaN(numVal)) { - proxySettingsFromEnvOrDefaults.stdioToolCallRetryDelayBaseMs = numVal; - } else { - logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); - } - } - - logger.log("Using proxy settings from environment/defaults due to mcp_server.json load error:", proxySettingsFromEnvOrDefaults); - return { - mcpServers: {}, - proxy: proxySettingsFromEnvOrDefaults, - }; - } + const defaultEnvProxySettings = { + retrySseToolCall: true, // Renamed from retrySseToolCallOnDisconnect + sseToolCallMaxRetries: 2, + sseToolCallRetryDelayBaseMs: 300, + retryHttpToolCall: true, + httpToolCallMaxRetries: 2, + httpToolCallRetryDelayBaseMs: 300, + retryStdioToolCall: true, + stdioToolCallMaxRetries: 2, + stdioToolCallRetryDelayBaseMs: 300, + }; + + let serverToolnameSeparator = DEFAULT_SERVER_TOOLNAME_SEPERATOR; + const envSeparator = process.env[SERVER_TOOLNAME_SEPERATOR_ENV_VAR]; + const separatorRegex = /^[a-zA-Z0-9_-]+$/; // Regex for valid characters + + if (envSeparator !== undefined && envSeparator.trim() !== '') { + const trimmedSeparator = envSeparator.trim(); + if (trimmedSeparator.length >= 2 && separatorRegex.test(trimmedSeparator)) { + serverToolnameSeparator = trimmedSeparator; + logger.log(`Using server toolname separator from environment variable ${SERVER_TOOLNAME_SEPERATOR_ENV_VAR}: "${serverToolnameSeparator}"`); + } else { + logger.warn(`Invalid value for environment variable ${SERVER_TOOLNAME_SEPERATOR_ENV_VAR}: "${envSeparator}". Separator must be at least 2 characters long and contain only letters, numbers, '-', and '_'. Using default: "${DEFAULT_SERVER_TOOLNAME_SEPERATOR}".`); + serverToolnameSeparator = DEFAULT_SERVER_TOOLNAME_SEPERATOR; + } + } else { + logger.log(`Environment variable ${SERVER_TOOLNAME_SEPERATOR_ENV_VAR} not set or empty. Using default separator: "${DEFAULT_SERVER_TOOLNAME_SEPERATOR}".`); + serverToolnameSeparator = DEFAULT_SERVER_TOOLNAME_SEPERATOR; + } + + + try { + const configPath = resolve(process.cwd(), 'config', 'mcp_server.json'); + console.log(`Attempting to load configuration from: ${configPath}`); + const fileContents = await readFile(configPath, 'utf-8'); + const parsedConfig = JSON.parse(fileContents) as Config; + + if (typeof parsedConfig !== 'object' || parsedConfig === null || typeof parsedConfig.mcpServers !== 'object') { + throw new Error('Invalid config format: mcpServers object not found.'); + } + + // Initialize proxy object on parsedConfig if it doesn't exist + parsedConfig.proxy = parsedConfig.proxy || {}; + + // Override with environment variables or defaults for the specific settings + + // SSE Retry Settings + const sseRetryEnv = process.env.RETRY_SSE_TOOL_CALL; // Changed env var name + if (sseRetryEnv && sseRetryEnv.trim() !== '') { + parsedConfig.proxy.retrySseToolCall = sseRetryEnv.toLowerCase() === 'true'; // Changed property name + } else { + parsedConfig.proxy.retrySseToolCall = defaultEnvProxySettings.retrySseToolCall; // Changed property name + } + + const sseMaxRetriesEnv = process.env.SSE_TOOL_CALL_MAX_RETRIES; + if (sseMaxRetriesEnv && sseMaxRetriesEnv.trim() !== '') { + const numVal = parseInt(sseMaxRetriesEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.sseToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for SSE_TOOL_CALL_MAX_RETRIES: "${sseMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.sseToolCallMaxRetries}.`); + parsedConfig.proxy.sseToolCallMaxRetries = defaultEnvProxySettings.sseToolCallMaxRetries; + } + } else { + parsedConfig.proxy.sseToolCallMaxRetries = defaultEnvProxySettings.sseToolCallMaxRetries; + } + + const sseDelayBaseEnv = process.env.SSE_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (sseDelayBaseEnv && sseDelayBaseEnv.trim() !== '') { + const numVal = parseInt(sseDelayBaseEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.sseToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for SSE_TOOL_CALL_RETRY_DELAY_BASE_MS: "${sseDelayBaseEnv}". Using default: ${defaultEnvProxySettings.sseToolCallRetryDelayBaseMs}.`); + parsedConfig.proxy.sseToolCallRetryDelayBaseMs = defaultEnvProxySettings.sseToolCallRetryDelayBaseMs; + } + } else { + parsedConfig.proxy.sseToolCallRetryDelayBaseMs = defaultEnvProxySettings.sseToolCallRetryDelayBaseMs; + } + + + // HTTP Retry Settings + const httpRetryEnv = process.env.RETRY_HTTP_TOOL_CALL; + if (httpRetryEnv && httpRetryEnv.trim() !== '') { + parsedConfig.proxy.retryHttpToolCall = httpRetryEnv.toLowerCase() === 'true'; + } else { + parsedConfig.proxy.retryHttpToolCall = defaultEnvProxySettings.retryHttpToolCall; + } + + const maxRetriesEnv = process.env.HTTP_TOOL_CALL_MAX_RETRIES; + if (maxRetriesEnv && maxRetriesEnv.trim() !== '') { + const numVal = parseInt(maxRetriesEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.httpToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnv}". Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); + parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; + } + } else { + parsedConfig.proxy.httpToolCallMaxRetries = defaultEnvProxySettings.httpToolCallMaxRetries; + } + + const delayBaseEnv = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (delayBaseEnv && delayBaseEnv.trim() !== '') { + const numVal = parseInt(delayBaseEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.httpToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnv}". Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); + parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; + } + } else { + parsedConfig.proxy.httpToolCallRetryDelayBaseMs = defaultEnvProxySettings.httpToolCallRetryDelayBaseMs; + } + + // STDIO Retry Settings + const stdioRetryEnv = process.env.RETRY_STDIO_TOOL_CALL; + if (stdioRetryEnv && stdioRetryEnv.trim() !== '') { + parsedConfig.proxy.retryStdioToolCall = stdioRetryEnv.toLowerCase() === 'true'; + } else { + parsedConfig.proxy.retryStdioToolCall = defaultEnvProxySettings.retryStdioToolCall; + } + + const stdioMaxRetriesEnv = process.env.STDIO_TOOL_CALL_MAX_RETRIES; + if (stdioMaxRetriesEnv && stdioMaxRetriesEnv.trim() !== '') { + const numVal = parseInt(stdioMaxRetriesEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.stdioToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); + parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; + } + } else { + parsedConfig.proxy.stdioToolCallMaxRetries = defaultEnvProxySettings.stdioToolCallMaxRetries; + } + + const stdioDelayBaseEnv = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (stdioDelayBaseEnv && stdioDelayBaseEnv.trim() !== '') { + const numVal = parseInt(stdioDelayBaseEnv, 10); + if (!isNaN(numVal)) { + parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnv}". Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); + parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; + } + } else { + parsedConfig.proxy.stdioToolCallRetryDelayBaseMs = defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs; + } + + logger.log("Loaded config with final proxy settings (after env overrides):", JSON.stringify(parsedConfig.proxy).slice(1, -1)); + + // Add the determined separator to the config object + parsedConfig.serverToolnameSeparator = serverToolnameSeparator; + + return parsedConfig; + + } catch (error: any) { + logger.error(`Error loading config/mcp_server.json: ${error.message}`); + + // If file loading fails, initialize with environment variables or defaults for proxy settings + const proxySettingsFromEnvOrDefaults: ProxySettings = { + retrySseToolCall: defaultEnvProxySettings.retrySseToolCall, + sseToolCallMaxRetries: defaultEnvProxySettings.sseToolCallMaxRetries, // Default for SSE max retries + sseToolCallRetryDelayBaseMs: defaultEnvProxySettings.sseToolCallRetryDelayBaseMs, // Default for SSE retry delay + retryHttpToolCall: defaultEnvProxySettings.retryHttpToolCall, + httpToolCallMaxRetries: defaultEnvProxySettings.httpToolCallMaxRetries, + httpToolCallRetryDelayBaseMs: defaultEnvProxySettings.httpToolCallRetryDelayBaseMs, + retryStdioToolCall: defaultEnvProxySettings.retryStdioToolCall, + stdioToolCallMaxRetries: defaultEnvProxySettings.stdioToolCallMaxRetries, + stdioToolCallRetryDelayBaseMs: defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs, + }; + + // SSE Retry Settings (during error handling) + const sseRetryEnvCatch = process.env.RETRY_SSE_TOOL_CALL; // Changed env var name + if (sseRetryEnvCatch && sseRetryEnvCatch.trim() !== '') { + proxySettingsFromEnvOrDefaults.retrySseToolCall = sseRetryEnvCatch.toLowerCase() === 'true'; // Changed property name + } + + const sseMaxRetriesEnvCatch = process.env.SSE_TOOL_CALL_MAX_RETRIES; + if (sseMaxRetriesEnvCatch && sseMaxRetriesEnvCatch.trim() !== '') { + const numVal = parseInt(sseMaxRetriesEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.sseToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for SSE_TOOL_CALL_MAX_RETRIES: "${sseMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.sseToolCallMaxRetries}.`); + } + } + + const sseDelayBaseEnvCatch = process.env.SSE_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (sseDelayBaseEnvCatch && sseDelayBaseEnvCatch.trim() !== '') { + const numVal = parseInt(sseDelayBaseEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.sseToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for SSE_TOOL_CALL_RETRY_DELAY_BASE_MS: "${sseDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.sseToolCallRetryDelayBaseMs}.`); + } + } + + // HTTP Retry Settings (during error handling) + const httpRetryEnvCatch = process.env.RETRY_HTTP_TOOL_CALL; + if (httpRetryEnvCatch && httpRetryEnvCatch.trim() !== '') { + proxySettingsFromEnvOrDefaults.retryHttpToolCall = httpRetryEnvCatch.toLowerCase() === 'true'; + } + + const maxRetriesEnvCatch = process.env.HTTP_TOOL_CALL_MAX_RETRIES; + if (maxRetriesEnvCatch && maxRetriesEnvCatch.trim() !== '') { + const numVal = parseInt(maxRetriesEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.httpToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for HTTP_TOOL_CALL_MAX_RETRIES: "${maxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallMaxRetries}.`); + } + } + + const delayBaseEnvCatch = process.env.HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (delayBaseEnvCatch && delayBaseEnvCatch.trim() !== '') { + const numVal = parseInt(delayBaseEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.httpToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for HTTP_TOOL_CALL_RETRY_DELAY_BASE_MS: "${delayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.httpToolCallRetryDelayBaseMs}.`); + } + } + + // STDIO Retry Settings (during error handling) + const stdioRetryEnvCatch = process.env.RETRY_STDIO_TOOL_CALL; + if (stdioRetryEnvCatch && stdioRetryEnvCatch.trim() !== '') { + proxySettingsFromEnvOrDefaults.retryStdioToolCall = stdioRetryEnvCatch.toLowerCase() === 'true'; + } + + const stdioMaxRetriesEnvCatch = process.env.STDIO_TOOL_CALL_MAX_RETRIES; + if (stdioMaxRetriesEnvCatch && stdioMaxRetriesEnvCatch.trim() !== '') { + const numVal = parseInt(stdioMaxRetriesEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.stdioToolCallMaxRetries = numVal; + } else { + logger.warn(`Invalid value for STDIO_TOOL_CALL_MAX_RETRIES: "${stdioMaxRetriesEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallMaxRetries}.`); + } + } + + const stdioDelayBaseEnvCatch = process.env.STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS; + if (stdioDelayBaseEnvCatch && stdioDelayBaseEnvCatch.trim() !== '') { + const numVal = parseInt(stdioDelayBaseEnvCatch, 10); + if (!isNaN(numVal)) { + proxySettingsFromEnvOrDefaults.stdioToolCallRetryDelayBaseMs = numVal; + } else { + logger.warn(`Invalid value for STDIO_TOOL_CALL_RETRY_DELAY_BASE_MS: "${stdioDelayBaseEnvCatch}" (during error handling). Using default: ${defaultEnvProxySettings.stdioToolCallRetryDelayBaseMs}.`); + } + } + + logger.log("Using proxy settings from environment/defaults due to mcp_server.json load error:", proxySettingsFromEnvOrDefaults); + return { + mcpServers: {}, + proxy: proxySettingsFromEnvOrDefaults, + serverToolnameSeparator: serverToolnameSeparator, // Add the determined separator here too + }; + } }; diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index a2f85cf..b4535cd 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -20,7 +20,7 @@ import { } from "@modelcontextprotocol/sdk/types.js"; import { createClients, ConnectedClient, reconnectSingleClient } from './client.js'; import { logger } from './logger.js'; -import { Config, loadConfig, TransportConfig, isSSEConfig, isStdioConfig, isHttpConfig, ToolConfig, loadToolConfig } from './config.js'; +import { Config, loadConfig, TransportConfig, isSSEConfig, isStdioConfig, isHttpConfig, ToolConfig, loadToolConfig, DEFAULT_SERVER_TOOLNAME_SEPERATOR } from './config.js'; import { z } from 'zod'; import * as eventsource from 'eventsource'; @@ -34,6 +34,7 @@ const resourceToClientMap = new Map(); const promptToClientMap = new Map(); let currentToolConfig: ToolConfig = { tools: {} }; // Store loaded tool config let currentActiveServersConfig: Record = {}; // Added for retry logic +let currentSeparator: string = DEFAULT_SERVER_TOOLNAME_SEPERATOR; // Store the current separator // Define Global Default Proxy Settings const defaultProxySettingsFull: Required> = { @@ -58,6 +59,9 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC ...defaultProxySettingsFull, ...(newServerConfig.proxy || {}), }; + // Update the current separator from the new config + currentSeparator = newServerConfig.serverToolnameSeparator || DEFAULT_SERVER_TOOLNAME_SEPERATOR; + logger.log(`Using server toolname separator: "${currentSeparator}"`); const activeServersConfigLocal: Record = {}; // Renamed to avoid conflict with module-level for (const serverKey in newServerConfig.mcpServers) { @@ -124,7 +128,7 @@ export const updateBackendConnections = async (newServerConfig: Config, newToolC const result = await connectedClient.client.request({ method: 'tools/list', params: {} }, ListToolsResultSchema); if (result.tools && result.tools.length > 0) { for (const tool of result.tools) { - const qualifiedName = `${connectedClient.name}--${tool.name}`; // Changed separator to -- + const qualifiedName = `${connectedClient.name}${currentSeparator}${tool.name}`; // Use the current separator const toolSettings = currentToolConfig.tools[qualifiedName]; const isEnabled = !toolSettings || toolSettings.enabled !== false; if (isEnabled) { @@ -239,7 +243,7 @@ async function refreshBackendConnection(serverKey: string, serverConfig: Transpo const result = await connectedClient.client.request({ method: 'tools/list', params: {} }, ListToolsResultSchema); if (result.tools && result.tools.length > 0) { for (const tool of result.tools) { - const qualifiedName = `${connectedClient.name}--${tool.name}`; + const qualifiedName = `${connectedClient.name}${currentSeparator}${tool.name}`; // Use the current separator const toolSettings = currentToolConfig.tools[qualifiedName]; const isEnabled = !toolSettings || toolSettings.enabled !== false; if (isEnabled) { @@ -316,7 +320,8 @@ export const getCurrentProxyState = () => { }; }); // Could add resources and prompts here if needed by admin UI later - return { tools }; + // Also return the current separator for the frontend + return { tools, serverToolnameSeparator: currentSeparator }; }; // Helper function to identify connection errors diff --git a/src/sse.ts b/src/sse.ts index 6cefc94..22b7307 100644 --- a/src/sse.ts +++ b/src/sse.ts @@ -277,10 +277,18 @@ if (enableAdminUI) { }); // New endpoint to provide environment info like TOOLS_FOLDER to the frontend - app.get('/admin/environment', isAuthenticated, (req, res) => { - res.json({ - toolsFolder: process.env.TOOLS_FOLDER || "" - }); + app.get('/admin/environment', isAuthenticated, async (req, res) => { + try { + // Load config to get the current separator + const config = await loadConfig(); + res.json({ + toolsFolder: process.env.TOOLS_FOLDER || "", + serverToolnameSeparator: config.serverToolnameSeparator // Expose the separator + }); + } catch (error: any) { + logger.error("Error fetching environment info for admin UI:", error); + res.status(500).json({ error: "Failed to fetch environment information." }); + } }); From 72dfb3b4514f692d0a0b136e21b6e21acbb20fac Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Sat, 28 Jun 2025 00:07:21 +0800 Subject: [PATCH 17/19] feat!: Make server-tool name separator configurable The default separator for combining server names and tool names has been changed from '--' to '__'. This is a breaking change for users who relied on the hardcoded separator in tool_config.json or other integrations. The separator can now be configured using the SERVER_TOOLNAME_SEPERATOR environment variable. It must be at least 2 characters long and contain only letters, numbers, '-', and '_'. Invalid values will fall back to the default '__'. --- README.md | 12 ++++++------ README_ZH.md | 12 ++++++------ public/tools.js | 4 ++-- src/config.ts | 2 +- 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/README.md b/README.md index a24b688..548cf96 100644 --- a/README.md +++ b/README.md @@ -121,18 +121,18 @@ Example `config/tool_config.json`: ```json { "tools": { - "unique-server-key1--tool-name-from-server": { + "unique-server-key1__tool-name-from-server": { "enabled": true, "displayName": "My Custom Tool Name", "description": "A more user-friendly description." }, - "another-sse-server--another-tool": { + "another-sse-server__another-tool": { "enabled": false } } } ``` -- Keys are in the format `--`. +- Keys are in the format ``, where `` is the value of the `SERVER_TOOLNAME_SEPERATOR` environment variable (defaults to `__`). - `enabled`: (Optional, default: `true`) Set to `false` to hide this tool from clients connecting to the proxy. - `displayName`: (Optional) Override the tool's name in client UIs. - `description`: (Optional) Override the tool's description. @@ -174,10 +174,10 @@ Example `config/tool_config.json`: export TOOLS_FOLDER=/srv/mcp_tools ``` -- **`SERVER_TOOLNAME_SEPERATOR`**: (Optional) Defines the separator used to combine the server name and tool name when generating the unique key for tools (e.g., `server-key--tool-name`). This key is used internally and in the `tool_config.json` file. - - Default: `--`. +- **`SERVER_TOOLNAME_SEPERATOR`**: (Optional) Defines the separator used to combine the server name and tool name when generating the unique key for tools (e.g., `server-key__tool-name`). This key is used internally and in the `tool_config.json` file. + - Default: `__`. - Must be at least 2 characters long and contain only letters (a-z, A-Z), numbers (0-9), hyphens (`-`), and underscores (`_`). - - If the provided value is invalid, the default (`--`) will be used, and a warning will be logged. + - If the provided value is invalid, the default (`__`) will be used, and a warning will be logged. ```bash export SERVER_TOOLNAME_SEPERATOR="___" # Example: using triple underscore ``` diff --git a/README_ZH.md b/README_ZH.md index def7611..8f6aa7f 100644 --- a/README_ZH.md +++ b/README_ZH.md @@ -122,18 +122,18 @@ ```json { "tools": { - "unique-server-key1--tool-name-from-server": { + "unique-server-key1__tool-name-from-server": { "enabled": true, "displayName": "我的自定义工具名称", "description": "一个更友好的描述。" }, - "another-sse-server--another-tool": { + "another-sse-server__another-tool": { "enabled": false } } } ``` -- 键的格式为 `--`。 +- 键的格式为 ``，其中 `` 是 `SERVER_TOOLNAME_SEPERATOR` 环境变量的值（默认为 `__`）。 - `enabled`: (可选, 默认: `true`) 设置为 `false` 以向连接到代理的客户端隐藏此工具。 - `displayName`: (可选) 在客户端 UI 中覆盖工具的名称。 - `description`: (可选) 覆盖工具的描述。 @@ -175,10 +175,10 @@ export TOOLS_FOLDER=/srv/mcp_tools ``` -- **`SERVER_TOOLNAME_SEPERATOR`**: (可选) 定义用于组合服务器名称和工具名称以生成工具唯一键的分隔符（例如 `server-key--tool-name`）。此键在内部和 `tool_config.json` 文件中使用。 - - 默认值：`--`。 +- **`SERVER_TOOLNAME_SEPERATOR`**: (可选) 定义用于组合服务器名称和工具名称以生成工具唯一键的分隔符（例如 `server-key__tool-name`）。此键在内部和 `tool_config.json` 文件中使用。 + - 默认值：`__`。 - 必须至少包含 2 个字符，且只能包含字母（a-z, A-Z）、数字（0-9）、连字符（`-`）和下划线（`_`）。 - - 如果提供的值无效，将使用默认值（`--`）并记录警告。 + - 如果提供的值无效，将使用默认值（`__`）并记录警告。 ```bash export SERVER_TOOLNAME_SEPERATOR="___" # 示例：使用三个下划线 ``` diff --git a/public/tools.js b/public/tools.js index 8a75c55..dacbf3e 100644 --- a/public/tools.js +++ b/public/tools.js @@ -4,7 +4,7 @@ const saveToolConfigButton = document.getElementById('save-tool-config-button'); // const saveToolStatus = document.getElementById('save-tool-status'); // Removed: Declared in script.js // Note: Assumes currentToolConfig and discoveredTools variables are globally accessible from script.js or passed. // Note: Assumes triggerReload function is globally accessible from script.js or passed. -let serverToolnameSeparator = '--'; // Default separator +let serverToolnameSeparator = '__'; // Default separator // --- Tool Configuration Management --- async function loadToolData() { @@ -33,7 +33,7 @@ async function loadToolData() { } const envResult = await envResponse.json(); // Parse environment info - serverToolnameSeparator = envResult.serverToolnameSeparator || '--'; // Update separator + serverToolnameSeparator = envResult.serverToolnameSeparator || '__'; // Update separator console.log(`Using server toolname separator from backend: "${serverToolnameSeparator}"`); renderTools(); // Render using both discovered and configured data diff --git a/src/config.ts b/src/config.ts index 680b911..7ca223e 100644 --- a/src/config.ts +++ b/src/config.ts @@ -47,7 +47,7 @@ export interface ProxySettings { stdioToolCallRetryDelayBaseMs?: number; } -export const DEFAULT_SERVER_TOOLNAME_SEPERATOR = '--'; +export const DEFAULT_SERVER_TOOLNAME_SEPERATOR = '__'; // Changed default separator export const SERVER_TOOLNAME_SEPERATOR_ENV_VAR = 'SERVER_TOOLNAME_SEPERATOR'; export interface Config { From da4ba0213f0a89aaa298e7579895f631832f4ad7 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Sat, 28 Jun 2025 14:26:55 +0800 Subject: [PATCH 18/19] Fix: Ensure McpError is returned to client in all failure scenarios --- src/mcp-proxy.ts | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index b4535cd..1904b5b 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -16,7 +16,8 @@ import { ListResourceTemplatesResultSchema, ResourceTemplate, CompatibilityCallToolResultSchema, - GetPromptResultSchema + GetPromptResultSchema, + McpError } from "@modelcontextprotocol/sdk/types.js"; import { createClients, ConnectedClient, reconnectSingleClient } from './client.js'; import { logger } from './logger.js'; @@ -439,8 +440,9 @@ export const createServer = async () => { // If no entry was found after checking all enabled tools and their potential overrides if (!mapEntry || !originalQualifiedName) { - logger.error(`Attempted to call tool with exposed name "${requestedExposedName}", but no corresponding enabled tool or override configuration found.`); - throw new Error(`Unknown or disabled tool: ${requestedExposedName}`); + const errorMessage = `Attempted to call tool with exposed name "${requestedExposedName}", but no corresponding enabled tool or override configuration found.`; + logger.error(errorMessage); + throw new McpError(-32601, errorMessage); // Method not found error code } // Now we have the correct mapEntry and the originalQualifiedName @@ -488,11 +490,11 @@ export const createServer = async () => { toolInfo = newMapEntry.toolInfo; } else { logger.error(`SSE Reconnection to server '${clientForTool.name}' failed.`); - // If reconnect fails, break retry loop - break; + // If reconnect fails, throw an error to exit the retry loop and propagate + throw new McpError(-32000, `SSE Reconnection to server '${clientForTool.name}' failed for tool '${requestedExposedName}'.`); } - } - } + } + } try { logger.log(`Forwarding tool call for exposed name '${requestedExposedName}' (original qualified name: '${originalQualifiedName}'). Forwarding to server '${clientForTool.name}' as tool '${originalToolNameForBackend}' (Attempt ${attempt + 1})`); @@ -521,13 +523,23 @@ export const createServer = async () => { if (!shouldRetry && attempt === 0) { // If it's the first attempt and not a retryable error type, re-throw immediately logger.error(`Tool call for '${requestedExposedName}' failed with non-retryable error on first attempt: ${error.message}`, error); - throw error; + // If the error is already an McpError, re-throw it directly. Otherwise, wrap it. + if (error instanceof McpError) { + throw error; + } else { + throw new McpError(error?.code || -32000, error.message || 'An unknown error occurred', error?.data); + } } if (!shouldRetry && attempt > 0) { // If it's a subsequent attempt and the error is no longer retryable (e.g., backend returned a specific error after reconnect) logger.error(`Tool call for '${requestedExposedName}' failed with non-retryable error after retries: ${error.message}`, error); - throw error; + // If the error is already an McpError, re-throw it directly. Otherwise, wrap it. + if (error instanceof McpError) { + throw error; + } else { + throw new McpError(error?.code || -32000, error.message || 'An unknown error occurred', error?.data); + } } // If it's a retryable error and we are within maxRetries, the loop continues. @@ -538,7 +550,8 @@ export const createServer = async () => { // If the loop finishes without returning, it means all retries failed. const errorMessage = `Error calling tool '${requestedExposedName}' after ${maxRetries} retries (on backend server '${clientForTool.name}', original tool name '${originalToolNameForBackend}'): ${lastError?.message || 'An unknown error occurred'}`; logger.error(errorMessage, lastError); - throw new Error(errorMessage); + // Ensure a structured McpError is returned to the client + throw new McpError(lastError?.code || -32000, errorMessage, lastError?.data); }); // ... rest of the file ... From 89d80baf772ec9eb8a8ba6db5378f37adaead099 Mon Sep 17 00:00:00 2001 From: ptbsare <496725701@qq.com> Date: Sun, 29 Jun 2025 10:30:17 +0800 Subject: [PATCH 19/19] fix: 404 Error POSTING session not found as connection error retry sse --- src/mcp-proxy.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/mcp-proxy.ts b/src/mcp-proxy.ts index 1904b5b..e3abd6f 100644 --- a/src/mcp-proxy.ts +++ b/src/mcp-proxy.ts @@ -334,7 +334,8 @@ const isConnectionError = (err: any): boolean => { lowerMessage.includes("connection closed") || lowerMessage.includes("transport is closed") || // SDK specific lowerMessage.includes("failed to fetch") || - lowerMessage.includes("not found") || //404 + lowerMessage.includes("not found") || //Error POSTING session not found + lowerMessage.includes("404") || lowerMessage.includes("eof") || // Network level lowerMessage.includes("tls") || // TLS handshake lowerMessage.includes("timeout") ||