@modelcontextprotocol/inspector 0.12.0 → 0.14.0

package/client/dist/assets/oauthUtils-DTcoXpSP.js

@@ -0,0 +1,33 @@
+const parseOAuthCallbackParams = (location) => {
+  const params = new URLSearchParams(location);
+  const code = params.get("code");
+  if (code) {
+    return { successful: true, code };
+  }
+  const error = params.get("error");
+  const error_description = params.get("error_description");
+  const error_uri = params.get("error_uri");
+  if (error) {
+    return { successful: false, error, error_description, error_uri };
+  }
+  return {
+    successful: false,
+    error: "invalid_request",
+    error_description: "Missing code or error in response",
+    error_uri: null
+  };
+};
+const generateOAuthErrorDescription = (params) => {
+  const error = params.error;
+  const errorDescription = params.error_description;
+  const errorUri = params.error_uri;
+  return [
+    `Error: ${error}.`,
+    errorDescription ? `Details: ${errorDescription}.` : "",
+    errorUri ? `More info: ${errorUri}.` : ""
+  ].filter(Boolean).join("\n");
+};
+export {
+  generateOAuthErrorDescription as g,
+  parseOAuthCallbackParams as p
+};

package/client/dist/index.html

@@ -5,8 +5,8 @@
     <link rel="icon" type="image/svg+xml" href="/mcp.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>MCP Inspector</title>
-    <script type="module" crossorigin src="/assets/index-CHwMp9hp.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-D5WIP3OH.css">
+    <script type="module" crossorigin src="/assets/index-CfNcvwpX.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-1IEtev7A.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelcontextprotocol/inspector",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Model Context Protocol inspector",
   "license": "MIT",
   "author": "Anthropic, PBC (https://anthropic.com)",
@@ -36,15 +36,17 @@
     "test-cli": "cd cli && npm run test",
     "prettier-fix": "prettier --write .",
     "prettier-check": "prettier --check .",
+    "lint": "prettier --check . && cd client && npm run lint",
     "prepare": "npm run build",
     "publish-all": "npm publish --workspaces --access public && npm publish --access public"
   },
   "dependencies": {
-    "@modelcontextprotocol/inspector-cli": "^0.12.0",
-    "@modelcontextprotocol/inspector-client": "^0.12.0",
-    "@modelcontextprotocol/inspector-server": "^0.12.0",
-    "@modelcontextprotocol/sdk": "^1.11.0",
+    "@modelcontextprotocol/inspector-cli": "^0.14.0",
+    "@modelcontextprotocol/inspector-client": "^0.14.0",
+    "@modelcontextprotocol/inspector-server": "^0.14.0",
+    "@modelcontextprotocol/sdk": "^1.12.1",
     "concurrently": "^9.0.1",
+    "open": "^10.1.0",
     "shell-quote": "^1.8.2",
     "spawn-rx": "^5.1.2",
     "ts-node": "^10.9.2",

package/server/build/index.js

@@ -28,13 +28,43 @@ const { values } = parseArgs({
         args: { type: "string", default: "" },
     },
 });
+// Function to get HTTP headers.
+// Supports only "sse" and "streamable-http" transport types.
+const getHttpHeaders = (req, transportType) => {
+    const headers = {
+        Accept: transportType === "sse"
+            ? "text/event-stream"
+            : "text/event-stream, application/json",
+    };
+    const defaultHeaders = transportType === "sse"
+        ? SSE_HEADERS_PASSTHROUGH
+        : STREAMABLE_HTTP_HEADERS_PASSTHROUGH;
+    for (const key of defaultHeaders) {
+        if (req.headers[key] === undefined) {
+            continue;
+        }
+        const value = req.headers[key];
+        headers[key] = Array.isArray(value) ? value[value.length - 1] : value;
+    }
+    // If the header "x-custom-auth-header" is present, use its value as the custom header name.
+    if (req.headers["x-custom-auth-header"] !== undefined) {
+        const customHeaderName = req.headers["x-custom-auth-header"];
+        const lowerCaseHeaderName = customHeaderName.toLowerCase();
+        if (req.headers[lowerCaseHeaderName] !== undefined) {
+            const value = req.headers[lowerCaseHeaderName];
+            headers[customHeaderName] = value;
+        }
+    }
+    return headers;
+};
 const app = express();
 app.use(cors());
 app.use((req, res, next) => {
     res.header("Access-Control-Expose-Headers", "mcp-session-id");
     next();
 });
