@modelcontextprotocol/inspector 2.1.0 → 2.3.0

package/clients/cli/build/index.js

@@ -83,9 +83,6 @@ function withConnectTimeout(settings, connectionTimeout) {
   };
 }
 
-// ../../core/auth/node/secret-store.ts
-import { AsyncEntry, findCredentialsAsync } from "@napi-rs/keyring";
-
 // ../../core/auth/secret-fields.ts
 var SECRET_FIELD_OAUTH_CLIENT_SECRET = "oauth-client-secret";
 var SECRET_FIELD_IDP_CLIENT_SECRET = "idp-client-secret";
@@ -93,6 +90,41 @@ var envSecretField = (envKey) => `env:${envKey}`;
 
 // ../../core/auth/node/secret-store.ts
 var SERVICE_NAME = "mcp-inspector";
+var keyringLoad;
+var KeyringModuleShapeError = class extends Error {
+  constructor(detail, options) {
+    super(`@napi-rs/keyring loaded but ${detail}`, options);
+    this.name = "KeyringModuleShapeError";
+  }
+};
+var checkKeyringShape = (mod) => {
+  try {
+    if (typeof mod.AsyncEntry === "function" && typeof mod.findCredentialsAsync === "function") {
+      return { ok: true, mod };
+    }
+    return {
+      ok: false,
+      err: new KeyringModuleShapeError(
+        "did not expose AsyncEntry / findCredentialsAsync"
+      )
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      err: new KeyringModuleShapeError(
+        `its exports could not be read: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      )
+    };
+  }
+};
+var loadKeyring = () => {
+  keyringLoad ??= import("@napi-rs/keyring").then(
+    checkKeyringShape,
+    (err) => ({ ok: false, err })
+  );
+  return keyringLoad;
+};
 function parseAccount(account) {
   const idx = account.indexOf(":");
   if (idx <= 0 || idx === account.length - 1) return null;
@@ -104,16 +136,31 @@ function parseAccount(account) {
 var buildAccount = (serverId, field) => `${serverId}:${field}`;
 var KeychainUnavailableError = class extends Error {
   constructor(cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
     super(
-      `OS keychain is not available. On Linux, install libsecret / gnome-keyring. Underlying error: ${cause instanceof Error ? cause.message : String(cause)}`
+      `OS keychain is not available. ${hintFor(cause, message)} Underlying error: ${message}`
     );
     this.name = "KeychainUnavailableError";
   }
 };
+var hintFor = (cause, message) => {
+  if (cause instanceof KeyringModuleShapeError) {
+    return `The @napi-rs/keyring package loaded but does not expose the API this build expects \u2014 most likely a version or packaging mismatch; reinstall the Inspector, and report this if it persists.`;
+  }
+  if (message.includes("Cannot find native binding")) {
+    return `The @napi-rs/keyring platform package for this OS is missing or unavailable \u2014 reinstall the Inspector (for npx, clear the npx cache under your npm cache directory first).`;
+  }
+  return `On Linux, install libsecret / gnome-keyring.`;
+};
 var KeyringSecretStore = class {
   async get(serverId, field) {
-    const entry = new AsyncEntry(SERVICE_NAME, buildAccount(serverId, field));
     try {
+      const keyring = await loadKeyring();
+      if (!keyring.ok) return null;
+      const entry = new keyring.mod.AsyncEntry(
+        SERVICE_NAME,
+        buildAccount(serverId, field)
+      );
       const v2 = await entry.getPassword();
       return v2 ?? null;
     } catch {
@@ -121,16 +168,27 @@ var KeyringSecretStore = class {
     }
   }
   async set(serverId, field, value) {
-    const entry = new AsyncEntry(SERVICE_NAME, buildAccount(serverId, field));
     try {
+      const keyring = await loadKeyring();
+      if (!keyring.ok) throw new KeychainUnavailableError(keyring.err);
+      const entry = new keyring.mod.AsyncEntry(
+        SERVICE_NAME,
+        buildAccount(serverId, field)
+      );
       await entry.setPassword(value);
     } catch (err) {
+      if (err instanceof KeychainUnavailableError) throw err;
       throw new KeychainUnavailableError(err);
     }
   }
   async delete(serverId, field) {
-    const entry = new AsyncEntry(SERVICE_NAME, buildAccount(serverId, field));
     try {
+      const keyring = await loadKeyring();
+      if (!keyring.ok) return;
+      const entry = new keyring.mod.AsyncEntry(
+        SERVICE_NAME,
+        buildAccount(serverId, field)
+      );
       await entry.deleteCredential();
     } catch {
     }
@@ -138,7 +196,9 @@ var KeyringSecretStore = class {
   async deleteAllForServer(serverId) {
     let creds;
     try {
-      creds = await findCredentialsAsync(SERVICE_NAME);
+      const keyring = await loadKeyring();
+      if (!keyring.ok) return;
+      creds = await keyring.mod.findCredentialsAsync(SERVICE_NAME);
     } catch {
       return;
     }
@@ -347,6 +407,60 @@ function cleanRoots(roots) {
 function envRecordToPairs(env) {
   return env ? Object.entries(env).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 record2 = envPairsToRecord(settings.oauthAuthorizationParams);
+  return Object.keys(record2).length > 0 ? record2 : 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;
@@ -384,6 +498,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;
   }
@@ -2479,7 +2606,10 @@ import {
   ListToolsResultSchema,
   ListResourcesResultSchema,
   ListResourceTemplatesResultSchema,
-  ListPromptsResultSchema
+  ListPromptsResultSchema,
+  ResourceSchema,
+  ResourceTemplateSchema,
+  PromptSchema
 } from "@modelcontextprotocol/core";
 import { AjvJsonSchemaValidator } from "@modelcontextprotocol/client/validators/ajv";
 
@@ -2499,16 +2629,322 @@ function validateToolOutput(provider, tool, result) {
   }
 }
 
+// ../../core/mcp/listSalvage.ts
+import { z as z2 } 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]: z2.array(z2.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 = z2.looseObject({
+  resultType: z2.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: z2.int().min(0),
+  cacheScope: z2.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 record2 = value;
+  for (const key of ["name", "uriTemplate", "uri", "title"]) {
+    const candidate = record2[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 path2 = issue.path.join(".");
+  const detail = expectedDetail(issue);
+  const message = detail ? `${issue.message} (${detail})` : issue.message;
+  return path2.length > 0 ? `${path2}: ${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: z2.looseObject({
+    type: z2.literal("object"),
+    $schema: z2.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 z2 } from "zod/v4";
+import { z as z3 } from "zod/v4";
 var TasksListChangedNotificationSchema = NotificationSchema.extend({
-  method: z2.literal("notifications/tasks/list_changed"),
-  params: z2.record(z2.string(), z2.unknown()).optional()
+  method: z3.literal("notifications/tasks/list_changed"),
+  params: z3.record(z3.string(), z3.unknown()).optional()
 });
 
-// ../../core/mcp/inspectorClient.ts
+// ../../core/mcp/uriTemplate.ts
 import { UriTemplate } from "@modelcontextprotocol/client";
+var OPERATORS = ["+", "#", ".", "/", ";", "?", "&"];
+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 literal2 = "";
+  let i2 = 0;
+  while (i2 < uriTemplate.length) {
+    if (uriTemplate[i2] !== "{") {
+      literal2 += uriTemplate[i2];
+      i2 += 1;
+      continue;
+    }
+    const end = uriTemplate.indexOf("}", i2);
+    if (end === -1) {
+      literal2 += uriTemplate.slice(i2);
+      break;
+    }
+    if (literal2) {
+      parts.push({ kind: "literal", text: literal2 });
+      literal2 = "";
+    }
+    const body = uriTemplate.slice(i2 + 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(i2, end + 1),
+      operator,
+      varspecs,
+      names: varspecs.map((spec) => spec.name),
+      invalid: parsed.includes("invalid")
+    });
+    i2 = end + 1;
+  }
+  if (literal2) parts.push({ kind: "literal", text: literal2 });
+  return parts;
+}
+function readValue(values, name) {
+  return Object.hasOwn(values, name) ? values[name] : void 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 {
@@ -2775,6 +3211,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((path2) => pathname.includes(path2));
+}
+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 = () => {
 };
@@ -2794,6 +3360,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 = "";
@@ -2829,12 +3430,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
@@ -2941,6 +3545,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) {
@@ -3805,7 +4430,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);
@@ -3922,6 +4547,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
@@ -3945,7 +4594,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();
@@ -4629,6 +5283,7 @@ async function* parseSSE(reader) {
 }
 var RemoteClientTransport = class {
   _sessionId = void 0;
+  _protocolVersion = void 0;
   eventStreamReader = null;
   eventStreamAbort = null;
   eventStreamConsumeTask = null;
@@ -4651,6 +5306,21 @@ var RemoteClientTransport = class {
   getRemoteBackendSessionId() {
     return this._sessionId;
   }
+  /**
+   * The SDK Client calls this with the negotiated protocol version as soon as
+   * `initialize` resolves — before it sends `notifications/initialized` — so an
+   * HTTP transport can stamp `Mcp-Protocol-Version` on every later request.
+   *
+   * Here the real upstream transport lives on the backend, so we can only
+   * record the version and forward it on the next `/api/mcp/send`, which
+   * applies it to the upstream transport *before* sending. Because
+   * `notifications/initialized` is that next send, it and everything after it
+   * (including the standalone SSE GET and the session DELETE, both issued by
+   * the upstream transport itself) carry the header (#1935).
+   */
+  setProtocolVersion(version) {
+    this._protocolVersion = version;
+  }
   /**
    * Reattach to an existing remote backend session after a full-page OAuth
    * redirect. Opens the SSE event stream without POST /connect.
@@ -5020,7 +5690,12 @@ var RemoteClientTransport = class {
       },
       // Forward per-send `Mcp-Param-*` headers (SEP-2243) for the backend to
       // apply to the upstream send; the browser can't set them cross-origin.
-      ...options?.headers != null && { headers: options.headers }
+      ...options?.headers != null && { headers: options.headers },
+      // Forward the negotiated protocol version so the backend's transport can
+      // stamp `Mcp-Protocol-Version` on this and every later request (#1935).
+      ...this._protocolVersion !== void 0 && {
+        protocolVersion: this._protocolVersion
+      }
     };
     const res = await this.fetchFn(`${this.baseUrl}/api/mcp/send`, {
       method: "POST",
@@ -5101,6 +5776,13 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   outputValidator = null;
   transport = null;
   baseTransport = null;
+  // Correlation for `markResponseRejected` (#1953): the method of each
+  // outbound request still awaiting a response, and — once one is answered —
+  // the id of the most recently answered request per method. Entries are
+  // dropped as responses arrive, so this holds at most one id per method
+  // rather than growing with the session.
+  outboundRequestMethods = /* @__PURE__ */ new Map();
+  lastAnsweredRequestByMethod = /* @__PURE__ */ new Map();
   /** True when the cached transport was built with an OAuth authProvider attached. */
   transportHasAuthProvider = false;
   /** Dedupes concurrent ambient auth challenges (reason + scopes). */
@@ -5143,6 +5825,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
@@ -5211,7 +5898,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   // `McpSubscription` whose filter's `resourceSubscriptions` mirrors
   // `subscribedResources`; mutating the set re-lists (close old, open new), and
   // an unexpected `"remote"` close re-lists (reconnect-by-re-listen — the stream
-  // is not resumable). `null` when no URI is subscribed or on the legacy era.
+  // is not resumable). `null` on the legacy era, and on the modern era whenever
+  // the filter is empty — which is *not* the same as "no URI subscribed": the
+  // stream also carries the list-change opt-ins, so a tools-only server opens it
+  // with no subscriptions at all (#1920).
   modernSubscription = null;
   // Monotonic guard so a stale re-list/reconnect (whose `listen()` or `closed`
   // resolves after a newer refresh already started) can detect it lost the race
@@ -5318,6 +6008,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) {
@@ -5345,6 +6039,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;
@@ -5434,6 +6133,9 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   createMessageTrackingCallbacks() {
     return {
       trackRequest: (message, origin) => {
+        if (origin === "client") {
+          this.outboundRequestMethods.set(message.id, message.method);
+        }
         const entry = {
           id: crypto.randomUUID(),
           timestamp: /* @__PURE__ */ new Date(),
@@ -5444,6 +6146,14 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
         this.dispatchTypedEvent("message", entry);
       },
       trackResponse: (message, origin) => {
+        const responseId = message.id;
+        if (origin === "server" && responseId !== void 0) {
+          const method = this.outboundRequestMethods.get(responseId);
+          this.outboundRequestMethods.delete(responseId);
+          if (method !== void 0) {
+            this.lastAnsweredRequestByMethod.set(method, responseId);
+          }
+        }
         const entry = {
           id: crypto.randomUUID(),
           timestamp: /* @__PURE__ */ new Date(),
@@ -6001,6 +6711,16 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.clearReceiverTasks();
     this.resetSubscriptionStream();
     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"));
     }
@@ -6224,8 +6944,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       this.status = "connected";
       this.dispatchTypedEvent("statusChange", this.status);
       await this.fetchServerInfo();
-      this.dispatchTypedEvent("connect");
-      if (this.initialLoggingLevel && this.capabilities?.logging) {
+      if (this.initialLoggingLevel && this.capabilities?.logging && this.protocolEra !== "modern") {
         await this.client.setLoggingLevel(
           this.initialLoggingLevel,
           this.getRequestOptions()
@@ -6303,6 +7022,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
           );
         }
       }
+      await this.openModernListenStreamOnConnect();
+      if (this.status === "connected" && !this.disconnecting) {
+        this.dispatchTypedEvent("connect");
+      }
     } catch (error) {
       if (!isConnectAuthRecoveryError(error)) {
         this.status = "error";
@@ -6366,6 +7089,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(
@@ -6379,6 +7103,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
@@ -6472,7 +7197,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
@@ -6484,6 +7208,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,
@@ -7080,7 +7824,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(
@@ -7108,15 +7856,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)
-      )
-    );
-    await this.refreshExcludedTools(options?.metadata).catch(() => {
+    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`
@@ -7127,6 +7889,222 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   excludesInvalidXMcpHeaderTools() {
     return this.isModernEra() && this.getServerType() !== "stdio";
   }
+  /**
+   * Mark the response that most recently answered `method` as rejected by the
+   * client, so its Protocol entry shows why instead of rendering as a clean
+   * success (#1953).
+   *
+   * The SDK gives no request id with a decode failure — `SdkError` carries the
+   * method and nothing else — so the id is recovered by correlation: the last
+   * response received for that method. That is exact rather than approximate,
+   * because the SDK rejects synchronously while decoding the response (inside
+   * the transport's `onmessage`) and the caller's `catch` runs in the very next
+   * microtask. Delivering another response for the same method in that window
+   * would take a macrotask (a socket read), which cannot interleave there.
+   *
+   * A no-op when nothing has answered `method` this session.
+   */
+  markResponseRejected(method, reason) {
+    const id = this.lastAnsweredRequestByMethod.get(method);
+    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;
@@ -7145,8 +8123,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 });
@@ -7162,6 +8143,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)
@@ -7948,13 +9013,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
@@ -8010,8 +9082,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)}`,
@@ -8073,14 +9144,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
@@ -8119,13 +9196,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
@@ -8394,9 +9478,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    * opted-in notification type (SEP §7.4).
    */
   buildSubscriptionFilter() {
-    const filter = {
-      resourceSubscriptions: Array.from(this.subscribedResources)
-    };
+    const filter = {};
+    if (this.subscribedResources.size > 0) {
+      filter.resourceSubscriptions = Array.from(this.subscribedResources);
+    }
     if (this.listChangedNotifications.tools && this.capabilities?.tools?.listChanged) {
       filter.toolsListChanged = true;
     }
@@ -8408,6 +9493,74 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     }
     return filter;
   }
+  /**
+   * Whether the modern listen stream should be open: the built filter carries
+   * something to listen for (#1920). Before #1920 this was "at least one URI is
+   * subscribed", which made the stream unreachable on a server with no resources
+   * — a tools-only server advertising `tools.listChanged` had no way to open it,
+   * so `notifications/tools/list_changed` could never arrive. The filter already
+   * modelled the list-change opt-ins; only the trigger was narrower than the
+   * filter it built. This matches the SDK's own `ClientOptions.listChanged`
+   * auto-open, which opens whenever the effective (config ∩ capability)
+   * intersection is non-empty.
+   *
+   * Note this is deliberately *not* the same predicate as the stream state's
+   * `active` — see `modernStreamActive()`.
+   */
+  wantsModernStream() {
+    const filter = this.buildSubscriptionFilter();
+    return (filter.resourceSubscriptions?.length ?? 0) > 0 || filter.toolsListChanged === true || filter.resourcesListChanged === true || filter.promptsListChanged === true;
+  }
+  /**
+   * Whether the stream state reports `active` — i.e. whether the *Subscriptions*
+   * UI has a stream to describe. That is a narrower question than
+   * `wantsModernStream()`: `ResourceSubscriptionStreamState` drives the
+   * Subscriptions section's badge, so a stream open purely for list-change
+   * notifications (no subscribed URI) has nothing to report there and stays
+   * `active: false` (#1920). Keeping the two apart also preserves the invariant
+   * the rest of this file is written against — an empty subscribed set is never
+   * announced alongside an `active` stream.
+   */
+  modernStreamActive() {
+    return this.subscribedResources.size > 0;
+  }
+  /**
+   * Open the modern listen stream at the end of a successful connect, when the
+   * filter is non-empty (#1920). Only the list-change opt-ins can make it
+   * non-empty here — the subscribed set is emptied by `resetSessionState()` on
+   * the way in — so this is exactly the "server advertises a listChanged the
+   * Inspector wants" case that had no trigger before.
+   *
+   * A failure is not allowed to fail the connect: the handshake succeeded and
+   * every request-scoped feature works without this stream. It is reported the
+   * way a lost stream is — hand it to the reconnect machinery, which retries
+   * with backoff and settles on `"ended"` past the cap.
+   *
+   * Gated on the same generation test as `subscribeToResource` — see the long
+   * comment there. The `connect` event has deliberately *not* been dispatched
+   * yet (that is the point of running here), so a list-state consumer is not the
+   * risk; what is, is anything else that bumps the generation while this
+   * `listen()` is in flight. `statusChange` has already fired, and any
+   * concurrent call on this instance qualifies: a `subscribeToResource` from a
+   * caller restoring subscriptions, or a `disconnect()` — whose
+   * `resetSubscriptionStream` bumps the generation too, making a reconcile here
+   * arm a reconnect for a session that is already gone.
+   */
+  async openModernListenStreamOnConnect() {
+    if (!this.isModernEra() || !this.wantsModernStream()) return;
+    const generationBefore = this.modernListenGeneration;
+    try {
+      await this.refreshModernSubscription();
+    } catch (error) {
+      this.logger.error(
+        { error },
+        "Failed to open the modern subscriptions/listen stream on connect"
+      );
+      if (this.modernListenGeneration === generationBefore + 1) {
+        this.reconcileModernStreamStateAfterFailedRefresh();
+      }
+    }
+  }
   /** Cancel a pending reconnect re-listen, if any (#1630). */
   clearModernReconnectTimer() {
     if (this.modernReconnectTimer !== void 0) {
@@ -8417,9 +9570,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   }
   /**
    * (Re-)establish the modern `subscriptions/listen` stream to match the current
-   * `subscribedResources` set (#1630). Because the stream is not resumable,
-   * every filter change re-lists: the existing stream is closed and a fresh
-   * `listen()` opened. With no subscribed URIs the stream is left closed.
+   * filter (#1630). Because the stream is not resumable, every filter change
+   * re-lists: the existing stream is closed and a fresh `listen()` opened. With
+   * an empty filter — no subscribed URIs *and* no enabled list-change opt-in the
+   * server advertises — the stream is left closed (#1920).
    *
    * `modernListenGeneration` guards against races — if a newer refresh starts
    * while this one awaits its acknowledgement, the just-opened stream is
@@ -8437,7 +9591,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     if (previous) {
       await closeSubscriptionBestEffort(previous);
     }
-    if (this.subscribedResources.size === 0) {
+    if (!this.wantsModernStream()) {
       this.setModernStreamState(INACTIVE_SUBSCRIPTION_STREAM_STATE);
       return;
     }
@@ -8452,7 +9606,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.modernSubscription = subscription;
     this.modernReconnectAttempts = 0;
     this.setModernStreamState({
-      active: true,
+      active: this.modernStreamActive(),
       status: "acknowledged",
       honoredUris: subscription.honoredFilter.resourceSubscriptions ?? []
     });
@@ -8483,10 +9637,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       return;
     }
     this.modernSubscription = null;
-    const shouldReconnect = reason === "remote" && !isTerminalStatus(this.status) && this.subscribedResources.size > 0;
+    const shouldReconnect = reason === "remote" && !isTerminalStatus(this.status) && this.wantsModernStream();
     if (!shouldReconnect) {
       this.setModernStreamState({
-        active: this.subscribedResources.size > 0,
+        active: this.modernStreamActive(),
         status: "ended",
         honoredUris: []
       });
@@ -8500,10 +9654,11 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    * refresh owns the state as well as the filter — so both call sites gate on
    * the generation first.
    *
-   * The empty case is the ordinary one: nothing subscribed, no stream, inactive.
-   * The non-empty one exists because a failed re-listen leaves
-   * `modernSubscription` null with URIs still subscribed, and nothing else will
-   * notice: the reconnect machinery is reachable only from a stream that closed
+   * The two branches are the empty and non-empty *filter* (#1920) — which is
+   * "nothing subscribed" only when no list-change opt-in is live. The empty case
+   * is the ordinary one: nothing to listen for, no stream, inactive. The
+   * non-empty one exists because a failed re-listen leaves `modernSubscription`
+   * null with the filter still wanting a stream, and nothing else will notice: the reconnect machinery is reachable only from a stream that closed
    * or a reconnect that failed, and neither happened here. Left alone, the state
    * keeps whatever the last success (or the optimistic `"connecting"`) wrote — a
    * badge that will never change over subscriptions the server may never have
@@ -8511,17 +9666,17 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    * Subscribe early-returns on the URI already being in the set).
    *
    * So it reconnects rather than settling for an honest-but-dead `"ended"`:
-   * every other route to "stream gone, URIs live" either expects the close or
+   * every other route to "stream gone, filter live" either expects the close or
    * has exhausted the retry cap, and this is the one that has made no attempt
    * at all. `scheduleModernReconnect` fits as-is — a user-initiated refresh
    * already reset `modernReconnectAttempts`, so it starts at the base delay; the
-   * timer bails on a terminal status or an emptied set; and past the cap
+   * timer bails on a terminal status or an emptied filter; and past the cap
    * `onModernReconnectFailed` lands on the same `"ended"` badge. The state
    * therefore becomes true or ends after a real attempt. The caller still sees
    * its error either way — the retry is about the subscriptions, not the call.
    */
   reconcileModernStreamStateAfterFailedRefresh() {
-    if (this.subscribedResources.size === 0) {
+    if (!this.wantsModernStream()) {
       this.setModernStreamState(INACTIVE_SUBSCRIPTION_STREAM_STATE);
       return;
     }
@@ -8535,7 +9690,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    */
   scheduleModernReconnect() {
     this.setModernStreamState({
-      active: true,
+      active: this.modernStreamActive(),
       status: "reconnecting",
       honoredUris: []
     });
@@ -8546,7 +9701,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.clearModernReconnectTimer();
     this.modernReconnectTimer = setTimeout(() => {
       this.modernReconnectTimer = void 0;
-      if (isTerminalStatus(this.status) || this.subscribedResources.size === 0) {
+      if (isTerminalStatus(this.status) || !this.wantsModernStream()) {
         return;
       }
       this.refreshModernSubscription(true).catch(
@@ -8561,9 +9716,9 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    */
   onModernReconnectFailed() {
     this.modernReconnectAttempts += 1;
-    if (this.modernReconnectAttempts > MODERN_RECONNECT_MAX_ATTEMPTS || isTerminalStatus(this.status) || this.subscribedResources.size === 0) {
+    if (this.modernReconnectAttempts > MODERN_RECONNECT_MAX_ATTEMPTS || isTerminalStatus(this.status) || !this.wantsModernStream()) {
       this.setModernStreamState({
-        active: this.subscribedResources.size > 0,
+        active: this.modernStreamActive(),
         status: "ended",
         honoredUris: []
       });
@@ -9216,6 +10371,11 @@ var ManagedListState = class extends TypedEventTarget {
   unsubscribe = null;
   _metadata = void 0;
   listChanged = false;
+  // The last fetch's failure, kept as observable state so a load that fails
+  // (a transport error, or a result the SDK codec rejects as invalid) is
+  // rendered by the list panel instead of vanishing into an unhandled
+  // rejection — which read as "this server has no tools" (#1953).
+  error = null;
   config;
   // Debounce a burst of `list_changed` notifications into a single
   // refresh (or one indicator light) once it settles.
@@ -9234,7 +10394,8 @@ var ManagedListState = class extends TypedEventTarget {
       if (this.config.deferWhenPaginated && this.client?.getServerSettings()?.paginatedLists) {
         return;
       }
-      void this.refresh();
+      void this.refresh().catch(() => {
+      });
     };
     const onListChanged = () => {
       if (this.listChangedTimer !== null) clearTimeout(this.listChangedTimer);
@@ -9252,6 +10413,7 @@ var ManagedListState = class extends TypedEventTarget {
         this.items = [];
         this.dispatchChange();
         this.setListChanged(false);
+        this.setError(null);
       }
     };
     this.client.addEventListener("connect", onConnect);
@@ -9293,7 +10455,8 @@ var ManagedListState = class extends TypedEventTarget {
         const settings = this.client?.getServerSettings();
         const skipAggregate = this.config.deferWhenPaginated && settings?.paginatedLists;
         if (!skipAggregate && settings?.autoRefreshOnListChanged) {
-          await this.refresh(void 0, "refresh");
+          await this.refresh(void 0, "refresh").catch(() => {
+          });
         } else if (this.config.supportsIndicator) {
           this.setListChanged(true);
         }
@@ -9335,6 +10498,18 @@ var ManagedListState = class extends TypedEventTarget {
     this.listChanged = value;
     this.emit("listChangedChange", value);
   }
+  /** The last fetch's failure, or `null` when the last fetch succeeded. */
+  getError() {
+    return this.error;
+  }
+  // Compared by identity rather than message: two distinct failures with the
+  // same text are still two events, and a re-render on a repeat failure is
+  // cheap next to silently coalescing them.
+  setError(value) {
+    if (this.error === value) return;
+    this.error = value;
+    this.emit("errorChange", value);
+  }
   setMetadata(metadata) {
     this._metadata = metadata;
   }
@@ -9343,9 +10518,29 @@ var ManagedListState = class extends TypedEventTarget {
    * this fetch: `undefined` (the connect-time load) uses the default `'use'`;
    * a user-initiated or auto refresh passes `'refresh'` to force a
    * cache-bypassing round trip and re-store the fresh aggregate.
+   *
+   * A failure is recorded as observable state (`getError`) AND re-thrown: the
+   * state drives the panel's error rendering, while the rejection is what the
+   * caller's auth-recovery wrapper keys off to detect a 401 and start a
+   * re-authorization. Callers with nobody to await them (the connect-time load,
+   * the `list_changed` auto-refresh) catch it explicitly (#1953).
    */
   async refresh(metadata, cacheMode) {
-    const next = await this.fetchItems(metadata, cacheMode);
+    let next;
+    try {
+      next = await this.fetchItems(metadata, cacheMode);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.setError(error);
+      if (isClientDecodeRejection(err)) {
+        this.client?.markResponseRejected?.(
+          this.config.listMethod,
+          error.message
+        );
+      }
+      throw err;
+    }
+    this.setError(null);
     if (next === null) return this.getItems();
     this.applyItems(next);
     return this.getItems();
@@ -9384,6 +10579,7 @@ var ManagedListState = class extends TypedEventTarget {
 var ManagedToolsState = class extends ManagedListState {
   constructor(client, debounceMs = DEFAULT_LIST_CHANGED_DEBOUNCE_MS) {
     super(client, {
+      listMethod: "tools/list",
       changeEvent: "toolsChange",
       listChangedEvent: "toolsListChanged",
       capabilityKey: "tools",
@@ -9445,6 +10641,20 @@ var MessageLogState = class extends TypedEventTarget {
       }
       pushEntry(entry);
     };
+    const onResponseRejected = (event) => {
+      const { id, reason } = event.detail;
+      for (let i2 = this.messages.length - 1; i2 >= 0; i2--) {
+        const entry = this.messages[i2];
+        const entryId = entry.message.id;
+        if (entryId !== id) continue;
+        if (entry.direction === "notification") continue;
+        if (entry.direction === "request" && !entry.response) continue;
+        entry.clientError = reason;
+        this.dispatchTypedEvent("message", entry);
+        this.dispatchTypedEvent("messagesChange", this.getMessages());
+        return;
+      }
+    };
     const onStatusChange = () => {
       if (isTerminalStatus(this.client?.getStatus())) {
         this.messages = [];
@@ -9453,10 +10663,12 @@ var MessageLogState = class extends TypedEventTarget {
       }
     };
     this.client.addEventListener("message", onMessage);
+    this.client.addEventListener("responseRejected", onResponseRejected);
     this.client.addEventListener("statusChange", onStatusChange);
     this.unsubscribe = () => {
       if (this.client) {
         this.client.removeEventListener("message", onMessage);
+        this.client.removeEventListener("responseRejected", onResponseRejected);
         this.client.removeEventListener("statusChange", onStatusChange);
       }
       this.client = null;
@@ -9502,6 +10714,7 @@ var MessageLogState = class extends TypedEventTarget {
 var ManagedResourcesState = class extends ManagedListState {
   constructor(client, debounceMs = DEFAULT_LIST_CHANGED_DEBOUNCE_MS) {
     super(client, {
+      listMethod: "resources/list",
       changeEvent: "resourcesChange",
       listChangedEvent: "resourcesListChanged",
       capabilityKey: "resources",
@@ -9523,6 +10736,7 @@ var ManagedResourcesState = class extends ManagedListState {
 var ManagedResourceTemplatesState = class extends ManagedListState {
   constructor(client, debounceMs = DEFAULT_LIST_CHANGED_DEBOUNCE_MS) {
     super(client, {
+      listMethod: "resources/templates/list",
       changeEvent: "resourceTemplatesChange",
       listChangedEvent: "resourceTemplatesListChanged",
       // Templates are gated on the broader `resources` capability.
@@ -9550,6 +10764,7 @@ var ManagedResourceTemplatesState = class extends ManagedListState {
 var ManagedPromptsState = class extends ManagedListState {
   constructor(client, debounceMs = DEFAULT_LIST_CHANGED_DEBOUNCE_MS) {
     super(client, {
+      listMethod: "prompts/list",
       changeEvent: "promptsChange",
       listChangedEvent: "promptsListChanged",
       capabilityKey: "prompts",
@@ -9758,29 +10973,29 @@ var ManagedRequestorTasksState = class extends TypedEventTarget {
 };
 
 // ../../node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
-import * as z3 from "zod/v4";
+import * as z4 from "zod/v4";
 var RELATED_TASK_META_KEY4 = "io.modelcontextprotocol/related-task";
 var JSONRPC_VERSION = "2.0";
-var AssertObjectSchema = z3.custom((v2) => v2 !== null && (typeof v2 === "object" || typeof v2 === "function"));
-var ProgressTokenSchema = z3.union([z3.string(), z3.number().int()]);
-var CursorSchema = z3.string();
-var TaskCreationParamsSchema = z3.looseObject({
+var AssertObjectSchema = z4.custom((v2) => v2 !== null && (typeof v2 === "object" || typeof v2 === "function"));
+var ProgressTokenSchema = z4.union([z4.string(), z4.number().int()]);
+var CursorSchema = z4.string();
+var TaskCreationParamsSchema = z4.looseObject({
   /**
    * Requested duration in milliseconds to retain task from creation.
    */
-  ttl: z3.number().optional(),
+  ttl: z4.number().optional(),
   /**
    * Time in milliseconds to wait between task status requests.
    */
-  pollInterval: z3.number().optional()
+  pollInterval: z4.number().optional()
 });
-var TaskMetadataSchema = z3.object({
-  ttl: z3.number().optional()
+var TaskMetadataSchema = z4.object({
+  ttl: z4.number().optional()
 });
-var RelatedTaskMetadataSchema = z3.object({
-  taskId: z3.string()
+var RelatedTaskMetadataSchema = z4.object({
+  taskId: z4.string()
 });
-var RequestMetaSchema = z3.looseObject({
+var RequestMetaSchema = z4.looseObject({
   /**
    * If specified, the caller is requesting out-of-band progress notifications for this request (as represented by notifications/progress). The value of this parameter is an opaque token that will be attached to any subsequent notifications. The receiver is not obligated to provide these notifications.
    */
@@ -9790,7 +11005,7 @@ var RequestMetaSchema = z3.looseObject({
    */
   [RELATED_TASK_META_KEY4]: RelatedTaskMetadataSchema.optional()
 });
-var BaseRequestParamsSchema = z3.object({
+var BaseRequestParamsSchema = z4.object({
   /**
    * See [General fields: `_meta`](/specification/draft/basic/index#meta) for notes on `_meta` usage.
    */
@@ -9807,40 +11022,40 @@ var TaskAugmentedRequestParamsSchema = BaseRequestParamsSchema.extend({
    */
   task: TaskMetadataSchema.optional()
 });
-var RequestSchema = z3.object({
-  method: z3.string(),
+var RequestSchema = z4.object({
+  method: z4.string(),
   params: BaseRequestParamsSchema.loose().optional()
 });
-var NotificationsParamsSchema = z3.object({
+var NotificationsParamsSchema = z4.object({
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
   _meta: RequestMetaSchema.optional()
 });
-var NotificationSchema2 = z3.object({
-  method: z3.string(),
+var NotificationSchema2 = z4.object({
+  method: z4.string(),
   params: NotificationsParamsSchema.loose().optional()
 });
-var ResultSchema = z3.looseObject({
+var ResultSchema = z4.looseObject({
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
   _meta: RequestMetaSchema.optional()
 });
-var RequestIdSchema = z3.union([z3.string(), z3.number().int()]);
-var JSONRPCRequestSchema = z3.object({
-  jsonrpc: z3.literal(JSONRPC_VERSION),
+var RequestIdSchema = z4.union([z4.string(), z4.number().int()]);
+var JSONRPCRequestSchema = z4.object({
+  jsonrpc: z4.literal(JSONRPC_VERSION),
   id: RequestIdSchema,
   ...RequestSchema.shape
 }).strict();
-var JSONRPCNotificationSchema = z3.object({
-  jsonrpc: z3.literal(JSONRPC_VERSION),
+var JSONRPCNotificationSchema = z4.object({
+  jsonrpc: z4.literal(JSONRPC_VERSION),
   ...NotificationSchema2.shape
 }).strict();
-var JSONRPCResultResponseSchema = z3.object({
-  jsonrpc: z3.literal(JSONRPC_VERSION),
+var JSONRPCResultResponseSchema = z4.object({
+  jsonrpc: z4.literal(JSONRPC_VERSION),
   id: RequestIdSchema,
   result: ResultSchema
 }).strict();
@@ -9855,31 +11070,31 @@ var ErrorCode;
   ErrorCode2[ErrorCode2["InternalError"] = -32603] = "InternalError";
   ErrorCode2[ErrorCode2["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
 })(ErrorCode || (ErrorCode = {}));
-var JSONRPCErrorResponseSchema = z3.object({
-  jsonrpc: z3.literal(JSONRPC_VERSION),
+var JSONRPCErrorResponseSchema = z4.object({
+  jsonrpc: z4.literal(JSONRPC_VERSION),
   id: RequestIdSchema.optional(),
-  error: z3.object({
+  error: z4.object({
     /**
      * The error type that occurred.
      */
-    code: z3.number().int(),
+    code: z4.number().int(),
     /**
      * A short description of the error. The message SHOULD be limited to a concise single sentence.
      */
-    message: z3.string(),
+    message: z4.string(),
     /**
      * Additional information about the error. The value of this member is defined by the sender (e.g. detailed error information, nested errors etc.).
      */
-    data: z3.unknown().optional()
+    data: z4.unknown().optional()
   })
 }).strict();
-var JSONRPCMessageSchema = z3.union([
+var JSONRPCMessageSchema = z4.union([
   JSONRPCRequestSchema,
   JSONRPCNotificationSchema,
   JSONRPCResultResponseSchema,
   JSONRPCErrorResponseSchema
 ]);
-var JSONRPCResponseSchema = z3.union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
+var JSONRPCResponseSchema = z4.union([JSONRPCResultResponseSchema, JSONRPCErrorResponseSchema]);
 var EmptyResultSchema2 = ResultSchema.strict();
 var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
   /**
@@ -9891,28 +11106,28 @@ var CancelledNotificationParamsSchema = NotificationsParamsSchema.extend({
   /**
    * An optional string describing the reason for the cancellation. This MAY be logged or presented to the user.
    */
-  reason: z3.string().optional()
+  reason: z4.string().optional()
 });
 var CancelledNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/cancelled"),
+  method: z4.literal("notifications/cancelled"),
   params: CancelledNotificationParamsSchema
 });
-var IconSchema = z3.object({
+var IconSchema = z4.object({
   /**
    * URL or data URI for the icon.
    */
-  src: z3.string(),
+  src: z4.string(),
   /**
    * Optional MIME type for the icon.
    */
-  mimeType: z3.string().optional(),
+  mimeType: z4.string().optional(),
   /**
    * Optional array of strings that specify sizes at which the icon can be used.
    * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
    *
    * If not provided, the client should assume that the icon can be used at any size.
    */
-  sizes: z3.array(z3.string()).optional(),
+  sizes: z4.array(z4.string()).optional(),
   /**
    * Optional specifier for the theme this icon is designed for. `light` indicates
    * the icon is designed to be used with a light background, and `dark` indicates
@@ -9920,9 +11135,9 @@ var IconSchema = z3.object({
    *
    * If not provided, the client should assume the icon can be used with any theme.
    */
-  theme: z3.enum(["light", "dark"]).optional()
+  theme: z4.enum(["light", "dark"]).optional()
 });
-var IconsSchema = z3.object({
+var IconsSchema = z4.object({
   /**
    * Optional set of sized icons that the client can display in a user interface.
    *
@@ -9934,11 +11149,11 @@ var IconsSchema = z3.object({
    * - `image/svg+xml` - SVG images (scalable but requires security precautions)
    * - `image/webp` - WebP images (modern, efficient format)
    */
-  icons: z3.array(IconSchema).optional()
+  icons: z4.array(IconSchema).optional()
 });
-var BaseMetadataSchema = z3.object({
+var BaseMetadataSchema = z4.object({
   /** Intended for programmatic or logical use, but used as a display name in past specs or fallback */
-  name: z3.string(),
+  name: z4.string(),
   /**
    * Intended for UI and end-user contexts — optimized to be human-readable and easily understood,
    * even by those unfamiliar with domain-specific terminology.
@@ -9947,16 +11162,16 @@ var BaseMetadataSchema = z3.object({
    * where `annotations.title` should be given precedence over using `name`,
    * if present).
    */
-  title: z3.string().optional()
+  title: z4.string().optional()
 });
 var ImplementationSchema = BaseMetadataSchema.extend({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
-  version: z3.string(),
+  version: z4.string(),
   /**
    * An optional URL of the website for this implementation.
    */
-  websiteUrl: z3.string().optional(),
+  websiteUrl: z4.string().optional(),
   /**
    * An optional human-readable description of what this implementation does.
    *
@@ -9964,23 +11179,23 @@ var ImplementationSchema = BaseMetadataSchema.extend({
    * and capabilities. For example, a server might describe the types of resources
    * or tools it provides, while a client might describe its intended use case.
    */
-  description: z3.string().optional()
+  description: z4.string().optional()
 });
-var FormElicitationCapabilitySchema = z3.intersection(z3.object({
-  applyDefaults: z3.boolean().optional()
-}), z3.record(z3.string(), z3.unknown()));
-var ElicitationCapabilitySchema = z3.preprocess((value) => {
+var FormElicitationCapabilitySchema = z4.intersection(z4.object({
+  applyDefaults: z4.boolean().optional()
+}), z4.record(z4.string(), z4.unknown()));
+var ElicitationCapabilitySchema = z4.preprocess((value) => {
   if (value && typeof value === "object" && !Array.isArray(value)) {
     if (Object.keys(value).length === 0) {
       return { form: {} };
     }
   }
   return value;
-}, z3.intersection(z3.object({
+}, z4.intersection(z4.object({
   form: FormElicitationCapabilitySchema.optional(),
   url: AssertObjectSchema.optional()
-}), z3.record(z3.string(), z3.unknown()).optional()));
-var ClientTasksCapabilitySchema = z3.looseObject({
+}), z4.record(z4.string(), z4.unknown()).optional()));
+var ClientTasksCapabilitySchema = z4.looseObject({
   /**
    * Present if the client supports listing tasks.
    */
@@ -9992,22 +11207,22 @@ var ClientTasksCapabilitySchema = z3.looseObject({
   /**
    * Capabilities for task creation on specific request types.
    */
-  requests: z3.looseObject({
+  requests: z4.looseObject({
     /**
      * Task support for sampling requests.
      */
-    sampling: z3.looseObject({
+    sampling: z4.looseObject({
       createMessage: AssertObjectSchema.optional()
     }).optional(),
     /**
      * Task support for elicitation requests.
      */
-    elicitation: z3.looseObject({
+    elicitation: z4.looseObject({
       create: AssertObjectSchema.optional()
     }).optional()
   }).optional()
 });
-var ServerTasksCapabilitySchema = z3.looseObject({
+var ServerTasksCapabilitySchema = z4.looseObject({
   /**
    * Present if the server supports listing tasks.
    */
@@ -10019,24 +11234,24 @@ var ServerTasksCapabilitySchema = z3.looseObject({
   /**
    * Capabilities for task creation on specific request types.
    */
-  requests: z3.looseObject({
+  requests: z4.looseObject({
     /**
      * Task support for tool requests.
      */
-    tools: z3.looseObject({
+    tools: z4.looseObject({
       call: AssertObjectSchema.optional()
     }).optional()
   }).optional()
 });
-var ClientCapabilitiesSchema = z3.object({
+var ClientCapabilitiesSchema = z4.object({
   /**
    * Experimental, non-standard capabilities that the client supports.
    */
-  experimental: z3.record(z3.string(), AssertObjectSchema).optional(),
+  experimental: z4.record(z4.string(), AssertObjectSchema).optional(),
   /**
    * Present if the client supports sampling from an LLM.
    */
-  sampling: z3.object({
+  sampling: z4.object({
     /**
      * Present if the client supports context inclusion via includeContext parameter.
      * If not declared, servers SHOULD only use `includeContext: "none"` (or omit it).
@@ -10054,11 +11269,11 @@ var ClientCapabilitiesSchema = z3.object({
   /**
    * Present if the client supports listing roots.
    */
-  roots: z3.object({
+  roots: z4.object({
     /**
      * Whether the client supports issuing notifications for changes to the roots list.
      */
-    listChanged: z3.boolean().optional()
+    listChanged: z4.boolean().optional()
   }).optional(),
   /**
    * Present if the client supports task creation.
@@ -10067,25 +11282,25 @@ var ClientCapabilitiesSchema = z3.object({
   /**
    * Extensions that the client supports. Keys are extension identifiers (vendor-prefix/extension-name).
    */
-  extensions: z3.record(z3.string(), AssertObjectSchema).optional()
+  extensions: z4.record(z4.string(), AssertObjectSchema).optional()
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   /**
    * The latest version of the Model Context Protocol that the client supports. The client MAY decide to support older versions as well.
    */
-  protocolVersion: z3.string(),
+  protocolVersion: z4.string(),
   capabilities: ClientCapabilitiesSchema,
   clientInfo: ImplementationSchema
 });
 var InitializeRequestSchema = RequestSchema.extend({
-  method: z3.literal("initialize"),
+  method: z4.literal("initialize"),
   params: InitializeRequestParamsSchema
 });
-var ServerCapabilitiesSchema = z3.object({
+var ServerCapabilitiesSchema = z4.object({
   /**
    * Experimental, non-standard capabilities that the server supports.
    */
-  experimental: z3.record(z3.string(), AssertObjectSchema).optional(),
+  experimental: z4.record(z4.string(), AssertObjectSchema).optional(),
   /**
    * Present if the server supports sending log messages to the client.
    */
@@ -10097,33 +11312,33 @@ var ServerCapabilitiesSchema = z3.object({
   /**
    * Present if the server offers any prompt templates.
    */
-  prompts: z3.object({
+  prompts: z4.object({
     /**
      * Whether this server supports issuing notifications for changes to the prompt list.
      */
-    listChanged: z3.boolean().optional()
+    listChanged: z4.boolean().optional()
   }).optional(),
   /**
    * Present if the server offers any resources to read.
    */
-  resources: z3.object({
+  resources: z4.object({
     /**
      * Whether this server supports clients subscribing to resource updates.
      */
-    subscribe: z3.boolean().optional(),
+    subscribe: z4.boolean().optional(),
     /**
      * Whether this server supports issuing notifications for changes to the resource list.
      */
-    listChanged: z3.boolean().optional()
+    listChanged: z4.boolean().optional()
   }).optional(),
   /**
    * Present if the server offers any tools to call.
    */
-  tools: z3.object({
+  tools: z4.object({
     /**
      * Whether this server supports issuing notifications for changes to the tool list.
      */
-    listChanged: z3.boolean().optional()
+    listChanged: z4.boolean().optional()
   }).optional(),
   /**
    * Present if the server supports task creation.
@@ -10132,13 +11347,13 @@ var ServerCapabilitiesSchema = z3.object({
   /**
    * Extensions that the server supports. Keys are extension identifiers (vendor-prefix/extension-name).
    */
-  extensions: z3.record(z3.string(), AssertObjectSchema).optional()
+  extensions: z4.record(z4.string(), AssertObjectSchema).optional()
 });
 var InitializeResultSchema = ResultSchema.extend({
   /**
    * The version of the Model Context Protocol that the server wants to use. This may not match the version that the client requested. If the client cannot support this version, it MUST disconnect.
    */
-  protocolVersion: z3.string(),
+  protocolVersion: z4.string(),
   capabilities: ServerCapabilitiesSchema,
   serverInfo: ImplementationSchema,
   /**
@@ -10146,31 +11361,31 @@ var InitializeResultSchema = ResultSchema.extend({
    *
    * This can be used by clients to improve the LLM's understanding of available tools, resources, etc. It can be thought of like a "hint" to the model. For example, this information MAY be added to the system prompt.
    */
-  instructions: z3.string().optional()
+  instructions: z4.string().optional()
 });
 var InitializedNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/initialized"),
+  method: z4.literal("notifications/initialized"),
   params: NotificationsParamsSchema.optional()
 });
 var PingRequestSchema = RequestSchema.extend({
-  method: z3.literal("ping"),
+  method: z4.literal("ping"),
   params: BaseRequestParamsSchema.optional()
 });
-var ProgressSchema = z3.object({
+var ProgressSchema = z4.object({
   /**
    * The progress thus far. This should increase every time progress is made, even if the total is unknown.
    */
-  progress: z3.number(),
+  progress: z4.number(),
   /**
    * Total number of items to process (or total progress required), if known.
    */
-  total: z3.optional(z3.number()),
+  total: z4.optional(z4.number()),
   /**
    * An optional message describing the current progress.
    */
-  message: z3.optional(z3.string())
+  message: z4.optional(z4.string())
 });
-var ProgressNotificationParamsSchema = z3.object({
+var ProgressNotificationParamsSchema = z4.object({
   ...NotificationsParamsSchema.shape,
   ...ProgressSchema.shape,
   /**
@@ -10179,7 +11394,7 @@ var ProgressNotificationParamsSchema = z3.object({
   progressToken: ProgressTokenSchema
 });
 var ProgressNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/progress"),
+  method: z4.literal("notifications/progress"),
   params: ProgressNotificationParamsSchema
 });
 var PaginatedRequestParamsSchema = BaseRequestParamsSchema.extend({
@@ -10199,86 +11414,86 @@ var PaginatedResultSchema = ResultSchema.extend({
    */
   nextCursor: CursorSchema.optional()
 });
-var TaskStatusSchema = z3.enum(["working", "input_required", "completed", "failed", "cancelled"]);
-var TaskSchema = z3.object({
-  taskId: z3.string(),
+var TaskStatusSchema = z4.enum(["working", "input_required", "completed", "failed", "cancelled"]);
+var TaskSchema = z4.object({
+  taskId: z4.string(),
   status: TaskStatusSchema,
   /**
    * Time in milliseconds to keep task results available after completion.
    * If null, the task has unlimited lifetime until manually cleaned up.
    */
-  ttl: z3.union([z3.number(), z3.null()]),
+  ttl: z4.union([z4.number(), z4.null()]),
   /**
    * ISO 8601 timestamp when the task was created.
    */
-  createdAt: z3.string(),
+  createdAt: z4.string(),
   /**
    * ISO 8601 timestamp when the task was last updated.
    */
-  lastUpdatedAt: z3.string(),
-  pollInterval: z3.optional(z3.number()),
+  lastUpdatedAt: z4.string(),
+  pollInterval: z4.optional(z4.number()),
   /**
    * Optional diagnostic message for failed tasks or other status information.
    */
-  statusMessage: z3.optional(z3.string())
+  statusMessage: z4.optional(z4.string())
 });
 var CreateTaskResultSchema2 = ResultSchema.extend({
   task: TaskSchema
 });
 var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
 var TaskStatusNotificationSchema2 = NotificationSchema2.extend({
-  method: z3.literal("notifications/tasks/status"),
+  method: z4.literal("notifications/tasks/status"),
   params: TaskStatusNotificationParamsSchema
 });
 var GetTaskRequestSchema2 = RequestSchema.extend({
-  method: z3.literal("tasks/get"),
+  method: z4.literal("tasks/get"),
   params: BaseRequestParamsSchema.extend({
-    taskId: z3.string()
+    taskId: z4.string()
   })
 });
 var GetTaskResultSchema2 = ResultSchema.merge(TaskSchema);
 var GetTaskPayloadRequestSchema2 = RequestSchema.extend({
-  method: z3.literal("tasks/result"),
+  method: z4.literal("tasks/result"),
   params: BaseRequestParamsSchema.extend({
-    taskId: z3.string()
+    taskId: z4.string()
   })
 });
 var GetTaskPayloadResultSchema = ResultSchema.loose();
 var ListTasksRequestSchema2 = PaginatedRequestSchema.extend({
-  method: z3.literal("tasks/list")
+  method: z4.literal("tasks/list")
 });
 var ListTasksResultSchema2 = PaginatedResultSchema.extend({
-  tasks: z3.array(TaskSchema)
+  tasks: z4.array(TaskSchema)
 });
 var CancelTaskRequestSchema2 = RequestSchema.extend({
-  method: z3.literal("tasks/cancel"),
+  method: z4.literal("tasks/cancel"),
   params: BaseRequestParamsSchema.extend({
-    taskId: z3.string()
+    taskId: z4.string()
   })
 });
 var CancelTaskResultSchema2 = ResultSchema.merge(TaskSchema);
-var ResourceContentsSchema = z3.object({
+var ResourceContentsSchema = z4.object({
   /**
    * The URI of this resource.
    */
-  uri: z3.string(),
+  uri: z4.string(),
   /**
    * The MIME type of this resource, if known.
    */
-  mimeType: z3.optional(z3.string()),
+  mimeType: z4.optional(z4.string()),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
   /**
    * The text of the item. This must only be set if the item can actually be represented as text (not binary data).
    */
-  text: z3.string()
+  text: z4.string()
 });
-var Base64Schema = z3.string().refine((val) => {
+var Base64Schema = z4.string().refine((val) => {
   try {
     atob(val);
     return true;
@@ -10292,44 +11507,44 @@ var BlobResourceContentsSchema = ResourceContentsSchema.extend({
    */
   blob: Base64Schema
 });
-var RoleSchema = z3.enum(["user", "assistant"]);
-var AnnotationsSchema = z3.object({
+var RoleSchema = z4.enum(["user", "assistant"]);
+var AnnotationsSchema = z4.object({
   /**
    * Intended audience(s) for the resource.
    */
-  audience: z3.array(RoleSchema).optional(),
+  audience: z4.array(RoleSchema).optional(),
   /**
    * Importance hint for the resource, from 0 (least) to 1 (most).
    */
-  priority: z3.number().min(0).max(1).optional(),
+  priority: z4.number().min(0).max(1).optional(),
   /**
    * ISO 8601 timestamp for the most recent modification.
    */
-  lastModified: z3.iso.datetime({ offset: true }).optional()
+  lastModified: z4.iso.datetime({ offset: true }).optional()
 });
-var ResourceSchema = z3.object({
+var ResourceSchema2 = z4.object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
   /**
    * The URI of this resource.
    */
-  uri: z3.string(),
+  uri: z4.string(),
   /**
    * A description of what this resource represents.
    *
    * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
    */
-  description: z3.optional(z3.string()),
+  description: z4.optional(z4.string()),
   /**
    * The MIME type of this resource, if known.
    */
-  mimeType: z3.optional(z3.string()),
+  mimeType: z4.optional(z4.string()),
   /**
    * The size of the raw resource content, in bytes (i.e., before base64 encoding or any tokenization), if known.
    *
    * This can be used by Hosts to display file sizes and estimate context window usage.
    */
-  size: z3.optional(z3.number()),
+  size: z4.optional(z4.number()),
   /**
    * Optional annotations for the client.
    */
@@ -10338,25 +11553,25 @@ var ResourceSchema = z3.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.optional(z3.looseObject({}))
+  _meta: z4.optional(z4.looseObject({}))
 });
-var ResourceTemplateSchema = z3.object({
+var ResourceTemplateSchema2 = z4.object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
   /**
    * A URI template (according to RFC 6570) that can be used to construct resource URIs.
    */
-  uriTemplate: z3.string(),
+  uriTemplate: z4.string(),
   /**
    * A description of what this template is for.
    *
    * This can be used by clients to improve the LLM's understanding of available resources. It can be thought of like a "hint" to the model.
    */
-  description: z3.optional(z3.string()),
+  description: z4.optional(z4.string()),
   /**
    * The MIME type for all resources that match this template. This should only be included if all resources matching this template have the same type.
    */
-  mimeType: z3.optional(z3.string()),
+  mimeType: z4.optional(z4.string()),
   /**
    * Optional annotations for the client.
    */
@@ -10365,19 +11580,19 @@ var ResourceTemplateSchema = z3.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.optional(z3.looseObject({}))
+  _meta: z4.optional(z4.looseObject({}))
 });
 var ListResourcesRequestSchema = PaginatedRequestSchema.extend({
-  method: z3.literal("resources/list")
+  method: z4.literal("resources/list")
 });
 var ListResourcesResultSchema2 = PaginatedResultSchema.extend({
-  resources: z3.array(ResourceSchema)
+  resources: z4.array(ResourceSchema2)
 });
 var ListResourceTemplatesRequestSchema = PaginatedRequestSchema.extend({
-  method: z3.literal("resources/templates/list")
+  method: z4.literal("resources/templates/list")
 });
 var ListResourceTemplatesResultSchema2 = PaginatedResultSchema.extend({
-  resourceTemplates: z3.array(ResourceTemplateSchema)
+  resourceTemplates: z4.array(ResourceTemplateSchema2)
 });
 var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({
   /**
@@ -10385,97 +11600,97 @@ var ResourceRequestParamsSchema = BaseRequestParamsSchema.extend({
    *
    * @format uri
    */
-  uri: z3.string()
+  uri: z4.string()
 });
 var ReadResourceRequestParamsSchema = ResourceRequestParamsSchema;
 var ReadResourceRequestSchema = RequestSchema.extend({
-  method: z3.literal("resources/read"),
+  method: z4.literal("resources/read"),
   params: ReadResourceRequestParamsSchema
 });
 var ReadResourceResultSchema2 = ResultSchema.extend({
-  contents: z3.array(z3.union([TextResourceContentsSchema, BlobResourceContentsSchema]))
+  contents: z4.array(z4.union([TextResourceContentsSchema, BlobResourceContentsSchema]))
 });
 var ResourceListChangedNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/resources/list_changed"),
+  method: z4.literal("notifications/resources/list_changed"),
   params: NotificationsParamsSchema.optional()
 });
 var SubscribeRequestParamsSchema = ResourceRequestParamsSchema;
 var SubscribeRequestSchema = RequestSchema.extend({
-  method: z3.literal("resources/subscribe"),
+  method: z4.literal("resources/subscribe"),
   params: SubscribeRequestParamsSchema
 });
 var UnsubscribeRequestParamsSchema = ResourceRequestParamsSchema;
 var UnsubscribeRequestSchema = RequestSchema.extend({
-  method: z3.literal("resources/unsubscribe"),
+  method: z4.literal("resources/unsubscribe"),
   params: UnsubscribeRequestParamsSchema
 });
 var ResourceUpdatedNotificationParamsSchema = NotificationsParamsSchema.extend({
   /**
    * The URI of the resource that has been updated. This might be a sub-resource of the one that the client actually subscribed to.
    */
-  uri: z3.string()
+  uri: z4.string()
 });
 var ResourceUpdatedNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/resources/updated"),
+  method: z4.literal("notifications/resources/updated"),
   params: ResourceUpdatedNotificationParamsSchema
 });
-var PromptArgumentSchema = z3.object({
+var PromptArgumentSchema = z4.object({
   /**
    * The name of the argument.
    */
-  name: z3.string(),
+  name: z4.string(),
   /**
    * A human-readable description of the argument.
    */
-  description: z3.optional(z3.string()),
+  description: z4.optional(z4.string()),
   /**
    * Whether this argument must be provided.
    */
-  required: z3.optional(z3.boolean())
+  required: z4.optional(z4.boolean())
 });
-var PromptSchema = z3.object({
+var PromptSchema2 = z4.object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
   /**
    * An optional description of what this prompt provides
    */
-  description: z3.optional(z3.string()),
+  description: z4.optional(z4.string()),
   /**
    * A list of arguments to use for templating the prompt.
    */
-  arguments: z3.optional(z3.array(PromptArgumentSchema)),
+  arguments: z4.optional(z4.array(PromptArgumentSchema)),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.optional(z3.looseObject({}))
+  _meta: z4.optional(z4.looseObject({}))
 });
 var ListPromptsRequestSchema = PaginatedRequestSchema.extend({
-  method: z3.literal("prompts/list")
+  method: z4.literal("prompts/list")
 });
 var ListPromptsResultSchema2 = PaginatedResultSchema.extend({
-  prompts: z3.array(PromptSchema)
+  prompts: z4.array(PromptSchema2)
 });
 var GetPromptRequestParamsSchema = BaseRequestParamsSchema.extend({
   /**
    * The name of the prompt or prompt template.
    */
-  name: z3.string(),
+  name: z4.string(),
   /**
    * Arguments to use for templating the prompt.
    */
-  arguments: z3.record(z3.string(), z3.string()).optional()
+  arguments: z4.record(z4.string(), z4.string()).optional()
 });
 var GetPromptRequestSchema = RequestSchema.extend({
-  method: z3.literal("prompts/get"),
+  method: z4.literal("prompts/get"),
   params: GetPromptRequestParamsSchema
 });
-var TextContentSchema = z3.object({
-  type: z3.literal("text"),
+var TextContentSchema = z4.object({
+  type: z4.literal("text"),
   /**
    * The text content of the message.
    */
-  text: z3.string(),
+  text: z4.string(),
   /**
    * Optional annotations for the client.
    */
@@ -10484,10 +11699,10 @@ var TextContentSchema = z3.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
-var ImageContentSchema = z3.object({
-  type: z3.literal("image"),
+var ImageContentSchema = z4.object({
+  type: z4.literal("image"),
   /**
    * The base64-encoded image data.
    */
@@ -10495,7 +11710,7 @@ var ImageContentSchema = z3.object({
   /**
    * The MIME type of the image. Different providers may support different image types.
    */
-  mimeType: z3.string(),
+  mimeType: z4.string(),
   /**
    * Optional annotations for the client.
    */
@@ -10504,10 +11719,10 @@ var ImageContentSchema = z3.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
-var AudioContentSchema = z3.object({
-  type: z3.literal("audio"),
+var AudioContentSchema = z4.object({
+  type: z4.literal("audio"),
   /**
    * The base64-encoded audio data.
    */
@@ -10515,7 +11730,7 @@ var AudioContentSchema = z3.object({
   /**
    * The MIME type of the audio. Different providers may support different audio types.
    */
-  mimeType: z3.string(),
+  mimeType: z4.string(),
   /**
    * Optional annotations for the client.
    */
@@ -10524,34 +11739,34 @@ var AudioContentSchema = z3.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
-var ToolUseContentSchema = z3.object({
-  type: z3.literal("tool_use"),
+var ToolUseContentSchema = z4.object({
+  type: z4.literal("tool_use"),
   /**
    * The name of the tool to invoke.
    * Must match a tool name from the request's tools array.
    */
-  name: z3.string(),
+  name: z4.string(),
   /**
    * Unique identifier for this tool call.
    * Used to correlate with ToolResultContent in subsequent messages.
    */
-  id: z3.string(),
+  id: z4.string(),
   /**
    * Arguments to pass to the tool.
    * Must conform to the tool's inputSchema.
    */
-  input: z3.record(z3.string(), z3.unknown()),
+  input: z4.record(z4.string(), z4.unknown()),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
-var EmbeddedResourceSchema = z3.object({
-  type: z3.literal("resource"),
-  resource: z3.union([TextResourceContentsSchema, BlobResourceContentsSchema]),
+var EmbeddedResourceSchema = z4.object({
+  type: z4.literal("resource"),
+  resource: z4.union([TextResourceContentsSchema, BlobResourceContentsSchema]),
   /**
    * Optional annotations for the client.
    */
@@ -10560,19 +11775,19 @@ var EmbeddedResourceSchema = z3.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
-var ResourceLinkSchema = ResourceSchema.extend({
-  type: z3.literal("resource_link")
+var ResourceLinkSchema = ResourceSchema2.extend({
+  type: z4.literal("resource_link")
 });
-var ContentBlockSchema = z3.union([
+var ContentBlockSchema = z4.union([
   TextContentSchema,
   ImageContentSchema,
   AudioContentSchema,
   ResourceLinkSchema,
   EmbeddedResourceSchema
 ]);
-var PromptMessageSchema = z3.object({
+var PromptMessageSchema = z4.object({
   role: RoleSchema,
   content: ContentBlockSchema
 });
@@ -10580,24 +11795,24 @@ var GetPromptResultSchema2 = ResultSchema.extend({
   /**
    * An optional description for the prompt.
    */
-  description: z3.string().optional(),
-  messages: z3.array(PromptMessageSchema)
+  description: z4.string().optional(),
+  messages: z4.array(PromptMessageSchema)
 });
 var PromptListChangedNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/prompts/list_changed"),
+  method: z4.literal("notifications/prompts/list_changed"),
   params: NotificationsParamsSchema.optional()
 });
-var ToolAnnotationsSchema = z3.object({
+var ToolAnnotationsSchema = z4.object({
   /**
    * A human-readable title for the tool.
    */
-  title: z3.string().optional(),
+  title: z4.string().optional(),
   /**
    * If true, the tool does not modify its environment.
    *
    * Default: false
    */
-  readOnlyHint: z3.boolean().optional(),
+  readOnlyHint: z4.boolean().optional(),
   /**
    * If true, the tool may perform destructive updates to its environment.
    * If false, the tool performs only additive updates.
@@ -10606,7 +11821,7 @@ var ToolAnnotationsSchema = z3.object({
    *
    * Default: true
    */
-  destructiveHint: z3.boolean().optional(),
+  destructiveHint: z4.boolean().optional(),
   /**
    * If true, calling the tool repeatedly with the same arguments
    * will have no additional effect on the its environment.
@@ -10615,7 +11830,7 @@ var ToolAnnotationsSchema = z3.object({
    *
    * Default: false
    */
-  idempotentHint: z3.boolean().optional(),
+  idempotentHint: z4.boolean().optional(),
   /**
    * If true, this tool may interact with an "open world" of external
    * entities. If false, the tool's domain of interaction is closed.
@@ -10624,9 +11839,9 @@ var ToolAnnotationsSchema = z3.object({
    *
    * Default: true
    */
-  openWorldHint: z3.boolean().optional()
+  openWorldHint: z4.boolean().optional()
 });
-var ToolExecutionSchema = z3.object({
+var ToolExecutionSchema = z4.object({
   /**
    * Indicates the tool's preference for task-augmented execution.
    * - "required": Clients MUST invoke the tool as a task
@@ -10635,34 +11850,34 @@ var ToolExecutionSchema = z3.object({
    *
    * If not present, defaults to "forbidden".
    */
-  taskSupport: z3.enum(["required", "optional", "forbidden"]).optional()
+  taskSupport: z4.enum(["required", "optional", "forbidden"]).optional()
 });
-var ToolSchema = z3.object({
+var ToolSchema2 = z4.object({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
   /**
    * A human-readable description of the tool.
    */
-  description: z3.string().optional(),
+  description: z4.string().optional(),
   /**
    * A JSON Schema 2020-12 object defining the expected parameters for the tool.
    * Must have type: 'object' at the root level per MCP spec.
    */
-  inputSchema: z3.object({
-    type: z3.literal("object"),
-    properties: z3.record(z3.string(), AssertObjectSchema).optional(),
-    required: z3.array(z3.string()).optional()
-  }).catchall(z3.unknown()),
+  inputSchema: z4.object({
+    type: z4.literal("object"),
+    properties: z4.record(z4.string(), AssertObjectSchema).optional(),
+    required: z4.array(z4.string()).optional()
+  }).catchall(z4.unknown()),
   /**
    * An optional JSON Schema 2020-12 object defining the structure of the tool's output
    * returned in the structuredContent field of a CallToolResult.
    * Must have type: 'object' at the root level per MCP spec.
    */
-  outputSchema: z3.object({
-    type: z3.literal("object"),
-    properties: z3.record(z3.string(), AssertObjectSchema).optional(),
-    required: z3.array(z3.string()).optional()
-  }).catchall(z3.unknown()).optional(),
+  outputSchema: z4.object({
+    type: z4.literal("object"),
+    properties: z4.record(z4.string(), AssertObjectSchema).optional(),
+    required: z4.array(z4.string()).optional()
+  }).catchall(z4.unknown()).optional(),
   /**
    * Optional additional tool information.
    */
@@ -10675,13 +11890,13 @@ var ToolSchema = z3.object({
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
 var ListToolsRequestSchema = PaginatedRequestSchema.extend({
-  method: z3.literal("tools/list")
+  method: z4.literal("tools/list")
 });
 var ListToolsResultSchema2 = PaginatedResultSchema.extend({
-  tools: z3.array(ToolSchema)
+  tools: z4.array(ToolSchema2)
 });
 var CallToolResultSchema2 = ResultSchema.extend({
   /**
@@ -10690,13 +11905,13 @@ var CallToolResultSchema2 = ResultSchema.extend({
    * If the Tool does not define an outputSchema, this field MUST be present in the result.
    * For backwards compatibility, this field is always present, but it may be empty.
    */
-  content: z3.array(ContentBlockSchema).default([]),
+  content: z4.array(ContentBlockSchema).default([]),
   /**
    * An object containing structured tool output.
    *
    * If the Tool defines an outputSchema, this field MUST be present in the result, and contain a JSON object that matches the schema.
    */
-  structuredContent: z3.record(z3.string(), z3.unknown()).optional(),
+  structuredContent: z4.record(z4.string(), z4.unknown()).optional(),
   /**
    * Whether the tool call ended in an error.
    *
@@ -10711,30 +11926,30 @@ var CallToolResultSchema2 = ResultSchema.extend({
    * server does not support tool calls, or any other exceptional conditions,
    * should be reported as an MCP error response.
    */
-  isError: z3.boolean().optional()
+  isError: z4.boolean().optional()
 });
 var CompatibilityCallToolResultSchema = CallToolResultSchema2.or(ResultSchema.extend({
-  toolResult: z3.unknown()
+  toolResult: z4.unknown()
 }));
 var CallToolRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
   /**
    * The name of the tool to call.
    */
-  name: z3.string(),
+  name: z4.string(),
   /**
    * Arguments to pass to the tool.
    */
-  arguments: z3.record(z3.string(), z3.unknown()).optional()
+  arguments: z4.record(z4.string(), z4.unknown()).optional()
 });
 var CallToolRequestSchema = RequestSchema.extend({
-  method: z3.literal("tools/call"),
+  method: z4.literal("tools/call"),
   params: CallToolRequestParamsSchema
 });
 var ToolListChangedNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/tools/list_changed"),
+  method: z4.literal("notifications/tools/list_changed"),
   params: NotificationsParamsSchema.optional()
 });
-var ListChangedOptionsBaseSchema = z3.object({
+var ListChangedOptionsBaseSchema = z4.object({
   /**
    * If true, the list will be refreshed automatically when a list changed notification is received.
    * The callback will be called with the updated list.
@@ -10743,7 +11958,7 @@ var ListChangedOptionsBaseSchema = z3.object({
    *
    * @default true
    */
-  autoRefresh: z3.boolean().default(true),
+  autoRefresh: z4.boolean().default(true),
   /**
    * Debounce time in milliseconds for list changed notification processing.
    *
@@ -10752,9 +11967,9 @@ var ListChangedOptionsBaseSchema = z3.object({
    *
    * @default 300
    */
-  debounceMs: z3.number().int().nonnegative().default(300)
+  debounceMs: z4.number().int().nonnegative().default(300)
 });
-var LoggingLevelSchema = z3.enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
+var LoggingLevelSchema = z4.enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
 var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({
   /**
    * The level of logging that the client wants to receive from the server. The server should send all logs at this level and higher (i.e., more severe) to the client as notifications/logging/message.
@@ -10762,7 +11977,7 @@ var SetLevelRequestParamsSchema = BaseRequestParamsSchema.extend({
   level: LoggingLevelSchema
 });
 var SetLevelRequestSchema = RequestSchema.extend({
-  method: z3.literal("logging/setLevel"),
+  method: z4.literal("logging/setLevel"),
   params: SetLevelRequestParamsSchema
 });
 var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
@@ -10773,80 +11988,80 @@ var LoggingMessageNotificationParamsSchema = NotificationsParamsSchema.extend({
   /**
    * An optional name of the logger issuing this message.
    */
-  logger: z3.string().optional(),
+  logger: z4.string().optional(),
   /**
    * The data to be logged, such as a string message or an object. Any JSON serializable type is allowed here.
    */
-  data: z3.unknown()
+  data: z4.unknown()
 });
 var LoggingMessageNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/message"),
+  method: z4.literal("notifications/message"),
   params: LoggingMessageNotificationParamsSchema
 });
-var ModelHintSchema = z3.object({
+var ModelHintSchema = z4.object({
   /**
    * A hint for a model name.
    */
-  name: z3.string().optional()
+  name: z4.string().optional()
 });
-var ModelPreferencesSchema = z3.object({
+var ModelPreferencesSchema = z4.object({
   /**
    * Optional hints to use for model selection.
    */
-  hints: z3.array(ModelHintSchema).optional(),
+  hints: z4.array(ModelHintSchema).optional(),
   /**
    * How much to prioritize cost when selecting a model.
    */
-  costPriority: z3.number().min(0).max(1).optional(),
+  costPriority: z4.number().min(0).max(1).optional(),
   /**
    * How much to prioritize sampling speed (latency) when selecting a model.
    */
-  speedPriority: z3.number().min(0).max(1).optional(),
+  speedPriority: z4.number().min(0).max(1).optional(),
   /**
    * How much to prioritize intelligence and capabilities when selecting a model.
    */
-  intelligencePriority: z3.number().min(0).max(1).optional()
+  intelligencePriority: z4.number().min(0).max(1).optional()
 });
-var ToolChoiceSchema = z3.object({
+var ToolChoiceSchema = z4.object({
   /**
    * Controls when tools are used:
    * - "auto": Model decides whether to use tools (default)
    * - "required": Model MUST use at least one tool before completing
    * - "none": Model MUST NOT use any tools
    */
-  mode: z3.enum(["auto", "required", "none"]).optional()
+  mode: z4.enum(["auto", "required", "none"]).optional()
 });
-var ToolResultContentSchema = z3.object({
-  type: z3.literal("tool_result"),
-  toolUseId: z3.string().describe("The unique identifier for the corresponding tool call."),
-  content: z3.array(ContentBlockSchema).default([]),
-  structuredContent: z3.object({}).loose().optional(),
-  isError: z3.boolean().optional(),
+var ToolResultContentSchema = z4.object({
+  type: z4.literal("tool_result"),
+  toolUseId: z4.string().describe("The unique identifier for the corresponding tool call."),
+  content: z4.array(ContentBlockSchema).default([]),
+  structuredContent: z4.object({}).loose().optional(),
+  isError: z4.boolean().optional(),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
-var SamplingContentSchema = z3.discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
-var SamplingMessageContentBlockSchema = z3.discriminatedUnion("type", [
+var SamplingContentSchema = z4.discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
+var SamplingMessageContentBlockSchema = z4.discriminatedUnion("type", [
   TextContentSchema,
   ImageContentSchema,
   AudioContentSchema,
   ToolUseContentSchema,
   ToolResultContentSchema
 ]);
-var SamplingMessageSchema = z3.object({
+var SamplingMessageSchema = z4.object({
   role: RoleSchema,
-  content: z3.union([SamplingMessageContentBlockSchema, z3.array(SamplingMessageContentBlockSchema)]),
+  content: z4.union([SamplingMessageContentBlockSchema, z4.array(SamplingMessageContentBlockSchema)]),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
 var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
-  messages: z3.array(SamplingMessageSchema),
+  messages: z4.array(SamplingMessageSchema),
   /**
    * The server's preferences for which model to select. The client MAY modify or omit this request.
    */
@@ -10854,7 +12069,7 @@ var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
   /**
    * An optional system prompt the server wants to use for sampling. The client MAY modify or omit this prompt.
    */
-  systemPrompt: z3.string().optional(),
+  systemPrompt: z4.string().optional(),
   /**
    * A request to include context from one or more MCP servers (including the caller), to be attached to the prompt.
    * The client MAY ignore this request.
@@ -10862,15 +12077,15 @@ var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
    * Default is "none". Values "thisServer" and "allServers" are soft-deprecated. Servers SHOULD only use these values if the client
    * declares ClientCapabilities.sampling.context. These values may be removed in future spec releases.
    */
-  includeContext: z3.enum(["none", "thisServer", "allServers"]).optional(),
-  temperature: z3.number().optional(),
+  includeContext: z4.enum(["none", "thisServer", "allServers"]).optional(),
+  temperature: z4.number().optional(),
   /**
    * The requested maximum number of tokens to sample (to prevent runaway completions).
    *
    * The client MAY choose to sample fewer tokens than the requested maximum.
    */
-  maxTokens: z3.number().int(),
-  stopSequences: z3.array(z3.string()).optional(),
+  maxTokens: z4.number().int(),
+  stopSequences: z4.array(z4.string()).optional(),
   /**
    * Optional metadata to pass through to the LLM provider. The format of this metadata is provider-specific.
    */
@@ -10879,7 +12094,7 @@ var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
    * Tools that the model may use during generation.
    * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
    */
-  tools: z3.array(ToolSchema).optional(),
+  tools: z4.array(ToolSchema2).optional(),
   /**
    * Controls how the model uses tools.
    * The client MUST return an error if this field is provided but ClientCapabilities.sampling.tools is not declared.
@@ -10888,14 +12103,14 @@ var CreateMessageRequestParamsSchema = TaskAugmentedRequestParamsSchema.extend({
   toolChoice: ToolChoiceSchema.optional()
 });
 var CreateMessageRequestSchema = RequestSchema.extend({
-  method: z3.literal("sampling/createMessage"),
+  method: z4.literal("sampling/createMessage"),
   params: CreateMessageRequestParamsSchema
 });
 var CreateMessageResultSchema = ResultSchema.extend({
   /**
    * The name of the model that generated the message.
    */
-  model: z3.string(),
+  model: z4.string(),
   /**
    * The reason why sampling stopped, if known.
    *
@@ -10906,7 +12121,7 @@ var CreateMessageResultSchema = ResultSchema.extend({
    *
    * This field is an open string to allow for provider-specific stop reasons.
    */
-  stopReason: z3.optional(z3.enum(["endTurn", "stopSequence", "maxTokens"]).or(z3.string())),
+  stopReason: z4.optional(z4.enum(["endTurn", "stopSequence", "maxTokens"]).or(z4.string())),
   role: RoleSchema,
   /**
    * Response content. Single content block (text, image, or audio).
@@ -10917,7 +12132,7 @@ var CreateMessageResultWithToolsSchema = ResultSchema.extend({
   /**
    * The name of the model that generated the message.
    */
-  model: z3.string(),
+  model: z4.string(),
   /**
    * The reason why sampling stopped, if known.
    *
@@ -10929,144 +12144,144 @@ var CreateMessageResultWithToolsSchema = ResultSchema.extend({
    *
    * This field is an open string to allow for provider-specific stop reasons.
    */
-  stopReason: z3.optional(z3.enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(z3.string())),
+  stopReason: z4.optional(z4.enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(z4.string())),
   role: RoleSchema,
   /**
    * Response content. May be a single block or array. May include ToolUseContent if stopReason is "toolUse".
    */
-  content: z3.union([SamplingMessageContentBlockSchema, z3.array(SamplingMessageContentBlockSchema)])
-});
-var BooleanSchemaSchema = z3.object({
-  type: z3.literal("boolean"),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  default: z3.boolean().optional()
-});
-var StringSchemaSchema = z3.object({
-  type: z3.literal("string"),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  minLength: z3.number().optional(),
-  maxLength: z3.number().optional(),
-  format: z3.enum(["email", "uri", "date", "date-time"]).optional(),
-  default: z3.string().optional()
-});
-var NumberSchemaSchema = z3.object({
-  type: z3.enum(["number", "integer"]),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  minimum: z3.number().optional(),
-  maximum: z3.number().optional(),
-  default: z3.number().optional()
-});
-var UntitledSingleSelectEnumSchemaSchema = z3.object({
-  type: z3.literal("string"),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  enum: z3.array(z3.string()),
-  default: z3.string().optional()
-});
-var TitledSingleSelectEnumSchemaSchema = z3.object({
-  type: z3.literal("string"),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  oneOf: z3.array(z3.object({
-    const: z3.string(),
-    title: z3.string()
+  content: z4.union([SamplingMessageContentBlockSchema, z4.array(SamplingMessageContentBlockSchema)])
+});
+var BooleanSchemaSchema = z4.object({
+  type: z4.literal("boolean"),
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  default: z4.boolean().optional()
+});
+var StringSchemaSchema = z4.object({
+  type: z4.literal("string"),
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  minLength: z4.number().optional(),
+  maxLength: z4.number().optional(),
+  format: z4.enum(["email", "uri", "date", "date-time"]).optional(),
+  default: z4.string().optional()
+});
+var NumberSchemaSchema = z4.object({
+  type: z4.enum(["number", "integer"]),
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  minimum: z4.number().optional(),
+  maximum: z4.number().optional(),
+  default: z4.number().optional()
+});
+var UntitledSingleSelectEnumSchemaSchema = z4.object({
+  type: z4.literal("string"),
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  enum: z4.array(z4.string()),
+  default: z4.string().optional()
+});
+var TitledSingleSelectEnumSchemaSchema = z4.object({
+  type: z4.literal("string"),
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  oneOf: z4.array(z4.object({
+    const: z4.string(),
+    title: z4.string()
   })),
-  default: z3.string().optional()
-});
-var LegacyTitledEnumSchemaSchema = z3.object({
-  type: z3.literal("string"),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  enum: z3.array(z3.string()),
-  enumNames: z3.array(z3.string()).optional(),
-  default: z3.string().optional()
-});
-var SingleSelectEnumSchemaSchema = z3.union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
-var UntitledMultiSelectEnumSchemaSchema = z3.object({
-  type: z3.literal("array"),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  minItems: z3.number().optional(),
-  maxItems: z3.number().optional(),
-  items: z3.object({
-    type: z3.literal("string"),
-    enum: z3.array(z3.string())
+  default: z4.string().optional()
+});
+var LegacyTitledEnumSchemaSchema = z4.object({
+  type: z4.literal("string"),
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  enum: z4.array(z4.string()),
+  enumNames: z4.array(z4.string()).optional(),
+  default: z4.string().optional()
+});
+var SingleSelectEnumSchemaSchema = z4.union([UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema]);
+var UntitledMultiSelectEnumSchemaSchema = z4.object({
+  type: z4.literal("array"),
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  minItems: z4.number().optional(),
+  maxItems: z4.number().optional(),
+  items: z4.object({
+    type: z4.literal("string"),
+    enum: z4.array(z4.string())
   }),
-  default: z3.array(z3.string()).optional()
-});
-var TitledMultiSelectEnumSchemaSchema = z3.object({
-  type: z3.literal("array"),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  minItems: z3.number().optional(),
-  maxItems: z3.number().optional(),
-  items: z3.object({
-    anyOf: z3.array(z3.object({
-      const: z3.string(),
-      title: z3.string()
+  default: z4.array(z4.string()).optional()
+});
+var TitledMultiSelectEnumSchemaSchema = z4.object({
+  type: z4.literal("array"),
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  minItems: z4.number().optional(),
+  maxItems: z4.number().optional(),
+  items: z4.object({
+    anyOf: z4.array(z4.object({
+      const: z4.string(),
+      title: z4.string()
     }))
   }),
-  default: z3.array(z3.string()).optional()
+  default: z4.array(z4.string()).optional()
 });
-var MultiSelectEnumSchemaSchema = z3.union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
-var EnumSchemaSchema = z3.union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]);
-var PrimitiveSchemaDefinitionSchema = z3.union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]);
+var MultiSelectEnumSchemaSchema = z4.union([UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema]);
+var EnumSchemaSchema = z4.union([LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema]);
+var PrimitiveSchemaDefinitionSchema = z4.union([EnumSchemaSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema]);
 var ElicitRequestFormParamsSchema = TaskAugmentedRequestParamsSchema.extend({
   /**
    * The elicitation mode.
    *
    * Optional for backward compatibility. Clients MUST treat missing mode as "form".
    */
-  mode: z3.literal("form").optional(),
+  mode: z4.literal("form").optional(),
   /**
    * The message to present to the user describing what information is being requested.
    */
-  message: z3.string(),
+  message: z4.string(),
   /**
    * A restricted subset of JSON Schema.
    * Only top-level properties are allowed, without nesting.
    */
-  requestedSchema: z3.object({
-    type: z3.literal("object"),
-    properties: z3.record(z3.string(), PrimitiveSchemaDefinitionSchema),
-    required: z3.array(z3.string()).optional()
+  requestedSchema: z4.object({
+    type: z4.literal("object"),
+    properties: z4.record(z4.string(), PrimitiveSchemaDefinitionSchema),
+    required: z4.array(z4.string()).optional()
   })
 });
 var ElicitRequestURLParamsSchema = TaskAugmentedRequestParamsSchema.extend({
   /**
    * The elicitation mode.
    */
-  mode: z3.literal("url"),
+  mode: z4.literal("url"),
   /**
    * The message to present to the user explaining why the interaction is needed.
    */
-  message: z3.string(),
+  message: z4.string(),
   /**
    * The ID of the elicitation, which must be unique within the context of the server.
    * The client MUST treat this ID as an opaque value.
    */
-  elicitationId: z3.string(),
+  elicitationId: z4.string(),
   /**
    * The URL that the user should navigate to.
    */
-  url: z3.string().url()
+  url: z4.string().url()
 });
-var ElicitRequestParamsSchema = z3.union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
+var ElicitRequestParamsSchema = z4.union([ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema]);
 var ElicitRequestSchema = RequestSchema.extend({
-  method: z3.literal("elicitation/create"),
+  method: z4.literal("elicitation/create"),
   params: ElicitRequestParamsSchema
 });
 var ElicitationCompleteNotificationParamsSchema = NotificationsParamsSchema.extend({
   /**
    * The ID of the elicitation that completed.
    */
-  elicitationId: z3.string()
+  elicitationId: z4.string()
 });
 var ElicitationCompleteNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/elicitation/complete"),
+  method: z4.literal("notifications/elicitation/complete"),
   params: ElicitationCompleteNotificationParamsSchema
 });
 var ElicitResultSchema = ResultSchema.extend({
@@ -11076,98 +12291,98 @@ var ElicitResultSchema = ResultSchema.extend({
    * - "decline": User explicitly decline the action
    * - "cancel": User dismissed without making an explicit choice
    */
-  action: z3.enum(["accept", "decline", "cancel"]),
+  action: z4.enum(["accept", "decline", "cancel"]),
   /**
    * The submitted form data, only present when action is "accept".
    * Contains values matching the requested schema.
    * Per MCP spec, content is "typically omitted" for decline/cancel actions.
    * We normalize null to undefined for leniency while maintaining type compatibility.
    */
-  content: z3.preprocess((val) => val === null ? void 0 : val, z3.record(z3.string(), z3.union([z3.string(), z3.number(), z3.boolean(), z3.array(z3.string())])).optional())
+  content: z4.preprocess((val) => val === null ? void 0 : val, z4.record(z4.string(), z4.union([z4.string(), z4.number(), z4.boolean(), z4.array(z4.string())])).optional())
 });
-var ResourceTemplateReferenceSchema = z3.object({
-  type: z3.literal("ref/resource"),
+var ResourceTemplateReferenceSchema = z4.object({
+  type: z4.literal("ref/resource"),
   /**
    * The URI or URI template of the resource.
    */
-  uri: z3.string()
+  uri: z4.string()
 });
-var PromptReferenceSchema = z3.object({
-  type: z3.literal("ref/prompt"),
+var PromptReferenceSchema = z4.object({
+  type: z4.literal("ref/prompt"),
   /**
    * The name of the prompt or prompt template
    */
-  name: z3.string()
+  name: z4.string()
 });
 var CompleteRequestParamsSchema = BaseRequestParamsSchema.extend({
-  ref: z3.union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
+  ref: z4.union([PromptReferenceSchema, ResourceTemplateReferenceSchema]),
   /**
    * The argument's information
    */
-  argument: z3.object({
+  argument: z4.object({
     /**
      * The name of the argument
      */
-    name: z3.string(),
+    name: z4.string(),
     /**
      * The value of the argument to use for completion matching.
      */
-    value: z3.string()
+    value: z4.string()
   }),
-  context: z3.object({
+  context: z4.object({
     /**
      * Previously-resolved variables in a URI template or prompt.
      */
-    arguments: z3.record(z3.string(), z3.string()).optional()
+    arguments: z4.record(z4.string(), z4.string()).optional()
   }).optional()
 });
 var CompleteRequestSchema = RequestSchema.extend({
-  method: z3.literal("completion/complete"),
+  method: z4.literal("completion/complete"),
   params: CompleteRequestParamsSchema
 });
 var CompleteResultSchema = ResultSchema.extend({
-  completion: z3.looseObject({
+  completion: z4.looseObject({
     /**
      * An array of completion values. Must not exceed 100 items.
      */
-    values: z3.array(z3.string()).max(100),
+    values: z4.array(z4.string()).max(100),
     /**
      * The total number of completion options available. This can exceed the number of values actually sent in the response.
      */
-    total: z3.optional(z3.number().int()),
+    total: z4.optional(z4.number().int()),
     /**
      * Indicates whether there are additional completion options beyond those provided in the current response, even if the exact total is unknown.
      */
-    hasMore: z3.optional(z3.boolean())
+    hasMore: z4.optional(z4.boolean())
   })
 });
-var RootSchema = z3.object({
+var RootSchema = z4.object({
   /**
    * The URI identifying the root. This *must* start with file:// for now.
    */
-  uri: z3.string().startsWith("file://"),
+  uri: z4.string().startsWith("file://"),
   /**
    * An optional name for the root.
    */
-  name: z3.string().optional(),
+  name: z4.string().optional(),
   /**
    * See [MCP specification](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/47339c03c143bb4ec01a26e721a1b8fe66634ebe/docs/specification/draft/basic/index.mdx#general-fields)
    * for notes on _meta usage.
    */
-  _meta: z3.record(z3.string(), z3.unknown()).optional()
+  _meta: z4.record(z4.string(), z4.unknown()).optional()
 });
 var ListRootsRequestSchema = RequestSchema.extend({
-  method: z3.literal("roots/list"),
+  method: z4.literal("roots/list"),
   params: BaseRequestParamsSchema.optional()
 });
 var ListRootsResultSchema = ResultSchema.extend({
-  roots: z3.array(RootSchema)
+  roots: z4.array(RootSchema)
 });
 var RootsListChangedNotificationSchema = NotificationSchema2.extend({
-  method: z3.literal("notifications/roots/list_changed"),
+  method: z4.literal("notifications/roots/list_changed"),
   params: NotificationsParamsSchema.optional()
 });
-var ClientRequestSchema = z3.union([
+var ClientRequestSchema = z4.union([
   PingRequestSchema,
   InitializeRequestSchema,
   CompleteRequestSchema,
@@ -11186,14 +12401,14 @@ var ClientRequestSchema = z3.union([
   ListTasksRequestSchema2,
   CancelTaskRequestSchema2
 ]);
-var ClientNotificationSchema = z3.union([
+var ClientNotificationSchema = z4.union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
   InitializedNotificationSchema,
   RootsListChangedNotificationSchema,
   TaskStatusNotificationSchema2
 ]);
-var ClientResultSchema = z3.union([
+var ClientResultSchema = z4.union([
   EmptyResultSchema2,
   CreateMessageResultSchema,
   CreateMessageResultWithToolsSchema,
@@ -11203,7 +12418,7 @@ var ClientResultSchema = z3.union([
   ListTasksResultSchema2,
   CreateTaskResultSchema2
 ]);
-var ServerRequestSchema = z3.union([
+var ServerRequestSchema = z4.union([
   PingRequestSchema,
   CreateMessageRequestSchema,
   ElicitRequestSchema,
@@ -11213,7 +12428,7 @@ var ServerRequestSchema = z3.union([
   ListTasksRequestSchema2,
   CancelTaskRequestSchema2
 ]);
-var ServerNotificationSchema = z3.union([
+var ServerNotificationSchema = z4.union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
   LoggingMessageNotificationSchema,
@@ -11224,7 +12439,7 @@ var ServerNotificationSchema = z3.union([
   TaskStatusNotificationSchema2,
   ElicitationCompleteNotificationSchema
 ]);
-var ServerResultSchema = z3.union([
+var ServerResultSchema = z4.union([
   EmptyResultSchema2,
   InitializeResultSchema,
   CompleteResultSchema,
@@ -11297,7 +12512,7 @@ var O = Q.object({ connectDomains: Q.array(Q.string()).optional().describe(`Orig
 
 - Maps to CSP \`connect-src\` directive
 - Empty or omitted \u2192 no network connections (secure default)`), resourceDomains: Q.array(Q.string()).optional().describe("Origins for static resources (images, scripts, stylesheets, fonts, media).\n\n- Maps to CSP `img-src`, `script-src`, `style-src`, `font-src`, `media-src` directives\n- Wildcard subdomains supported: `https://*.example.com`\n- Empty or omitted \u2192 no network resources (secure default)"), frameDomains: Q.array(Q.string()).optional().describe("Origins for nested iframes.\n\n- Maps to CSP `frame-src` directive\n- Empty or omitted \u2192 no nested iframes allowed (`frame-src 'none'`)"), baseUriDomains: Q.array(Q.string()).optional().describe("Allowed base URIs for the document.\n\n- Maps to CSP `base-uri` directive\n- Empty or omitted \u2192 only same origin allowed (`base-uri 'self'`)") });
-var z4 = Q.object({ camera: Q.object({}).optional().describe("Request camera access.\n\nMaps to Permission Policy `camera` feature."), microphone: Q.object({}).optional().describe("Request microphone access.\n\nMaps to Permission Policy `microphone` feature."), geolocation: Q.object({}).optional().describe("Request geolocation access.\n\nMaps to Permission Policy `geolocation` feature."), clipboardWrite: Q.object({}).optional().describe("Request clipboard write access.\n\nMaps to Permission Policy `clipboard-write` feature.") });
+var z5 = Q.object({ camera: Q.object({}).optional().describe("Request camera access.\n\nMaps to Permission Policy `camera` feature."), microphone: Q.object({}).optional().describe("Request microphone access.\n\nMaps to Permission Policy `microphone` feature."), geolocation: Q.object({}).optional().describe("Request geolocation access.\n\nMaps to Permission Policy `geolocation` feature."), clipboardWrite: Q.object({}).optional().describe("Request clipboard write access.\n\nMaps to Permission Policy `clipboard-write` feature.") });
 var H = Q.object({ method: Q.literal("ui/notifications/size-changed"), params: Q.object({ width: Q.number().optional().describe("New width in pixels."), height: Q.number().optional().describe("New height in pixels.") }) });
 var R = Q.object({ method: Q.literal("ui/notifications/tool-input"), params: Q.object({ arguments: Q.record(Q.string(), Q.unknown().describe("Complete tool call arguments as key-value pairs.")).optional().describe("Complete tool call arguments as key-value pairs.") }) });
 var T = Q.object({ method: Q.literal("ui/notifications/tool-input-partial"), params: Q.object({ arguments: Q.record(Q.string(), Q.unknown().describe("Partial tool call arguments (incomplete, may change).")).optional().describe("Partial tool call arguments (incomplete, may change).") }) });
@@ -11308,10 +12523,10 @@ var C = Q.object({ method: Q.literal("ui/resource-teardown"), params: Q.object({
 var S = Q.record(Q.string(), Q.unknown());
 var F = Q.object({ text: Q.object({}).optional().describe("Host supports text content blocks."), image: Q.object({}).optional().describe("Host supports image content blocks."), audio: Q.object({}).optional().describe("Host supports audio content blocks."), resource: Q.object({}).optional().describe("Host supports resource content blocks."), resourceLink: Q.object({}).optional().describe("Host supports resource link content blocks."), structuredContent: Q.object({}).optional().describe("Host supports structured content.") });
 var q = Q.object({ method: Q.literal("ui/notifications/request-teardown"), params: Q.object({}).optional() });
-var t = Q.object({ experimental: Q.object({}).optional().describe("Experimental features (structure TBD)."), openLinks: Q.object({}).optional().describe("Host supports opening external URLs."), downloadFile: Q.object({}).optional().describe("Host supports file downloads via ui/download-file."), serverTools: Q.object({ listChanged: Q.boolean().optional().describe("Host supports tools/list_changed notifications.") }).optional().describe("Host can proxy tool calls to the MCP server."), serverResources: Q.object({ listChanged: Q.boolean().optional().describe("Host supports resources/list_changed notifications.") }).optional().describe("Host can proxy resource reads to the MCP server."), logging: Q.object({}).optional().describe("Host accepts log messages."), sandbox: Q.object({ permissions: z4.optional().describe("Permissions granted by the host (camera, microphone, geolocation)."), csp: O.optional().describe("CSP domains approved by the host.") }).optional().describe("Sandbox configuration applied by the host."), updateModelContext: F.optional().describe("Host accepts context updates (ui/update-model-context) to be included in the model's context for future turns."), message: F.optional().describe("Host supports receiving content messages (ui/message) from the view."), sampling: Q.object({ tools: Q.object({}).optional().describe("Host supports tool use via `tools` and `toolChoice` parameters.") }).optional().describe("Host supports LLM sampling (sampling/createMessage) from the view.\nMirrors the MCP `ClientCapabilities.sampling` shape so hosts can pass it through.") });
-var a = Q.object({ experimental: Q.object({}).optional().describe("Experimental features (structure TBD)."), tools: Q.object({ listChanged: Q.boolean().optional().describe("App supports tools/list_changed notifications.") }).optional().describe("App exposes MCP-style tools that the host can call."), availableDisplayModes: Q.array(B).optional().describe("Display modes the app supports.") });
+var t = Q.object({ experimental: Q.record(Q.string(), Q.record(Q.string(), Q.any()).describe("Experimental features keyed by identifier.")).optional().describe("Experimental features keyed by identifier."), openLinks: Q.object({}).optional().describe("Host supports opening external URLs."), downloadFile: Q.object({}).optional().describe("Host supports file downloads via ui/download-file."), serverTools: Q.object({ listChanged: Q.boolean().optional().describe("Host supports tools/list_changed notifications.") }).optional().describe("Host can proxy tool calls to the MCP server."), serverResources: Q.object({ listChanged: Q.boolean().optional().describe("Host supports resources/list_changed notifications.") }).optional().describe("Host can proxy resource reads to the MCP server."), logging: Q.object({}).optional().describe("Host accepts log messages."), sandbox: Q.object({ permissions: z5.optional().describe("Permissions granted by the host (camera, microphone, geolocation)."), csp: O.optional().describe("CSP domains approved by the host.") }).optional().describe("Sandbox configuration applied by the host."), updateModelContext: F.optional().describe("Host accepts context updates (ui/update-model-context) to be included in the model's context for future turns."), message: F.optional().describe("Host supports receiving content messages (ui/message) from the view."), sampling: Q.object({ tools: Q.object({}).optional().describe("Host supports tool use via `tools` and `toolChoice` parameters.") }).optional().describe("Host supports LLM sampling (sampling/createMessage) from the view.\nMirrors the MCP `ClientCapabilities.sampling` shape so hosts can pass it through.") });
+var a = Q.object({ experimental: Q.record(Q.string(), Q.record(Q.string(), Q.any()).describe("Experimental features keyed by identifier.")).optional().describe("Experimental features keyed by identifier."), tools: Q.object({ listChanged: Q.boolean().optional().describe("App supports tools/list_changed notifications.") }).optional().describe("App exposes MCP-style tools that the host can call."), availableDisplayModes: Q.array(B).optional().describe("Display modes the app supports.") });
 var y = Q.object({ method: Q.literal("ui/notifications/initialized"), params: Q.object({}).optional() });
-var TQ = Q.object({ csp: O.optional().describe("Content Security Policy configuration for UI resources."), permissions: z4.optional().describe("Sandbox permissions requested by the UI resource."), domain: Q.string().optional().describe(`Dedicated origin for view sandbox.
+var TQ = Q.object({ csp: O.optional().describe("Content Security Policy configuration for UI resources."), permissions: z5.optional().describe("Sandbox permissions requested by the UI resource."), domain: Q.string().optional().describe(`Dedicated origin for view sandbox.
 
 Useful when views need stable, dedicated origins for OAuth callbacks, CORS policies, or API key allowlists.
 
@@ -11335,9 +12550,9 @@ var MQ = Q.object({ resourceUri: Q.string().optional(), visibility: Q.array(e).o
 var OX = Q.object({ mimeTypes: Q.array(Q.string()).optional().describe('Array of supported MIME types for UI resources.\nMust include `"text/html;profile=mcp-app"` for MCP Apps support.') });
 var f = Q.object({ method: Q.literal("ui/download-file"), params: Q.object({ contents: Q.array(Q.union([EmbeddedResourceSchema, ResourceLinkSchema])).describe("Resource contents to download \u2014 embedded (inline data) or linked (host fetches). Uses standard MCP resource types.") }) });
 var k = Q.object({ method: Q.literal("ui/message"), params: Q.object({ role: Q.literal("user").describe('Message role, currently only "user" is supported.'), content: Q.array(ContentBlockSchema).describe("Message content blocks (text, image, etc.).") }) });
-var CQ = Q.object({ method: Q.literal("ui/notifications/sandbox-resource-ready"), params: Q.object({ html: Q.string().describe("HTML content to load into the inner iframe."), sandbox: Q.string().optional().describe("Optional override for the inner iframe's sandbox attribute."), csp: O.optional().describe("CSP configuration from resource metadata."), permissions: z4.optional().describe("Sandbox permissions from resource metadata.") }) });
+var CQ = Q.object({ method: Q.literal("ui/notifications/sandbox-resource-ready"), params: Q.object({ html: Q.string().describe("HTML content to load into the inner iframe."), sandbox: Q.string().optional().describe("Optional override for the inner iframe's sandbox attribute."), csp: O.optional().describe("CSP configuration from resource metadata."), permissions: z5.optional().describe("Sandbox permissions from resource metadata.") }) });
 var v = Q.object({ method: Q.literal("ui/notifications/tool-result"), params: CallToolResultSchema2.describe("Standard MCP tool execution result.") });
-var x = Q.object({ toolInfo: Q.object({ id: RequestIdSchema.optional().describe("JSON-RPC id of the tools/call request."), tool: ToolSchema.describe("Tool definition including name, inputSchema, etc.") }).optional().describe("Metadata of the tool call that instantiated this App."), theme: r.optional().describe("Current color theme preference."), styles: s.optional().describe("Style configuration for theming the app."), displayMode: B.optional().describe("How the UI is currently displayed."), availableDisplayModes: Q.array(B).optional().describe("Display modes the host supports."), containerDimensions: Q.union([Q.object({ height: Q.number().describe("Fixed container height in pixels.") }), Q.object({ maxHeight: Q.union([Q.number(), Q.undefined()]).optional().describe("Maximum container height in pixels.") })]).and(Q.union([Q.object({ width: Q.number().describe("Fixed container width in pixels.") }), Q.object({ maxWidth: Q.union([Q.number(), Q.undefined()]).optional().describe("Maximum container width in pixels.") })])).optional().describe(`Container dimensions. Represents the dimensions of the iframe or other
+var x = Q.object({ toolInfo: Q.object({ id: RequestIdSchema.optional().describe("JSON-RPC id of the tools/call request."), tool: ToolSchema2.describe("Tool definition including name, inputSchema, etc.") }).optional().describe("Metadata of the tool call that instantiated this App."), theme: r.optional().describe("Current color theme preference."), styles: s.optional().describe("Style configuration for theming the app."), displayMode: B.optional().describe("How the UI is currently displayed."), availableDisplayModes: Q.array(B).optional().describe("Display modes the host supports."), containerDimensions: Q.union([Q.object({ height: Q.number().describe("Fixed container height in pixels.") }), Q.object({ maxHeight: Q.union([Q.number(), Q.undefined()]).optional().describe("Maximum container height in pixels.") })]).and(Q.union([Q.object({ width: Q.number().describe("Fixed container width in pixels.") }), Q.object({ maxWidth: Q.union([Q.number(), Q.undefined()]).optional().describe("Maximum container width in pixels.") })])).optional().describe(`Container dimensions. Represents the dimensions of the iframe or other
 container holding the app. Specify either width or maxWidth, and either height or maxHeight.`), locale: Q.string().optional().describe("User's language and region preference in BCP 47 format."), timeZone: Q.string().optional().describe("User's timezone in IANA format."), userAgent: Q.string().optional().describe("Host application identifier."), platform: Q.union([Q.literal("web"), Q.literal("desktop"), Q.literal("mobile")]).optional().describe("Platform type for responsive design decisions."), deviceCapabilities: Q.object({ touch: Q.boolean().optional().describe("Whether the device supports touch input."), hover: Q.boolean().optional().describe("Whether the device supports hover interactions.") }).optional().describe("Device input capabilities."), safeAreaInsets: Q.object({ top: Q.number().describe("Top safe area inset in pixels."), right: Q.number().describe("Right safe area inset in pixels."), bottom: Q.number().describe("Bottom safe area inset in pixels."), left: Q.number().describe("Left safe area inset in pixels.") }).optional().describe("Mobile safe area boundaries in pixels.") }).passthrough();
 var b = Q.object({ method: Q.literal("ui/notifications/host-context-changed"), params: x.describe("Partial context update containing only changed fields.") });
 var d = Q.object({ method: Q.literal("ui/update-model-context"), params: Q.object({ content: Q.array(ContentBlockSchema).optional().describe("Context content blocks (text, image, etc.)."), structuredContent: Q.record(Q.string(), Q.unknown().describe("Structured content for machine-readable context data.")).optional().describe("Structured content for machine-readable context data.") }) });
@@ -12143,7 +13358,7 @@ function createCliOAuthNavigation(options = {}) {
 }
 
 // ../../core/client/config-parse.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function isAbsoluteHttpUrl(value) {
   let url;
   try {
@@ -12160,11 +13375,11 @@ function isRealHost(hostname) {
   const labels = hostname.split(".");
   return labels.length >= 2 && labels.every((label) => label !== "");
 }
-var HttpUrlStringSchema = z5.string().min(1).superRefine((val, ctx) => {
+var HttpUrlStringSchema = z6.string().min(1).superRefine((val, ctx) => {
   const trimmed = val.trim();
   if (!isAbsoluteHttpUrl(trimmed)) {
     ctx.addIssue({
-      code: z5.ZodIssueCode.custom,
+      code: z6.ZodIssueCode.custom,
       message: `Invalid URL: "${trimmed}" \u2014 must be an http(s) URL (e.g. https://idp.example.com)`
     });
   }
@@ -12196,7 +13411,7 @@ function refineCimdMetadataUrl(val, ctx, required) {
   if (trimmed === "") {
     if (required) {
       ctx.addIssue({
-        code: z5.ZodIssueCode.custom,
+        code: z6.ZodIssueCode.custom,
         message: "CIMD client metadata URL is required when CIMD is enabled"
       });
     }
@@ -12205,25 +13420,25 @@ function refineCimdMetadataUrl(val, ctx, required) {
   const error = getCimdClientMetadataUrlError(trimmed);
   if (error) {
     ctx.addIssue({
-      code: z5.ZodIssueCode.custom,
+      code: z6.ZodIssueCode.custom,
       message: error
     });
   }
 }
-var CimdConfigSchema = z5.object({
-  enabled: z5.boolean(),
-  clientMetadataUrl: z5.string()
+var CimdConfigSchema = z6.object({
+  enabled: z6.boolean(),
+  clientMetadataUrl: z6.string()
 }).superRefine((data, ctx) => {
   refineCimdMetadataUrl(data.clientMetadataUrl, ctx, data.enabled === true);
 });
-var EnterpriseManagedAuthIdpConfigSchema = z5.object({
+var EnterpriseManagedAuthIdpConfigSchema = z6.object({
   issuer: HttpUrlStringSchema,
-  clientId: z5.string().min(1),
-  clientSecret: z5.string().optional()
+  clientId: z6.string().min(1),
+  clientSecret: z6.string().optional()
 });
-var ClientConfigSchema = z5.object({
-  enterpriseManagedAuth: z5.object({
-    enabled: z5.boolean().optional(),
+var ClientConfigSchema = z6.object({
+  enterpriseManagedAuth: z6.object({
+    enabled: z6.boolean().optional(),
     idp: EnterpriseManagedAuthIdpConfigSchema
   }).optional(),
   cimd: CimdConfigSchema.optional()
@@ -12370,7 +13585,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
     },
@@ -12380,6 +13597,10 @@ function buildRunnerClientAuthOptions(clientConfig, savedSettings, cliOverrides)
     ...savedSettings.oauthScopes && {
       scope: savedSettings.oauthScopes
     },
+    ...serverAuthorizationParams && {
+      authorizationParams: serverAuthorizationParams
+    },
+    ...serverEndpointOverrides,
     ...savedSettings.enterpriseManaged && {
       enterpriseManaged: true
     }