@modelcontextprotocol/inspector 2.2.0 → 2.3.0

package/clients/tui/build/index.js

@@ -233,6 +233,60 @@ function cleanRoots(roots) {
 function envRecordToPairs(env2) {
   return env2 ? Object.entries(env2).map(([key, value]) => ({ key, value })) : [];
 }
+function envPairsToRecord(pairs) {
+  const out = {};
+  for (const { key, value } of pairs) {
+    if (key.trim() === "") continue;
+    out[key] = value;
+  }
+  return out;
+}
+function cleanAuthorizationParams(params) {
+  if (params === void 0) return void 0;
+  if (typeof params !== "object" || params === null || Array.isArray(params)) {
+    console.warn(
+      "Ignoring `oauth.authorizationParams`: expected an object of string values, got",
+      Array.isArray(params) ? "array" : typeof params
+    );
+    return void 0;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (typeof value !== "string") {
+      console.warn(
+        `Dropping \`oauth.authorizationParams.${key}\`: expected a string value, got ${typeof value}.`
+      );
+      continue;
+    }
+    if (key.trim() === "") continue;
+    out[key] = value;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function oauthAuthorizationParamsFromSettings(settings) {
+  if (!settings.oauthAuthorizationParams) return void 0;
+  const record = envPairsToRecord(settings.oauthAuthorizationParams);
+  return Object.keys(record).length > 0 ? record : void 0;
+}
+function cleanEndpointOverride(value, field) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    console.warn(
+      `Ignoring \`oauth.${field}\`: expected a string, got ${typeof value}.`
+    );
+    return void 0;
+  }
+  return value.trim() || void 0;
+}
+function oauthEndpointOverridesFromSettings(settings) {
+  const authorizationUrl = settings.oauthAuthorizationUrl?.trim();
+  const tokenUrl = settings.oauthTokenUrl?.trim();
+  if (!authorizationUrl && !tokenUrl) return void 0;
+  return {
+    ...authorizationUrl && { authorizationUrl },
+    ...tokenUrl && { tokenUrl }
+  };
+}
 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.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;
@@ -270,6 +324,19 @@ function storedFieldsToInspectorSettings(stored) {
   if (stored.oauth?.clientSecret)
     settings.oauthClientSecret = stored.oauth.clientSecret;
   if (stored.oauth?.scopes) settings.oauthScopes = stored.oauth.scopes;
+  const authorizationParams = cleanAuthorizationParams(
+    stored.oauth?.authorizationParams
+  );
+  if (authorizationParams) {
+    settings.oauthAuthorizationParams = envRecordToPairs(authorizationParams);
+  }
+  const authorizationUrl = cleanEndpointOverride(
+    stored.oauth?.authorizationUrl,
+    "authorizationUrl"
+  );
+  if (authorizationUrl) settings.oauthAuthorizationUrl = authorizationUrl;
+  const tokenUrl = cleanEndpointOverride(stored.oauth?.tokenUrl, "tokenUrl");
+  if (tokenUrl) settings.oauthTokenUrl = tokenUrl;
   if (stored.oauth?.onInsufficientScope) {
     settings.oauthOnInsufficientScope = stored.oauth.onInsufficientScope;
   }
@@ -1369,7 +1436,7 @@ function withProxyDispatcher(baseFetch) {
   if (readProxyEnv() === void 0) return baseFetch;
   let dispatcherPromise;
   const getDispatcher = () => {
-    dispatcherPromise ??= import("./undici-HXPKCIY3.js").then(
+    dispatcherPromise ??= import("./undici-KNXAVD2F.js").then(
       ({ EnvHttpProxyAgent }) => new EnvHttpProxyAgent(),
       (cause) => {
         throw new Error(
@@ -1713,7 +1780,9 @@ function isOAuthCapableServerConfig(config) {
 function buildRunnerClientAuthOptions(clientConfig, savedSettings, cliOverrides) {
   const activeIdp = getActiveEnterpriseManagedAuthIdp(clientConfig);
   const activeCimdUrl = getActiveCimdClientMetadataUrl(clientConfig);
-  const oauthFromServer = savedSettings && (savedSettings.oauthClientId || savedSettings.oauthClientSecret || savedSettings.oauthScopes || savedSettings.enterpriseManaged) ? {
+  const serverAuthorizationParams = savedSettings ? oauthAuthorizationParamsFromSettings(savedSettings) : void 0;
+  const serverEndpointOverrides = savedSettings ? oauthEndpointOverridesFromSettings(savedSettings) : void 0;
+  const oauthFromServer = savedSettings && (savedSettings.oauthClientId || savedSettings.oauthClientSecret || savedSettings.oauthScopes || serverAuthorizationParams || serverEndpointOverrides || savedSettings.enterpriseManaged) ? {
     ...savedSettings.oauthClientId && {
       clientId: savedSettings.oauthClientId
     },
@@ -1723,6 +1792,10 @@ function buildRunnerClientAuthOptions(clientConfig, savedSettings, cliOverrides)
     ...savedSettings.oauthScopes && {
       scope: savedSettings.oauthScopes
     },
+    ...serverAuthorizationParams && {
+      authorizationParams: serverAuthorizationParams
+    },
+    ...serverEndpointOverrides,
     ...savedSettings.enterpriseManaged && {
       enterpriseManaged: true
     }
@@ -2220,7 +2293,10 @@ import {
   ListToolsResultSchema,
   ListResourcesResultSchema,
   ListResourceTemplatesResultSchema,
-  ListPromptsResultSchema
+  ListPromptsResultSchema,
+  ResourceSchema,
+  ResourceTemplateSchema,
+  PromptSchema
 } from "@modelcontextprotocol/core";
 import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
 
@@ -2240,16 +2316,367 @@ function validateToolOutput(provider, tool, result) {
   }
 }
 
+// ../../core/mcp/listSalvage.ts
+import { z as z3 } from "zod/v4";
+import { SdkError, SdkErrorCode } from "@modelcontextprotocol/client";
+import { ToolSchema } from "@modelcontextprotocol/core";
+var LIST_MAX_PAGES = 64;
+function listPaginationExceeded(method) {
+  return new Error(
+    `Salvage walk for ${method} exceeded ${LIST_MAX_PAGES} pages without the server's pagination converging`
+  );
+}
+function isClientDecodeRejection(err) {
+  return SdkError.isInstance(err) && (err.code === SdkErrorCode.InvalidResult || err.code === SdkErrorCode.UnsupportedResultType);
+}
+function isSalvageableRejection(err) {
+  return SdkError.isInstance(err) && err.code === SdkErrorCode.InvalidResult;
+}
+function lenientListPageSchema(resultSchema, itemsKey) {
+  return resultSchema.extend({ [itemsKey]: z3.array(z3.unknown()) });
+}
+function nextCursorOf(page) {
+  if (typeof page !== "object" || page === null) return void 0;
+  const value = page.nextCursor;
+  return typeof value === "string" ? value : void 0;
+}
+var ModernResultEnvelopeSchema = z3.looseObject({
+  resultType: z3.literal("complete"),
+  // A non-negative INTEGER, matching the codec: `ttlMs: -1` or `0.5` is an
+  // envelope violation the strict path rejects, and accepting it here on the
+  // strength of an unrelated bad entry would hide it.
+  ttlMs: z3.int().min(0),
+  cacheScope: z3.enum(["public", "private"])
+});
+function rawItemsOf(page, itemsKey) {
+  if (typeof page !== "object" || page === null) return void 0;
+  const value = page[itemsKey];
+  return Array.isArray(value) ? value : void 0;
+}
+function labelForRawItem(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  for (const key of ["name", "uriTemplate", "uri", "title"]) {
+    const candidate = record[key];
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return void 0;
+}
+function describeIssues(error) {
+  const [issue] = error.issues;
+  if (!issue) return "did not match the expected shape";
+  const path3 = issue.path.join(".");
+  const detail = expectedDetail(issue);
+  const message = detail ? `${issue.message} (${detail})` : issue.message;
+  return path3.length > 0 ? `${path3}: ${message}` : message;
+}
+function expectedDetail(issue) {
+  if (!("expected" in issue) || typeof issue.expected !== "string") {
+    return void 0;
+  }
+  const detail = `expected ${issue.expected}`;
+  return issue.message.includes(detail) ? void 0 : detail;
+}
+function salvageListItems({
+  method,
+  items,
+  schema,
+  startIndex = 0
+}) {
+  const valid = [];
+  const malformed = [];
+  items.forEach((item, offset) => {
+    const parsed = schema.safeParse(item);
+    if (parsed.success) {
+      valid.push(parsed.data);
+      return;
+    }
+    const label = labelForRawItem(item);
+    malformed.push({
+      method,
+      index: startIndex + offset,
+      ...label !== void 0 && { label },
+      reason: describeIssues(parsed.error)
+    });
+  });
+  return { valid, malformed };
+}
+function summarizeMalformed(malformed) {
+  const [first] = malformed;
+  if (!first) return "";
+  const where = first.label ?? `index ${first.index}`;
+  const rest = malformed.length > 1 ? ` (+${malformed.length - 1} more)` : "";
+  return `Dropped ${malformed.length} malformed ${malformed.length === 1 ? "entry" : "entries"} \u2014 ${where}: ${first.reason}${rest}`;
+}
+function toolItemSchemaForEra(isModern) {
+  return isModern ? eraToolItemSchema(ModernToolWireSchema, stripExecution) : eraToolItemSchema(LegacyToolWireSchema, (tool) => tool);
+}
+var LegacyToolWireSchema = ToolSchema.extend({
+  outputSchema: ToolSchema.shape.inputSchema.optional()
+});
+var ModernToolWireSchema = ToolSchema.extend({
+  inputSchema: z3.looseObject({
+    type: z3.literal("object"),
+    $schema: z3.string().optional()
+  })
+});
+function stripExecution(tool) {
+  if (tool.execution === void 0) return tool;
+  const { execution: _execution, ...rest } = tool;
+  return rest;
+}
+function eraToolItemSchema(wire, normalize) {
+  return wire.transform((parsed) => normalize(parsed));
+}
+
 // ../../core/mcp/taskNotificationSchemas.ts
 import { NotificationSchema } from "@modelcontextprotocol/core";
-import { z as z3 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 var TasksListChangedNotificationSchema = NotificationSchema.extend({
-  method: z3.literal("notifications/tasks/list_changed"),
-  params: z3.record(z3.string(), z3.unknown()).optional()
+  method: z4.literal("notifications/tasks/list_changed"),
+  params: z4.record(z4.string(), z4.unknown()).optional()
 });
 
-// ../../core/mcp/inspectorClient.ts
+// ../../core/mcp/uriTemplate.ts
 import { UriTemplate } from "@modelcontextprotocol/client";
+var OPERATORS = ["+", "#", ".", "/", ";", "?", "&"];
+var OMITTABLE_OPERATORS = /* @__PURE__ */ new Set(["#", ".", "/", ";", "?", "&"]);
+var NAMED_OPERATORS = /* @__PURE__ */ new Set([";", "?", "&"]);
+var VARCHAR = String.raw`(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})`;
+var TOLERATED_VARCHAR = String.raw`[-~]`;
+function varnameGrammar(varchar) {
+  return `${varchar}(?:\\.?${varchar})*`;
+}
+var MODIFIER = String.raw`(?:\*|:([1-9][0-9]{0,3}))?`;
+var CONFORMING_VARSPEC = new RegExp(
+  `^(${varnameGrammar(VARCHAR)})${MODIFIER}$`
+);
+var TOLERATED_VARSPEC = new RegExp(
+  `^(${varnameGrammar(`(?:${VARCHAR}|${TOLERATED_VARCHAR})`)})${MODIFIER}$`
+);
+function parseVarSpec(raw) {
+  const conforming = CONFORMING_VARSPEC.exec(raw);
+  const match = conforming ?? TOLERATED_VARSPEC.exec(raw);
+  if (match === null) return "invalid";
+  const [, name, maxLength] = match;
+  return {
+    name,
+    ...maxLength === void 0 ? {} : { maxLength: +maxLength },
+    ...conforming === null ? { conforming: false } : {}
+  };
+}
+function parseUriTemplate(uriTemplate) {
+  const parts = [];
+  let literal = "";
+  let i = 0;
+  while (i < uriTemplate.length) {
+    if (uriTemplate[i] !== "{") {
+      literal += uriTemplate[i];
+      i += 1;
+      continue;
+    }
+    const end = uriTemplate.indexOf("}", i);
+    if (end === -1) {
+      literal += uriTemplate.slice(i);
+      break;
+    }
+    if (literal) {
+      parts.push({ kind: "literal", text: literal });
+      literal = "";
+    }
+    const body = uriTemplate.slice(i + 1, end);
+    const operator = OPERATORS.find((op) => body.startsWith(op)) ?? "";
+    const parsed = body.slice(operator.length).split(",").map(parseVarSpec);
+    const varspecs = parsed.filter(
+      (spec) => spec !== "invalid"
+    );
+    parts.push({
+      kind: "expression",
+      source: uriTemplate.slice(i, end + 1),
+      operator,
+      varspecs,
+      names: varspecs.map((spec) => spec.name),
+      invalid: parsed.includes("invalid")
+    });
+    i = end + 1;
+  }
+  if (literal) parts.push({ kind: "literal", text: literal });
+  return parts;
+}
+function templateVariables(uriTemplate) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const part of parseUriTemplate(uriTemplate)) {
+    if (part.kind !== "expression") continue;
+    const required = !OMITTABLE_OPERATORS.has(part.operator);
+    for (const spec of part.varspecs) {
+      const { name } = spec;
+      const conforming = spec.conforming !== false;
+      const existing = byName.get(name);
+      if (existing) {
+        existing.required = existing.required || required;
+        existing.conforming = existing.conforming && conforming;
+      } else {
+        byName.set(name, {
+          name,
+          operator: part.operator,
+          required,
+          conforming
+        });
+      }
+    }
+  }
+  return [...byName.values()];
+}
+function requiredGroups(uriTemplate) {
+  const groups = [];
+  for (const part of parseUriTemplate(uriTemplate)) {
+    if (part.kind !== "expression") continue;
+    if (OMITTABLE_OPERATORS.has(part.operator)) continue;
+    if (part.names.length === 0) continue;
+    groups.push([...new Set(part.names)]);
+  }
+  return groups;
+}
+function unmetRequiredGroups(groups, values) {
+  return groups.filter(
+    (names) => !names.some((name) => (readValue(values, name) ?? "").length > 0)
+  );
+}
+function readValue(values, name) {
+  return Object.hasOwn(values, name) ? values[name] : void 0;
+}
+function definedValues(values) {
+  return Object.fromEntries(
+    Object.entries(values).filter(([, value]) => value.length > 0)
+  );
+}
+var ALLOW_RESERVED = /[^A-Za-z0-9\-._~:/?#[\]@!$&'()*+,;=]/gu;
+function encodeLiteral(text) {
+  return text.split(/([{}])/g).map(
+    (chunk, index) => index % 2 === 1 ? chunk : encodeAllowReserved(chunk)
+  ).join("");
+}
+function encodeAllowReserved(value) {
+  return value.split(/(%[0-9A-Fa-f]{2})/g).map(
+    (chunk, index) => index % 2 === 1 ? chunk : chunk.replace(ALLOW_RESERVED, (char) => encodeURIComponent(char))
+  ).join("");
+}
+var FORCE_ENCODED = {
+  "!": "%21",
+  "'": "%27",
+  "(": "%28",
+  ")": "%29",
+  "*": "%2A"
+};
+function encodeUnreserved(value) {
+  return encodeURIComponent(value).replace(
+    /[!'()*]/g,
+    (char) => FORCE_ENCODED[char]
+  );
+}
+function allowsReserved(operator) {
+  return operator === "+" || operator === "#";
+}
+function encodeValue(value, operator) {
+  return allowsReserved(operator) ? encodeAllowReserved(value) : encodeUnreserved(value);
+}
+var CONTINUATION = String.raw`%[89AB][0-9A-F]`;
+var UTF8_SEQUENCE = [
+  String.raw`(?:%F0%(?:9[0-9A-F]|[AB][0-9A-F])|%F[1-3]${CONTINUATION}|%F4%8[0-9A-F])${CONTINUATION}${CONTINUATION}`,
+  String.raw`(?:%E0%[AB][0-9A-F]|%E[1-9ABCEF]${CONTINUATION}|%ED%[89][0-9A-F])${CONTINUATION}`,
+  String.raw`%(?:C[2-9A-F]|D[0-9A-F])${CONTINUATION}`
+].join("|");
+var PREFIX_UNIT = new RegExp(`${UTF8_SEQUENCE}|%[0-9A-F]{2}|[\\s\\S]`, "giu");
+function prefixUnits(value) {
+  return value.match(PREFIX_UNIT) ?? [];
+}
+function renderValue(value, spec, operator) {
+  const truncated = spec.maxLength === void 0 ? value : prefixUnits(value).slice(0, spec.maxLength).join("");
+  return encodeValue(truncated, operator);
+}
+function expandTemplateExpression(part, values) {
+  const present = part.varspecs.flatMap((spec) => {
+    const value = readValue(values, spec.name);
+    return value === void 0 ? [] : [{ spec, value }];
+  });
+  if (present.length === 0) return "";
+  const { operator } = part;
+  if (NAMED_OPERATORS.has(operator)) {
+    const pairs = present.map(({ spec, value }) => {
+      const rendered2 = renderValue(value, spec, operator);
+      return operator === ";" && rendered2.length === 0 ? spec.name : `${spec.name}=${rendered2}`;
+    });
+    return operator === ";" ? `;${pairs.join(";")}` : `${operator}${pairs.join("&")}`;
+  }
+  const rendered = present.map(
+    ({ spec, value }) => renderValue(value, spec, operator)
+  );
+  switch (operator) {
+    case "#":
+      return `#${rendered.join(",")}`;
+    case ".":
+      return `.${rendered.join(".")}`;
+    case "/":
+      return `/${rendered.join("/")}`;
+    // "" and "+" — a bare comma-joined list, no prefix.
+    default:
+      return rendered.join(",");
+  }
+}
+function expandParts(parts, values) {
+  return parts.map(
+    (part) => part.kind === "literal" ? encodeLiteral(part.text) : expandTemplateExpression(part, values)
+  ).join("");
+}
+function expandUriTemplateStrict(uriTemplate, values) {
+  const sdk = sdkTemplateError(uriTemplate);
+  if (sdk) throw new Error(sdk);
+  const parts = parseUriTemplate(uriTemplate);
+  const invalid = partsError(uriTemplate, parts);
+  if (invalid) throw new Error(invalid);
+  const tooLong = valueLengthError(values, declaredNames(parts));
+  if (tooLong) throw new Error(tooLong);
+  return expandParts(parts, values);
+}
+function sdkTemplateError(uriTemplate) {
+  try {
+    new UriTemplate(uriTemplate);
+    return null;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+function partsError(uriTemplate, parts) {
+  const stray = parts.find(
+    (part) => part.kind === "literal" && /[{}]/.test(part.text)
+  );
+  if (stray) {
+    return `Unmatched brace in "${uriTemplate}" \u2014 an expression must be a complete {\u2026}.`;
+  }
+  const bad = parts.find((part) => part.kind === "expression" && part.invalid);
+  if (bad) {
+    return `Invalid RFC 6570 varspec in "${uriTemplate}": ${bad.kind === "expression" ? bad.source : ""} \u2014 each varspec must name a variable, optionally with an explode (*) or a 1-9999 prefix modifier.`;
+  }
+  return null;
+}
+var MAX_VALUE_LENGTH = 1e6;
+function valueLengthError(values, names) {
+  const considered = names === void 0 ? Object.keys(values) : [...new Set(names)];
+  for (const name of considered) {
+    const value = readValue(values, name);
+    if (value !== void 0 && value.length > MAX_VALUE_LENGTH) {
+      return `The value for "${name}" exceeds the ${MAX_VALUE_LENGTH}-character limit.`;
+    }
+  }
+  return null;
+}
+function declaredNames(parts) {
+  return [
+    ...new Set(
+      parts.flatMap((part) => part.kind === "expression" ? part.names : [])
+    )
+  ];
+}
 
 // ../../core/mcp/typedEventTarget.ts
 var TypedEventGeneric = class extends CustomEvent {
@@ -2516,6 +2943,136 @@ var ToolCallCancelledError = class extends Error {
   }
 };
 
+// ../../core/auth/endpointOverrides.ts
+var OVERRIDE_FIELDS = {
+  authorizationUrl: "authorization_endpoint",
+  tokenUrl: "token_endpoint"
+};
+function oauthEndpointUrlError(value) {
+  const trimmed = value.trim();
+  if (trimmed === "") return void 0;
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    return `"${trimmed}" is not an absolute URL.`;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return `"${trimmed}" is not an http(s) URL.`;
+  }
+  if (parsed.username || parsed.password) {
+    return "URL must not contain a username or password.";
+  }
+  return void 0;
+}
+function normalizeEndpointUrl(value, field) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (trimmed === "") return void 0;
+  const error = oauthEndpointUrlError(trimmed);
+  if (error) {
+    console.warn(`[oauth] Ignoring \`${field}\`: ${error}`);
+    return void 0;
+  }
+  return trimmed;
+}
+function normalizeOAuthEndpointOverrides(overrides) {
+  if (!overrides) return void 0;
+  const authorizationUrl = normalizeEndpointUrl(
+    overrides.authorizationUrl,
+    "authorizationUrl"
+  );
+  const tokenUrl = normalizeEndpointUrl(overrides.tokenUrl, "tokenUrl");
+  if (!authorizationUrl && !tokenUrl) return void 0;
+  return {
+    ...authorizationUrl && { authorizationUrl },
+    ...tokenUrl && { tokenUrl }
+  };
+}
+function isAuthorizationServerMetadata(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const doc = value;
+  if (typeof doc.issuer !== "string") return false;
+  return typeof doc.authorization_endpoint === "string" || typeof doc.token_endpoint === "string";
+}
+function applyOAuthEndpointOverrides(metadata, overrides) {
+  const patched = { ...metadata };
+  for (const [key, field] of Object.entries(OVERRIDE_FIELDS)) {
+    const override = overrides[key];
+    if (override) patched[field] = override;
+  }
+  return patched;
+}
+var AS_METADATA_WELL_KNOWN_PATHS = [
+  "/.well-known/oauth-authorization-server",
+  "/.well-known/openid-configuration"
+];
+function requestUrlOf(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+function isAuthorizationServerMetadataRequest(input) {
+  const raw = requestUrlOf(input);
+  let pathname;
+  try {
+    pathname = new URL(raw).pathname;
+  } catch {
+    pathname = raw;
+  }
+  return AS_METADATA_WELL_KNOWN_PATHS.some((path3) => pathname.includes(path3));
+}
+function isJsonDocumentResponse(contentType) {
+  if (!contentType) return false;
+  const mediaType = contentType.split(";")[0].trim().toLowerCase();
+  return mediaType === "application/json" || mediaType.endsWith("+json");
+}
+function responseWithBody(response, body) {
+  const headers = new Headers(response.headers);
+  headers.delete("content-length");
+  headers.delete("content-encoding");
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function withOAuthEndpointOverrides(fetchFn, getOverrides) {
+  let lastKey;
+  let lastNormalized;
+  const resolveOverrides = () => {
+    const raw = getOverrides();
+    const key = JSON.stringify([raw?.authorizationUrl, raw?.tokenUrl]);
+    if (key !== lastKey) {
+      lastKey = key;
+      lastNormalized = normalizeOAuthEndpointOverrides(raw);
+    }
+    return lastNormalized;
+  };
+  return async (input, init) => {
+    const response = await fetchFn(input, init);
+    const overrides = resolveOverrides();
+    if (!overrides) return response;
+    if (!isAuthorizationServerMetadataRequest(input)) return response;
+    if (!response.ok) return response;
+    if (!isJsonDocumentResponse(response.headers.get("content-type")))
+      return response;
+    let parsed;
+    try {
+      parsed = await response.clone().json();
+    } catch {
+      return response;
+    }
+    if (!isAuthorizationServerMetadata(parsed)) return response;
+    return responseWithBody(
+      response,
+      JSON.stringify(applyOAuthEndpointOverrides(parsed, overrides))
+    );
+  };
+}
+
 // ../../core/logging/logger.ts
 var noop = () => {
 };
@@ -2535,6 +3092,41 @@ function createSilentLogger() {
 }
 var silentLogger = createSilentLogger();
 
+// ../../core/auth/authorizationParams.ts
+var RESERVED_AUTHORIZATION_PARAMS = [
+  "client_id",
+  "code_challenge",
+  "code_challenge_method",
+  "redirect_uri",
+  "resource",
+  "response_type",
+  "scope",
+  "state"
+];
+var RESERVED = new Set(RESERVED_AUTHORIZATION_PARAMS);
+function isReservedAuthorizationParam(key) {
+  return RESERVED.has(key.trim().toLowerCase());
+}
+function applyAuthorizationParams(authorizationUrl, params) {
+  if (!params) return authorizationUrl;
+  const applicable = Object.entries(params).filter(([key]) => {
+    if (key.trim() === "") return false;
+    if (isReservedAuthorizationParam(key)) {
+      console.warn(
+        `[oauth] Ignoring reserved authorization parameter "${key.trim()}" \u2014 it is set by the authorization flow.`
+      );
+      return false;
+    }
+    return true;
+  });
+  if (applicable.length === 0) return authorizationUrl;
+  const merged = new URL(authorizationUrl.href);
+  for (const [key, value] of applicable) {
+    merged.searchParams.set(key.trim(), value);
+  }
+  return merged;
+}
+
 // ../../core/auth/providers.ts
 var MutableRedirectUrlProvider = class {
   redirectUrl = "";
@@ -2570,12 +3162,15 @@ var BaseOAuthClientProvider = class {
   redirectUrlProvider;
   navigation;
   clientMetadataUrl;
+  /** Custom authorization-request parameters (#2018). Authorize URL only. */
+  authorizationParams;
   constructor(serverUrl, oauthConfig) {
     this.serverUrl = serverUrl;
     this.storage = oauthConfig.storage;
     this.redirectUrlProvider = oauthConfig.redirectUrlProvider;
     this.navigation = oauthConfig.navigation;
     this.clientMetadataUrl = oauthConfig.clientMetadataUrl;
+    this.authorizationParams = oauthConfig.authorizationParams;
   }
   /**
    * Load persisted scope into {@link cachedScope} before SDK `auth()` (which
@@ -2682,6 +3277,27 @@ var BaseOAuthClientProvider = class {
     });
   }
   redirectToAuthorization(authorizationUrl) {
+    this.performAuthorizationRedirect(
+      applyAuthorizationParams(authorizationUrl, this.authorizationParams)
+    );
+  }
+  /**
+   * Redirect to an authorize URL belonging to a **different** authorization
+   * server than the one this provider was configured for, so the per-server
+   * custom parameters (#2018) MUST NOT be applied.
+   *
+   * The only caller is the enterprise-managed (EMA) transport provider, which
+   * discards the resource AS URL and sends the user to the enterprise IdP
+   * instead. Parameters a user configured for their MCP server's authorization
+   * server — a `kc_idp_hint`, an `audience` — are meaningless and potentially
+   * flow-breaking on the IdP's, and appending them there would leak per-server
+   * config across an authorization-server boundary.
+   */
+  redirectToExternalAuthorization(authorizationUrl) {
+    this.performAuthorizationRedirect(authorizationUrl);
+  }
+  /** Capture, announce, and navigate to a finished authorize URL. */
+  performAuthorizationRedirect(authorizationUrl) {
     this.capturedAuthUrl = authorizationUrl;
     if (!this.suppressAuthorizationNavigation) {
       if (this.eventTarget) {
@@ -3549,7 +4165,7 @@ var EmaTransportOAuthProvider = class {
   async redirectToAuthorization(_authorizationUrl) {
     const idpAuthorizationUrl = await startEmaIdpAuthorization(this.emaConfig);
     this.inner.clearCapturedAuthUrl();
-    this.inner.redirectToAuthorization(idpAuthorizationUrl);
+    this.inner.redirectToExternalAuthorization(idpAuthorizationUrl);
   }
   saveCodeVerifier(codeVerifier) {
     return this.inner.saveCodeVerifier(codeVerifier);
@@ -3684,6 +4300,30 @@ var OAuthManager = class {
   getServerUrl() {
     return this.params.getServerUrl();
   }
+  /**
+   * The per-server authorization/token endpoint overrides, read live so a
+   * `setOAuthConfig` between requests takes effect without rebuilding the
+   * client's fetch. `InspectorClient` reads this from inside its fetch wrapper.
+   * (#1906)
+   *
+   * Returns nothing under enterprise-managed authorization, for the same reason
+   * `redirectToExternalAuthorization` skips the custom authorization parameters
+   * (#2018): the EMA leg authorizes against the enterprise IdP, a *different*
+   * authorization server, and its OIDC discovery runs through this same fetch
+   * (`emaFlow` → `idpOidc`). Rewriting that document would point the IdP login —
+   * or the IdP code/refresh-token exchange — at the resource server's
+   * authorization server, which is both wrong and a way to leak an IdP
+   * credential across an authorization-server boundary.
+   */
+  getEndpointOverrides() {
+    if (this.isEnterpriseManaged()) return void 0;
+    const { authorizationUrl, tokenUrl } = this.oauthConfig;
+    if (!authorizationUrl && !tokenUrl) return void 0;
+    return {
+      ...authorizationUrl && { authorizationUrl },
+      ...tokenUrl && { tokenUrl }
+    };
+  }
   /**
    * Return the configured OAuth storage, throwing a clear error if it is
    * absent. Used on the EMA re-mint/persist paths, which are only reached for
@@ -3707,7 +4347,12 @@ var OAuthManager = class {
       storage: this.oauthConfig.storage,
       redirectUrlProvider: this.oauthConfig.redirectUrlProvider,
       navigation: this.oauthConfig.navigation,
-      clientMetadataUrl: this.oauthConfig.clientMetadataUrl
+      clientMetadataUrl: this.oauthConfig.clientMetadataUrl,
+      // #2018: per-server custom authorization-request parameters. Carried on
+      // the provider (not in OAuth storage like `scope`) — they are pure config
+      // read from mcp.json, and nothing in the flow needs to persist or union
+      // them.
+      authorizationParams: this.oauthConfig.authorizationParams
     });
     provider.setEventTarget(this.params.getEventTarget());
     await provider.prepareForAuth();
@@ -4933,6 +5578,11 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   // annotations (SEP-2243), recomputed on every aggregate tools refresh and
   // surfaced so the Tools tab can show why a tool vanished (#1632).
   excludedTools = [];
+  // Entries the Inspector dropped from a list result because they failed the
+  // spec schema for that primitive, keyed by list method. Populated only by the
+  // salvage fallback in `listAllSalvaging` — empty against a conforming server
+  // (#1909).
+  malformedListItems = /* @__PURE__ */ new Map();
   // The capabilities this Inspector client advertises to the server during the
   // initialize handshake. Built once in setupClient() and snapshotted here so
   // UI surfaces (Server Info modal) can display them without poking at the
@@ -5111,6 +5761,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       resources: options.listChangedNotifications?.resources ?? true,
       prompts: options.listChangedNotifications?.prompts ?? true
     };
+    this.fetchFn = withOAuthEndpointOverrides(
+      this.fetchFn ?? fetch,
+      () => this.oauthManager?.getEndpointOverrides()
+    );
     this.effectiveAuthFetch = this.buildEffectiveAuthFetch();
     this.sessionId = options.sessionId;
     if (options.oauth || options.environment.oauth) {
@@ -5138,6 +5792,11 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       });
     }
     const clientOptions = {
+      // Bound the SDK's auto-aggregate with the SAME constant the #1909 salvage
+      // re-walks use, so the strict path and its fallback cannot drift apart.
+      // This is the SDK's own default today; setting it explicitly is what makes
+      // the shared value a fact rather than a copied guess.
+      listMaxPages: LIST_MAX_PAGES,
       // Per-server protocol era (SEP §7.8), threaded from config via
       // `eraToVersionNegotiation` and defaulted to `{ mode: "legacy" }` in the
       // constructor. "legacy" keeps the wire byte-identical to a 2025 client;
@@ -5807,6 +6466,14 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.cancelledTaskIds.clear();
     this.outboundRequestMethods.clear();
     this.lastAnsweredRequestByMethod.clear();
+    if (this.malformedListItems.size > 0) {
+      this.malformedListItems.clear();
+      this.dispatchTypedEvent("malformedListItemsChange", []);
+    }
+    if (this.excludedTools.length > 0) {
+      this.excludedTools = [];
+      this.dispatchTypedEvent("excludedToolsChange", []);
+    }
     for (const [, controller] of this.taskInputAbortControllers) {
       controller.abort(new Error("Connection ended"));
     }
@@ -6030,7 +6697,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       this.status = "connected";
       this.dispatchTypedEvent("statusChange", this.status);
       await this.fetchServerInfo();
-      if (this.initialLoggingLevel && this.capabilities?.logging) {
+      if (this.initialLoggingLevel && this.capabilities?.logging && this.protocolEra !== "modern") {
         await this.client.setLoggingLevel(
           this.initialLoggingLevel,
           this.getRequestOptions()
@@ -6175,6 +6842,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.protocolEra = void 0;
     this.discoverResult = void 0;
     this.excludedTools = [];
+    this.malformedListItems.clear();
     this.modernLogLevel = void 0;
     this.dispatchTypedEvent("pendingSamplesChange", this.pendingSamples);
     this.dispatchTypedEvent(
@@ -6188,6 +6856,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.dispatchTypedEvent("protocolEraChange", this.protocolEra);
     this.dispatchTypedEvent("discoverResultChange", this.discoverResult);
     this.dispatchTypedEvent("excludedToolsChange", this.excludedTools);
+    this.dispatchTypedEvent("malformedListItemsChange", []);
   }
   /**
    * Returns a client proxy for use by AppRenderer / @mcp-ui. Delegates to the
@@ -6281,7 +6950,6 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    * `clientCapabilities` carrying the tasks extension). We reproduce it here.
    */
   withModernTaskEnvelope(params) {
-    const existingMeta = params._meta ?? {};
     const clientCapabilities = {
       ...this.clientCapabilities,
       // Force-stamp the tasks extension regardless of what the client
@@ -6293,6 +6961,26 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
         [TASKS_EXTENSION_KEY]: {}
       }
     };
+    return this.withModernEnvelope(params, clientCapabilities);
+  }
+  /**
+   * Stamp the `_meta` envelope every raw-wire request needs on the modern leg:
+   * the negotiated protocol version, the client identity, and the client
+   * capabilities.
+   *
+   * Split out of {@link withModernTaskEnvelope} so the list-salvage re-walk
+   * (#1909) can reuse it WITHOUT that method's force-stamped tasks extension —
+   * a `tools/list` has no business claiming an extension the user may have
+   * deliberately turned off (#1738).
+   *
+   * The NEGOTIATED protocol version is used so the envelope agrees with the
+   * `MCP-Protocol-Version` header the transport stamps from the same source — a
+   * future modern-family revision would negotiate a different string, and the
+   * two must not disagree. The raw channel only runs on a connected modern
+   * session, so this is always set; the constant is a defensive fallback.
+   */
+  withModernEnvelope(params, clientCapabilities = this.clientCapabilities) {
+    const existingMeta = params._meta ?? {};
     const protocolVersion = this.getProtocolVersion() ?? MODERN_PROTOCOL_VERSION2;
     return {
       ...params,
@@ -6889,7 +7577,11 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     const effectiveMeta = this.mergeMeta(metadata);
     const params = {
       ...effectiveMeta ? { _meta: effectiveMeta } : {},
-      ...cursor ? { cursor } : {}
+      // `!== undefined`, not truthiness: "" is a valid cursor. Dropping it asks
+      // for page one again — and `listToolsForScan` pairs this call with a
+      // fallback that already preserves it, so the two legs of one scan page
+      // would otherwise disagree about which page they fetched.
+      ...cursor !== void 0 && { cursor }
     };
     const response = await this.invokeMcpClient(
       () => this.client.request(
@@ -6917,19 +7609,29 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     if (!this.client) {
       throw new Error("Client is not connected");
     }
-    const response = await this.invokeMcpClient(
-      () => this.client.listTools(
-        this.aggregateListParams(options?.metadata),
-        this.getCacheableRequestOptions(options?.cacheMode)
-      )
-    );
+    const tools = await this.listAllSalvaging({
+      method: "tools/list",
+      itemsKey: "tools",
+      resultSchema: ListToolsResultSchema,
+      // Era-aware: the neutral `ToolSchema` is more permissive than the
+      // negotiated era's wire schema — see `toolItemSchemaForEra`.
+      itemSchema: toolItemSchemaForEra(this.isModernEra()),
+      metadata: options?.metadata,
+      finalize: (salvaged) => this.excludeInvalidXMcpHeaderTools(salvaged),
+      aggregate: async () => [
+        ...(await this.client.listTools(
+          this.aggregateListParams(options?.metadata),
+          this.getCacheableRequestOptions(options?.cacheMode)
+        )).tools
+      ]
+    });
     await this.refreshExcludedTools(options?.metadata).catch((err) => {
       this.logger.warn(
         { err },
         "Excluded-tools walk failed; the SEP-2243 excluded list may be incomplete"
       );
     });
-    return { tools: [...response.tools] };
+    return { tools };
   }
   /**
    * Whether this connection excludes tools with invalid `x-mcp-header`
@@ -6960,6 +7662,202 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     if (id === void 0) return;
     this.dispatchTypedEvent("responseRejected", { id, reason });
   }
+  /**
+   * Put the method's response correlation back where it was before a salvage
+   * re-walk, so a caller that goes on to mark the failure still marks the
+   * ORIGINAL rejected response.
+   *
+   * The re-walk answers the same method, so on any rethrow path the map points
+   * at a lenient page that succeeded. `ManagedListState.refresh()` catches the
+   * rethrown error and calls `markResponseRejected(method, ...)`, which would
+   * then stamp "Rejected by the Inspector" onto that page and leave the real
+   * one rendering clean — the same misattribution the capture inside
+   * `salvageList` exists to prevent, just one frame further out. Deleting when
+   * nothing had answered before makes the outer mark a no-op rather than a lie.
+   */
+  restoreResponseCorrelation(method, id) {
+    if (id === void 0) this.lastAnsweredRequestByMethod.delete(method);
+    else this.lastAnsweredRequestByMethod.set(method, id);
+  }
+  /** Every entry dropped from a list result as malformed, across methods (#1909). */
+  getMalformedListItems() {
+    return [...this.malformedListItems.values()].flat();
+  }
+  /**
+   * Record (or clear) the malformed entries for one list method and notify.
+   *
+   * A no-op when the method had none and still has none, so the common case —
+   * every conforming refresh, of which there are many — costs no event and no
+   * re-render.
+   */
+  setMalformedListItems(method, malformed) {
+    const previous = this.malformedListItems.get(method) ?? [];
+    if (previous.length === 0 && malformed.length === 0) return;
+    if (malformed.length === 0) this.malformedListItems.delete(method);
+    else this.malformedListItems.set(method, malformed);
+    this.dispatchTypedEvent(
+      "malformedListItemsChange",
+      this.getMalformedListItems()
+    );
+  }
+  /**
+   * Run a list aggregate, falling back to a per-item salvage when the SDK
+   * rejects the result it received (#1909).
+   *
+   * The strict aggregate runs first and unchanged, so a conforming server pays
+   * nothing: no extra request, no extra parse, and the SDK's response cache
+   * still serves it. Only an `InvalidResult` rejection — a response in hand
+   * that failed validation — reaches {@link salvageList}; every other failure
+   * (transport drop, timeout, server-sent error) rethrows untouched, because
+   * re-listing would not produce anything to salvage.
+   */
+  async listAllSalvaging({
+    method,
+    itemsKey,
+    itemSchema,
+    resultSchema,
+    aggregate,
+    metadata,
+    finalize
+  }) {
+    try {
+      const items = await this.invokeMcpClient(aggregate, { method });
+      this.setMalformedListItems(method, []);
+      return items;
+    } catch (err) {
+      if (!isSalvageableRejection(err)) throw err;
+      const salvaged = await this.salvageList({
+        method,
+        itemsKey,
+        itemSchema,
+        resultSchema,
+        metadata,
+        err
+      });
+      return finalize ? finalize(salvaged) : salvaged;
+    }
+  }
+  /**
+   * Drop the tools the SDK would have excluded from `tools/list` for invalid
+   * `x-mcp-header` annotations (SEP-2243).
+   *
+   * The strict aggregate is filtered by the SDK before we see it, so the
+   * salvage path has to reapply the same rule itself: otherwise one ordinary
+   * malformed tool anywhere in the list would trip the fallback and quietly
+   * readmit every invalid-header tool alongside it — turning a rendering fix
+   * into a spec violation. The dropped tools are still reported through
+   * `refreshExcludedTools`, which lists them with their reason.
+   */
+  excludeInvalidXMcpHeaderTools(tools) {
+    if (!this.excludesInvalidXMcpHeaderTools()) return tools;
+    return tools.filter(
+      (tool) => scanXMcpHeaderDeclarations(tool.inputSchema).valid
+    );
+  }
+  /**
+   * Re-walk a list method with pagination validated but entries left raw, then
+   * validate each entry on its own — keeping the good ones and reporting the
+   * rest (#1909).
+   *
+   * Two deliberate properties:
+   *
+   * - **The original error wins when nothing is salvageable.** If every entry
+   *   validates here, the strict rejection was about something else (a
+   *   top-level field, an era codec decision), so there is no per-item story to
+   *   tell and swallowing it would hide a real failure. Rethrow the original.
+   * - **A salvaged response is still a rejected response.** The Protocol entry
+   *   is marked (#1953) with what was dropped, so the wire truth survives even
+   *   though the list now renders.
+   *
+   * This walk is deliberately un-cached (it uses the raw per-page path), which
+   * is fine: it only runs against a server that just returned a non-conforming
+   * result.
+   */
+  async salvageList({
+    method,
+    itemsKey,
+    itemSchema,
+    resultSchema,
+    metadata,
+    err
+  }) {
+    const pageSchema = lenientListPageSchema(resultSchema, itemsKey);
+    const rejectedResponseId = this.lastAnsweredRequestByMethod.get(method);
+    const valid = [];
+    const malformed = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let cursor;
+    let pages = 0;
+    try {
+      do {
+        if (pages >= LIST_MAX_PAGES) throw listPaginationExceeded(method);
+        pages += 1;
+        const effectiveMeta = this.mergeMeta(metadata);
+        const params = {
+          ...effectiveMeta ? { _meta: effectiveMeta } : {},
+          // `!== undefined`, not truthiness: "" is a valid cursor, and dropping it
+          // would re-request page one and duplicate its entries until the
+          // repeated-cursor guard below stopped the walk.
+          ...cursor !== void 0 && { cursor }
+        };
+        const page = await this.invokeMcpClient(
+          () => this.isModernEra() ? this.rawWireRequest(
+            method,
+            this.withModernEnvelope(params),
+            pageSchema
+          ) : this.client.request(
+            { method, params },
+            pageSchema,
+            this.getRequestOptions(metadata?.progressToken)
+          ),
+          { method }
+        );
+        if (this.isModernEra() && !ModernResultEnvelopeSchema.safeParse(page).success) {
+          throw err;
+        }
+        const items = rawItemsOf(page, itemsKey);
+        if (items === void 0) throw err;
+        const salvaged = salvageListItems({
+          method,
+          items,
+          schema: itemSchema,
+          startIndex: valid.length + malformed.length
+        });
+        valid.push(...salvaged.valid);
+        malformed.push(...salvaged.malformed);
+        cursor = nextCursorOf(page);
+        if (cursor !== void 0) {
+          if (seenCursors.has(cursor)) break;
+          seenCursors.add(cursor);
+        }
+      } while (cursor !== void 0);
+    } catch (walkErr) {
+      if (walkErr !== err) {
+        this.logger.warn(
+          { err: walkErr, method },
+          "Salvage re-walk failed; surfacing the original list error"
+        );
+      }
+      this.restoreResponseCorrelation(method, rejectedResponseId);
+      throw err;
+    }
+    if (malformed.length === 0) {
+      this.restoreResponseCorrelation(method, rejectedResponseId);
+      throw err;
+    }
+    if (rejectedResponseId !== void 0) {
+      this.dispatchTypedEvent("responseRejected", {
+        id: rejectedResponseId,
+        reason: summarizeMalformed(malformed)
+      });
+    }
+    this.setMalformedListItems(method, malformed);
+    this.logger.warn(
+      { method, malformed },
+      "Dropped malformed entries from a list result; the rest of the list was kept"
+    );
+    return valid;
+  }
   /** The current SEP-2243 excluded-tools set (empty on legacy/stdio). */
   getExcludedTools() {
     return this.excludedTools;
@@ -6978,8 +7876,11 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     if (this.excludesInvalidXMcpHeaderTools()) {
       const seenCursors = /* @__PURE__ */ new Set();
       let cursor;
+      let pages = 0;
       do {
-        const page = await this.listTools(cursor, metadata);
+        if (pages >= LIST_MAX_PAGES) throw listPaginationExceeded("tools/list");
+        pages += 1;
+        const page = await this.listToolsForScan(cursor, metadata);
         for (const tool of page.tools) {
           const scan = scanXMcpHeaderDeclarations(tool.inputSchema);
           if (!scan.valid) excluded.push({ tool, reason: scan.reason });
@@ -6995,6 +7896,90 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.dispatchTypedEvent("excludedToolsChange", excluded);
     return excluded;
   }
+  /**
+   * One page of the RAW `tools/list` for the SEP-2243 scan, tolerating a
+   * malformed sibling entry (#1632 + #1909).
+   *
+   * The scan needs the unfiltered list, so it uses the strict single-page call
+   * — but that call rejects the whole page when any entry is non-conforming,
+   * which would blank the excluded set and leave a tool that vanished for an
+   * invalid header with no explanation at all. That is the same failure #1909
+   * is about, one level down. So on a decode rejection the page is re-fetched
+   * leniently and scanned entry by entry.
+   *
+   * The malformed ones are not "excluded tools" and are not returned: they
+   * describe THIS exchange, not the aggregate the Tools panel renders, so they
+   * surface as the rejection reason on this response's own Protocol entry and
+   * go no further (see `refreshExcludedTools`).
+   */
+  async listToolsForScan(cursor, metadata) {
+    try {
+      return await this.listTools(cursor, metadata);
+    } catch (err) {
+      if (!isSalvageableRejection(err)) throw err;
+      const rejectedResponseId = this.lastAnsweredRequestByMethod.get("tools/list");
+      try {
+        const effectiveMeta = this.mergeMeta(metadata);
+        const params = {
+          ...effectiveMeta ? { _meta: effectiveMeta } : {},
+          // See `salvageList`: "" is a valid cursor.
+          ...cursor !== void 0 && { cursor }
+        };
+        const pageSchema = lenientListPageSchema(
+          ListToolsResultSchema,
+          "tools"
+        );
+        const page = await this.invokeMcpClient(
+          () => this.isModernEra() ? this.rawWireRequest(
+            "tools/list",
+            this.withModernEnvelope(params),
+            pageSchema
+          ) : this.client.request(
+            { method: "tools/list", params },
+            pageSchema,
+            this.getRequestOptions(metadata?.progressToken)
+          ),
+          { method: "tools/list" }
+        );
+        if (this.isModernEra() && !ModernResultEnvelopeSchema.safeParse(page).success) {
+          throw err;
+        }
+        const items = rawItemsOf(page, "tools");
+        if (items === void 0) throw err;
+        const { valid, malformed } = salvageListItems({
+          method: "tools/list",
+          items,
+          schema: toolItemSchemaForEra(this.isModernEra())
+        });
+        if (rejectedResponseId !== void 0) {
+          this.dispatchTypedEvent("responseRejected", {
+            id: rejectedResponseId,
+            reason: malformed.length > 0 ? summarizeMalformed(malformed) : err instanceof Error ? err.message : String(err)
+          });
+        }
+        const nextCursor = nextCursorOf(page);
+        return {
+          tools: valid,
+          ...nextCursor !== void 0 && { nextCursor }
+        };
+      } catch (fallbackErr) {
+        if (rejectedResponseId !== void 0) {
+          this.dispatchTypedEvent("responseRejected", {
+            id: rejectedResponseId,
+            reason: err instanceof Error ? err.message : String(err)
+          });
+        }
+        if (fallbackErr !== err) {
+          this.logger.warn(
+            { err: fallbackErr },
+            "Excluded-tools salvage re-fetch failed; surfacing the original list error"
+          );
+        }
+        this.restoreResponseCorrelation("tools/list", rejectedResponseId);
+        throw err;
+      }
+    }
+  }
   /**
    * Call a tool. Caller must provide the Tool (e.g. from a state manager).
    * @param tool The tool to call (use tool.name for the request)
@@ -7781,13 +8766,20 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     if (!this.client) {
       throw new Error("Client is not connected");
     }
-    const response = await this.invokeMcpClient(
-      () => this.client.listResources(
-        this.aggregateListParams(options?.metadata),
-        this.getCacheableRequestOptions(options?.cacheMode)
-      )
-    );
-    return { resources: [...response.resources] };
+    const resources = await this.listAllSalvaging({
+      method: "resources/list",
+      itemsKey: "resources",
+      resultSchema: ListResourcesResultSchema,
+      itemSchema: ResourceSchema,
+      metadata: options?.metadata,
+      aggregate: async () => [
+        ...(await this.client.listResources(
+          this.aggregateListParams(options?.metadata),
+          this.getCacheableRequestOptions(options?.cacheMode)
+        )).resources
+      ]
+    });
+    return { resources };
   }
   /**
    * Read a resource by URI
@@ -7843,8 +8835,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     const uriTemplateString = uriTemplate;
     let expandedUri;
     try {
-      const uriTemplate2 = new UriTemplate(uriTemplateString);
-      expandedUri = uriTemplate2.expand(params);
+      expandedUri = expandUriTemplateStrict(uriTemplateString, params);
     } catch (error) {
       throw new Error(
         `Failed to expand URI template "${uriTemplate}": ${error instanceof Error ? error.message : String(error)}`,
@@ -7906,14 +8897,20 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     if (!this.client) {
       throw new Error("Client is not connected");
     }
-    const response = await this.invokeMcpClient(
-      () => this.client.listResourceTemplates(
-        this.aggregateListParams(options?.metadata),
-        this.getCacheableRequestOptions(options?.cacheMode)
-      ),
-      { method: "resources/templates/list" }
-    );
-    return { resourceTemplates: [...response.resourceTemplates] };
+    const resourceTemplates = await this.listAllSalvaging({
+      method: "resources/templates/list",
+      itemsKey: "resourceTemplates",
+      resultSchema: ListResourceTemplatesResultSchema,
+      itemSchema: ResourceTemplateSchema,
+      metadata: options?.metadata,
+      aggregate: async () => [
+        ...(await this.client.listResourceTemplates(
+          this.aggregateListParams(options?.metadata),
+          this.getCacheableRequestOptions(options?.cacheMode)
+        )).resourceTemplates
+      ]
+    });
+    return { resourceTemplates };
   }
   /**
    * List available prompts with pagination support
@@ -7952,13 +8949,20 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     if (!this.client) {
       throw new Error("Client is not connected");
     }
-    const response = await this.invokeMcpClient(
-      () => this.client.listPrompts(
-        this.aggregateListParams(options?.metadata),
-        this.getCacheableRequestOptions(options?.cacheMode)
-      )
-    );
-    return { prompts: [...response.prompts] };
+    const prompts = await this.listAllSalvaging({
+      method: "prompts/list",
+      itemsKey: "prompts",
+      resultSchema: ListPromptsResultSchema,
+      itemSchema: PromptSchema,
+      metadata: options?.metadata,
+      aggregate: async () => [
+        ...(await this.client.listPrompts(
+          this.aggregateListParams(options?.metadata),
+          this.getCacheableRequestOptions(options?.cacheMode)
+        )).prompts
+      ]
+    });
+    return { prompts };
   }
   /**
    * Get a prompt by name
@@ -8874,11 +9878,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
 };
 
 // ../../core/mcp/state/managedListState.ts
-import { SdkError, SdkErrorCode } from "@modelcontextprotocol/client";
 var DEFAULT_LIST_CHANGED_DEBOUNCE_MS = 250;
-function isClientDecodeRejection(err) {
-  return SdkError.isInstance(err) && (err.code === SdkErrorCode.InvalidResult || err.code === SdkErrorCode.UnsupportedResultType);
-}
 var ManagedListState = class extends TypedEventTarget {
   items = [];
   client = null;
@@ -9509,6 +10509,7 @@ function useInspectorClient(inspectorClient) {
   const [excludedTools, setExcludedTools] = useState(
     inspectorClient?.getExcludedTools() ?? []
   );
+  const [malformedListItems, setMalformedListItems] = useState(inspectorClient?.getMalformedListItems() ?? []);
   const [lastError, setLastError] = useState(void 0);
   useEffect(() => {
     if (!inspectorClient) {
@@ -9520,6 +10521,7 @@ function useInspectorClient(inspectorClient) {
       setProtocolEra(void 0);
       setDiscoverResult(void 0);
       setExcludedTools([]);
+      setMalformedListItems([]);
       setLastError(void 0);
       return;
     }
@@ -9531,6 +10533,7 @@ function useInspectorClient(inspectorClient) {
     setProtocolEra(inspectorClient.getProtocolEra());
     setDiscoverResult(inspectorClient.getDiscoverResult());
     setExcludedTools(inspectorClient.getExcludedTools());
+    setMalformedListItems(inspectorClient.getMalformedListItems());
     setLastError(void 0);
     const onStatusChange = (event) => {
       setStatus(event.detail);
@@ -9559,6 +10562,9 @@ function useInspectorClient(inspectorClient) {
     const onDiscoverResultChange = (event) => {
       setDiscoverResult(event.detail);
     };
+    const onMalformedListItemsChange = (event) => {
+      setMalformedListItems(event.detail);
+    };
     const onExcludedToolsChange = (event) => {
       setExcludedTools(event.detail);
     };
@@ -9586,6 +10592,10 @@ function useInspectorClient(inspectorClient) {
       "excludedToolsChange",
       onExcludedToolsChange
     );
+    inspectorClient.addEventListener(
+      "malformedListItemsChange",
+      onMalformedListItemsChange
+    );
     return () => {
       inspectorClient.removeEventListener("statusChange", onStatusChange);
       inspectorClient.removeEventListener("error", onError);
@@ -9617,6 +10627,10 @@ function useInspectorClient(inspectorClient) {
         "excludedToolsChange",
         onExcludedToolsChange
       );
+      inspectorClient.removeEventListener(
+        "malformedListItemsChange",
+        onMalformedListItemsChange
+      );
     };
   }, [inspectorClient]);
   const connect = useCallback(async () => {
@@ -9642,6 +10656,7 @@ function useInspectorClient(inspectorClient) {
     protocolEra,
     discoverResult,
     excludedTools,
+    malformedListItems,
     lastError,
     appRendererClient: inspectorClient?.getAppRendererClient() ?? null,
     connect,
@@ -9652,9 +10667,9 @@ function useInspectorClient(inspectorClient) {
 // ../../core/react/useManagedTools.ts
 import { useState as useState2, useEffect as useEffect2, useCallback as useCallback3 } from "react";
 
-// ../../core/react/useManagedListError.ts
+// ../../core/react/useListError.ts
 import { useCallback as useCallback2, useSyncExternalStore } from "react";
-function useManagedListError(state) {
+function useListError(state) {
   const subscribe = useCallback2(
     (onStoreChange) => {
       if (!state) return () => {
@@ -9706,7 +10721,7 @@ function useManagedTools(client, managedToolsState) {
       );
     };
   }, [managedToolsState]);
-  const error = useManagedListError(managedToolsState);
+  const error = useListError(managedToolsState);
   const refresh = useCallback3(async () => {
     if (!managedToolsState || !client) return [];
     managedToolsState.clearListChanged();
@@ -9762,7 +10777,7 @@ function useManagedResources(client, managedResourcesState) {
       );
     };
   }, [managedResourcesState]);
-  const error = useManagedListError(managedResourcesState);
+  const error = useListError(managedResourcesState);
   const refresh = useCallback4(async () => {
     if (!managedResourcesState || !client) return [];
     managedResourcesState.clearListChanged();
@@ -9800,7 +10815,7 @@ function useManagedResourceTemplates(client, managedResourceTemplatesState) {
       );
     };
   }, [managedResourceTemplatesState]);
-  const error = useManagedListError(managedResourceTemplatesState);
+  const error = useListError(managedResourceTemplatesState);
   const refresh = useCallback5(async () => {
     if (!managedResourceTemplatesState || !client) return [];
     const next = await managedResourceTemplatesState.refresh(
@@ -9849,7 +10864,7 @@ function useManagedPrompts(client, managedPromptsState) {
       );
     };
   }, [managedPromptsState]);
-  const error = useManagedListError(managedPromptsState);
+  const error = useListError(managedPromptsState);
   const refresh = useCallback6(async () => {
     if (!managedPromptsState || !client) return [];
     managedPromptsState.clearListChanged();
@@ -11796,7 +12811,7 @@ function ResourcesTab({
         setShouldFetchResource(null);
       }
     };
-    fetchContent();
+    void fetchContent();
   }, [shouldFetchResource, inspectorClient, onAuthRecoveryRequired]);
   const listWidth = Math.floor(width * 0.4);
   const detailWidth = width - listWidth;
@@ -11979,7 +12994,7 @@ function PromptsTab({
         if (selectedPrompt.arguments && selectedPrompt.arguments.length > 0) {
           onFetchPrompt(selectedPrompt);
         } else {
-          (async () => {
+          void (async () => {
             try {
               const invocation = await inspectorClient.getPrompt(
                 selectedPrompt.name
@@ -14361,6 +15376,161 @@ var Form = (props) => {
 import { render } from "ink";
 import React24 from "react";
 
+// ../../core/json/nullableUnion.ts
+var RENDERABLE_TYPES = [
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "array",
+  "object"
+];
+function isRenderableType(type) {
+  return RENDERABLE_TYPES.includes(type);
+}
+function toBranch(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function isStringEnum(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((member) => typeof member === "string");
+}
+function nullExcludedBySiblings(schema) {
+  if (Array.isArray(schema.enum) && !schema.enum.includes(null)) {
+    return true;
+  }
+  return schema.const !== void 0 && schema.const !== null;
+}
+var ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "default",
+  "enumNames",
+  "examples",
+  "deprecated",
+  "readOnly",
+  "writeOnly",
+  "$comment",
+  "$schema",
+  "$id"
+]);
+function wrapperCarriesConstraints(schema) {
+  return Object.keys(schema).some(
+    (key) => key !== "anyOf" && !ANNOTATION_KEYWORDS.has(key)
+  );
+}
+function typeNamesNull(type) {
+  return Array.isArray(type) ? type.includes("null") : type === "null";
+}
+function hasOpaqueApplicator(schema) {
+  return schema.not !== void 0 || schema.allOf !== void 0 || schema.oneOf !== void 0 || // `$ref` points at a schema this module never resolves, and it applies
+  // *alongside* its siblings — `{ type: "string", $ref: "#/$defs/intOnly" }`
+  // can be unsatisfiable. The wrapper path already declines on it (it is not
+  // an annotation); this is the same rule for every other position.
+  schema.$ref !== void 0;
+}
+function hasUnevaluatedComposition(schema) {
+  return schema.anyOf !== void 0 || hasOpaqueApplicator(schema);
+}
+function stripNullEnumMembers(members, names) {
+  if (!Array.isArray(members)) {
+    return { kind: "unchanged" };
+  }
+  const kept = members.map((member, index) => ({ member, index })).filter((entry) => entry.member !== null);
+  if (kept.length === 0) {
+    return { kind: "unselectable" };
+  }
+  if (kept.length === members.length) {
+    return { kind: "unchanged" };
+  }
+  const wasParallel = Array.isArray(names) && names.length === members.length;
+  const aligned = wasParallel ? kept.map((entry) => names[entry.index]) : void 0;
+  return {
+    kind: "filtered",
+    members: kept.map((entry) => entry.member),
+    names: aligned
+  };
+}
+function collapsed(schema, branch, type) {
+  const merged = { ...schema, ...branch };
+  const strip = stripNullEnumMembers(
+    merged.enum,
+    merged.enumNames
+  );
+  if (strip.kind === "unselectable") {
+    return null;
+  }
+  return {
+    ...merged,
+    type,
+    anyOf: void 0,
+    // Read off the ORIGINAL schema, not the merge: a hoisted branch `enum` is
+    // not a sibling constraint, and treating it as one would mark the very
+    // shape #1928 is about as non-nullable. See `nullExcludedBySiblings`.
+    nullable: admitsNull(schema),
+    ...strip.kind === "filtered" ? { enum: strip.members, enumNames: strip.names } : {}
+  };
+}
+function admitsNull(schema) {
+  if (nullExcludedBySiblings(schema)) {
+    return false;
+  }
+  if (hasOpaqueApplicator(schema)) {
+    return false;
+  }
+  if (schema.nullable === true) {
+    return true;
+  }
+  if (schema.type !== void 0) {
+    if (schema.anyOf !== void 0) {
+      return false;
+    }
+    return typeNamesNull(schema.type);
+  }
+  return schema.anyOf?.some((entry) => {
+    const branch = toBranch(entry);
+    if (branch === null || !typeNamesNull(branch.type)) {
+      return false;
+    }
+    const branchSchema = branch;
+    return !nullExcludedBySiblings(branchSchema) && !hasUnevaluatedComposition(branchSchema);
+  }) ?? false;
+}
+function normalizeNullableUnion(schema) {
+  if (schema.anyOf?.length === 2) {
+    const branches = schema.anyOf.map(toBranch);
+    const nullBranch = branches.find((entry) => entry?.type === "null");
+    const branch = branches.find(
+      (entry) => entry !== null && entry.type !== "null"
+    );
+    if (nullBranch && branch && !wrapperCarriesConstraints(schema) && !hasUnevaluatedComposition(branch)) {
+      const type = branch.type ?? (isStringEnum(branch.enum) ? "string" : void 0);
+      if (isRenderableType(type)) {
+        const result = collapsed(schema, branch, type);
+        if (result !== null) {
+          return result;
+        }
+      }
+    }
+  }
+  if (Array.isArray(schema.type) && schema.type.length === 2 && schema.type.includes("null") && // This path keeps the schema's own keywords, but `collapsed` clears `anyOf`
+  // and the renderers ignore the other applicators — so a compound schema
+  // like `{ type: ["string", "null"], anyOf: [{ const: "a" }] }` would be
+  // widened into an unconstrained string field. Leave it for the JSON editor.
+  !hasUnevaluatedComposition(schema)) {
+    const type = schema.type.find((member) => member !== "null");
+    if (isRenderableType(type)) {
+      const result = collapsed(schema, void 0, type);
+      if (result !== null) {
+        return result;
+      }
+    }
+  }
+  return schema;
+}
+
 // src/utils/schemaToForm.ts
 function toSelectOptions(values, names) {
   const useNames = names !== void 0 && names.length === values.length;
@@ -14380,7 +15550,9 @@ function schemaToForm(schema, toolName) {
   const properties = schema.properties || {};
   const required = schema.required || [];
   for (const [key, prop] of Object.entries(properties)) {
-    const property = typeof prop === "object" && prop !== null ? prop : {};
+    const property = normalizeNullableUnion(
+      typeof prop === "object" && prop !== null ? prop : {}
+    );
     const baseField = {
       name: key,
       label: property.title || key,
@@ -14393,11 +15565,11 @@ function schemaToForm(schema, toolName) {
         ...baseField,
         options: toSelectOptions(property.items.enum, property.items.enumNames)
       };
-    } else if (property.enum) {
+    } else if (isStringEnum(property.enum)) {
       field = {
         type: "select",
         ...baseField,
-        options: toSelectOptions(property.enum, property.enumNames)
+        options: toSelectOptions(property.enum ?? [], property.enumNames)
       };
     } else {
       switch (property.type) {
@@ -14639,20 +15811,18 @@ import { Box as Box24, Text as Text21, useInput as useInput18 } from "ink";
 // src/utils/uriTemplateToForm.ts
 import { UriTemplate as UriTemplate2 } from "@modelcontextprotocol/client";
 function uriTemplateToForm(uriTemplate, templateName) {
-  const fields = [];
+  let fields = [];
   try {
-    const template = new UriTemplate2(uriTemplate);
-    const variableNames = template.variableNames || [];
-    for (const variableName of variableNames) {
-      const field = {
-        name: variableName,
-        label: variableName,
-        type: "string",
-        required: false
-        // URI template variables are typically optional
-      };
-      fields.push(field);
-    }
+    new UriTemplate2(uriTemplate);
+    const mandatory = new Set(
+      requiredGroups(uriTemplate).filter((names) => names.length === 1).map(([name]) => name)
+    );
+    fields = templateVariables(uriTemplate).map(({ name }) => ({
+      name,
+      label: name,
+      type: "string",
+      required: mandatory.has(name)
+    }));
   } catch (error) {
     console.error("Failed to parse URI template:", error);
   }
@@ -14749,12 +15919,28 @@ function ResourceTestModal({
   );
   const handleFormSubmit = async (values) => {
     if (!inspectorClient || !template) return;
+    const unmetGroups = unmetRequiredGroups(
+      requiredGroups(template.uriTemplate),
+      values
+    );
+    if (unmetGroups.length > 0) {
+      const unmet = unmetGroups.map((names) => names.join(" or "));
+      setResult({
+        input: values,
+        output: null,
+        error: `Missing required template variable(s): ${unmet.join(", ")}`,
+        duration: 0,
+        uri: template.uriTemplate
+      });
+      setState("results");
+      return;
+    }
     setState("loading");
     const startTime = Date.now();
     try {
       const invocation = await inspectorClient.readResourceFromTemplate(
         template.uriTemplate,
-        values
+        definedValues(values)
       );
       const duration = Date.now() - startTime;
       setResult({
@@ -15222,6 +16408,8 @@ function App({
     pendingStepUpRef.current = pendingStepUp;
   }, [pendingStepUp]);
   const [connectError, setConnectError] = useState23(null);
+  const disconnectAttemptRef = useRef13(0);
+  const [disconnectError, setDisconnectError] = useState23(null);
   const oauthInProgressRef = useRef13(false);
   const callbackServerRef = useRef13(null);
   const selectedServerRef = useRef13(null);
@@ -15409,6 +16597,8 @@ function App({
   useEffect20(() => {
     setOauthStatus("idle");
     setOauthMessage(null);
+    disconnectAttemptRef.current++;
+    setDisconnectError(null);
     const stepUp = pendingStepUpRef.current;
     if (stepUp && selectedServer && stepUp.serverName !== selectedServer) {
       setPendingStepUp(null);
@@ -15653,6 +16843,8 @@ function App({
     if (!selectedServer || !selectedInspectorClient || !selectedServerConfig) {
       return;
     }
+    disconnectAttemptRef.current++;
+    setDisconnectError(null);
     const finishConnect = async () => {
       await connectInspector();
       setConnectError(null);
@@ -15760,7 +16952,17 @@ function App({
   }, [inspectorClients, handleAuthRecoveryRequired]);
   const handleDisconnect = useCallback11(async () => {
     if (!selectedServer) return;
-    await disconnectInspector();
+    const attempt = ++disconnectAttemptRef.current;
+    const attemptServer = selectedServer;
+    setDisconnectError(null);
+    try {
+      await disconnectInspector();
+    } catch (err) {
+      if (disconnectAttemptRef.current !== attempt || selectedServerRef.current !== attemptServer) {
+        return;
+      }
+      setDisconnectError(err instanceof Error ? err.message : String(err));
+    }
   }, [selectedServer, disconnectInspector]);
   const handleClearOAuth = useCallback11(async () => {
     if (!selectedInspectorClient) return;
@@ -16121,9 +17323,9 @@ function App({
     }
     if (selectedServer) {
       if (input.toLowerCase() === "c" && (inspectorStatus === "disconnected" || inspectorStatus === "error")) {
-        handleConnect();
+        void handleConnect();
       } else if (input.toLowerCase() === "d" && (inspectorStatus === "connected" || inspectorStatus === "connecting")) {
-        handleDisconnect();
+        void handleDisconnect();
       }
     }
   });
@@ -16294,6 +17496,10 @@ function App({
                           oauthStatus === "error" && oauthMessage && /* @__PURE__ */ jsx16(Box27, { marginTop: 1, children: /* @__PURE__ */ jsxs15(Text24, { color: "red", children: [
                             "OAuth: ",
                             oauthMessage
+                          ] }) }),
+                          disconnectError && /* @__PURE__ */ jsx16(Box27, { marginTop: 1, children: /* @__PURE__ */ jsxs15(Text24, { color: "red", children: [
+                            "Disconnect failed: ",
+                            disconnectError
                           ] }) })
                         ] })
                       }