mcp-compress-router 1.5.1 → 1.5.2

package/build/services/auth-errors.js

@@ -20,3 +20,76 @@ export class GuidedAuthError extends Error {
         this.serverName = serverName;
     }
 }
+/**
+ * HTTP status codes that indicate an authentication or authorization
+ * failure at the transport layer. The MCP SDK's streamable HTTP
+ * transport surfaces the upstream response status as a numeric `code`
+ * property on the thrown error — e.g. 401 when the server rejects a
+ * request without driving the SDK's `redirectToAuthorization` flow.
+ */
+const AUTH_ERROR_STATUSES = new Set([401, 403]);
+/**
+ * Error message substrings that indicate a downstream OAuth /
+ * access-token failure rather than a network, transport, or tool-level
+ * error. These surface when a server rejects a request in the response
+ * body (e.g. with an OAuth error code) instead of returning a clean 401
+ * that would drive the SDK's `redirectToAuthorization` flow (which
+ * throws {@link GuidedAuthError} directly).
+ *
+ * Matching is case-insensitive to tolerate casing differences across
+ * SDK versions and server implementations.
+ */
+const AUTH_ERROR_PATTERNS = [
+    'invalid_token',
+    'invalid_grant',
+    'invalid_client',
+    'missing or invalid access token',
+];
+/**
+ * Reads the HTTP status code attached to an error, if any.
+ *
+ * The MCP SDK's `StreamableHTTPError` exposes the upstream HTTP status
+ * as a numeric `code` property. JSON-RPC error codes (e.g. `-32601`
+ * Method not found) are negative and never collide with HTTP status
+ * codes, so a positive value here is unambiguously an HTTP status.
+ * Duck-typed to avoid importing the SDK error class (mirrors the
+ * `isMethodNotFound` approach in `discovery.ts`).
+ *
+ * @param err - The thrown value from connect, reconnect, or invoke.
+ * @returns The HTTP status code, or `undefined` when none is present.
+ */
+function getHttpStatus(err) {
+    if (typeof err === 'object' && err !== null && 'code' in err) {
+        const code = err.code;
+        return typeof code === 'number' ? code : undefined;
+    }
+    return undefined;
+}
+/**
+ * Determines whether an error represents an authentication failure
+ * (missing, invalid, or expired OAuth credentials) rather than a
+ * network, transport, or tool-level error.
+ *
+ * Returns true for {@link GuidedAuthError} instances, for raw
+ * transport errors carrying an HTTP 401/403 status (read from the
+ * `code` property), and for errors whose message carries an OAuth
+ * error code such as `invalid_token` or `invalid_grant`. Without
+ * this, a server that rejects a request is misclassified as a generic
+ * connection failure, and the guided error tells the user to check
+ * their network instead of running `login`.
+ *
+ * @param err - The error thrown during connect, reconnect, or invoke.
+ * @returns True when the error indicates authentication is required.
+ */
+export function isAuthError(err) {
+    if (err instanceof GuidedAuthError) {
+        return true;
+    }
+    const status = getHttpStatus(err);
+    if (status !== undefined && AUTH_ERROR_STATUSES.has(status)) {
+        return true;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    const lower = message.toLowerCase();
+    return AUTH_ERROR_PATTERNS.some((pattern) => lower.includes(pattern));
+}

package/build/services/guided-error.js

@@ -95,8 +95,7 @@ function restartGuidance(isStdio) {
         : 'If the issue persists, restart the MCP server in your coding agent.';
     return (restartClause +
         ' If you have already fixed the issue, restart the MCP server in your ' +
-        'coding agent (e.g. restart Claude Code, opencode, or Codex) so it ' +
-        're-initializes the connection.');
+        'coding agent so it re-initializes the connection.');
 }
 function extractMessage(err) {
     if (err instanceof Error) {

package/build/services/index.js

@@ -9,5 +9,5 @@ export { saveToolCache } from './tool-cache.js';
 export { OAuthCredentialManager } from './oauth.js';
 export { computeAuthStatus, persistAuthRequirements } from './auth-status.js';
 export { discoverAuth } from './oauth-discovery.js';
-export { GuidedAuthError } from './auth-errors.js';
+export { GuidedAuthError, isAuthError } from './auth-errors.js';
 export { buildGuidedError } from './guided-error.js';

package/build/services/invoke-with-recovery.js

@@ -1,5 +1,5 @@
 import { updateServerInCatalog } from './catalog.js';
-import { buildGuidedError, GuidedAuthError } from './index.js';
+import { buildGuidedError, isAuthError } from './index.js';
 /**
  * Set of error message substrings that indicate a recoverable
  * network/transport failure (as opposed to a tool-level or protocol
@@ -30,7 +30,7 @@ const RECOVERABLE_PATTERNS = [
  * @returns True when a reconnect + retry might succeed.
  */
 export function isRecoverable(err) {
-    if (err instanceof GuidedAuthError) {
+    if (isAuthError(err)) {
         return true;
     }
     const message = err instanceof Error ? err.message : String(err);
@@ -154,7 +154,7 @@ async function invokeToolWithRetry(conn, tool, args, server, serverConfig, selec
                 // server is reachable, so 'unavailable' would be misleading —
                 // surface auth errors as 'authentication required', re-throw
                 // the rest as-is so the caller sees the real downstream error.
-                if (retryErr instanceof GuidedAuthError) {
+                if (isAuthError(retryErr)) {
                     throw buildGuidedError(serverConfig, retryErr, 'unauthorized', true);
                 }
                 throw retryErr;
@@ -162,7 +162,7 @@ async function invokeToolWithRetry(conn, tool, args, server, serverConfig, selec
             // Reconnect itself failed: the server is down or requires auth.
             // doReconnect has already transitioned the connection's status
             // + cooldown so subsequent calls back off.
-            const status = retryErr instanceof GuidedAuthError ? 'unauthorized' : 'unavailable';
+            const status = isAuthError(retryErr) ? 'unauthorized' : 'unavailable';
             throw buildGuidedError(serverConfig, retryErr, status, true);
         }
     }

package/build/services/server-connection.js

@@ -2,7 +2,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { createTransport, listToolsOrEmpty } from './discovery.js';
 import { OAuthCredentialManager } from './oauth.js';
 import { saveToolCache, loadToolCache } from './tool-cache.js';
-import { GuidedAuthError } from './index.js';
+import { isAuthError } from './index.js';
 /**
  * 30-second cooldown after a failed reconnect attempt. Subsequent
  * `invokeWithRecovery` calls within this window return the cached
@@ -122,7 +122,7 @@ export class ServerConnection {
                     cause: err,
                 });
             }
-            const status = err instanceof GuidedAuthError ? 'unauthorized' : 'unavailable';
+            const status = isAuthError(err) ? 'unauthorized' : 'unavailable';
             this._status = status;
             this.logger.warn(`Server "${this.server.name}" failed (${status}) — using ${cachedTools.length} cached tools`, { server: this.server.name, type: this.server.type, error: message, status });
             return {
@@ -202,7 +202,7 @@ export class ServerConnection {
             // backoff. Auth failures are classified as 'unauthorized' so
             // guided errors point at `login` instead of "connection failed".
             this._lastError = err instanceof Error ? err.message : String(err);
-            this._status = err instanceof GuidedAuthError ? 'unauthorized' : 'unavailable';
+            this._status = isAuthError(err) ? 'unauthorized' : 'unavailable';
             throw err;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-compress-router",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "Compress all connected MCP servers into a single router MCP to save tokens",
   "license": "MIT",
   "type": "module",