@modelcontextprotocol/inspector 2.7.0 → 2.8.0

package/clients/cli/build/index.js

@@ -1041,6 +1041,176 @@ function checkSkillNameCollisions(entries) {
   return issues;
 }
 
+// ../../core/json/localRefs.ts
+var SUBSCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
+  "items",
+  "contains",
+  "not",
+  "propertyNames",
+  "if",
+  "then",
+  "else",
+  "additionalProperties",
+  "unevaluatedProperties",
+  "additionalItems",
+  "unevaluatedItems",
+  "contentSchema"
+]);
+var SUBSCHEMA_ARRAY_KEYWORDS = /* @__PURE__ */ new Set([
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "prefixItems"
+]);
+var SUBSCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
+  "properties",
+  "patternProperties",
+  "dependentSchemas",
+  // Pre-2019 spelling of `dependentSchemas`; its array values are property
+  // name lists, which are not schemas and pass through untouched.
+  "dependencies",
+  "$defs",
+  "definitions"
+]);
+var NON_CONSTRAINT_SIBLINGS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "default",
+  "examples",
+  "deprecated",
+  "readOnly",
+  "writeOnly",
+  // Non-standard labels for `enum` values, read by both form builders.
+  "enumNames",
+  "$comment",
+  "$schema",
+  "$id",
+  "$defs",
+  "definitions"
+]);
+var EXPANSION_BUDGET = 1e4;
+var MAX_DEPTH = 64;
+var Bail = class extends Error {
+};
+function spend(traversal) {
+  traversal.remaining -= 1;
+  if (traversal.remaining < 0) throw new Bail();
+}
+function mapSubschemas(node, visit) {
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    let next = value;
+    if (SUBSCHEMA_KEYWORDS.has(key)) {
+      next = Array.isArray(value) ? value.map(visit) : visit(value);
+    } else if (SUBSCHEMA_ARRAY_KEYWORDS.has(key) && Array.isArray(value)) {
+      next = value.map(visit);
+    } else if (SUBSCHEMA_MAP_KEYWORDS.has(key) && isRecord(value)) {
+      next = mapNames(value, visit);
+    }
+    define(result, key, next);
+  }
+  return result;
+}
+function mapNames(map, visit) {
+  const result = {};
+  for (const [name, value] of Object.entries(map)) {
+    define(result, name, Array.isArray(value) ? value : visit(value));
+  }
+  return result;
+}
+function define(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolvePointer(root, ref) {
+  if (!ref.startsWith("#")) return void 0;
+  let pointer;
+  try {
+    pointer = decodeURIComponent(ref.slice(1));
+  } catch {
+    return void 0;
+  }
+  if (pointer === "") return root;
+  if (!pointer.startsWith("/")) return void 0;
+  let current = root;
+  for (const token of pointer.slice(1).split("/")) {
+    if (/~(?![01])/.test(token)) return void 0;
+    const segment = token.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      if (!/^(0|[1-9]\d*)$/.test(segment) || index >= current.length) {
+        return void 0;
+      }
+      current = current[index];
+    } else if (isRecord(current) && Object.hasOwn(current, segment)) {
+      current = current[segment];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function containsRef(node, depth) {
+  if (depth > MAX_DEPTH) throw new Bail();
+  if (!isRecord(node)) return false;
+  if (typeof node.$ref === "string") return true;
+  let found = false;
+  mapSubschemas(node, (child) => {
+    found ||= containsRef(child, depth + 1);
+    return child;
+  });
+  return found;
+}
+function inline(node, traversal, depth) {
+  if (depth > MAX_DEPTH) throw new Bail();
+  if (!isRecord(node)) return node;
+  if (node !== traversal.root && typeof node.$id === "string") return node;
+  spend(traversal);
+  const visit = (child) => inline(child, traversal, depth + 1);
+  const ref = node.$ref;
+  const siblingsConstrain = Object.keys(node).some(
+    (key) => key !== "$ref" && !NON_CONSTRAINT_SIBLINGS.has(key)
+  );
+  if (typeof ref === "string" && !siblingsConstrain && !traversal.active.has(ref)) {
+    const target = resolvePointer(traversal.root, ref);
+    if (isRecord(target)) {
+      traversal.active.add(ref);
+      const resolved2 = visit(target);
+      traversal.active.delete(ref);
+      const siblings = { ...node };
+      delete siblings.$ref;
+      return { ...resolved2, ...mapSubschemas(siblings, visit) };
+    }
+  }
+  return mapSubschemas(node, visit);
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function inlineLocalRefs(schema) {
+  if (!isRecord(schema)) return schema;
+  const cached = cache.get(schema);
+  if (cached !== void 0) return cached;
+  let resolved2;
+  try {
+    resolved2 = containsRef(schema, 0) ? inline(
+      schema,
+      { root: schema, active: /* @__PURE__ */ new Set(), remaining: EXPANSION_BUDGET },
+      0
+    ) : schema;
+  } catch (error) {
+    if (!(error instanceof Bail)) throw error;
+    resolved2 = schema;
+  }
+  cache.set(schema, resolved2);
+  return resolved2;
+}
+
 // ../../core/json/nullableUnion.ts
 var RENDERABLE_TYPES = [
   "string",
@@ -1639,7 +1809,7 @@ function convertToolParameters(tool, params) {
 function convertParametersForSchema(inputSchema, params) {
   const result = {};
   const { base, branches } = resolveRootUnion(
-    inputSchema ?? {}
+    inlineLocalRefs(inputSchema ?? {})
   );
   const properties = coercionProperties(base, branches, params);
   for (const [key, value] of Object.entries(params)) {
@@ -1831,7 +2001,7 @@ function oauthEndpointOverridesFromSettings(settings) {
   };
 }
 function storedFieldsToInspectorSettings(stored) {
-  const hasAny = stored.headers !== void 0 || stored.metadata !== void 0 || stored.connectionTimeout !== void 0 || stored.requestTimeout !== void 0 || stored.taskTtl !== void 0 || stored.autoRefreshOnListChanged !== void 0 || stored.paginatedLists !== void 0 || stored.advertisedExtensions !== void 0 || stored.maxFetchRequests !== void 0 || stored.skillCatalogMaxSkills !== void 0 || stored.skillCatalogMaxBytes !== void 0 || stored.oauth !== void 0 || stored.roots !== void 0 || stored.protocolEra !== void 0 || stored.modernLogLevel !== void 0 || stored.env !== void 0 || stored.cwd !== void 0;
+  const hasAny = stored.headers !== void 0 || stored.metadata !== void 0 || stored.connectionTimeout !== void 0 || stored.requestTimeout !== void 0 || stored.taskTtl !== void 0 || stored.autoRefreshOnListChanged !== void 0 || stored.paginatedLists !== void 0 || stored.suppressNotificationStream !== void 0 || stored.advertisedExtensions !== void 0 || stored.maxFetchRequests !== void 0 || stored.skillCatalogMaxSkills !== void 0 || stored.skillCatalogMaxBytes !== void 0 || stored.oauth !== void 0 || stored.roots !== void 0 || stored.protocolEra !== void 0 || stored.modernLogLevel !== void 0 || stored.env !== void 0 || stored.cwd !== void 0;
   if (!hasAny) return void 0;
   const headersPairs = stored.headers ? Object.entries(stored.headers).map(([key, value]) => ({ key, value })) : [];
   const settings = {
@@ -1863,6 +2033,9 @@ function storedFieldsToInspectorSettings(stored) {
   if (isSkillCatalogLimit(stored.skillCatalogMaxBytes)) {
     settings.skillCatalogMaxBytes = stored.skillCatalogMaxBytes;
   }
+  if (stored.suppressNotificationStream === true) {
+    settings.suppressNotificationStream = true;
+  }
   if (isProtocolEra(stored.protocolEra)) {
     settings.protocolEra = stored.protocolEra;
   }
@@ -1914,6 +2087,7 @@ var INSPECTOR_FIELD_KEY_MAP = {
   taskTtl: true,
   autoRefreshOnListChanged: true,
   paginatedLists: true,
+  suppressNotificationStream: true,
   advertisedExtensions: true,
   maxFetchRequests: true,
   skillCatalogMaxSkills: true,
@@ -2268,7 +2442,7 @@ function secretStorageCaveat(info) {
     return `The secrets file could not be read (${info.encryptionUnknown}). Saving a secret will fail rather than overwrite it.`;
   }
   if (info.plaintext) {
-    return info.pendingEncryption ? "Existing secrets in this file are still unencrypted (file mode 0600). They are re-encrypted the next time a secret is saved." : "Secrets are stored unencrypted (file mode 0600). Set MCP_INSPECTOR_SECRET_KEY to encrypt them.";
+    return info.pendingEncryption ? "Existing secrets in this file are still unencrypted (file mode 0600). They are re-encrypted the next time a secret is saved." : "Secrets are stored unencrypted (file mode 0600). Set MCP_INSPECTOR_SECRET_KEY or MCP_INSPECTOR_SECRET_KEY_FILE to encrypt them.";
   }
   return void 0;
 }
@@ -2283,6 +2457,7 @@ function secretStorageSummary(info) {
 
 // ../../core/auth/node/file-secret-store.ts
 import * as crypto2 from "crypto";
+import { readFileSync as readFileSync2, statSync as statSync2 } from "fs";
 import * as fs3 from "fs/promises";
 import * as path3 from "path";
 
@@ -2485,6 +2660,55 @@ var SCRYPT_N = 16384;
 var SCRYPT_R = 8;
 var SCRYPT_P = 1;
 var SECRET_KEY_ENV = "MCP_INSPECTOR_SECRET_KEY";
+var SECRET_KEY_FILE_ENV = "MCP_INSPECTOR_SECRET_KEY_FILE";
+function isSameFile(a, b) {
+  if (path3.resolve(a) === path3.resolve(b)) return true;
+  try {
+    const sa = statSync2(a);
+    const sb = statSync2(b);
+    return sa.dev === sb.dev && sa.ino === sb.ino;
+  } catch {
+    return false;
+  }
+}
+function resolveSecretPassphrase(env = process.env, secretFilePath) {
+  const direct = env[SECRET_KEY_ENV];
+  const hasDirect = direct !== void 0 && direct.trim() !== "";
+  const rawKeyFile = env[SECRET_KEY_FILE_ENV];
+  const wantsKeyFile = rawKeyFile !== void 0;
+  const keyFile = rawKeyFile?.trim();
+  if (hasDirect && wantsKeyFile) {
+    return {
+      problem: `both ${SECRET_KEY_ENV} and ${SECRET_KEY_FILE_ENV} are set; set only one`
+    };
+  }
+  if (hasDirect) return { passphrase: direct };
+  if (!wantsKeyFile) return {};
+  if (!keyFile) {
+    return { problem: `${SECRET_KEY_FILE_ENV} is set but empty` };
+  }
+  const resolved2 = path3.resolve(keyFile);
+  if (secretFilePath !== void 0 && isSameFile(resolved2, secretFilePath)) {
+    return {
+      problem: `${SECRET_KEY_FILE_ENV} (${resolved2}) is the secrets file itself; point it at a separate key file`
+    };
+  }
+  let contents;
+  try {
+    contents = readFileSync2(resolved2, "utf-8");
+  } catch (err) {
+    return {
+      // `String(err)` rather than `.message`: `readFileSync` only ever throws
+      // an `Error`, so an `instanceof` guard would be a branch no test can take.
+      problem: `${SECRET_KEY_FILE_ENV} (${resolved2}) could not be read: ${String(err)}`
+    };
+  }
+  const passphrase = contents.replace(/[\r\n]+$/, "");
+  if (passphrase.trim() === "") {
+    return { problem: `${SECRET_KEY_FILE_ENV} (${resolved2}) is empty` };
+  }
+  return { passphrase };
+}
 var buildAccount2 = (serverId, field) => `${serverId}:${field}`;
 function asSecretMap(value, filePath) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -2504,7 +2728,7 @@ function asSecretMap(value, filePath) {
 var SecretFileKeyMismatchError = class extends SecretStoreUnavailableError {
   constructor(filePath, hasKey) {
     super(
-      hasKey ? `The secrets file at ${filePath} could not be decrypted with the current ${SECRET_KEY_ENV}. Refusing to write, which would overwrite the existing secrets. Restore the original passphrase, or delete the file to start over.` : `The secrets file at ${filePath} is encrypted but ${SECRET_KEY_ENV} is not set. Refusing to write, which would overwrite the existing secrets. Set the passphrase this file was written with, or delete the file to start over.`
+      hasKey ? `The secrets file at ${filePath} could not be decrypted with the current ${SECRET_KEY_ENV} (or ${SECRET_KEY_FILE_ENV}). Refusing to write, which would overwrite the existing secrets. Restore the original passphrase, or delete the file to start over.` : `The secrets file at ${filePath} is encrypted but ${SECRET_KEY_ENV} is not set (nor ${SECRET_KEY_FILE_ENV}). Refusing to write, which would overwrite the existing secrets. Set the passphrase this file was written with, or delete the file to start over.`
     );
     this.name = "SecretFileKeyMismatchError";
   }
@@ -2562,10 +2786,17 @@ function encryptedEnvelopeProblem(parsed) {
 var FileSecretStore = class {
   filePath;
   passphrase;
+  /**
+   * Why a configured key could not be obtained. While set, every read throws
+   * and every write refuses — see {@link SecretPassphrase}.
+   */
+  keyProblem;
   constructor(options) {
     this.filePath = options.filePath;
-    const raw = options.passphrase ?? process.env[SECRET_KEY_ENV];
+    const resolved2 = options.passphrase !== void 0 ? { passphrase: options.passphrase } : resolveSecretPassphrase(process.env, this.filePath);
+    const raw = resolved2.passphrase;
     this.passphrase = raw && raw.trim() ? raw : void 0;
+    this.keyProblem = resolved2.problem;
   }
   /**
    * True when the *next write* will encrypt. This is the configured policy,
@@ -2580,7 +2811,8 @@ var FileSecretStore = class {
    * no file yet, or when it cannot be read or parsed.
    *
    * Separate from {@link encrypted} because the two genuinely disagree for a
-   * whole session: adding `MCP_INSPECTOR_SECRET_KEY` to an install that
+   * whole session: adding a passphrase (`MCP_INSPECTOR_SECRET_KEY` or
+   * `MCP_INSPECTOR_SECRET_KEY_FILE`) to an install that
    * already has a plaintext file flips `encrypted` to true immediately,
    * while the bytes stay readable until the next `set`. A descriptor built
    * from the policy would tell that user "File (encrypted)" while their
@@ -2604,6 +2836,9 @@ var FileSecretStore = class {
    * `set` is in fact about to refuse.
    */
   async readOnDiskEncryption() {
+    if (this.keyProblem !== void 0) {
+      return { state: "unreadable", detail: this.keyProblem };
+    }
     let raw;
     try {
       raw = await readStoreFile(this.filePath);
@@ -2641,7 +2876,7 @@ var FileSecretStore = class {
         } catch (err) {
           return {
             state: "unreadable",
-            detail: err instanceof SecretFileKeyMismatchError ? `it cannot be decrypted with the current ${SECRET_KEY_ENV}` : err instanceof Error ? err.message : String(err)
+            detail: err instanceof SecretFileKeyMismatchError ? `it cannot be decrypted with the current ${SECRET_KEY_ENV} (or ${SECRET_KEY_FILE_ENV})` : err instanceof Error ? err.message : String(err)
           };
         }
         return { state: "encrypted" };
@@ -2692,6 +2927,11 @@ var FileSecretStore = class {
     return this.serialize(() => this.readMap());
   }
   async readMap() {
+    if (this.keyProblem !== void 0) {
+      throw new SecretStoreUnavailableError(
+        `The secrets file at ${this.filePath} cannot be used: ${this.keyProblem}. Refusing to read or write it rather than store secrets unencrypted.`
+      );
+    }
     const raw = await readStoreFile(this.filePath);
     if (raw === null) return null;
     let parsed;
@@ -3047,6 +3287,7 @@ async function readSecretFilePermissions(filePath) {
 var SECRET_STORE_ENV = "MCP_INSPECTOR_SECRET_STORE";
 var SECRET_FILE_ENV = "MCP_INSPECTOR_SECRET_FILE";
 var STORAGE_DIR_ENV = "MCP_STORAGE_DIR";
+var SECRET_STORAGE_DOCS_URL = "https://github.com/modelcontextprotocol/inspector/blob/main/docs/secret-storage.md";
 var KINDS = ["keyring", "file", "memory"];
 function parseSecretStoreEnv(raw) {
   const value = raw?.trim().toLowerCase();
@@ -3189,6 +3430,11 @@ function warnAboutSecretStorage(info) {
   }
   const caveat = secretStorageCaveat(info);
   if (caveat) console.warn(`[mcp-inspector] ${caveat}`);
+  if (info.reason === "fallback" || caveat) {
+    console.warn(
+      `[mcp-inspector] How the secret store is chosen, and how to secure it: ${SECRET_STORAGE_DOCS_URL}`
+    );
+  }
 }
 var resolved;
 function resolveSecretStore() {
@@ -4351,6 +4597,73 @@ function createProxyFetch() {
   };
 }
 
+// ../../core/mcp/node/notificationHeadersFetch.ts
+import { PROTOCOL_VERSION_META_KEY } from "@modelcontextprotocol/client";
+function createNotificationHeadersFetch(baseFetch) {
+  return (input, init) => {
+    const method = modernNotificationMethod(init);
+    if (method === void 0) return baseFetch(input, init);
+    const headers = new Headers(init?.headers);
+    headers.set("mcp-protocol-version", method.version);
+    headers.set("mcp-method", method.method);
+    return baseFetch(input, { ...init, headers });
+  };
+}
+function modernNotificationMethod(init) {
+  if (init?.method?.toUpperCase() !== "POST") return void 0;
+  if (typeof init.body !== "string") return void 0;
+  let message;
+  try {
+    message = JSON.parse(init.body);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord2(message) || "id" in message) return void 0;
+  if (typeof message.method !== "string") return void 0;
+  const meta = isRecord2(message.params) ? message.params._meta : void 0;
+  const version = isRecord2(meta) ? meta[PROTOCOL_VERSION_META_KEY] : void 0;
+  if (typeof version !== "string" || version < MODERN_PROTOCOL_VERSION) {
+    return void 0;
+  }
+  return { method: message.method, version };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../../core/mcp/node/suppressNotificationStreamFetch.ts
+function createSuppressNotificationStreamFetch(baseFetch, endpoint) {
+  return async (input, init) => {
+    if (isStandaloneStreamRequest(input, init, endpoint)) {
+      return new Response(null, {
+        status: 405,
+        statusText: "Method Not Allowed"
+      });
+    }
+    return baseFetch(input, init);
+  };
+}
+function requestUrl(input) {
+  const raw = input instanceof Request ? input.url : input instanceof URL ? input.href : input;
+  try {
+    return new URL(raw);
+  } catch {
+    return void 0;
+  }
+}
+function isStandaloneStreamRequest(input, init, endpoint) {
+  const request = input instanceof Request ? input : void 0;
+  const method = (init?.method ?? request?.method ?? "GET").toUpperCase();
+  if (method !== "GET") return false;
+  const url = requestUrl(input);
+  if (!url || url.origin !== endpoint.origin || url.pathname !== endpoint.pathname || url.search !== endpoint.search) {
+    return false;
+  }
+  const headers = new Headers(init?.headers ?? request?.headers);
+  const accept = headers.get("accept")?.toLowerCase() ?? "";
+  return accept.includes("text/event-stream") && !headers.has("last-event-id");
+}
+
 // ../../core/mcp/node/transport.ts
 function headersFromSettings(settings) {
   if (!settings || settings.headers.length === 0) return void 0;
@@ -4438,10 +4751,14 @@ function createTransportNode(config, options = {}) {
       ...httpConfig.requestInit,
       ...headers && { headers }
     };
+    const stampedFetch = createNotificationHeadersFetch(
+      fetchWithOptionalAuthIntercept
+    );
+    const httpFetch = settings?.suppressNotificationStream === true ? createSuppressNotificationStreamFetch(stampedFetch, url) : stampedFetch;
     const transport = new StreamableHTTPClientTransport(url, {
       authProvider,
       requestInit,
-      fetch: fetchWithOptionalAuthIntercept,
+      fetch: httpFetch,
       // SEP-2350: how the transport reacts to a `403 insufficient_scope`
       // challenge. Defaults to the SDK's `reauthorize` when unset.
       ...settings?.oauthOnInsufficientScope && {
@@ -4981,7 +5298,7 @@ var OAuthMemoryStore = class {
 };
 
 // ../../core/auth/oauth-persist.ts
-function isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function snapshotFromPayload(payload) {
@@ -4995,10 +5312,10 @@ function parseOAuthPersistBlob(raw) {
     return null;
   }
   const parsed = typeof raw === "string" ? raw ? parseStore(raw) : null : raw;
-  if (!isRecord(parsed)) {
+  if (!isRecord3(parsed)) {
     return null;
   }
-  if (isRecord(parsed.state) && "version" in parsed) {
+  if (isRecord3(parsed.state) && "version" in parsed) {
     return snapshotFromPayload(parsed.state);
   }
   if ("servers" in parsed || "idpSessions" in parsed) {
@@ -5462,14 +5779,14 @@ var OBJECT_VALUED_SUBSCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
 function pathName(path5) {
   return path5.length === 0 ? "<root>" : path5.join(".");
 }
-function isRecord2(node) {
+function isRecord4(node) {
   return node !== null && typeof node === "object";
 }
 function scanXMcpHeaderDeclarations(inputSchema) {
   const declarations = [];
   const seenLower = /* @__PURE__ */ new Map();
   const visit = (node, path5, reachable) => {
-    if (!isRecord2(node)) return void 0;
+    if (!isRecord4(node)) return void 0;
     const schema = node;
     if (X_MCP_HEADER_KEY in schema) {
       if (!reachable || path5.length === 0) {
@@ -5495,7 +5812,7 @@ function scanXMcpHeaderDeclarations(inputSchema) {
       declarations.push({ path: path5, headerName: raw, type });
     }
     const properties = schema.properties;
-    if (isRecord2(properties)) {
+    if (isRecord4(properties)) {
       for (const [key, child] of Object.entries(properties)) {
         const fault2 = visit(child, [...path5, key], reachable);
         if (fault2 !== void 0) return fault2;
@@ -5504,7 +5821,7 @@ function scanXMcpHeaderDeclarations(inputSchema) {
     for (const k of NON_REACHABLE_SUBSCHEMA_KEYWORDS) {
       const sub = schema[k];
       if (sub === void 0) continue;
-      const branches = Array.isArray(sub) ? sub : isRecord2(sub) && OBJECT_VALUED_SUBSCHEMA_KEYWORDS.has(k) ? Object.values(sub) : [sub];
+      const branches = Array.isArray(sub) ? sub : isRecord4(sub) && OBJECT_VALUED_SUBSCHEMA_KEYWORDS.has(k) ? Object.values(sub) : [sub];
       for (const branch of branches) {
         const fault2 = visit(branch, [...path5, `<${k}>`], false);
         if (fault2 !== void 0) return fault2;
@@ -5736,7 +6053,7 @@ import {
   LOG_LEVEL_META_KEY,
   CLIENT_CAPABILITIES_META_KEY,
   CLIENT_INFO_META_KEY,
-  PROTOCOL_VERSION_META_KEY,
+  PROTOCOL_VERSION_META_KEY as PROTOCOL_VERSION_META_KEY2,
   RELATED_TASK_META_KEY as RELATED_TASK_META_KEY3
 } from "@modelcontextprotocol/client";
 
@@ -6942,7 +7259,7 @@ function withRfc8414OidcCompat(fetchFn) {
         return response;
       }
       if (!probe.ok) {
-        await releaseBody(probe);
+        releaseBodyDetached(probe);
         if (callerSignal?.aborted) {
           releaseBodyDetached(response);
           throw callerSignal.reason;
@@ -6966,7 +7283,7 @@ function withRfc8414OidcCompat(fetchFn) {
         return response;
       }
       const source = probe.url || candidate;
-      await releaseBody(response);
+      releaseBodyDetached(response);
       console.warn(
         `[oauth] ${source} returned RFC 8414 OAuth 2.0 authorization server metadata, not an OpenID provider document. The MCP TypeScript SDK validates that path as OpenID Connect Discovery and would reject it (modelcontextprotocol/typescript-sdk#2733), so the Inspector is handing it to discovery as the RFC 8414 document it is.`
       );
@@ -11521,7 +11838,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       ...params,
       _meta: {
         ...existingMeta,
-        [PROTOCOL_VERSION_META_KEY]: protocolVersion,
+        [PROTOCOL_VERSION_META_KEY2]: protocolVersion,
         [CLIENT_INFO_META_KEY]: this.clientInfo,
         [CLIENT_CAPABILITIES_META_KEY]: clientCapabilities
       }
@@ -14998,7 +15315,7 @@ var BOOLEAN_VALUED_KEYWORDS = /* @__PURE__ */ new Set([
   "additionalItems",
   "unevaluatedItems"
 ]);
-var SUBSCHEMA_KEYWORDS = [
+var SUBSCHEMA_KEYWORDS2 = [
   "items",
   "contains",
   "not",
@@ -15015,13 +15332,13 @@ var SUBSCHEMA_KEYWORDS = [
   // real finding.
   "contentSchema"
 ];
-var SUBSCHEMA_ARRAY_KEYWORDS = [
+var SUBSCHEMA_ARRAY_KEYWORDS2 = [
   "allOf",
   "anyOf",
   "oneOf",
   "prefixItems"
 ];
-var SUBSCHEMA_MAP_KEYWORDS = [
+var SUBSCHEMA_MAP_KEYWORDS2 = [
   "properties",
   "patternProperties",
   "dependentSchemas",
@@ -15103,8 +15420,8 @@ function isPortableTypeUnion(type) {
   }
   return new Set(type).size === type.length;
 }
-var MAX_DEPTH = 64;
-function isRecord3(value) {
+var MAX_DEPTH2 = 64;
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function childPath(parent, key) {
@@ -15120,7 +15437,7 @@ function describeSchemaPath(schema, path5) {
   return path5 === "" ? schema : `${schema}.${path5}`;
 }
 function declaresAnyId(node, depth = 0) {
-  if (depth > MAX_DEPTH || !isRecord3(node)) return false;
+  if (depth > MAX_DEPTH2 || !isRecord5(node)) return false;
   if (typeof node.$id === "string" && node.$id !== "") return true;
   let found = false;
   forEachSubschema(node, "", (child) => {
@@ -15139,21 +15456,21 @@ function add(ctx, rule, severity, path5, issue, suggestion) {
   });
 }
 function forEachSubschema(node, path5, visit) {
-  for (const key of SUBSCHEMA_MAP_KEYWORDS) {
+  for (const key of SUBSCHEMA_MAP_KEYWORDS2) {
     const map = node[key];
-    if (!isRecord3(map)) continue;
+    if (!isRecord5(map)) continue;
     for (const [name, sub] of Object.entries(map)) {
       visit(sub, childPath(childPath(path5, key), name), key);
     }
   }
-  for (const key of SUBSCHEMA_ARRAY_KEYWORDS) {
+  for (const key of SUBSCHEMA_ARRAY_KEYWORDS2) {
     const arr = node[key];
     if (!Array.isArray(arr)) continue;
     arr.forEach((sub, i) => {
       visit(sub, indexPath(childPath(path5, key), i), key);
     });
   }
-  for (const key of SUBSCHEMA_KEYWORDS) {
+  for (const key of SUBSCHEMA_KEYWORDS2) {
     if (!(key in node)) continue;
     const value = node[key];
     if (key === "items" && Array.isArray(value)) {
@@ -15172,7 +15489,7 @@ function booleanTrueSuggestion(keyword) {
   return 'Declare what the value actually is \u2014 e.g. `{"type": "object", "additionalProperties": true}` for a free-form object. That is a deliberate change of contract, not an equivalent rewrite: `true` accepts any JSON value at all.';
 }
 function walk(node, path5, keyword, depth, ctx) {
-  if (depth > MAX_DEPTH) return;
+  if (depth > MAX_DEPTH2) return;
   if (typeof node === "boolean") {
     if (keyword !== void 0 && BOOLEAN_VALUED_KEYWORDS.has(keyword)) return;
     add(
@@ -15191,12 +15508,13 @@ function walk(node, path5, keyword, depth, ctx) {
     );
     return;
   }
-  if (!isRecord3(node)) return;
+  if (!isRecord5(node)) return;
   lintNode(node, path5, keyword, ctx);
   forEachSubschema(node, path5, (child, childPathValue, childKeyword) => {
     walk(child, childPathValue, childKeyword, depth + 1, ctx);
   });
 }
+var NULL_BRANCH_CAVEAT = " A dialect with no `null` type, such as OpenAPI 3.0, still cannot express the `null` branch directly; there nullability is written `nullable: true`, which is not JSON Schema, so no single spelling is portable to both.";
 function lintNode(node, path5, keyword, ctx) {
   const type = node.type;
   if (Array.isArray(type) && isPortableTypeUnion(type)) {
@@ -15205,10 +15523,10 @@ function lintNode(node, path5, keyword, ctx) {
       "type-union",
       "warning",
       path5,
-      `\`type\` is an array (${JSON.stringify(type)}). The array form is legal JSON Schema, but several MCP clients read \`type\` as a single string and either reject the tool or drop the constraint.`,
+      `\`type\` is an array (${JSON.stringify(type)}). This is legal JSON Schema, and some model providers recommend it for nullable fields, but it is less portable: a client that maps tool schemas onto a single-\`type\` dialect (such as the OpenAPI subset used for Gemini function declarations) may reject the tool or drop the constraint.`,
       `Split it into \`anyOf\` branches, each with a single \`type\` \u2014 \`{"anyOf": [${type.map((t) => `{"type": "${t}"}`).join(
         ", "
-      )}]}\`. (Making the property optional instead is a different contract: absent is not the same as \`null\`.)`
+      )}]}\`. (Making the property optional instead is a different contract: absent is not the same as \`null\`.)${type.includes("null") ? NULL_BRANCH_CAVEAT : ""}`
     );
   }
   const ref = node.$ref;
@@ -17764,7 +18082,7 @@ async function withCliAuthRecoveryRetry(inspectorClient, serverConfig, redirectU
 import { LoggingLevelSchema } from "@modelcontextprotocol/core";
 
 // ../../core/node/version.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { dirname as dirname5, join as join3, parse } from "path";
 import { fileURLToPath } from "url";
 var ROOT_PACKAGE_NAME = "@modelcontextprotocol/inspector";
@@ -17776,7 +18094,7 @@ function readInspectorVersion(callerUrl) {
     let manifest;
     try {
       manifest = JSON.parse(
-        readFileSync3(join3(dir, "package.json"), "utf-8")
+        readFileSync4(join3(dir, "package.json"), "utf-8")
       );
     } catch {
     }