@gleanwork/mcp-server-tester 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/fixtures/mcp.d.ts

@@ -285,6 +285,9 @@ interface HostEvent {
     isError?: boolean;
     rawName?: string;
     id?: string;
+    durationMs?: number;
+    startedAt?: string;
+    completedAt?: string;
 }
 
 /**

package/dist/fixtures/mcp.js

@@ -1874,7 +1874,7 @@ var debugHttp = createDebug(`${NAMESPACE}:http`);
 
 // package.json
 var package_default = {
-  version: "2.0.0-beta.3"};
+  version: "2.0.0-beta.5"};
 var debug = createDebug("mcp-server-tester:oauth-flow");
 async function generatePKCE() {
   const codeVerifier = oauth.generateRandomCodeVerifier();
@@ -2038,8 +2038,55 @@ async function performClientCredentialsFlow(config) {
   };
 }
 
+// src/mcp/connectionDiagnostics.ts
+function classifyMCPConnectionFailure(error) {
+  if (typeof error !== "object" || error === null) return "connection_failed";
+  const details = error;
+  const status = details.response?.status ?? details.status ?? details.code;
+  if (typeof status === "number" && Number.isInteger(status) && status >= 400 && status <= 599) {
+    return `http_${status}`;
+  }
+  const message = error instanceof Error ? error.message : "";
+  const httpStatus = /\b(?:HTTP|status(?: code)?|code:)\s*[:=(]?\s*([45]\d{2})\b/i.exec(
+    message
+  )?.[1];
+  if (httpStatus) return `http_${httpStatus}`;
+  for (const code of ["ECONNRESET", "ECONNREFUSED", "ETIMEDOUT", "ENOTFOUND"]) {
+    if (details.code === code || message.toUpperCase().includes(code)) {
+      return code.toLowerCase();
+    }
+  }
+  if (/timed out|timeout/i.test(message)) return "timeout";
+  if (/network|socket hang up|fetch failed/i.test(message))
+    return "network_error";
+  return "connection_failed";
+}
+var MCPHttpConnectionError = class extends Error {
+  constructor(streamableError, sseError, retryable, retryAfterMs) {
+    const streamableHttpFailure = classifyMCPConnectionFailure(streamableError);
+    const sseFailure = classifyMCPConnectionFailure(sseError);
+    super(
+      `MCP connection failed: streamableHttp=${streamableHttpFailure}; sse=${sseFailure}`
+    );
+    this.retryable = retryable;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "MCPHttpConnectionError";
+    this.streamableHttpFailure = streamableHttpFailure;
+    this.sseFailure = sseFailure;
+  }
+  streamableHttpFailure;
+  sseFailure;
+};
+function formatMCPConnectionFailure(error) {
+  if (error instanceof MCPHttpConnectionError) {
+    return `MCP connection failed: streamableHttp=${error.streamableHttpFailure}; sse=${error.sseFailure}`;
+  }
+  return classifyMCPConnectionFailure(error);
+}
+
 // src/mcp/clientFactory.ts
 function getRetryAfterDelayMs(err) {
+  if (err instanceof MCPHttpConnectionError) return err.retryAfterMs;
   const response = err?.response;
   const retryAfter = response?.headers?.get?.("Retry-After");
   if (retryAfter) {
@@ -2058,6 +2105,7 @@ function isTransientNetworkError(err) {
   return msg.includes("econnreset") || msg.includes("econnrefused") || msg.includes("etimedout") || msg.includes("enotfound") || msg.includes("network") || msg.includes("socket hang up") || msg.includes("fetch failed");
 }
 function isRetryableError(err) {
+  if (err instanceof MCPHttpConnectionError) return err.retryable;
   return isTransientNetworkError(err) || isRateLimitError(err);
 }
 async function retryWithBackoff(fn, maxAttempts) {
@@ -2075,7 +2123,7 @@ async function retryWithBackoff(fn, maxAttempts) {
           attempt + 1,
           maxAttempts + 1,
           delayMs,
-          err.message
+          formatMCPConnectionFailure(err)
         );
         await new Promise((resolve) => setTimeout(resolve, delayMs));
       } else {
@@ -2232,15 +2280,24 @@ async function createMCPClientForConfig(config, options) {
       } catch (err) {
         debugHttp(
           "streamableHttp failed (%s), falling back to SSE",
-          err.message
+          formatMCPConnectionFailure(err)
         );
         debugClient("Streamable HTTP failed, falling back to SSE transport");
         debugHttp("Attempting transport: sse");
-        const sseTransport = new SSEClientTransport(url, {
-          requestInit,
-          ...options?.authProvider ? { authProvider: options.authProvider } : {}
-        });
-        await client.connect(sseTransport, connectOptions);
+        try {
+          const sseTransport = new SSEClientTransport(url, {
+            requestInit,
+            ...options?.authProvider ? { authProvider: options.authProvider } : {}
+          });
+          await client.connect(sseTransport, connectOptions);
+        } catch (sseError) {
+          throw new MCPHttpConnectionError(
+            err,
+            sseError,
+            isRetryableError(err) || isRetryableError(sseError),
+            getRetryAfterDelayMs(err) ?? getRetryAfterDelayMs(sseError)
+          );
+        }
         debugClient("Connected via SSE");
         debugHttp("Connection established via sse");
       }