-const webAppTransports = new Map(); // Transports by sessionId
+const webAppTransports = new Map(); // Web app transports by web app sessionId
+const serverTransports = new Map(); // Server Transports by web app sessionId
 const createTransport = async (req) => {
     const query = req.query;
     console.log("Query parameters:", query);
@@ -58,16 +88,7 @@ const createTransport = async (req) => {
     }
     else if (transportType === "sse") {
         const url = query.url;
-        const headers = {
-            Accept: "text/event-stream",
-        };
-        for (const key of SSE_HEADERS_PASSTHROUGH) {
-            if (req.headers[key] === undefined) {
-                continue;
-            }
-            const value = req.headers[key];
-            headers[key] = Array.isArray(value) ? value[value.length - 1] : value;
-        }
+        const headers = getHttpHeaders(req, transportType);
         console.log(`SSE transport: url=${url}, headers=${Object.keys(headers)}`);
         const transport = new SSEClientTransport(new URL(url), {
             eventSourceInit: {
@@ -82,16 +103,7 @@ const createTransport = async (req) => {
         return transport;
     }
     else if (transportType === "streamable-http") {
-        const headers = {
-            Accept: "text/event-stream, application/json",
-        };
-        for (const key of STREAMABLE_HTTP_HEADERS_PASSTHROUGH) {
-            if (req.headers[key] === undefined) {
-                continue;
-            }
-            const value = req.headers[key];
-            headers[key] = Array.isArray(value) ? value[value.length - 1] : value;
-        }
+        const headers = getHttpHeaders(req, transportType);
         const transport = new StreamableHTTPClientTransport(new URL(query.url), {
             requestInit: {
                 headers,
@@ -106,7 +118,6 @@ const createTransport = async (req) => {
         throw new Error("Invalid transport type specified");
     }
 };
-let backingServerTransport;
 app.get("/mcp", async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
     console.log(`Received GET message for sessionId ${sessionId}`);
@@ -128,12 +139,12 @@ app.get("/mcp", async (req, res) => {
 app.post("/mcp", async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
     console.log(`Received POST message for sessionId ${sessionId}`);
+    let serverTransport;
     if (!sessionId) {
         try {
             console.log("New streamable-http connection");
             try {
-                await backingServerTransport?.close();
-                backingServerTransport = await createTransport(req);
+                serverTransport = await createTransport(req);
             }
             catch (error) {
                 if (error instanceof SseError && error.code === 401) {
@@ -143,18 +154,19 @@ app.post("/mcp", async (req, res) => {
                 }
                 throw error;
             }
-            console.log("Connected MCP client to backing server transport");
+            console.log("Connected MCP client to server transport");
             const webAppTransport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: randomUUID,
                 onsessioninitialized: (sessionId) => {
                     webAppTransports.set(sessionId, webAppTransport);
+                    serverTransports.set(sessionId, serverTransport);
                     console.log("Created streamable web app transport " + sessionId);
                 },
             });
             await webAppTransport.start();
             mcpProxy({
                 transportToClient: webAppTransport,
-                transportToServer: backingServerTransport,
+                transportToServer: serverTransport,
             });
             await webAppTransport.handleRequest(req, res, req.body);
         }
@@ -179,12 +191,36 @@ app.post("/mcp", async (req, res) => {
         }
     }
 });
+app.delete("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    console.log(`Received DELETE message for sessionId ${sessionId}`);
+    let serverTransport;
+    if (sessionId) {
+        try {
+            serverTransport = serverTransports.get(sessionId);
+            if (!serverTransport) {
+                res.status(404).end("Transport not found for sessionId " + sessionId);
+            }
+            else {
+                await serverTransport.terminateSession();
+                webAppTransports.delete(sessionId);
+                serverTransports.delete(sessionId);
+                console.log(`Transports removed for sessionId ${sessionId}`);
+            }
+            res.status(200).end();
+        }
+        catch (error) {
+            console.error("Error in /mcp route:", error);
+            res.status(500).json(error);
+        }
+    }
+});
 app.get("/stdio", async (req, res) => {
     try {
         console.log("New connection");
+        let serverTransport;
         try {
-            await backingServerTransport?.close();
-            backingServerTransport = await createTransport(req);
+            serverTransport = await createTransport(req);
         }
         catch (error) {
             if (error instanceof SseError && error.code === 401) {
@@ -197,9 +233,10 @@ app.get("/stdio", async (req, res) => {
         console.log("Connected MCP client to backing server transport");
         const webAppTransport = new SSEServerTransport("/message", res);
         webAppTransports.set(webAppTransport.sessionId, webAppTransport);
-        console.log("Created web app transport");
+        serverTransports.set(webAppTransport.sessionId, serverTransport);
+        console.log("Created client/server transports");
         await webAppTransport.start();
-        backingServerTransport.stderr.on("data", (chunk) => {
+        serverTransport.stderr.on("data", (chunk) => {
             webAppTransport.send({
                 jsonrpc: "2.0",
                 method: "notifications/stderr",
@@ -210,7 +247,7 @@ app.get("/stdio", async (req, res) => {
         });
         mcpProxy({
             transportToClient: webAppTransport,
-            transportToServer: backingServerTransport,
+            transportToServer: serverTransport,
         });
         console.log("Set up MCP proxy");
     }
@@ -222,9 +259,9 @@ app.get("/stdio", async (req, res) => {
 app.get("/sse", async (req, res) => {
     try {
         console.log("New SSE connection. NOTE: The sse transport is deprecated and has been replaced by streamable-http");
+        let serverTransport;
         try {
-            await backingServerTransport?.close();
-            backingServerTransport = await createTransport(req);
+            serverTransport = await createTransport(req);
         }
         catch (error) {
             if (error instanceof SseError && error.code === 401) {
@@ -237,11 +274,13 @@ app.get("/sse", async (req, res) => {
         console.log("Connected MCP client to backing server transport");
         const webAppTransport = new SSEServerTransport("/message", res);
         webAppTransports.set(webAppTransport.sessionId, webAppTransport);
-        console.log("Created web app transport");
+        console.log("Created client transport");
+        serverTransports.set(webAppTransport.sessionId, serverTransport);
+        console.log("Created server transport");
         await webAppTransport.start();
         mcpProxy({
             transportToClient: webAppTransport,
-            transportToServer: backingServerTransport,
+            transportToServer: serverTransport,
         });
         console.log("Set up MCP proxy");
     }

package/server/build/mcpProxy.js

@@ -1,3 +1,4 @@
+import { isJSONRPCRequest } from "@modelcontextprotocol/sdk/types.js";
 function onClientError(error) {
     console.error("Error from inspector client:", error);
 }
@@ -8,7 +9,21 @@ export default function mcpProxy({ transportToClient, transportToServer, }) {
     let transportToClientClosed = false;
     let transportToServerClosed = false;
     transportToClient.onmessage = (message) => {
-        transportToServer.send(message).catch(onServerError);
+        transportToServer.send(message).catch((error) => {
+            // Send error response back to client if it was a request (has id) and connection is still open
+            if (isJSONRPCRequest(message) && !transportToClientClosed) {
+                const errorResponse = {
+                    jsonrpc: "2.0",
+                    id: message.id,
+                    error: {
+                        code: -32001,
+                        message: error.message,
+                        data: error,
+                    },
+                };
+                transportToClient.send(errorResponse).catch(onClientError);
+            }
+        });
     };
     transportToServer.onmessage = (message) => {
         transportToClient.send(message).catch(onClientError);