@modelcontextprotocol/inspector 2.4.0 → 2.5.0

package/clients/tui/build/index.js

@@ -130,6 +130,491 @@ var SECRET_FIELD_OAUTH_CLIENT_SECRET = "oauth-client-secret";
 var SECRET_FIELD_IDP_CLIENT_SECRET = "idp-client-secret";
 var envSecretField = (envKey) => `env:${envKey}`;
 
+// ../../core/json/nullableUnion.ts
+var RENDERABLE_TYPES = [
+  "string",
+  "number",
+  "integer",
+  "boolean",
+  "array",
+  "object"
+];
+function isRenderableType(type) {
+  return RENDERABLE_TYPES.includes(type);
+}
+function toBranch(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function isStringEnum(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((member) => typeof member === "string");
+}
+function nullExcludedBySiblings(schema) {
+  if (Array.isArray(schema.enum) && !schema.enum.includes(null)) {
+    return true;
+  }
+  return schema.const !== void 0 && schema.const !== null;
+}
+var ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "default",
+  "enumNames",
+  "examples",
+  "deprecated",
+  "readOnly",
+  "writeOnly",
+  "$comment",
+  "$schema",
+  "$id"
+]);
+function wrapperCarriesConstraints(schema) {
+  return Object.keys(schema).some(
+    (key) => key !== "anyOf" && !ANNOTATION_KEYWORDS.has(key)
+  );
+}
+function typeNamesNull(type) {
+  return Array.isArray(type) ? type.includes("null") : type === "null";
+}
+function hasOpaqueApplicator(schema) {
+  return schema.not !== void 0 || schema.allOf !== void 0 || schema.oneOf !== void 0 || // `$ref` points at a schema this module never resolves, and it applies
+  // *alongside* its siblings — `{ type: "string", $ref: "#/$defs/intOnly" }`
+  // can be unsatisfiable. The wrapper path already declines on it (it is not
+  // an annotation); this is the same rule for every other position.
+  schema.$ref !== void 0;
+}
+function hasUnevaluatedComposition(schema) {
+  return schema.anyOf !== void 0 || hasOpaqueApplicator(schema);
+}
+function stripNullEnumMembers(members, names) {
+  if (!Array.isArray(members)) {
+    return { kind: "unchanged" };
+  }
+  const kept = members.map((member, index) => ({ member, index })).filter((entry) => entry.member !== null);
+  if (kept.length === 0) {
+    return { kind: "unselectable" };
+  }
+  if (kept.length === members.length) {
+    return { kind: "unchanged" };
+  }
+  const wasParallel = Array.isArray(names) && names.length === members.length;
+  const aligned = wasParallel ? kept.map((entry) => names[entry.index]) : void 0;
+  return {
+    kind: "filtered",
+    members: kept.map((entry) => entry.member),
+    names: aligned
+  };
+}
+function collapsed(schema, branch, type) {
+  const merged = { ...schema, ...branch };
+  const strip = stripNullEnumMembers(
+    merged.enum,
+    merged.enumNames
+  );
+  if (strip.kind === "unselectable") {
+    return null;
+  }
+  return {
+    ...merged,
+    type,
+    anyOf: void 0,
+    // Read off the ORIGINAL schema, not the merge: a hoisted branch `enum` is
+    // not a sibling constraint, and treating it as one would mark the very
+    // shape #1928 is about as non-nullable. See `nullExcludedBySiblings`.
+    nullable: admitsNull(schema),
+    ...strip.kind === "filtered" ? { enum: strip.members, enumNames: strip.names } : {}
+  };
+}
+function typeAdmitsNull(type) {
+  return type === void 0 || typeNamesNull(type);
+}
+function admitsNull(schema) {
+  if (nullExcludedBySiblings(schema)) {
+    return false;
+  }
+  if (hasOpaqueApplicator(schema)) {
+    return false;
+  }
+  if (schema.const === null) {
+    if (schema.nullable !== true && !typeAdmitsNull(schema.type)) return false;
+    return schema.anyOf === void 0 || anyOfAdmitsNull(schema);
+  }
+  if (Array.isArray(schema.enum) && schema.enum.includes(null)) {
+    return (schema.nullable === true || typeAdmitsNull(schema.type)) && (schema.anyOf === void 0 || anyOfAdmitsNull(schema));
+  }
+  if (schema.nullable === true) {
+    return true;
+  }
+  if (schema.type !== void 0) {
+    if (schema.anyOf !== void 0) {
+      return false;
+    }
+    return typeNamesNull(schema.type);
+  }
+  return anyOfAdmitsNull(schema);
+}
+var ANNOTATION_ONLY_KEYWORDS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "examples",
+  "default",
+  "deprecated",
+  "readOnly",
+  "writeOnly",
+  "$comment",
+  // Core keywords that identify or declare rather than assert. `$ref` is
+  // deliberately absent: it applies whatever it points at, which is exactly an
+  // assertion this module cannot see.
+  "$defs",
+  "$id",
+  "$schema",
+  "$anchor",
+  "$dynamicAnchor",
+  "$vocabulary"
+]);
+function constrainsNothing(schema) {
+  return Object.keys(schema).every(
+    (keyword) => ANNOTATION_ONLY_KEYWORDS.has(keyword)
+  );
+}
+function anyOfAdmitsNull(schema) {
+  const branches = schema.anyOf;
+  if (!Array.isArray(branches)) return false;
+  return branches.some((entry) => {
+    if (typeof entry === "boolean") return entry;
+    const branch = toBranch(entry);
+    if (branch === null) return false;
+    const branchSchema = branch;
+    if (hasUnevaluatedComposition(branchSchema)) return false;
+    if (constrainsNothing(branchSchema)) return true;
+    return admitsNull(branchSchema);
+  });
+}
+function normalizeNullableUnion(schema) {
+  if (schema.anyOf?.length === 2) {
+    const branches = schema.anyOf.map(toBranch);
+    const nullBranch = branches.find((entry) => entry?.type === "null");
+    const branch = branches.find(
+      (entry) => entry !== null && entry.type !== "null"
+    );
+    if (nullBranch && branch && !wrapperCarriesConstraints(schema) && !hasUnevaluatedComposition(branch)) {
+      const type = branch.type ?? (isStringEnum(branch.enum) ? "string" : void 0);
+      if (isRenderableType(type)) {
+        const result = collapsed(schema, branch, type);
+        if (result !== null) {
+          return result;
+        }
+      }
+    }
+  }
+  if (Array.isArray(schema.type) && schema.type.length === 2 && schema.type.includes("null") && // This path keeps the schema's own keywords, but `collapsed` clears `anyOf`
+  // and the renderers ignore the other applicators — so a compound schema
+  // like `{ type: ["string", "null"], anyOf: [{ const: "a" }] }` would be
+  // widened into an unconstrained string field. Leave it for the JSON editor.
+  !hasUnevaluatedComposition(schema)) {
+    const type = schema.type.find((member) => member !== "null");
+    if (isRenderableType(type)) {
+      const result = collapsed(schema, void 0, type);
+      if (result !== null) {
+        return result;
+      }
+    }
+  }
+  return schema;
+}
+
+// ../../core/json/rootUnion.ts
+function membersOf(value) {
+  return Array.isArray(value) ? value : [];
+}
+function requiredOf(schema) {
+  const { required } = schema;
+  return Array.isArray(required) ? required.filter((name) => typeof name === "string") : [];
+}
+function toBranch2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function admitsObject(schema) {
+  const { type } = schema;
+  if (type === void 0) return true;
+  return Array.isArray(type) ? type.includes("object") : type === "object";
+}
+function hasReadableProperties(schema) {
+  const { properties } = schema;
+  return typeof properties === "object" && properties !== null && !Array.isArray(properties);
+}
+function propertiesOf(schema) {
+  return hasReadableProperties(schema) ? schema.properties : {};
+}
+function isOfferable(branch, merged) {
+  if (branch.properties !== void 0 && !hasReadableProperties(branch)) {
+    return false;
+  }
+  if (!admitsObject(branch)) return false;
+  const properties = Object.values(propertiesOf(merged));
+  return properties.length > 0 && // Every value has to be something a renderer can read AND something a
+  // caller can satisfy. A `null` or an array is not a schema at all, and the
+  // web form dereferences one on the way to choosing a widget. JSON Schema's
+  // boolean form is legal, but only `true` is harmless — it constrains
+  // nothing and answers every keyword lookup with `undefined`, while `false`
+  // admits no value whatsoever, so a field declared with it can never be
+  // filled and a required one makes the whole branch unsatisfiable. Either
+  // way the branch is declined rather than offered as a callable shape.
+  properties.every(
+    (property) => property === true || typeof property === "object" && property !== null && !Array.isArray(property)
+  );
+}
+var ANNOTATION_KEYWORDS2 = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "examples",
+  "deprecated",
+  "readOnly",
+  "writeOnly",
+  "$comment",
+  // An annotation too: a suggested initial value constrains nothing, so two
+  // declarations suggesting different ones still accept the same values.
+  "default"
+]);
+function canonicalJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(",")}]`;
+  }
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(
+      ([key, member]) => `${JSON.stringify(key)}:${canonicalJson(member)}`
+    );
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "undefined";
+}
+function sameJsonValue(a, b) {
+  return sameValue(a, b);
+}
+function sameValue(a, b) {
+  return a === b || canonicalJson(a) === canonicalJson(b);
+}
+function conflicts(baseProperty, branchProperty) {
+  const a = toBranch2(baseProperty);
+  const b = toBranch2(branchProperty);
+  if (a === null || b === null) {
+    return !sameValue(baseProperty, branchProperty);
+  }
+  const left = a;
+  const right = b;
+  if (Object.keys(right).some(
+    (keyword) => !ANNOTATION_KEYWORDS2.has(keyword) && keyword in left && !sameValue(left[keyword], right[keyword])
+  )) {
+    return true;
+  }
+  return !constSatisfiesSiblings({ ...left, ...right });
+}
+function jsonTypeOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? "integer" : "number";
+  }
+  return typeof value;
+}
+var CONST_CHECKABLE = /* @__PURE__ */ new Set(["const", "type", "enum"]);
+function constSatisfiesSiblings(schema) {
+  if (!("const" in schema)) return true;
+  const value = schema.const;
+  const { type, enum: allowed } = schema;
+  if (Object.keys(schema).some(
+    (keyword) => !CONST_CHECKABLE.has(keyword) && !ANNOTATION_KEYWORDS2.has(keyword)
+  )) {
+    return false;
+  }
+  const actual = jsonTypeOf(value);
+  const admits = (name) => name === actual || name === "number" && actual === "integer";
+  if (typeof type === "string" && !admits(type)) return false;
+  if (Array.isArray(type) && !type.some(admits)) return false;
+  if (Array.isArray(allowed) && !allowed.some((member) => sameValue(member, value))) {
+    return false;
+  }
+  return true;
+}
+function mergeProperty(baseProperty, branchProperty) {
+  const a = toBranch2(baseProperty);
+  const b = toBranch2(branchProperty);
+  if (a === null || b === null) {
+    return branchProperty;
+  }
+  return { ...a, ...b };
+}
+var MERGEABLE_KEYWORDS = /* @__PURE__ */ new Set(["type", "properties", "required"]);
+function isFlattenable(member) {
+  const branch = toBranch2(member);
+  if (branch === null || !admitsObject(branch)) return false;
+  return Object.keys(branch).every(
+    (keyword) => MERGEABLE_KEYWORDS.has(keyword) || ANNOTATION_KEYWORDS2.has(keyword)
+  );
+}
+function conflictsWithBase(base, branch) {
+  const baseProperties = propertiesOf(base);
+  const branchProperties = propertiesOf(branch);
+  return Object.entries(branchProperties).some(
+    ([name, branchProperty]) => (
+      // `hasOwn`, not `in`: `properties` is a JSON record, so `constructor` and
+      // `toString` are legal argument names that `in` would find on
+      // `Object.prototype` and report as collisions the root never declared.
+      Object.hasOwn(baseProperties, name) && conflicts(baseProperties[name], branchProperty)
+    )
+  );
+}
+function hasDiscriminator(members, named, rootRequired) {
+  const first = propertiesOf(members[0] ?? {});
+  const candidates = named !== void 0 ? [named] : Object.keys(first);
+  return candidates.some((name) => {
+    const constants = members.map((member) => {
+      if (!rootRequired.includes(name) && !requiredOf(member).includes(name)) {
+        return void 0;
+      }
+      const property = toBranch2(propertiesOf(member)[name]);
+      return property?.const;
+    });
+    if (constants.some((value) => value === void 0)) return false;
+    const seen = new Set(constants.map(canonicalJson));
+    return seen.size === constants.length;
+  });
+}
+function restrictsAdditional(schema) {
+  const additional = schema.additionalProperties;
+  return additional === false || typeof additional === "object" && additional !== null && Object.keys(additional).some(
+    (keyword) => !ANNOTATION_KEYWORDS2.has(keyword)
+  );
+}
+function addsForbiddenNames(base, member) {
+  if (!restrictsAdditional(base)) return false;
+  const baseNames = propertiesOf(base);
+  return Object.keys(propertiesOf(member)).some(
+    (name) => !Object.hasOwn(baseNames, name)
+  );
+}
+function mergeBranch(base, branch) {
+  const baseProperties = propertiesOf(base);
+  const branchProperties = propertiesOf(branch);
+  const properties = Object.fromEntries([
+    ...Object.entries(baseProperties),
+    ...Object.entries(branchProperties).map(([name, branchProperty]) => [
+      name,
+      Object.hasOwn(baseProperties, name) ? mergeProperty(baseProperties[name], branchProperty) : branchProperty
+    ])
+  ]);
+  const baseRequired = requiredOf(base);
+  const required = [
+    ...baseRequired,
+    ...requiredOf(branch).filter((name) => !baseRequired.includes(name))
+  ];
+  return {
+    ...base,
+    ...Object.keys(properties).length > 0 ? { properties } : {},
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function withoutComposition(schema) {
+  const { allOf: _allOf, anyOf: _anyOf, oneOf: _oneOf, ...rest } = schema;
+  return rest;
+}
+function branchLabel(branch, index, discriminatorProperty) {
+  if (typeof branch.title === "string" && branch.title.trim() !== "") {
+    return branch.title;
+  }
+  const properties = propertiesOf(branch);
+  const constOf2 = (name) => {
+    const property = toBranch2(properties[name]);
+    if (property === null || !("const" in property)) return void 0;
+    const value = property.const;
+    return value === null || typeof value !== "object" ? String(value) : void 0;
+  };
+  if (discriminatorProperty !== void 0) {
+    const value = constOf2(discriminatorProperty);
+    if (value !== void 0) return value;
+  }
+  const constants = Object.keys(properties).map((name) => constOf2(name)).filter((value) => value !== void 0);
+  if (constants.length === 1) return constants[0];
+  return `Option ${index + 1}`;
+}
+function resolveRootUnion(schema) {
+  const allOfMembers = membersOf(schema.allOf);
+  let merged = schema;
+  for (const member of allOfMembers) {
+    const branch = toBranch2(member);
+    if (branch === null || !isFlattenable(member) || conflictsWithBase(merged, branch) || addsForbiddenNames(merged, branch)) {
+      return { base: schema, branches: [] };
+    }
+    merged = mergeBranch(merged, branch);
+  }
+  const base = withoutComposition(merged);
+  if (schema.oneOf !== void 0 && schema.anyOf !== void 0) {
+    return { base, branches: [] };
+  }
+  const isExclusiveUnion = schema.oneOf !== void 0;
+  const members = membersOf(schema.oneOf ?? schema.anyOf);
+  const branches = members.map(toBranch2);
+  if (branches.length === 0 || branches.some(
+    (branch) => branch === null || !isOfferable(branch, mergeBranch(base, branch)) || // The same faithfulness test the `allOf` fold applies: a member
+    // carrying a constraint the merge does not copy — a nested `allOf`, a
+    // `not`, a `$ref` — would have it erased along with the union keyword,
+    // which can present an unsatisfiable branch as a callable one.
+    !isFlattenable(branch) || conflictsWithBase(base, branch)
+  )) {
+    return { base, branches: [] };
+  }
+  if (branches.some(
+    (branch) => addsForbiddenNames(base, branch)
+  )) {
+    return { base, branches: [] };
+  }
+  if (isExclusiveUnion && !hasDiscriminator(
+    branches,
+    schema.discriminator?.propertyName,
+    requiredOf(base)
+  )) {
+    return { base, branches: [] };
+  }
+  const discriminatorProperty = schema.discriminator?.propertyName;
+  return {
+    base,
+    branches: branches.filter((branch) => branch !== null).map((branch, index) => ({
+      // `base` is already composition-free and `mergeBranch` copies only
+      // `properties`/`required` off the branch, so the merge stays that way.
+      schema: mergeBranch(base, branch),
+      label: branchLabel(branch, index, discriminatorProperty),
+      declaredFields: Object.keys(propertiesOf(branch))
+    }))
+  };
+}
+function narrowBySuppliedNames(branches, candidates, suppliedNames) {
+  if (candidates.length === 1) return candidates[0];
+  if (candidates.length === 0 || suppliedNames.length === 0) return null;
+  const supplied = new Set(suppliedNames);
+  const satisfied = candidates.filter((index) => {
+    const branch = branches[index];
+    const required = requiredOf(branch.schema);
+    const own = required.filter((name) => branch.declaredFields.includes(name));
+    return own.length > 0 && own.every((name) => supplied.has(name));
+  });
+  if (satisfied.length === 1) return satisfied[0];
+  const exclusiveTo = /* @__PURE__ */ new Map();
+  for (const index of candidates) {
+    for (const name of branches[index].declaredFields) {
+      exclusiveTo.set(name, exclusiveTo.has(name) ? -1 : index);
+    }
+  }
+  const named = new Set(
+    suppliedNames.map((name) => exclusiveTo.get(name)).filter((index) => index !== void 0 && index >= 0)
+  );
+  return named.size === 1 ? [...named][0] : null;
+}
+
 // ../../core/json/jsonUtils.ts
 function isSerializableJson(value) {
   if (value === null) return true;
@@ -169,16 +654,90 @@ function convertParameterValue(value, schema) {
   }
   return value;
 }
+function coercionProperties(base, branches, params) {
+  if (branches.length === 0) {
+    return { ...base.properties };
+  }
+  const candidates = branches.map((branch, index) => ({ branch, index })).filter(
+    ({ branch }) => matchesConstants(branch.schema.properties ?? {}, params)
+  ).map(({ index }) => index);
+  const selected = narrowBySuppliedNames(
+    branches,
+    candidates,
+    Object.keys(params)
+  );
+  if (selected !== null) {
+    return { ...branches[selected].schema.properties };
+  }
+  const properties = Object.fromEntries(
+    Object.entries(base.properties ?? {})
+  );
+  const pool = candidates.length > 0 ? candidates.map((i) => branches[i]) : branches;
+  for (const name of new Set(pool.flatMap((b) => b.declaredFields))) {
+    const declarations = pool.filter((branch) => branch.declaredFields.includes(name)).map((branch) => branch.schema.properties?.[name]).filter((schema) => typeof schema === "object" && schema !== null).map((schema) => normalizeNullableUnion(schema));
+    const types = new Set(declarations.map((schema) => typeNameOf(schema)));
+    const pinnedOf = (schema) => typeof schema === "object" && schema !== null && "const" in schema ? schema.const : void 0;
+    const constsAgree = declarations.every(
+      (schema) => sameJsonValue(pinnedOf(schema), pinnedOf(declarations[0]))
+    );
+    if (types.size === 1 && constsAgree && declarations.length > 0) {
+      Object.defineProperty(properties, name, {
+        value: declarations[0],
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    } else {
+      delete properties[name];
+    }
+  }
+  return properties;
+}
+function typeNameOf(schema) {
+  if (typeof schema !== "object" || schema === null) return "";
+  const { type } = schema;
+  return Array.isArray(type) ? [...type].map(String).sort().join(",") : typeof type === "string" ? type : "";
+}
+function matchesConstants(properties, params) {
+  return Object.entries(properties).every(([name, schema]) => {
+    if (typeof schema !== "object" || schema === null) return true;
+    const constValue = schema.const;
+    if (constValue === void 0) return true;
+    if (!Object.hasOwn(params, name)) return true;
+    const supplied = params[name];
+    return supplied === void 0 || suppliedMatchesConst(supplied, constValue);
+  });
+}
+function suppliedMatchesConst(value, constValue) {
+  if (constValue === null || typeof constValue !== "object") {
+    return value === String(constValue);
+  }
+  try {
+    return sameJsonValue(JSON.parse(value), constValue);
+  } catch {
+    return false;
+  }
+}
 function convertToolParameters(tool, params) {
+  return convertParametersForSchema(tool.inputSchema, params);
+}
+function convertParametersForSchema(inputSchema, params) {
   const result = {};
-  const properties = tool.inputSchema?.properties || {};
+  const { base, branches } = resolveRootUnion(
+    inputSchema ?? {}
+  );
+  const properties = coercionProperties(base, branches, params);
   for (const [key, value] of Object.entries(params)) {
-    const paramSchema = properties[key];
-    if (paramSchema) {
-      result[key] = convertParameterValue(value, paramSchema);
-    } else {
-      result[key] = value;
-    }
+    const declared = properties[key];
+    const paramSchema = typeof declared === "object" && declared !== null ? normalizeNullableUnion(declared) : declared;
+    const pinned = paramSchema?.const;
+    const converted = pinned !== void 0 && suppliedMatchesConst(value, pinned) ? pinned : paramSchema ? convertParameterValue(value, paramSchema) : value;
+    Object.defineProperty(result, key, {
+      value: converted,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
   }
   return result;
 }
@@ -415,6 +974,9 @@ function storedFieldsToInspectorSettings(stored) {
   if (stored.oauth?.requestRefreshToken === false) {
     settings.oauthRequestRefreshToken = false;
   }
+  if (stored.oauth?.revokeOnClear === false) {
+    settings.oauthRevokeOnClear = false;
+  }
   if (stored.cwd) settings.cwd = stored.cwd;
   return settings;
 }
@@ -3360,11 +3922,11 @@ function formatRunnerOAuthRedirectUrl(config) {
 
 // src/App.tsx
 import {
-  useState as useState23,
+  useState as useState16,
   useMemo as useMemo4,
-  useEffect as useEffect20,
-  useCallback as useCallback11,
-  useRef as useRef13
+  useEffect as useEffect13,
+  useCallback as useCallback12,
+  useRef as useRef14
 } from "react";
 import { Box as Box27, Text as Text24, useInput as useInput21, useApp } from "ink";
 
@@ -3528,6 +4090,20 @@ function mcpParamHeadersForTool(tool, args) {
   return buildMcpParamHeaders(scan.declarations, args);
 }
 
+// ../../core/mcp/subscriptionAck.ts
+import { SdkError, SdkErrorCode } from "@modelcontextprotocol/client";
+var NEVER_ACKNOWLEDGED_SDK_MESSAGE = "closed the subscription gracefully before acknowledging";
+var NEVER_ACKNOWLEDGED_SUBSCRIPTION_MESSAGE = "The server closed the subscription without acknowledging it. A subscriptions/listen request must first be answered with a notifications/subscriptions/acknowledged notification; a JSON-RPC result for the listen id means graceful closure. Not retrying \u2014 the server would answer the same way again.";
+function isNeverAcknowledgedSubscriptionClose(error) {
+  return SdkError.isInstance(error) && error.code === SdkErrorCode.ConnectionClosed && error.message.includes(NEVER_ACKNOWLEDGED_SDK_MESSAGE);
+}
+function subscriptionFailureMessage(error) {
+  if (isNeverAcknowledgedSubscriptionClose(error)) {
+    return NEVER_ACKNOWLEDGED_SUBSCRIPTION_MESSAGE;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+
 // ../../core/mcp/messageTrackingTransport.ts
 var MessageTrackingTransport = class {
   baseTransport;
@@ -3619,6 +4195,29 @@ var MessageTrackingTransport = class {
   get sessionId() {
     return this.baseTransport.sessionId;
   }
+  /**
+   * Forward the base transport's per-request-stream capability (#2140).
+   *
+   * The SDK's `Protocol.request` reads this off the transport it was handed —
+   * which is always this wrapper — to decide how a cancelled request is
+   * signalled: abort that request's own stream (the 2026-07-28 signal for
+   * Streamable HTTP) or POST a `notifications/cancelled` (the stdio one).
+   *
+   * Not forwarding it made the wrapper *answer* the question, `undefined`, for
+   * every client. So the Cancel button POSTed a notification even on a modern
+   * Streamable HTTP connection, where a spec-compliant server acknowledges it
+   * `202` and drops it — the tool kept running and only a disconnect really
+   * cancelled anything. That hit the CLI and TUI as much as the web client:
+   * their real `StreamableHTTPClientTransport` advertises the flag correctly
+   * and this wrapper hid it.
+   *
+   * A base transport that says nothing stays `undefined` rather than becoming
+   * `false`, since the SDK's check is `=== true` either way and inventing a
+   * value here would misreport what the transport claimed.
+   */
+  get hasPerRequestStream() {
+    return this.baseTransport.hasPerRequestStream;
+  }
   // Implemented as a concrete method (rather than delegating the base
   // transport's optional `setProtocolVersion`) so the SDK Client always
   // invokes it after the initialize handshake — including for stdio, whose
@@ -3847,7 +4446,7 @@ function validateToolOutput(provider, tool, result) {
 
 // ../../core/mcp/listSalvage.ts
 import { z as z3 } from "zod/v4";
-import { SdkError, SdkErrorCode } from "@modelcontextprotocol/client";
+import { SdkError as SdkError2, SdkErrorCode as SdkErrorCode2 } from "@modelcontextprotocol/client";
 import { ToolSchema } from "@modelcontextprotocol/core";
 var LIST_MAX_PAGES = 64;
 function listPaginationExceeded(method) {
@@ -3856,10 +4455,10 @@ function listPaginationExceeded(method) {
   );
 }
 function isClientDecodeRejection(err) {
-  return SdkError.isInstance(err) && (err.code === SdkErrorCode.InvalidResult || err.code === SdkErrorCode.UnsupportedResultType);
+  return SdkError2.isInstance(err) && (err.code === SdkErrorCode2.InvalidResult || err.code === SdkErrorCode2.UnsupportedResultType);
 }
 function isSalvageableRejection(err) {
-  return SdkError.isInstance(err) && err.code === SdkErrorCode.InvalidResult;
+  return SdkError2.isInstance(err) && err.code === SdkErrorCode2.InvalidResult;
 }
 function lenientListPageSchema(resultSchema, itemsKey) {
   return resultSchema.extend({ [itemsKey]: z3.array(z3.unknown()) });
@@ -4214,6 +4813,52 @@ var TypedEventGeneric = class extends CustomEvent {
   }
 };
 var TypedEventTarget = class extends EventTarget {
+  /**
+   * Per-event-type dispatch counter. Read through `getEventRevision` by
+   * `useStoreSnapshot` (core/react) to tell "nothing has happened on this
+   * event since I last looked" from "something has", without comparing the
+   * snapshot's contents (#1955).
+   */
+  eventRevisions = /* @__PURE__ */ new Map();
+  /**
+   * How many times an event of this type has been dispatched from this
+   * target. Monotonic per type, and per type only: an `errorChange` does not
+   * advance `toolsChange`, so a subscriber to one is not re-read because of
+   * the other.
+   *
+   * The counter — not the list's contents — is what a `useSyncExternalStore`
+   * snapshot is cached against. That distinction is load-bearing rather than
+   * an optimization: these stores hand out a defensive copy, so comparing
+   * contents is the only alternative, and a contents comparison cannot see an
+   * in-place mutation of an entry the list already holds. `MessageLogState`
+   * does exactly that when a response is folded into its request entry
+   * (filling in `response`/`duration`), and it dispatches — so the counter
+   * moves and the fold reaches the UI, where a shallow compare would report
+   * "unchanged" and never re-render it.
+   */
+  getEventRevision(type) {
+    return this.eventRevisions.get(type) ?? 0;
+  }
+  /**
+   * Overridden solely to advance the counter. It sits on `dispatchEvent`
+   * rather than on `dispatchTypedEvent` because that is the one funnel every
+   * dispatch passes through — the typed helper below delegates to it, and so
+   * does a hand-rolled `dispatchEvent(new CustomEvent(...))`, which the tests
+   * use extensively. A counter bumped only in the typed helper would be
+   * silently stale for those, i.e. exactly where nobody would look for it.
+   *
+   * Bumped BEFORE dispatching: the state mutation always precedes the
+   * dispatch, so by the time a listener runs the counter must already reflect
+   * it, or a snapshot read from inside that listener would return the cached
+   * pre-change value.
+   */
+  dispatchEvent(event) {
+    this.eventRevisions.set(
+      event.type,
+      (this.eventRevisions.get(event.type) ?? 0) + 1
+    );
+    return super.dispatchEvent(event);
+  }
   dispatchTypedEvent(type, ...args) {
     const detail = args[0] ?? void 0;
     this.dispatchEvent(new TypedEventGeneric(type, detail));
@@ -4602,6 +5247,115 @@ function withOAuthEndpointOverrides(fetchFn, getOverrides) {
   };
 }
 
+// ../../core/auth/oidcDiscoveryCompat.ts
+import {
+  OAuthMetadataSchema,
+  OpenIdProviderDiscoveryMetadataSchema
+} from "@modelcontextprotocol/core";
+var RFC8414_WELL_KNOWN = "/.well-known/oauth-authorization-server";
+var OIDC_WELL_KNOWN = "/.well-known/openid-configuration";
+var COMPAT_SOURCE_HEADER = "x-inspector-oauth-metadata-source";
+function oidcDiscoveryCandidates(rfc8414Url) {
+  let url;
+  try {
+    url = new URL(rfc8414Url);
+  } catch {
+    return [];
+  }
+  if (!url.pathname.startsWith(RFC8414_WELL_KNOWN)) return [];
+  const path6 = url.pathname.slice(RFC8414_WELL_KNOWN.length);
+  if (path6 !== "" && !path6.startsWith("/")) return [];
+  if (path6 === "") return [new URL(OIDC_WELL_KNOWN, url.origin).href];
+  return [
+    new URL(`${OIDC_WELL_KNOWN}${path6}`, url.origin).href,
+    new URL(`${path6}${OIDC_WELL_KNOWN}`, url.origin).href
+  ];
+}
+function continuesDiscovery(status) {
+  return status >= 400 && status < 500 || status === 502;
+}
+async function releaseBody(response) {
+  await response.body?.cancel().catch(() => {
+  });
+}
+function isRfc8414OnlyMetadata(value) {
+  if (!OAuthMetadataSchema.safeParse(value).success) return false;
+  return !OpenIdProviderDiscoveryMetadataSchema.safeParse(value).success;
+}
+function requestUrlOf2(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+function discoveryHeaders(input, init) {
+  if (init?.headers) return new Headers(init.headers);
+  if (typeof input !== "string" && !(input instanceof URL)) {
+    return new Headers(input.headers);
+  }
+  return new Headers();
+}
+function requestMethodOf(input, init) {
+  if (init?.method) return init.method.toUpperCase();
+  if (typeof input !== "string" && !(input instanceof URL)) {
+    return input.method.toUpperCase();
+  }
+  return "GET";
+}
+function withRfc8414OidcCompat(fetchFn) {
+  return async (input, init) => {
+    const response = await fetchFn(input, init);
+    if (response.ok) return response;
+    if (!continuesDiscovery(response.status)) return response;
+    if (requestMethodOf(input, init) !== "GET") return response;
+    const candidates = oidcDiscoveryCandidates(requestUrlOf2(input));
+    if (candidates.length === 0) return response;
+    const headers = discoveryHeaders(input, init);
+    for (const candidate of candidates) {
+      let probe;
+      try {
+        probe = await fetchFn(candidate, { headers });
+      } catch {
+        return response;
+      }
+      if (!probe.ok) {
+        await releaseBody(probe);
+        if (continuesDiscovery(probe.status)) continue;
+        return response;
+      }
+      let parsed;
+      let body;
+      try {
+        body = await probe.text();
+        parsed = JSON.parse(body);
+      } catch {
+        return response;
+      }
+      if (!isRfc8414OnlyMetadata(parsed)) {
+        return response;
+      }
+      const source = probe.url || candidate;
+      await releaseBody(response);
+      console.warn(
+        `[oauth] ${source} returned RFC 8414 OAuth 2.0 authorization server metadata, not an OpenID provider document. The MCP TypeScript SDK validates that path as OpenID Connect Discovery and would reject it (modelcontextprotocol/typescript-sdk#2733), so the Inspector is handing it to discovery as the RFC 8414 document it is.`
+      );
+      return new Response(body, {
+        status: 200,
+        statusText: "OK",
+        headers: {
+          "content-type": "application/json",
+          // The substituted response is what the fetch trackers above this
+          // wrapper record, so it says where its body actually came from
+          // rather than letting the Network tab imply the RFC 8414 path
+          // answered. Named on the response, not logged only, so it survives
+          // into the captured entry.
+          [COMPAT_SOURCE_HEADER]: source
+        }
+      });
+    }
+    return response;
+  };
+}
+
 // ../../core/logging/logger.ts
 var noop = () => {
 };
@@ -4953,49 +5707,331 @@ var BaseOAuthClientProvider = class {
         await this.storage.clearDiscoveryState(this.serverUrl);
         return;
     }
-  }
-};
-
-// ../../core/auth/types.ts
-function authProtocolFromEnterpriseManaged(enterpriseManaged) {
-  return enterpriseManaged ? "ema" : "standard";
-}
-var EMPTY_OAUTH_FLOW_STATE = {
-  completedAt: null,
-  isInitiatingAuth: false,
-  oauthTokens: null,
-  oauthStep: "authorization_code",
-  oauthMetadata: null,
-  resourceMetadata: null,
-  resourceMetadataError: null,
-  resource: null,
-  authServerUrl: null,
-  oauthClientInfo: null,
-  authorizationUrl: null,
-  authorizationCode: "",
-  latestError: null,
-  statusMessage: null,
-  validationError: null
-};
-
-// ../../core/auth/mcpAuth.ts
-import { auth as sdkAuth } from "@modelcontextprotocol/client";
-async function mcpAuth(provider, options) {
-  if (options.forceReauthorization && options.authorizationCode !== void 0) {
-    throw new Error(
-      "forceReauthorization cannot be combined with authorizationCode"
+  }
+};
+
+// ../../core/auth/types.ts
+function authProtocolFromEnterpriseManaged(enterpriseManaged) {
+  return enterpriseManaged ? "ema" : "standard";
+}
+var EMPTY_OAUTH_FLOW_STATE = {
+  completedAt: null,
+  isInitiatingAuth: false,
+  oauthTokens: null,
+  oauthStep: "authorization_code",
+  oauthMetadata: null,
+  resourceMetadata: null,
+  resourceMetadataError: null,
+  resource: null,
+  authServerUrl: null,
+  oauthClientInfo: null,
+  authorizationUrl: null,
+  authorizationCode: "",
+  latestError: null,
+  statusMessage: null,
+  validationError: null
+};
+
+// ../../core/auth/mcpAuth.ts
+import { auth as sdkAuth } from "@modelcontextprotocol/client";
+async function mcpAuth(provider, options) {
+  if (options.forceReauthorization && options.authorizationCode !== void 0) {
+    throw new Error(
+      "forceReauthorization cannot be combined with authorizationCode"
+    );
+  }
+  return sdkAuth(provider, {
+    serverUrl: options.serverUrl,
+    authorizationCode: options.authorizationCode,
+    iss: options.iss,
+    scope: options.scope,
+    resourceMetadataUrl: options.resourceMetadataUrl,
+    fetchFn: options.fetchFn,
+    skipIssuerMetadataValidation: options.skipIssuerMetadataValidation,
+    forceReauthorization: options.forceReauthorization
+  });
+}
+
+// ../../core/auth/revocation.ts
+import { selectClientAuthMethod } from "@modelcontextprotocol/client";
+import {
+  OAuthClientInformationSchema,
+  OAuthTokensSchema
+} from "@modelcontextprotocol/core";
+var DEFAULT_REVOCATION_TIMEOUT_MS = 5e3;
+function selectRevocableToken(tokens) {
+  if (!tokens) return null;
+  if (tokens.refresh_token) {
+    return { token: tokens.refresh_token, tokenTypeHint: "refresh_token" };
+  }
+  if (tokens.access_token) {
+    return { token: tokens.access_token, tokenTypeHint: "access_token" };
+  }
+  return null;
+}
+function revocationAuthMethods(metadata) {
+  return metadata.revocation_endpoint_auth_methods_supported ?? [
+    "client_secret_basic"
+  ];
+}
+function buildRevocationRequest(params) {
+  const body = new URLSearchParams({
+    token: params.token,
+    token_type_hint: params.tokenTypeHint
+  });
+  const headers = {
+    "Content-Type": "application/x-www-form-urlencoded",
+    Accept: "application/json"
+  };
+  const client = params.clientInformation;
+  if (client) {
+    const method = selectClientAuthMethod(client, params.supportedAuthMethods);
+    if (method === "client_secret_basic" && client.client_secret) {
+      const credentials = `${encodeURIComponent(client.client_id)}:${encodeURIComponent(client.client_secret)}`;
+      headers.Authorization = `Basic ${base64Encode(credentials)}`;
+    } else if (method === "client_secret_post" && client.client_secret) {
+      body.set("client_id", client.client_id);
+      body.set("client_secret", client.client_secret);
+    } else {
+      body.set("client_id", client.client_id);
+    }
+  }
+  return {
+    url: params.endpoint,
+    init: { method: "POST", headers, body: body.toString() }
+  };
+}
+function base64Encode(value) {
+  if (typeof btoa === "function") return btoa(value);
+  return Buffer.from(value, "utf8").toString("base64");
+}
+async function revokeToken(params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_REVOCATION_TIMEOUT_MS;
+  try {
+    const { url, init } = buildRevocationRequest(params);
+    const response = await withDeadline(
+      params.fetchFn(url, { ...init, signal: AbortSignal.timeout(timeoutMs) }),
+      timeoutMs
+    );
+    if (!response.ok) {
+      return {
+        status: "failed",
+        endpoint: url,
+        detail: `revocation endpoint responded ${response.status} ${response.statusText}`.trim()
+      };
+    }
+    return {
+      status: "revoked",
+      tokenTypeHint: params.tokenTypeHint,
+      endpoint: url
+    };
+  } catch (err) {
+    return {
+      // `params.endpoint`, not the built `url`: construction is inside the try
+      // now, so `url` may not exist on this path.
+      status: "failed",
+      endpoint: params.endpoint,
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function withDeadline(promise, timeoutMs) {
+  let timer;
+  const deadline = new Promise((_resolve, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`revocation request timed out after ${timeoutMs}ms`)),
+      timeoutMs
+    );
+  });
+  try {
+    return await Promise.race([promise, deadline]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function emptyPlan(serverUrl, outcome, failures = []) {
+  return {
+    serverUrl,
+    grants: [],
+    failures,
+    supportedAuthMethods: [],
+    outcome: failures.length > 0 ? aggregateOutcomes([...failures, outcome]) : outcome
+  };
+}
+async function clearAndPlanRevocation(params) {
+  const { serverUrl, storage } = params;
+  let snapshot;
+  try {
+    snapshot = await storage.takeRevocationSnapshot(serverUrl);
+  } catch (err) {
+    throw err instanceof Error ? err : new Error(String(err));
+  }
+  if (params.enabled === false) {
+    return emptyPlan(serverUrl, { status: "skipped", reason: "disabled" });
+  }
+  try {
+    const { grants, failures } = await collectGrants(snapshot);
+    if (grants.length === 0) {
+      return emptyPlan(
+        serverUrl,
+        { status: "skipped", reason: "no_tokens" },
+        failures
+      );
+    }
+    const metadata = parseServerMetadata(snapshot.serverMetadata);
+    if (!metadata) {
+      return emptyPlan(
+        serverUrl,
+        { status: "skipped", reason: "no_metadata" },
+        failures
+      );
+    }
+    if (!metadata.revocation_endpoint) {
+      return emptyPlan(
+        serverUrl,
+        { status: "skipped", reason: "no_endpoint" },
+        failures
+      );
+    }
+    return {
+      serverUrl,
+      grants,
+      failures,
+      endpoint: metadata.revocation_endpoint,
+      supportedAuthMethods: revocationAuthMethods(metadata),
+      metadataIssuer: metadata.issuer
+    };
+  } catch (err) {
+    return emptyPlan(serverUrl, {
+      status: "failed",
+      detail: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function parseServerMetadata(raw) {
+  if (raw === null || typeof raw !== "object") return void 0;
+  return raw;
+}
+async function executeOAuthRevocation(plan, params) {
+  const outcome = await runPlan(plan, params);
+  const { logger } = params;
+  if (outcome.status === "failed") {
+    logger?.warn(
+      {
+        serverUrl: plan.serverUrl,
+        endpoint: outcome.endpoint,
+        detail: outcome.detail
+      },
+      "Token revocation failed; local OAuth state was cleared anyway"
+    );
+  } else if (outcome.status === "skipped" && outcome.reason === "no_endpoint") {
+    logger?.debug(
+      { serverUrl: plan.serverUrl },
+      "Skipping token revocation: authorization server metadata has no revocation_endpoint"
+    );
+  }
+  return outcome;
+}
+async function collectGrants(snapshot) {
+  const grants = [];
+  const failures = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  let preregistered;
+  try {
+    preregistered = await parseClient(snapshot.preregisteredClientInformation);
+  } catch (err) {
+    failures.push({
+      status: "failed",
+      detail: `could not read the preconfigured client registration: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  const add2 = async (issuer, rawTokens, rawClient) => {
+    const revocable = selectRevocableToken(await parseTokens(rawTokens));
+    if (!revocable) return;
+    const key = `${issuer ?? "\0legacy"}\0${revocable.token}`;
+    if (seenKeys.has(key)) return;
+    seenKeys.add(key);
+    const bound = await parseClient(rawClient);
+    grants.push({
+      issuer,
+      ...revocable,
+      clientInformation: bound ?? preregistered
+    });
+  };
+  const addSafely = async (issuer, rawTokens, rawClient) => {
+    try {
+      await add2(issuer, rawTokens, rawClient);
+    } catch (err) {
+      const where = issuer === void 0 ? "the unkeyed slot" : `issuer ${issuer}`;
+      failures.push({
+        status: "failed",
+        detail: `could not read the stored grant for ${where}: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  };
+  for (const [issuer, slot] of Object.entries(snapshot.byIssuer)) {
+    await addSafely(issuer, slot?.tokens, slot?.clientInformation);
+  }
+  await addSafely(
+    void 0,
+    snapshot.legacyTokens,
+    snapshot.legacyClientInformation
+  );
+  return { grants, failures };
+}
+async function parseTokens(raw) {
+  return raw === void 0 || raw === null ? void 0 : await OAuthTokensSchema.parseAsync(raw);
+}
+async function parseClient(raw) {
+  return raw === void 0 || raw === null ? void 0 : await OAuthClientInformationSchema.parseAsync(raw);
+}
+function aggregateOutcomes(outcomes) {
+  return outcomes.find((o) => o.status === "failed") ?? outcomes.find((o) => o.status === "revoked") ?? outcomes[0] ?? { status: "skipped", reason: "no_tokens" };
+}
+async function runPlan(plan, params) {
+  if (plan.outcome) return plan.outcome;
+  const endpoint = plan.endpoint;
+  if (!endpoint) return { status: "skipped", reason: "no_endpoint" };
+  const outcomes = [...plan.failures];
+  const timeoutMs = params.timeoutMs ?? DEFAULT_REVOCATION_TIMEOUT_MS;
+  const deadlineAt = Date.now() + timeoutMs;
+  for (const grant of plan.grants) {
+    if (grant.issuer === void 0) {
+      outcomes.push({
+        status: "failed",
+        detail: "the stored grant is not bound to an authorization server (it predates issuer binding), so it could not be matched to this revocation endpoint and was cleared without revocation \u2014 re-authorize to make future clears revocable"
+      });
+      continue;
+    }
+    if (plan.metadataIssuer !== grant.issuer) {
+      outcomes.push({
+        status: "failed",
+        detail: plan.metadataIssuer === void 0 ? `the cached authorization-server metadata names no issuer, so the grant bound to ${grant.issuer} could not be matched to this revocation endpoint and was cleared without revocation` : `the cached authorization-server metadata is for ${plan.metadataIssuer}, so the grant bound to ${grant.issuer} was cleared without revocation`
+      });
+      continue;
+    }
+    const remainingMs = deadlineAt - Date.now();
+    if (remainingMs <= 0) {
+      outcomes.push({
+        status: "failed",
+        endpoint,
+        detail: `the ${timeoutMs}ms revocation budget was exhausted before this grant was attempted${grant.issuer === void 0 ? "" : ` (issuer ${grant.issuer})`}`
+      });
+      continue;
+    }
+    outcomes.push(
+      await revokeToken({
+        endpoint,
+        token: grant.token,
+        tokenTypeHint: grant.tokenTypeHint,
+        clientInformation: grant.clientInformation,
+        supportedAuthMethods: plan.supportedAuthMethods,
+        fetchFn: params.fetchFn,
+        timeoutMs: remainingMs
+      })
     );
   }
-  return sdkAuth(provider, {
-    serverUrl: options.serverUrl,
-    authorizationCode: options.authorizationCode,
-    iss: options.iss,
-    scope: options.scope,
-    resourceMetadataUrl: options.resourceMetadataUrl,
-    fetchFn: options.fetchFn,
-    skipIssuerMetadataValidation: options.skipIssuerMetadataValidation,
-    forceReauthorization: options.forceReauthorization
-  });
+  return aggregateOutcomes(outcomes);
 }
 
 // ../../core/auth/ema/clientConfigError.ts
@@ -5023,7 +6059,7 @@ import {
   exchangeAuthorization,
   startAuthorization
 } from "@modelcontextprotocol/client";
-import { OAuthMetadataSchema } from "@modelcontextprotocol/core";
+import { OAuthMetadataSchema as OAuthMetadataSchema2 } from "@modelcontextprotocol/core";
 
 // ../../core/auth/ema/constants.ts
 var GRANT_TYPE_JWT_BEARER = "urn:ietf:params:oauth:grant-type:jwt-bearer";
@@ -5072,7 +6108,7 @@ function idpOAuthStorageKey(issuer) {
 }
 
 // ../../core/auth/ema/tokenEndpoint.ts
-import { selectClientAuthMethod } from "@modelcontextprotocol/client";
+import { selectClientAuthMethod as selectClientAuthMethod2 } from "@modelcontextprotocol/client";
 async function parseOAuthTokenErrorResponse(response, step) {
   let body;
   try {
@@ -5093,7 +6129,7 @@ async function parseOAuthTokenErrorResponse(response, step) {
 }
 function applyClientAuth(metadata, clientInformation, headers, body) {
   const supported = metadata?.token_endpoint_auth_methods_supported ?? [];
-  const method = selectClientAuthMethod(clientInformation, supported);
+  const method = selectClientAuthMethod2(clientInformation, supported);
   if (method === "client_secret_basic" && clientInformation.client_secret) {
     const credentials = btoa(
       `${clientInformation.client_id}:${clientInformation.client_secret}`
@@ -5147,7 +6183,7 @@ async function discoverIdpMetadata(issuer, fetchFn) {
       `Failed to discover OIDC metadata for IdP issuer ${issuer}`
     );
   }
-  return OAuthMetadataSchema.parse(metadata);
+  return OAuthMetadataSchema2.parse(metadata);
 }
 async function startIdpOidcAuthorization(params) {
   const issuer = normalizeIdpIssuer(params.idp.issuer);
@@ -5403,7 +6439,7 @@ async function discoverResourceAsMetadata(resourceAsUrl, fetchFn) {
 
 // ../../core/auth/ema/wire.ts
 import { discoverAndRequestJwtAuthGrant } from "@modelcontextprotocol/client";
-import { OAuthTokensSchema } from "@modelcontextprotocol/core";
+import { OAuthTokensSchema as OAuthTokensSchema2 } from "@modelcontextprotocol/core";
 async function exchangeIdJag(params) {
   const issuer = normalizeIdpIssuer(params.idp.issuer);
   const resource = params.resource.trim();
@@ -5482,7 +6518,7 @@ async function redeemIdJagForAccessToken(params) {
       "EMA leg 3 (resource AS JWT bearer grant)"
     );
   }
-  return OAuthTokensSchema.parse(await response.json());
+  return OAuthTokensSchema2.parse(await response.json());
 }
 
 // ../../core/auth/ema/emaFlow.ts
@@ -6229,14 +7265,41 @@ var OAuthManager = class {
       return void 0;
     }
   }
-  async clearOAuthTokens() {
+  /**
+   * Drop this server's local OAuth state, and revoke the grant at the
+   * authorization server (RFC 7009).
+   *
+   * The state is taken and deleted in one atomic step, and the requests are
+   * sent afterwards from what was taken. Both halves matter: the requests need
+   * state the clear destroys, and the clear must not wait on the network, or a
+   * fresh authorization completing during a five-second revocation would be
+   * deleted by a clear reasoning about the grant it replaced.
+   *
+   * Best-effort by construction: every failure is reported through the returned
+   * outcome and the clear has already happened regardless, because forgetting
+   * the tokens is what the caller actually asked for (#2144).
+   *
+   * `options.revoke === false` skips the request. That is not only an escape
+   * hatch for an authorization server that mishandles it — disconnecting while
+   * still holding live tokens is a case a user may want to reproduce
+   * deliberately, to watch how a server under test copes with it.
+   */
+  async clearOAuthTokens(options) {
     if (!this.oauthConfig?.storage) {
-      return;
+      return { status: "skipped", reason: "no_tokens" };
     }
     const serverUrl = this.getServerUrl();
-    await this.oauthConfig.storage.clear(serverUrl);
+    const plan = await clearAndPlanRevocation({
+      serverUrl,
+      storage: this.oauthConfig.storage,
+      enabled: options?.revoke
+    });
     this.oauthFlowState = null;
     this.pendingAuthorizationScope = void 0;
+    return executeOAuthRevocation(plan, {
+      fetchFn: this.params.effectiveAuthFetch,
+      logger: this.params.logger
+    });
   }
   async isOAuthAuthorized() {
     const tokens = await this.getOAuthTokens();
@@ -6563,10 +7626,11 @@ var OAuthManager = class {
         await this.params.onBeforeOAuthRedirect(parsedState.authId);
       }
     }
-    this.requireNavigation().navigateToAuthorization(authorizationUrl);
+    const navigation = this.requireNavigation();
     const provider = await this.createOAuthProvider();
     const clientInfo = await provider.clientInformation();
     await this.recordAuthorizationCodeFlowState(authorizationUrl, clientInfo);
+    navigation.navigateToAuthorization(authorizationUrl);
     this.params.dispatchOAuthAuthorizationRequired({ url: authorizationUrl });
   }
   requireNavigation() {
@@ -6723,6 +7787,24 @@ var RemoteClientTransport = class {
   sseResponseWaits = /* @__PURE__ */ new Map();
   options;
   config;
+  /**
+   * Whether the upstream connection gives each request its own response stream
+   * (#2140). The SDK's `Protocol.request` reads this: on a 2026-era connection
+   * a transport advertising it has its per-request stream **aborted** as the
+   * spec's cancellation signal, and no `notifications/cancelled` is sent; a
+   * transport that does not gets the stdio mechanism instead.
+   *
+   * The real upstream transport lives on the backend, so this transport has to
+   * answer for it. Streamable HTTP opens one POST — and one SSE response
+   * stream — per request, so it qualifies; stdio and SSE multiplex every
+   * request over one shared channel and must keep sending the notification.
+   *
+   * Advertising it is only half the fix: `requestSend` applies the SDK's
+   * `requestSignal` to the browser-to-backend fetch, and `/api/mcp/send`
+   * forwards that disconnect to the upstream `transport.send`, which is what
+   * actually closes the stream the server is watching.
+   */
+  hasPerRequestStream;
   /**
    * Intentionally returns undefined. The MCP Client checks transport.sessionId to detect
    * reconnects and skip initialize. Our _sessionId is the remote server's session ID, not
@@ -6767,6 +7849,7 @@ var RemoteClientTransport = class {
   constructor(options, config) {
     this.options = options;
     this.config = config;
+    this.hasPerRequestStream = config.type === "streamable-http";
   }
   setAuthRecovery(handlers) {
     this.options.authRecovery = handlers;
@@ -7131,7 +8214,8 @@ var RemoteClientTransport = class {
     const res = await this.fetchFn(`${this.baseUrl}/api/mcp/send`, {
       method: "POST",
       headers: this.headers,
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      ...options?.requestSignal && { signal: options.requestSignal }
     });
     if (!res.ok) {
       const text = await res.text();
@@ -7368,6 +8452,13 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   // pending re-listen timer.
   modernReconnectAttempts = 0;
   modernReconnectTimer;
+  // Set when the last `listen()` was rejected because the server answered it
+  // with a bare graceful-closure result instead of acknowledging (#2097). That
+  // condition is deterministic, so the reconnect machinery must not treat it as
+  // a drop to retry; the flag is what carries the distinction from the rejection
+  // site to the two failure handlers. Cleared by any user-initiated refresh (a
+  // subscribe/unsubscribe is a fresh attempt, and the server may have changed).
+  modernNeverAcknowledged = false;
   // Task ids the user explicitly cancelled. A cancel makes the in-flight
   // `callToolStream` reject with a generic -32603 error, which the stream's
   // error path would otherwise report as a *failed* task — flashing "failed"
@@ -7389,9 +8480,12 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   pendingRawWireRequests = /* @__PURE__ */ new Map();
   rawWireRequestCounter = 0;
   // Abort controller for the in-flight ordinary (non-task) tool call. Aborting
-  // it makes the SDK send a `notifications/cancelled` for that request (the MCP
-  // cancellation flow) and reject the pending call, which `callTool` surfaces as
-  // a `ToolCallCancelledError`. Undefined when no ordinary call is in flight.
+  // it hands the SDK the MCP cancellation flow for that request and rejects the
+  // pending call, which `callTool` surfaces as a `ToolCallCancelledError`. Which
+  // signal reaches the server is the transport's business, not ours: a
+  // per-request-stream transport on a 2026-era connection has that request's
+  // stream aborted, and everything else gets `notifications/cancelled` (#2140).
+  // Undefined when no ordinary call is in flight.
   // Task-augmented calls have a server-side task and are cancelled via
   // `cancelRequestorTask` instead, so they don't use this (#1458).
   activeToolCallAbortController;
@@ -7498,6 +8592,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       this.fetchFn ?? fetch,
       () => this.oauthManager?.getEndpointOverrides()
     );
+    this.fetchFn = withRfc8414OidcCompat(this.fetchFn);
     this.effectiveAuthFetch = this.buildEffectiveAuthFetch();
     this.sessionId = options.sessionId;
     if (options.oauth || options.environment.oauth) {
@@ -7517,6 +8612,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
           return Promise.resolve();
         },
         initialConfig: oauthConfig,
+        logger: this.logger,
         enterpriseManagedAuth: options.enterpriseManagedAuth,
         installEnterpriseManagedAuth: options.installEnterpriseManagedAuth,
         dispatchOAuthComplete: (detail) => this.dispatchTypedEvent("oauthComplete", detail),
@@ -8207,6 +9303,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     this.modernListenGeneration++;
     this.clearModernReconnectTimer();
     this.modernReconnectAttempts = 0;
+    this.modernNeverAcknowledged = false;
     this.modernSubscription = null;
     this.setModernStreamState(INACTIVE_SUBSCRIPTION_STREAM_STATE);
     this.dispatchSubscriptionsChange();
@@ -8993,10 +10090,13 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
   }
   /**
    * Cancel the in-flight ordinary (non-task) tool call started by
-   * {@link callTool}. Aborting its request makes the SDK send a
-   * `notifications/cancelled` to the server (the MCP cancellation flow) and
-   * reject the pending call, which `callTool` surfaces as a
-   * {@link ToolCallCancelledError}.
+   * {@link callTool}. Aborting its request runs the MCP cancellation flow and
+   * rejects the pending call, which `callTool` surfaces as a
+   * {@link ToolCallCancelledError}. The SDK chooses the wire signal from the
+   * transport: on a 2026-era Streamable HTTP connection it aborts that
+   * request's own SSE response stream — the spec's cancellation signal —
+   * rather than sending `notifications/cancelled`, which is the stdio
+   * mechanism and remains in use there (#2140).
    *
    * Task-augmented calls have a server-side task and are cancelled via
    * {@link cancelRequestorTask} instead — this is a no-op for them (and whenever
@@ -11212,6 +12312,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     if (!fromReconnect) {
       this.clearModernReconnectTimer();
       this.modernReconnectAttempts = 0;
+      this.modernNeverAcknowledged = false;
     }
     const generation = ++this.modernListenGeneration;
     const previous = this.modernSubscription;
@@ -11223,10 +12324,18 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       this.setModernStreamState(INACTIVE_SUBSCRIPTION_STREAM_STATE);
       return;
     }
-    const subscription = await this.client.listen(
-      this.buildSubscriptionFilter(),
-      this.getRequestOptions()
-    );
+    let subscription;
+    try {
+      subscription = await this.client.listen(
+        this.buildSubscriptionFilter(),
+        this.getRequestOptions()
+      );
+    } catch (error) {
+      if (generation === this.modernListenGeneration && isNeverAcknowledgedSubscriptionClose(error)) {
+        this.modernNeverAcknowledged = true;
+      }
+      throw error;
+    }
     if (generation !== this.modernListenGeneration) {
       await closeSubscriptionBestEffort(subscription);
       return;
@@ -11308,8 +12417,34 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       this.setModernStreamState(INACTIVE_SUBSCRIPTION_STREAM_STATE);
       return;
     }
+    if (this.modernNeverAcknowledged) {
+      this.endModernStreamNeverAcknowledged();
+      return;
+    }
     this.scheduleModernReconnect();
   }
+  /**
+   * Settle the stream on the never-acknowledged close (#2097): a status of its
+   * own so the UI can say what happened, no reconnect, and a log line carrying
+   * the same sentence the UI shows.
+   *
+   * The state is *not* `"ended"` — that badge covers the two expected closes (a
+   * server shutting an established stream down, and reconnection abandoned after
+   * repeated failures), and reading this case as either of them is exactly the
+   * silence #2063 reported.
+   */
+  endModernStreamNeverAcknowledged() {
+    this.clearModernReconnectTimer();
+    this.logger.warn(
+      { message: NEVER_ACKNOWLEDGED_SUBSCRIPTION_MESSAGE },
+      "subscriptions/listen closed without an acknowledgement"
+    );
+    this.setModernStreamState({
+      active: this.modernStreamActive(),
+      status: "never-acknowledged",
+      honoredUris: []
+    });
+  }
   /**
    * Schedule a reconnect re-listen after the current backoff delay (#1630).
    * `modernReconnectAttempts` reflects the number of *consecutive failed*
@@ -11343,6 +12478,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    * stream ended (re-subscribing resets the run and tries again).
    */
   onModernReconnectFailed() {
+    if (this.modernNeverAcknowledged && !isTerminalStatus(this.status) && this.wantsModernStream()) {
+      this.endModernStreamNeverAcknowledged();
+      return;
+    }
     this.modernReconnectAttempts += 1;
     if (this.modernReconnectAttempts > MODERN_RECONNECT_MAX_ATTEMPTS || isTerminalStatus(this.status) || !this.wantsModernStream()) {
       this.setModernStreamState({
@@ -11399,7 +12538,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       this.dispatchSubscriptionsChange();
     } catch (error) {
       throw new Error(
-        `Failed to subscribe to resource: ${error instanceof Error ? error.message : String(error)}`,
+        `Failed to subscribe to resource: ${subscriptionFailureMessage(error)}`,
         { cause: error }
       );
     }
@@ -11444,7 +12583,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       }
     } catch (error) {
       throw new Error(
-        `Failed to unsubscribe from resource: ${error instanceof Error ? error.message : String(error)}`,
+        `Failed to unsubscribe from resource: ${subscriptionFailureMessage(error)}`,
         { cause: error }
       );
     }
@@ -11715,10 +12854,23 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     return this.oauthManager.getOAuthTokens();
   }
   /**
-   * Clears OAuth tokens and client information
+   * Drop this server's stored OAuth state and revoke the grant at the
+   * authorization server (RFC 7009, #2144).
+   *
+   * The request is planned from the stored state, the state is cleared, and
+   * only then is the request sent — so the clear never waits on the network.
+   *
+   * The revocation is best-effort — an authorization server that advertises no
+   * `revocation_endpoint` is left behaving exactly as before, and a network
+   * error, a non-2xx or a timeout is reported in the returned outcome rather
+   * than thrown — so the local clear always completes. Pass
+   * `{ revoke: false }` to skip it.
    */
-  async clearOAuthTokens() {
-    await this.oauthManager?.clearOAuthTokens();
+  async clearOAuthTokens(options) {
+    return await this.oauthManager?.clearOAuthTokens(options) ?? {
+      status: "skipped",
+      reason: "no_tokens"
+    };
   }
   /**
    * Checks if client is currently OAuth authorized
@@ -12361,158 +13513,131 @@ var ManagedPromptsState = class extends ManagedListState {
 };
 
 // ../../core/react/useInspectorClient.ts
-import { useState, useEffect, useCallback } from "react";
+import { useCallback as useCallback2, useEffect, useState } from "react";
+
+// ../../core/react/useStoreSnapshot.ts
+import { useCallback, useRef, useSyncExternalStore } from "react";
+function useStoreSnapshot(store, event, read, whenAbsent) {
+  const cache = useRef(null);
+  const subscribe = useCallback(
+    (onStoreChange) => {
+      if (!store) return () => {
+      };
+      store.addEventListener(event, onStoreChange);
+      return () => {
+        store.removeEventListener(event, onStoreChange);
+      };
+    },
+    [store, event]
+  );
+  const getSnapshot = useCallback(() => {
+    const revision = store ? store.getEventRevision(event) : 0;
+    const cached = cache.current;
+    if (cached && Object.is(cached.store, store) && cached.event === event && cached.read === read && Object.is(cached.whenAbsent, whenAbsent) && cached.revision === revision) {
+      return cached.value;
+    }
+    const value = store ? read(store) : whenAbsent;
+    cache.current = { store, event, read, whenAbsent, revision, value };
+    return value;
+  }, [store, event, read, whenAbsent]);
+  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
+// ../../core/react/useInspectorClient.ts
 var EMPTY_CLIENT_CAPABILITIES = Object.freeze({});
+var NO_EXCLUDED_TOOLS = [];
+var NO_MALFORMED_LIST_ITEMS = [];
+var readStatus = (client) => client.getStatus();
+var readCapabilities = (client) => client.getCapabilities();
+var readServerInfo = (client) => client.getServerInfo();
+var readInstructions = (client) => client.getInstructions();
+var readProtocolVersion = (client) => client.getProtocolVersion();
+var readProtocolEra = (client) => client.getProtocolEra();
+var readDiscoverResult = (client) => client.getDiscoverResult();
+var readExcludedTools = (client) => client.getExcludedTools();
+var readMalformedListItems = (client) => client.getMalformedListItems();
 function useInspectorClient(inspectorClient) {
-  const [status, setStatus] = useState(
-    inspectorClient?.getStatus() ?? "disconnected"
+  const status = useStoreSnapshot(
+    inspectorClient,
+    "statusChange",
+    readStatus,
+    "disconnected"
+  );
+  const capabilities = useStoreSnapshot(
+    inspectorClient,
+    "capabilitiesChange",
+    readCapabilities,
+    void 0
+  );
+  const serverInfo = useStoreSnapshot(
+    inspectorClient,
+    "serverInfoChange",
+    readServerInfo,
+    void 0
   );
-  const [capabilities, setCapabilities] = useState(inspectorClient?.getCapabilities());
-  const [serverInfo, setServerInfo] = useState(
-    inspectorClient?.getServerInfo()
+  const instructions = useStoreSnapshot(
+    inspectorClient,
+    "instructionsChange",
+    readInstructions,
+    void 0
   );
-  const [instructions, setInstructions] = useState(
-    inspectorClient?.getInstructions()
+  const protocolVersion = useStoreSnapshot(
+    inspectorClient,
+    "protocolVersionChange",
+    readProtocolVersion,
+    void 0
   );
-  const [protocolVersion, setProtocolVersion] = useState(
-    inspectorClient?.getProtocolVersion()
+  const protocolEra = useStoreSnapshot(
+    inspectorClient,
+    "protocolEraChange",
+    readProtocolEra,
+    void 0
   );
-  const [protocolEra, setProtocolEra] = useState(
-    inspectorClient?.getProtocolEra()
+  const discoverResult = useStoreSnapshot(
+    inspectorClient,
+    "discoverResultChange",
+    readDiscoverResult,
+    void 0
   );
-  const [discoverResult, setDiscoverResult] = useState(inspectorClient?.getDiscoverResult());
-  const [excludedTools, setExcludedTools] = useState(
-    inspectorClient?.getExcludedTools() ?? []
+  const excludedTools = useStoreSnapshot(
+    inspectorClient,
+    "excludedToolsChange",
+    readExcludedTools,
+    NO_EXCLUDED_TOOLS
   );
-  const [malformedListItems, setMalformedListItems] = useState(inspectorClient?.getMalformedListItems() ?? []);
-  const [lastError, setLastError] = useState(void 0);
+  const malformedListItems = useStoreSnapshot(
+    inspectorClient,
+    "malformedListItemsChange",
+    readMalformedListItems,
+    NO_MALFORMED_LIST_ITEMS
+  );
+  const [errorState, setErrorState] = useState({ client: inspectorClient });
+  if (errorState.client !== inspectorClient) {
+    setErrorState({ client: inspectorClient });
+  }
+  const lastError = errorState.client === inspectorClient ? errorState.message : void 0;
   useEffect(() => {
-    if (!inspectorClient) {
-      setStatus("disconnected");
-      setCapabilities(void 0);
-      setServerInfo(void 0);
-      setInstructions(void 0);
-      setProtocolVersion(void 0);
-      setProtocolEra(void 0);
-      setDiscoverResult(void 0);
-      setExcludedTools([]);
-      setMalformedListItems([]);
-      setLastError(void 0);
-      return;
-    }
-    setStatus(inspectorClient.getStatus());
-    setCapabilities(inspectorClient.getCapabilities());
-    setServerInfo(inspectorClient.getServerInfo());
-    setInstructions(inspectorClient.getInstructions());
-    setProtocolVersion(inspectorClient.getProtocolVersion());
-    setProtocolEra(inspectorClient.getProtocolEra());
-    setDiscoverResult(inspectorClient.getDiscoverResult());
-    setExcludedTools(inspectorClient.getExcludedTools());
-    setMalformedListItems(inspectorClient.getMalformedListItems());
-    setLastError(void 0);
+    if (!inspectorClient) return;
     const onStatusChange = (event) => {
-      setStatus(event.detail);
       if (event.detail === "connecting") {
-        setLastError(void 0);
+        setErrorState({ client: inspectorClient });
       }
     };
     const onError = (event) => {
-      setLastError(event.detail.message);
-    };
-    const onCapabilitiesChange = (event) => {
-      setCapabilities(event.detail);
-    };
-    const onServerInfoChange = (event) => {
-      setServerInfo(event.detail);
-    };
-    const onInstructionsChange = (event) => {
-      setInstructions(event.detail);
-    };
-    const onProtocolVersionChange = (event) => {
-      setProtocolVersion(event.detail);
-    };
-    const onProtocolEraChange = (event) => {
-      setProtocolEra(event.detail);
-    };
-    const onDiscoverResultChange = (event) => {
-      setDiscoverResult(event.detail);
-    };
-    const onMalformedListItemsChange = (event) => {
-      setMalformedListItems(event.detail);
-    };
-    const onExcludedToolsChange = (event) => {
-      setExcludedTools(event.detail);
+      setErrorState({ client: inspectorClient, message: event.detail.message });
     };
     inspectorClient.addEventListener("statusChange", onStatusChange);
     inspectorClient.addEventListener("error", onError);
-    inspectorClient.addEventListener(
-      "capabilitiesChange",
-      onCapabilitiesChange
-    );
-    inspectorClient.addEventListener("serverInfoChange", onServerInfoChange);
-    inspectorClient.addEventListener(
-      "instructionsChange",
-      onInstructionsChange
-    );
-    inspectorClient.addEventListener(
-      "protocolVersionChange",
-      onProtocolVersionChange
-    );
-    inspectorClient.addEventListener("protocolEraChange", onProtocolEraChange);
-    inspectorClient.addEventListener(
-      "discoverResultChange",
-      onDiscoverResultChange
-    );
-    inspectorClient.addEventListener(
-      "excludedToolsChange",
-      onExcludedToolsChange
-    );
-    inspectorClient.addEventListener(
-      "malformedListItemsChange",
-      onMalformedListItemsChange
-    );
     return () => {
       inspectorClient.removeEventListener("statusChange", onStatusChange);
       inspectorClient.removeEventListener("error", onError);
-      inspectorClient.removeEventListener(
-        "capabilitiesChange",
-        onCapabilitiesChange
-      );
-      inspectorClient.removeEventListener(
-        "serverInfoChange",
-        onServerInfoChange
-      );
-      inspectorClient.removeEventListener(
-        "instructionsChange",
-        onInstructionsChange
-      );
-      inspectorClient.removeEventListener(
-        "protocolVersionChange",
-        onProtocolVersionChange
-      );
-      inspectorClient.removeEventListener(
-        "protocolEraChange",
-        onProtocolEraChange
-      );
-      inspectorClient.removeEventListener(
-        "discoverResultChange",
-        onDiscoverResultChange
-      );
-      inspectorClient.removeEventListener(
-        "excludedToolsChange",
-        onExcludedToolsChange
-      );
-      inspectorClient.removeEventListener(
-        "malformedListItemsChange",
-        onMalformedListItemsChange
-      );
     };
   }, [inspectorClient]);
-  const connect = useCallback(async () => {
+  const connect = useCallback2(async () => {
     if (!inspectorClient) return;
     await inspectorClient.connect();
   }, [inspectorClient]);
-  const disconnect = useCallback(async () => {
+  const disconnect = useCallback2(async () => {
     if (!inspectorClient) return;
     await inspectorClient.disconnect();
   }, [inspectorClient]);
@@ -12540,12 +13665,12 @@ function useInspectorClient(inspectorClient) {
 }
 
 // ../../core/react/useManagedTools.ts
-import { useState as useState2, useEffect as useEffect2, useCallback as useCallback3 } from "react";
+import { useCallback as useCallback4 } from "react";
 
 // ../../core/react/useListError.ts
-import { useCallback as useCallback2, useSyncExternalStore } from "react";
+import { useCallback as useCallback3, useSyncExternalStore as useSyncExternalStore2 } from "react";
 function useListError(state) {
-  const subscribe = useCallback2(
+  const subscribe = useCallback3(
     (onStoreChange) => {
       if (!state) return () => {
       };
@@ -12557,277 +13682,156 @@ function useListError(state) {
     },
     [state]
   );
-  const getSnapshot = useCallback2(() => state?.getError() ?? null, [state]);
-  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  const getSnapshot = useCallback3(() => state?.getError() ?? null, [state]);
+  return useSyncExternalStore2(subscribe, getSnapshot, getSnapshot);
 }
 
 // ../../core/react/useManagedTools.ts
+var NO_TOOLS = [];
+var readTools = (state) => state.getTools();
+var readListChanged = (state) => state.getListChanged();
 function useManagedTools(client, managedToolsState) {
-  const [tools, setTools] = useState2(
-    managedToolsState?.getTools() ?? []
+  const tools = useStoreSnapshot(
+    managedToolsState,
+    "toolsChange",
+    readTools,
+    NO_TOOLS
   );
-  const [listChanged, setListChanged] = useState2(
-    managedToolsState?.getListChanged() ?? false
+  const listChanged = useStoreSnapshot(
+    managedToolsState,
+    "listChangedChange",
+    readListChanged,
+    false
   );
-  useEffect2(() => {
-    if (!managedToolsState) {
-      setTools([]);
-      setListChanged(false);
-      return;
-    }
-    setTools(managedToolsState.getTools());
-    setListChanged(managedToolsState.getListChanged());
-    const onToolsChange = (event) => {
-      setTools(event.detail);
-    };
-    const onListChangedChange = (event) => {
-      setListChanged(event.detail);
-    };
-    managedToolsState.addEventListener("toolsChange", onToolsChange);
-    managedToolsState.addEventListener(
-      "listChangedChange",
-      onListChangedChange
-    );
-    return () => {
-      managedToolsState.removeEventListener("toolsChange", onToolsChange);
-      managedToolsState.removeEventListener(
-        "listChangedChange",
-        onListChangedChange
-      );
-    };
-  }, [managedToolsState]);
   const error = useListError(managedToolsState);
-  const refresh = useCallback3(async () => {
-    if (!managedToolsState || !client) return [];
+  const refresh = useCallback4(async () => {
+    if (!managedToolsState || !client) return NO_TOOLS;
     managedToolsState.clearListChanged();
-    const next = await managedToolsState.refresh(void 0, "refresh");
-    setTools(next);
-    return next;
+    return managedToolsState.refresh(void 0, "refresh");
   }, [client, managedToolsState]);
-  const clearListChanged = useCallback3(() => {
+  const clearListChanged = useCallback4(() => {
     managedToolsState?.clearListChanged();
   }, [managedToolsState]);
   return { tools, error, listChanged, refresh, clearListChanged };
 }
 
 // ../../core/react/useManagedResources.ts
-import { useState as useState3, useEffect as useEffect3, useCallback as useCallback4 } from "react";
+import { useCallback as useCallback5 } from "react";
+var NO_RESOURCES = [];
+var readResources = (state) => state.getResources();
+var readListChanged2 = (state) => state.getListChanged();
 function useManagedResources(client, managedResourcesState) {
-  const [resources, setResources] = useState3(
-    managedResourcesState?.getResources() ?? []
+  const resources = useStoreSnapshot(
+    managedResourcesState,
+    "resourcesChange",
+    readResources,
+    NO_RESOURCES
   );
-  const [listChanged, setListChanged] = useState3(
-    managedResourcesState?.getListChanged() ?? false
+  const listChanged = useStoreSnapshot(
+    managedResourcesState,
+    "listChangedChange",
+    readListChanged2,
+    false
   );
-  useEffect3(() => {
-    if (!managedResourcesState) {
-      setResources([]);
-      setListChanged(false);
-      return;
-    }
-    setResources(managedResourcesState.getResources());
-    setListChanged(managedResourcesState.getListChanged());
-    const onResourcesChange = (event) => {
-      setResources(event.detail);
-    };
-    const onListChangedChange = (event) => {
-      setListChanged(event.detail);
-    };
-    managedResourcesState.addEventListener(
-      "resourcesChange",
-      onResourcesChange
-    );
-    managedResourcesState.addEventListener(
-      "listChangedChange",
-      onListChangedChange
-    );
-    return () => {
-      managedResourcesState.removeEventListener(
-        "resourcesChange",
-        onResourcesChange
-      );
-      managedResourcesState.removeEventListener(
-        "listChangedChange",
-        onListChangedChange
-      );
-    };
-  }, [managedResourcesState]);
   const error = useListError(managedResourcesState);
-  const refresh = useCallback4(async () => {
-    if (!managedResourcesState || !client) return [];
+  const refresh = useCallback5(async () => {
+    if (!managedResourcesState || !client) return NO_RESOURCES;
     managedResourcesState.clearListChanged();
-    const next = await managedResourcesState.refresh(void 0, "refresh");
-    setResources(next);
-    return next;
+    return managedResourcesState.refresh(void 0, "refresh");
   }, [client, managedResourcesState]);
-  const clearListChanged = useCallback4(() => {
+  const clearListChanged = useCallback5(() => {
     managedResourcesState?.clearListChanged();
   }, [managedResourcesState]);
   return { resources, error, listChanged, refresh, clearListChanged };
 }
 
 // ../../core/react/useManagedResourceTemplates.ts
-import { useState as useState4, useEffect as useEffect4, useCallback as useCallback5 } from "react";
+import { useCallback as useCallback6 } from "react";
+var NO_RESOURCE_TEMPLATES = [];
+var readResourceTemplates = (state) => state.getResourceTemplates();
 function useManagedResourceTemplates(client, managedResourceTemplatesState) {
-  const [resourceTemplates, setResourceTemplates] = useState4(managedResourceTemplatesState?.getResourceTemplates() ?? []);
-  useEffect4(() => {
-    if (!managedResourceTemplatesState) {
-      setResourceTemplates([]);
-      return;
-    }
-    setResourceTemplates(managedResourceTemplatesState.getResourceTemplates());
-    const onResourceTemplatesChange = (event) => {
-      setResourceTemplates(event.detail);
-    };
-    managedResourceTemplatesState.addEventListener(
-      "resourceTemplatesChange",
-      onResourceTemplatesChange
-    );
-    return () => {
-      managedResourceTemplatesState.removeEventListener(
-        "resourceTemplatesChange",
-        onResourceTemplatesChange
-      );
-    };
-  }, [managedResourceTemplatesState]);
+  const resourceTemplates = useStoreSnapshot(
+    managedResourceTemplatesState,
+    "resourceTemplatesChange",
+    readResourceTemplates,
+    NO_RESOURCE_TEMPLATES
+  );
   const error = useListError(managedResourceTemplatesState);
-  const refresh = useCallback5(async () => {
-    if (!managedResourceTemplatesState || !client) return [];
-    const next = await managedResourceTemplatesState.refresh(
-      void 0,
-      "refresh"
-    );
-    setResourceTemplates(next);
-    return next;
+  const refresh = useCallback6(async () => {
+    if (!managedResourceTemplatesState || !client) {
+      return NO_RESOURCE_TEMPLATES;
+    }
+    return managedResourceTemplatesState.refresh(void 0, "refresh");
   }, [client, managedResourceTemplatesState]);
   return { resourceTemplates, error, refresh };
 }
 
 // ../../core/react/useManagedPrompts.ts
-import { useState as useState5, useEffect as useEffect5, useCallback as useCallback6 } from "react";
+import { useCallback as useCallback7 } from "react";
+var NO_PROMPTS = [];
+var readPrompts = (state) => state.getPrompts();
+var readListChanged3 = (state) => state.getListChanged();
 function useManagedPrompts(client, managedPromptsState) {
-  const [prompts, setPrompts] = useState5(
-    managedPromptsState?.getPrompts() ?? []
+  const prompts = useStoreSnapshot(
+    managedPromptsState,
+    "promptsChange",
+    readPrompts,
+    NO_PROMPTS
   );
-  const [listChanged, setListChanged] = useState5(
-    managedPromptsState?.getListChanged() ?? false
+  const listChanged = useStoreSnapshot(
+    managedPromptsState,
+    "listChangedChange",
+    readListChanged3,
+    false
   );
-  useEffect5(() => {
-    if (!managedPromptsState) {
-      setPrompts([]);
-      setListChanged(false);
-      return;
-    }
-    setPrompts(managedPromptsState.getPrompts());
-    setListChanged(managedPromptsState.getListChanged());
-    const onPromptsChange = (event) => {
-      setPrompts(event.detail);
-    };
-    const onListChangedChange = (event) => {
-      setListChanged(event.detail);
-    };
-    managedPromptsState.addEventListener("promptsChange", onPromptsChange);
-    managedPromptsState.addEventListener(
-      "listChangedChange",
-      onListChangedChange
-    );
-    return () => {
-      managedPromptsState.removeEventListener("promptsChange", onPromptsChange);
-      managedPromptsState.removeEventListener(
-        "listChangedChange",
-        onListChangedChange
-      );
-    };
-  }, [managedPromptsState]);
   const error = useListError(managedPromptsState);
-  const refresh = useCallback6(async () => {
-    if (!managedPromptsState || !client) return [];
+  const refresh = useCallback7(async () => {
+    if (!managedPromptsState || !client) return NO_PROMPTS;
     managedPromptsState.clearListChanged();
-    const next = await managedPromptsState.refresh(void 0, "refresh");
-    setPrompts(next);
-    return next;
+    return managedPromptsState.refresh(void 0, "refresh");
   }, [client, managedPromptsState]);
-  const clearListChanged = useCallback6(() => {
+  const clearListChanged = useCallback7(() => {
     managedPromptsState?.clearListChanged();
   }, [managedPromptsState]);
   return { prompts, error, listChanged, refresh, clearListChanged };
 }
 
 // ../../core/react/useMessageLog.ts
-import { useState as useState6, useEffect as useEffect6 } from "react";
+var NO_MESSAGES = [];
+var readMessages = (state) => state.getMessages();
 function useMessageLog(messageLogState) {
-  const [messages, setMessages] = useState6(
-    messageLogState?.getMessages() ?? []
+  const messages = useStoreSnapshot(
+    messageLogState,
+    "messagesChange",
+    readMessages,
+    NO_MESSAGES
   );
-  useEffect6(() => {
-    if (!messageLogState) {
-      setMessages([]);
-      return;
-    }
-    setMessages(messageLogState.getMessages());
-    const onMessagesChange = (event) => {
-      setMessages(event.detail);
-    };
-    messageLogState.addEventListener("messagesChange", onMessagesChange);
-    return () => {
-      messageLogState.removeEventListener("messagesChange", onMessagesChange);
-    };
-  }, [messageLogState]);
   return { messages };
 }
 
 // ../../core/react/useFetchRequestLog.ts
-import { useState as useState7, useEffect as useEffect7 } from "react";
+var NO_FETCH_REQUESTS = [];
+var readFetchRequests = (state) => state.getFetchRequests();
 function useFetchRequestLog(fetchRequestLogState) {
-  const [fetchRequests, setFetchRequests] = useState7(
-    fetchRequestLogState?.getFetchRequests() ?? []
+  const fetchRequests = useStoreSnapshot(
+    fetchRequestLogState,
+    "fetchRequestsChange",
+    readFetchRequests,
+    NO_FETCH_REQUESTS
   );
-  useEffect7(() => {
-    if (!fetchRequestLogState) {
-      setFetchRequests([]);
-      return;
-    }
-    setFetchRequests(fetchRequestLogState.getFetchRequests());
-    const onFetchRequestsChange = (event) => {
-      setFetchRequests(event.detail);
-    };
-    fetchRequestLogState.addEventListener(
-      "fetchRequestsChange",
-      onFetchRequestsChange
-    );
-    return () => {
-      fetchRequestLogState.removeEventListener(
-        "fetchRequestsChange",
-        onFetchRequestsChange
-      );
-    };
-  }, [fetchRequestLogState]);
   return { fetchRequests };
 }
 
 // ../../core/react/useStderrLog.ts
-import { useState as useState8, useEffect as useEffect8 } from "react";
+var NO_STDERR_LOGS = [];
+var readStderrLogs = (state) => state.getStderrLogs();
 function useStderrLog(stderrLogState) {
-  const [stderrLogs, setStderrLogs] = useState8(
-    stderrLogState?.getStderrLogs() ?? []
+  const stderrLogs = useStoreSnapshot(
+    stderrLogState,
+    "stderrLogsChange",
+    readStderrLogs,
+    NO_STDERR_LOGS
   );
-  useEffect8(() => {
-    if (!stderrLogState) {
-      setStderrLogs([]);
-      return;
-    }
-    setStderrLogs(stderrLogState.getStderrLogs());
-    const onStderrLogsChange = (event) => {
-      setStderrLogs(event.detail);
-    };
-    stderrLogState.addEventListener("stderrLogsChange", onStderrLogsChange);
-    return () => {
-      stderrLogState.removeEventListener(
-        "stderrLogsChange",
-        onStderrLogsChange
-      );
-    };
-  }, [stderrLogState]);
   return { stderrLogs };
 }
 
@@ -12926,8 +13930,8 @@ function readInspectorVersion(callerUrl) {
 
 // ../../core/auth/oauth-storage.ts
 import {
-  OAuthClientInformationSchema,
-  OAuthTokensSchema as OAuthTokensSchema2
+  OAuthClientInformationSchema as OAuthClientInformationSchema2,
+  OAuthTokensSchema as OAuthTokensSchema3
 } from "@modelcontextprotocol/core";
 function withIssuer(value, issuer) {
   return issuer === void 0 ? value : { ...value, issuer };
@@ -13013,7 +14017,7 @@ var OAuthStorageBase = class {
     const state = this.memory.getState().getServerState(serverUrl);
     if (isPreregistered) {
       const prereg = state.preregisteredClientInformation;
-      return prereg ? await OAuthClientInformationSchema.parseAsync(prereg) : void 0;
+      return prereg ? await OAuthClientInformationSchema2.parseAsync(prereg) : void 0;
     }
     const slot = this.issuerSlot(state, issuer);
     const fromSlot = slot?.clientInformation;
@@ -13021,7 +14025,7 @@ var OAuthStorageBase = class {
     if (!clientInfo) {
       return void 0;
     }
-    const parsed = await OAuthClientInformationSchema.parseAsync(clientInfo);
+    const parsed = await OAuthClientInformationSchema2.parseAsync(clientInfo);
     return withIssuer(
       parsed,
       fromSlot ? this.resolveReadIssuer(state, issuer) : void 0
@@ -13100,7 +14104,7 @@ var OAuthStorageBase = class {
     if (!tokens) {
       return void 0;
     }
-    const parsed = await OAuthTokensSchema2.parseAsync(tokens);
+    const parsed = await OAuthTokensSchema3.parseAsync(tokens);
     return withIssuer(
       parsed,
       fromSlot ? this.resolveReadIssuer(state, issuer) : void 0
@@ -13206,6 +14210,25 @@ var OAuthStorageBase = class {
     this.memory.getState().setServerState(serverUrl, { discoveryState: void 0 });
     await this.persist();
   }
+  async takeRevocationSnapshot(serverUrl) {
+    await this.ensureLoaded();
+    const state = this.memory.getState().getServerState(serverUrl);
+    const snapshot = {
+      byIssuer: Object.fromEntries(
+        Object.entries(state.byIssuer ?? {}).map(([issuer, slot]) => [
+          issuer,
+          { tokens: slot?.tokens, clientInformation: slot?.clientInformation }
+        ])
+      ),
+      legacyTokens: state.tokens,
+      legacyClientInformation: state.clientInformation,
+      preregisteredClientInformation: state.preregisteredClientInformation,
+      serverMetadata: state.serverMetadata
+    };
+    this.memory.getState().clearServerState(serverUrl);
+    await this.persist();
+    return snapshot;
+  }
   async clear(serverUrl) {
     await this.ensureLoaded();
     this.memory.getState().clearServerState(serverUrl);
@@ -13634,6 +14657,11 @@ async function runRunnerInteractiveOAuth(options) {
   }
 }
 
+// src/oauthMessageTone.ts
+function oauthMessageToneFor(message, warningText) {
+  return message !== null && message === warningText ? "warning" : "info";
+}
+
 // src/logger.ts
 import path5 from "path";
 import pino from "pino";
@@ -13759,24 +14787,24 @@ function Tabs({
 }
 
 // src/components/InfoTab.tsx
-import { useRef as useRef3 } from "react";
+import { useRef as useRef4 } from "react";
 import { Box as Box3, Text as Text2, useInput } from "ink";
 
 // node_modules/ink-scroll-view/dist/index.js
 import {
-  useState as useState22,
+  useState as useState2,
   useRef as useRef2,
   forwardRef as forwardRef2,
   useImperativeHandle as useImperativeHandle2,
   useCallback as useCallback22
 } from "react";
 import {
-  useState as useState9,
-  useRef,
+  useState as useState3,
+  useRef as useRef3,
   forwardRef,
   useImperativeHandle,
   useLayoutEffect,
-  useCallback as useCallback7,
+  useCallback as useCallback8,
   Children,
   isValidElement
 } from "react";
@@ -13790,7 +14818,7 @@ var MeasurableItem = ({
   width,
   measureKey
 }) => {
-  const ref = useRef(null);
+  const ref = useRef3(null);
   useLayoutEffect(() => {
     if (ref.current) {
       const { height } = measureElement(ref.current);
@@ -13800,14 +14828,14 @@ var MeasurableItem = ({
   return /* @__PURE__ */ jsx2(Box2, { ref, flexShrink: 0, width: "100%", flexDirection: "column", children });
 };
 function useStateRef(initialValue) {
-  const [state, setStateInternal] = useState9(initialValue);
-  const ref = useRef(initialValue);
-  const setState = useCallback7((update) => {
+  const [state, setStateInternal] = useState3(initialValue);
+  const ref = useRef3(initialValue);
+  const setState = useCallback8((update) => {
     const nextValue = typeof update === "function" ? update(ref.current) : update;
     ref.current = nextValue;
     setStateInternal(nextValue);
   }, []);
-  const getState = useCallback7(() => ref.current, []);
+  const getState = useCallback8(() => ref.current, []);
   return [state, setState, getState];
 }
 var ControlledScrollView = forwardRef(
@@ -13825,21 +14853,21 @@ var ControlledScrollView = forwardRef(
       width: 0
     });
     const [contentHeight, setContentHeight, getContentHeight] = useStateRef(0);
-    const [itemMeasureKeys, setItemMeasureKeys] = useState9({});
-    const viewportRef = useRef(null);
-    const contentRef = useRef(null);
-    const prevContentHeightRef = useRef(0);
+    const [itemMeasureKeys, setItemMeasureKeys] = useState3({});
+    const viewportRef = useRef3(null);
+    const contentRef = useRef3(null);
+    const prevContentHeightRef = useRef3(0);
     useLayoutEffect(() => {
       if (contentHeight !== prevContentHeightRef.current) {
         onContentHeightChange?.(contentHeight, prevContentHeightRef.current);
         prevContentHeightRef.current = contentHeight;
       }
     }, [contentHeight, onContentHeightChange]);
-    const itemHeightsRef = useRef({});
-    const itemKeysRef = useRef([]);
-    const itemOffsetsRef = useRef([]);
-    const firstInvalidOffsetIndexRef = useRef(0);
-    const handleItemMeasure = useCallback7(
+    const itemHeightsRef = useRef3({});
+    const itemKeysRef = useRef3([]);
+    const itemOffsetsRef = useRef3([]);
+    const firstInvalidOffsetIndexRef = useRef3(0);
+    const handleItemMeasure = useCallback8(
       (index, height) => {
         const key = itemKeysRef.current[index] || index;
         if (itemHeightsRef.current[key] !== height) {
@@ -13870,7 +14898,7 @@ var ControlledScrollView = forwardRef(
         setContentHeight
       ]
     );
-    const measureViewport = useCallback7(() => {
+    const measureViewport = useCallback8(() => {
       if (viewportRef.current) {
         const { width, height } = measureElement(viewportRef.current);
         const currentSize = getViewportSize();
@@ -13883,7 +14911,7 @@ var ControlledScrollView = forwardRef(
     useLayoutEffect(() => {
       measureViewport();
     });
-    const prevChildrenRef = useRef(null);
+    const prevChildrenRef = useRef3(null);
     if (prevChildrenRef.current !== children) {
       prevChildrenRef.current = children;
       const newItemKeys = [];
@@ -13980,7 +15008,7 @@ var ControlledScrollView = forwardRef(
   }
 );
 function useStateRef2(initialValue) {
-  const [state, setStateInternal] = useState22(initialValue);
+  const [state, setStateInternal] = useState2(initialValue);
   const ref = useRef2(initialValue);
   const setState = useCallback22((update) => {
     const nextValue = typeof update === "function" ? update(ref.current) : update;
@@ -14109,7 +15137,7 @@ function InfoTab({
     " ",
     headerPairs.map(({ key, value }) => `${key}=${value}`).join(", ")
   ] }) }) : null;
-  const scrollViewRef = useRef3(null);
+  const scrollViewRef = useRef4(null);
   useInput(
     (input, key) => {
       if (focused) {
@@ -14231,7 +15259,7 @@ function InfoTab({
 }
 
 // src/components/AuthTab.tsx
-import { useState as useState10, useEffect as useEffect9, useRef as useRef4, useCallback as useCallback8 } from "react";
+import { useState as useState4, useEffect as useEffect2, useRef as useRef5, useCallback as useCallback9 } from "react";
 import { Box as Box5, Text as Text4, useInput as useInput2 } from "ink";
 
 // src/components/SelectableItem.tsx
@@ -14294,6 +15322,7 @@ function AuthTab({
   inspectorClient,
   oauthStatus,
   oauthMessage,
+  oauthMessageTone = "info",
   oauthRevision,
   pendingStepUp,
   onAuthorizeStepUp,
@@ -14305,12 +15334,28 @@ function AuthTab({
   connectionStatus
 }) {
   const isLiveConnection = connectionStatus === "connected" || connectionStatus === "connecting";
-  const scrollViewRef = useRef4(null);
-  const [oauthState, setOauthState] = useState10(void 0);
-  const [clearedConfirmation, setClearedConfirmation] = useState10(false);
-  const [lastClearDisconnected, setLastClearDisconnected] = useState10(false);
-  const [stepUpChoiceIndex, setStepUpChoiceIndex] = useState10(0);
-  const refreshOAuthState = useCallback8(async () => {
+  const scrollViewRef = useRef5(null);
+  const [oauthState, setOauthState] = useState4(void 0);
+  const [clearState, setClearState] = useState4("idle");
+  const [clearFailure, setClearFailure] = useState4(null);
+  const clearAttemptRef = useRef5(0);
+  const clearInFlightRef = useRef5(false);
+  const ownClearRef = useRef5(false);
+  const serverNameRef = useRef5(serverName);
+  useEffect2(() => {
+    serverNameRef.current = serverName;
+  }, [serverName]);
+  useEffect2(() => {
+    clearAttemptRef.current++;
+    clearInFlightRef.current = false;
+    ownClearRef.current = false;
+    setClearState("idle");
+    setClearFailure(null);
+    setLastClearDisconnected(false);
+  }, [serverName]);
+  const [lastClearDisconnected, setLastClearDisconnected] = useState4(false);
+  const [stepUpChoiceIndex, setStepUpChoiceIndex] = useState4(0);
+  const refreshOAuthState = useCallback9(async () => {
     if (!inspectorClient) {
       setOauthState(void 0);
       return;
@@ -14318,17 +15363,22 @@ function AuthTab({
     const state = await inspectorClient.getOAuthState();
     setOauthState(state);
   }, [inspectorClient]);
-  useEffect9(() => {
+  useEffect2(() => {
     void refreshOAuthState();
   }, [refreshOAuthState, oauthRevision, connectionStatus]);
-  useEffect9(() => {
-    setClearedConfirmation(false);
+  useEffect2(() => {
+    if (ownClearRef.current) {
+      ownClearRef.current = false;
+      return;
+    }
+    setClearState("idle");
+    setClearFailure(null);
     setLastClearDisconnected(false);
   }, [oauthRevision]);
-  useEffect9(() => {
+  useEffect2(() => {
     setStepUpChoiceIndex(0);
   }, [pendingStepUp]);
-  useEffect9(() => {
+  useEffect2(() => {
     if (!inspectorClient) return;
     const update = () => {
       void refreshOAuthState();
@@ -14379,9 +15429,29 @@ function AuthTab({
         const h = scrollViewRef.current.getViewportHeight() || 1;
         scrollViewRef.current.scrollBy(h);
       } else if (input.toLowerCase() === "s") {
+        if (clearInFlightRef.current) return;
+        clearInFlightRef.current = true;
+        const attempt = ++clearAttemptRef.current;
+        const attemptServer = serverName;
         setLastClearDisconnected(isLiveConnection);
-        onClearOAuth();
-        setClearedConfirmation(true);
+        setClearFailure(null);
+        ownClearRef.current = true;
+        setClearState("clearing");
+        const current = () => clearAttemptRef.current === attempt && serverNameRef.current === attemptServer;
+        void Promise.resolve(onClearOAuth()).then(
+          () => {
+            if (!current()) return;
+            clearInFlightRef.current = false;
+            setClearState("cleared");
+          },
+          (err) => {
+            if (!current()) return;
+            clearInFlightRef.current = false;
+            ownClearRef.current = false;
+            setClearFailure(err instanceof Error ? err.message : String(err));
+            setClearState("failed");
+          }
+        );
       }
     },
     { isActive: focused }
@@ -14396,7 +15466,7 @@ function AuthTab({
     /* @__PURE__ */ jsx5(ScrollView, { ref: scrollViewRef, height: height - 8, children: /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", gap: 0, children: [
       oauthStatus === "authenticating" && /* @__PURE__ */ jsx5(Text4, { color: "yellow", children: "Authenticating\u2026" }),
       oauthStatus === "error" && oauthMessage && /* @__PURE__ */ jsx5(Text4, { color: "red", children: oauthMessage }),
-      oauthStatus === "idle" && oauthMessage && /* @__PURE__ */ jsx5(Text4, { color: "cyan", children: oauthMessage }),
+      oauthStatus === "idle" && oauthMessage && /* @__PURE__ */ jsx5(Text4, { color: oauthMessageTone === "warning" ? "yellow" : "cyan", children: oauthMessage }),
       pendingStepUp ? /* @__PURE__ */ jsxs4(Box5, { marginTop: 1, flexDirection: "column", gap: 0, children: [
         /* @__PURE__ */ jsx5(Text4, { bold: true, color: "yellow", children: stepUpModalTitle({
           enterpriseManaged: pendingStepUp.enterpriseManaged
@@ -14505,7 +15575,12 @@ function AuthTab({
           "tate",
           isLiveConnection && " and disconnect"
         ] }),
-        clearedConfirmation && /* @__PURE__ */ jsx5(Text4, { color: "green", children: lastClearDisconnected ? "OAuth state cleared. Disconnected." : "OAuth state cleared." })
+        clearState === "clearing" && /* @__PURE__ */ jsx5(Text4, { color: "yellow", children: "Clearing OAuth state\u2026" }),
+        clearState === "cleared" && /* @__PURE__ */ jsx5(Text4, { color: "green", children: lastClearDisconnected ? "OAuth state cleared. Disconnected." : "OAuth state cleared." }),
+        clearState === "failed" && /* @__PURE__ */ jsxs4(Text4, { color: "red", children: [
+          "Could not clear OAuth state",
+          clearFailure ? `: ${clearFailure}` : "."
+        ] })
       ] })
     ] }) }),
     focused && /* @__PURE__ */ jsx5(
@@ -14522,20 +15597,20 @@ function AuthTab({
 }
 
 // src/components/ResourcesTab.tsx
-import { useState as useState12, useEffect as useEffect11, useRef as useRef5, useMemo } from "react";
+import { useState as useState6, useEffect as useEffect4, useRef as useRef6, useMemo } from "react";
 import { Box as Box6, Text as Text5, useInput as useInput3 } from "ink";
 
 // src/hooks/useSelectableList.ts
-import { useState as useState11, useEffect as useEffect10, useCallback as useCallback9 } from "react";
+import { useState as useState5, useEffect as useEffect3, useCallback as useCallback10 } from "react";
 function clampFirstVisible(first, selected, visibleCount) {
   if (selected < first) return selected;
   if (selected >= first + visibleCount) return selected - visibleCount + 1;
   return first;
 }
 function useSelectableList(itemCount, visibleCount, options) {
-  const [selectedIndex, setSelectedIndex] = useState11(0);
-  const [firstVisible, setFirstVisible] = useState11(0);
-  const setSelection = useCallback9(
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const [firstVisible, setFirstVisible] = useState5(0);
+  const setSelection = useCallback10(
     (newIndex) => {
       setSelectedIndex(newIndex);
       setFirstVisible(
@@ -14544,13 +15619,13 @@ function useSelectableList(itemCount, visibleCount, options) {
     },
     [visibleCount]
   );
-  useEffect10(() => {
+  useEffect3(() => {
     if (options?.resetWhen !== void 0) {
       setSelectedIndex(0);
       setFirstVisible(0);
     }
   }, [options?.resetWhen]);
-  useEffect10(() => {
+  useEffect3(() => {
     if (itemCount > 0 && selectedIndex >= itemCount) {
       const newIndex = itemCount - 1;
       setSelectedIndex(newIndex);
@@ -14578,13 +15653,13 @@ function ResourcesTab({
   onAuthRecoveryRequired,
   modalOpen = false
 }) {
-  const [error, setError] = useState12(null);
-  const [resourceContent, setResourceContent] = useState12(null);
-  const [loading, setLoading] = useState12(false);
-  const [shouldFetchResource, setShouldFetchResource] = useState12(
+  const [error, setError] = useState6(null);
+  const [resourceContent, setResourceContent] = useState6(null);
+  const [loading, setLoading] = useState6(false);
+  const [shouldFetchResource, setShouldFetchResource] = useState6(
     null
   );
-  const scrollViewRef = useRef5(null);
+  const scrollViewRef = useRef6(null);
   const allItems = useMemo(
     () => [
       ...resources.map((r) => ({ type: "resource", data: r })),
@@ -14649,11 +15724,11 @@ function ResourcesTab({
       isActive: !modalOpen && (focusedPane === "list" || focusedPane === "details")
     }
   );
-  useEffect11(() => {
+  useEffect4(() => {
     scrollViewRef.current?.scrollTo(0);
   }, [selectedIndex]);
-  const prevResourcesRef = useRef5(resources);
-  useEffect11(() => {
+  const prevResourcesRef = useRef6(resources);
+  useEffect4(() => {
     if (prevResourcesRef.current !== resources) {
       setResourceContent(null);
       setShouldFetchResource(null);
@@ -14664,7 +15739,7 @@ function ResourcesTab({
   const isTemplate = selectedItem?.type === "template";
   const selectedResource = isResource ? selectedItem.data : null;
   const selectedTemplate = isTemplate ? selectedItem.data : null;
-  useEffect11(() => {
+  useEffect4(() => {
     if (!shouldFetchResource || !inspectorClient) return;
     const fetchContent = async () => {
       setLoading(true);
@@ -14690,8 +15765,8 @@ function ResourcesTab({
   }, [shouldFetchResource, inspectorClient, onAuthRecoveryRequired]);
   const listWidth = Math.floor(width * 0.4);
   const detailWidth = width - listWidth;
-  const prevCountRef = useRef5(totalCount);
-  useEffect11(() => {
+  const prevCountRef = useRef6(totalCount);
+  useEffect4(() => {
     if (prevCountRef.current !== totalCount) {
       prevCountRef.current = totalCount;
       onCountChange?.(totalCount);
@@ -14841,7 +15916,7 @@ function ResourcesTab({
 }
 
 // src/components/PromptsTab.tsx
-import { useState as useState13, useEffect as useEffect12, useRef as useRef6 } from "react";
+import { useState as useState7, useEffect as useEffect5, useRef as useRef7 } from "react";
 import { Box as Box7, Text as Text6, useInput as useInput4 } from "ink";
 import { Fragment as Fragment4, jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 function PromptsTab({
@@ -14861,8 +15936,8 @@ function PromptsTab({
     visibleCount,
     { resetWhen: prompts }
   );
-  const [error, setError] = useState13(null);
-  const scrollViewRef = useRef6(null);
+  const [error, setError] = useState7(null);
+  const scrollViewRef = useRef7(null);
   useInput4(
     (input, key) => {
       if (key.return && selectedPrompt && inspectorClient && onFetchPrompt) {
@@ -14923,7 +15998,7 @@ function PromptsTab({
       isActive: !modalOpen && (focusedPane === "list" || focusedPane === "details")
     }
   );
-  useEffect12(() => {
+  useEffect5(() => {
     scrollViewRef.current?.scrollTo(0);
   }, [selectedIndex]);
   const selectedPrompt = prompts[selectedIndex] || null;
@@ -15043,7 +16118,7 @@ function PromptsTab({
 }
 
 // src/components/ToolsTab.tsx
-import { useState as useState14, useEffect as useEffect13, useMemo as useMemo2, useRef as useRef7 } from "react";
+import { useState as useState8, useEffect as useEffect6, useMemo as useMemo2, useRef as useRef8 } from "react";
 import { Box as Box8, Text as Text7, useInput as useInput5 } from "ink";
 
 // ../../core/json/schemaLint.ts
@@ -15336,12 +16411,12 @@ function ToolsTab({
     visibleCount,
     { resetWhen: tools }
   );
-  const [error] = useState14(null);
+  const [error] = useState8(null);
   const findingsByTool = useMemo2(
     () => tools.map((tool) => lintToolSchemas(tool)),
     [tools]
   );
-  const scrollViewRef = useRef7(null);
+  const scrollViewRef = useRef8(null);
   const listWidth = Math.floor(width * 0.4);
   const detailWidth = width - listWidth;
   useInput5(
@@ -15380,7 +16455,7 @@ function ToolsTab({
       isActive: !modalOpen && (focusedPane === "list" || focusedPane === "details")
     }
   );
-  useEffect13(() => {
+  useEffect6(() => {
     scrollViewRef.current?.scrollTo(0);
   }, [selectedIndex]);
   const selectedTool = tools[selectedIndex] || null;
@@ -15539,7 +16614,7 @@ function ToolsTab({
 }
 
 // src/components/NotificationsTab.tsx
-import { useEffect as useEffect14, useRef as useRef8 } from "react";
+import { useEffect as useEffect7, useRef as useRef9 } from "react";
 import { Box as Box9, Text as Text8, useInput as useInput6 } from "ink";
 import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
 function NotificationsTab({
@@ -15549,12 +16624,12 @@ function NotificationsTab({
   onCountChange,
   focused = false
 }) {
-  const scrollViewRef = useRef8(null);
-  const onCountChangeRef = useRef8(onCountChange);
-  useEffect14(() => {
+  const scrollViewRef = useRef9(null);
+  const onCountChangeRef = useRef9(onCountChange);
+  useEffect7(() => {
     onCountChangeRef.current = onCountChange;
   }, [onCountChange]);
-  useEffect14(() => {
+  useEffect7(() => {
     onCountChangeRef.current?.(stderrLogs.length);
   }, [stderrLogs.length]);
   useInput6(
@@ -15602,7 +16677,7 @@ function NotificationsTab({
 }
 
 // src/components/HistoryTab.tsx
-import React7, { useEffect as useEffect15, useRef as useRef9 } from "react";
+import React7, { useEffect as useEffect8, useRef as useRef10 } from "react";
 import { Box as Box10, Text as Text9, useInput as useInput7 } from "ink";
 import { Fragment as Fragment6, jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
 function HistoryTab({
@@ -15619,7 +16694,7 @@ function HistoryTab({
     messages.length,
     visibleCount
   );
-  const scrollViewRef = useRef9(null);
+  const scrollViewRef = useRef10(null);
   const selectedMessage = messages[selectedIndex] || null;
   useInput7(
     (input, key) => {
@@ -15660,7 +16735,7 @@ function HistoryTab({
   React7.useEffect(() => {
     onCountChange?.(messages.length);
   }, [messages.length]);
-  useEffect15(() => {
+  useEffect8(() => {
     scrollViewRef.current?.scrollTo(0);
   }, [selectedIndex]);
   const listWidth = Math.floor(width * 0.4);
@@ -15822,7 +16897,7 @@ function HistoryTab({
 }
 
 // src/components/RequestsTab.tsx
-import React8, { useEffect as useEffect16, useRef as useRef10 } from "react";
+import React8, { useEffect as useEffect9, useRef as useRef11 } from "react";
 import { Box as Box11, Text as Text10, useInput as useInput8 } from "ink";
 import { Fragment as Fragment7, jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
 function RequestsTab({
@@ -15839,7 +16914,7 @@ function RequestsTab({
     requests.length,
     visibleCount
   );
-  const scrollViewRef = useRef10(null);
+  const scrollViewRef = useRef11(null);
   const selectedRequest = requests[selectedIndex] || null;
   useInput8(
     (input, key) => {
@@ -15880,7 +16955,7 @@ function RequestsTab({
   React8.useEffect(() => {
     onCountChange?.(requests.length);
   }, [requests.length]);
-  useEffect16(() => {
+  useEffect9(() => {
     scrollViewRef.current?.scrollTo(0);
   }, [selectedIndex]);
   const listWidth = Math.floor(width * 0.4);
@@ -16093,12 +17168,12 @@ function RequestsTab({
 }
 
 // src/components/ToolTestModal.tsx
-import React25, { useState as useState19 } from "react";
+import React25, { useState as useState13 } from "react";
 import { Box as Box23, Text as Text20, useInput as useInput17 } from "ink";
 
 // node_modules/ink-form/lib/Form.js
 import { Box as Box22, useFocusManager, useInput as useInput16 } from "ink";
-import { useEffect as useEffect19, useMemo as useMemo3, useState as useState18 } from "react";
+import { useEffect as useEffect12, useMemo as useMemo3, useState as useState12 } from "react";
 import * as React23 from "react";
 
 // node_modules/ink-form/lib/FormHeader.js
@@ -16166,7 +17241,7 @@ var FormHeader = (props) => {
 };
 
 // node_modules/ink-form/lib/FormFieldRenderer.js
-import React21, { useState as useState17 } from "react";
+import React21, { useState as useState11 } from "react";
 import { Box as Box20, useFocus, Text as Text18, useInput as useInput14 } from "ink";
 
 // node_modules/ink-form/lib/managers/FloatFormFieldManager.js
@@ -16177,7 +17252,7 @@ import React11 from "react";
 import { Box as Box13, Text as Text13, useInput as useInput11 } from "ink";
 
 // node_modules/ink-text-input/build/index.js
-import React10, { useState as useState15, useEffect as useEffect17 } from "react";
+import React10, { useState as useState9, useEffect as useEffect10 } from "react";
 import { Text as Text12, useInput as useInput10 } from "ink";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
@@ -16677,12 +17752,12 @@ var source_default = chalk;
 
 // node_modules/ink-text-input/build/index.js
 function TextInput({ value: originalValue, placeholder = "", focus = true, mask, highlightPastedText = false, showCursor = true, onChange, onSubmit }) {
-  const [state, setState] = useState15({
+  const [state, setState] = useState9({
     cursorOffset: (originalValue || "").length,
     cursorWidth: 0
   });
   const { cursorOffset, cursorWidth } = state;
-  useEffect17(() => {
+  useEffect10(() => {
     setState((previousState) => {
       if (!focus || !showCursor) {
         return previousState;
@@ -17153,7 +18228,7 @@ var Item_default = Item;
 
 // node_modules/ink-select-input/build/SelectInput.js
 import { isDeepStrictEqual } from "util";
-import React16, { useState as useState16, useEffect as useEffect18, useRef as useRef11, useCallback as useCallback10 } from "react";
+import React16, { useState as useState10, useEffect as useEffect11, useRef as useRef12, useCallback as useCallback11 } from "react";
 
 // node_modules/to-rotated/index.js
 function toRotated(array, steps) {
@@ -17183,17 +18258,17 @@ function SelectInput({ items = [], isFocused = true, initialIndex = 0, indicator
   const hasLimit = typeof customLimit === "number" && items.length > customLimit;
   const limit = hasLimit ? Math.min(customLimit, items.length) : items.length;
   const lastIndex = limit - 1;
-  const [rotateIndex, setRotateIndex] = useState16(initialIndex > lastIndex ? lastIndex - initialIndex : 0);
-  const [selectedIndex, setSelectedIndex] = useState16(initialIndex ? initialIndex > lastIndex ? lastIndex : initialIndex : 0);
-  const previousItems = useRef11(items);
-  useEffect18(() => {
+  const [rotateIndex, setRotateIndex] = useState10(initialIndex > lastIndex ? lastIndex - initialIndex : 0);
+  const [selectedIndex, setSelectedIndex] = useState10(initialIndex ? initialIndex > lastIndex ? lastIndex : initialIndex : 0);
+  const previousItems = useRef12(items);
+  useEffect11(() => {
     if (!isDeepStrictEqual(previousItems.current.map((item) => item.value), items.map((item) => item.value))) {
       setRotateIndex(0);
       setSelectedIndex(0);
     }
     previousItems.current = items;
   }, [items]);
-  useInput12(useCallback10((input, key) => {
+  useInput12(useCallback11((input, key) => {
     if (input === "k" || key.upArrow) {
       const lastIndex2 = (hasLimit ? limit : items.length) - 1;
       const atFirstIndex = selectedIndex === 0;
@@ -17354,8 +18429,8 @@ var DescriptionRenderer = (props) => {
 // node_modules/ink-form/lib/FormFieldRenderer.js
 var FormFieldRenderer = (props) => {
   const manager = getManager(props.field.type, props.customManagers);
-  const [error, setError] = useState17();
-  const [currentValue, setCurrentValue] = useState17(props.value ?? props.field.initialValue);
+  const [error, setError] = useState11();
+  const [currentValue, setCurrentValue] = useState11(props.value ?? props.field.initialValue);
   const isEditing = !!props.editingField && props.editingField === (props.field.label ?? props.field.name);
   const hide = !isEditing && !!props.editingField;
   const save = (newValue) => {
@@ -17513,20 +18588,20 @@ var SubmitButton = (props) => {
 // node_modules/ink-form/lib/Form.js
 var Form = (props) => {
   const isControlled = props.value !== void 0;
-  const [currentTab, setCurrentTab] = useState18(0);
-  const [value, setValue] = useState18(props.value ?? {});
-  const [editingField, setEditingField] = useState18();
+  const [currentTab, setCurrentTab] = useState12(0);
+  const [value, setValue] = useState12(props.value ?? {});
+  const [editingField, setEditingField] = useState12();
   const canSubmitForm = useMemo3(() => canSubmit(props.form, value), [value, props.form]);
   const focusManager = useFocusManager();
-  useEffect19(() => {
+  useEffect12(() => {
     focusManager.enableFocus();
   }, []);
-  useEffect19(() => {
+  useEffect12(() => {
     if (props.value) {
       setValue(props.value);
     }
   }, [props.value]);
-  useEffect19(() => {
+  useEffect12(() => {
     if (!isControlled) {
       setValueAndPropagate({
         ...value,
@@ -17567,179 +18642,159 @@ var Form = (props) => {
 import { render } from "ink";
 import React24 from "react";
 
-// ../../core/json/nullableUnion.ts
-var RENDERABLE_TYPES = [
-  "string",
-  "number",
-  "integer",
-  "boolean",
-  "array",
-  "object"
-];
-function isRenderableType(type) {
-  return RENDERABLE_TYPES.includes(type);
+// src/utils/schemaToForm.ts
+function toSelectOptions(values, names) {
+  const useNames = names !== void 0 && names.length === values.length;
+  return values.map((val, index) => ({
+    label: useNames ? names[index] : String(val),
+    value: String(val)
+  }));
 }
-function toBranch(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return null;
-  }
-  return value;
+function generatedNames(base, branches) {
+  const declared = [
+    ...Object.keys(base.properties ?? {}),
+    ...branches.flatMap((branch) => branch.declaredFields)
+  ];
+  let variant = "__variant";
+  while (declared.includes(variant)) variant += "_";
+  let prefix = "__b";
+  while (declared.some((name) => name.startsWith(prefix))) prefix += "_";
+  return { variant, prefix };
+}
+function branchFieldName(prefix, branchIndex, name) {
+  return `${prefix}${branchIndex}__${name}`;
+}
+function sharedFieldNames(base, branches) {
+  const declared = new Set(branches.flatMap((branch) => branch.declaredFields));
+  return Object.keys(base.properties ?? {}).filter(
+    (name) => declared.has(name)
+  );
 }
-function isStringEnum(value) {
-  return Array.isArray(value) && value.length > 0 && value.every((member) => typeof member === "string");
+function branchFields(base, branches, index) {
+  const own = branches[index].declaredFields;
+  return [.../* @__PURE__ */ new Set([...own, ...sharedFieldNames(base, branches)])];
 }
-function nullExcludedBySiblings(schema) {
-  if (Array.isArray(schema.enum) && !schema.enum.includes(null)) {
-    return true;
+function labelled(property, name) {
+  if (typeof property !== "object" || property === null) {
+    return { title: name };
   }
-  return schema.const !== void 0 && schema.const !== null;
-}
-var ANNOTATION_KEYWORDS = /* @__PURE__ */ new Set([
-  "title",
-  "description",
-  "default",
-  "enumNames",
-  "examples",
-  "deprecated",
-  "readOnly",
-  "writeOnly",
-  "$comment",
-  "$schema",
-  "$id"
-]);
-function wrapperCarriesConstraints(schema) {
-  return Object.keys(schema).some(
-    (key) => key !== "anyOf" && !ANNOTATION_KEYWORDS.has(key)
-  );
-}
-function typeNamesNull(type) {
-  return Array.isArray(type) ? type.includes("null") : type === "null";
+  return { title: name, ...property };
 }
-function hasOpaqueApplicator(schema) {
-  return schema.not !== void 0 || schema.allOf !== void 0 || schema.oneOf !== void 0 || // `$ref` points at a schema this module never resolves, and it applies
-  // *alongside* its siblings — `{ type: "string", $ref: "#/$defs/intOnly" }`
-  // can be unsatisfiable. The wrapper path already declines on it (it is not
-  // an annotation); this is the same rule for every other position.
-  schema.$ref !== void 0;
+function requiredOf2(schema) {
+  return Array.isArray(schema.required) ? schema.required.filter((name) => typeof name === "string") : [];
 }
-function hasUnevaluatedComposition(schema) {
-  return schema.anyOf !== void 0 || hasOpaqueApplicator(schema);
+function constOf(schema) {
+  if (typeof schema !== "object" || schema === null) return void 0;
+  return schema.const;
 }
-function stripNullEnumMembers(members, names) {
-  if (!Array.isArray(members)) {
-    return { kind: "unchanged" };
-  }
-  const kept = members.map((member, index) => ({ member, index })).filter((entry) => entry.member !== null);
-  if (kept.length === 0) {
-    return { kind: "unselectable" };
+function schemaToForm(schema, toolName) {
+  const title = `Test Tool: ${toolName}`;
+  if (!schema) {
+    return { title, sections: [{ title: "Parameters", fields: [] }] };
   }
-  if (kept.length === members.length) {
-    return { kind: "unchanged" };
+  const { base, branches } = resolveRootUnion(schema);
+  if (branches.length === 0) {
+    return {
+      title,
+      sections: [{ title: "Parameters", fields: buildFields(base) }]
+    };
   }
-  const wasParallel = Array.isArray(names) && names.length === members.length;
-  const aligned = wasParallel ? kept.map((entry) => names[entry.index]) : void 0;
-  return {
-    kind: "filtered",
-    members: kept.map((entry) => entry.member),
-    names: aligned
-  };
-}
-function collapsed(schema, branch, type) {
-  const merged = { ...schema, ...branch };
-  const strip = stripNullEnumMembers(
-    merged.enum,
-    merged.enumNames
+  const { variant, prefix } = generatedNames(base, branches);
+  const shared = sharedFieldNames(base, branches);
+  const baseProperties = Object.fromEntries(
+    Object.entries(base.properties ?? {}).filter(
+      ([name]) => !shared.includes(name)
+    )
   );
-  if (strip.kind === "unselectable") {
-    return null;
-  }
-  return {
-    ...merged,
-    type,
-    anyOf: void 0,
-    // Read off the ORIGINAL schema, not the merge: a hoisted branch `enum` is
-    // not a sibling constraint, and treating it as one would mark the very
-    // shape #1928 is about as non-nullable. See `nullExcludedBySiblings`.
-    nullable: admitsNull(schema),
-    ...strip.kind === "filtered" ? { enum: strip.members, enumNames: strip.names } : {}
-  };
+  const parameters = [
+    {
+      type: "select",
+      name: variant,
+      label: "Variant",
+      required: true,
+      initialValue: "0",
+      options: branches.map((branch, index) => ({
+        label: branch.label,
+        value: String(index)
+      }))
+    },
+    ...buildFields({ properties: baseProperties, required: base.required })
+  ];
+  const sections = [{ title: "Parameters", fields: parameters }];
+  branches.forEach((branch, index) => {
+    const byRealName = Object.fromEntries(
+      branchFields(base, branches, index).map((name) => [name, true])
+    );
+    const properties = Object.fromEntries(
+      branchFields(base, branches, index).map((name) => [
+        branchFieldName(prefix, index, name),
+        // The prefix is an internal field NAME, never a label: `buildFields`
+        // falls back to its map key when a declaration carries no `title`, so
+        // without this the form would show `__b0__address` where the schema
+        // says `address`.
+        labelled(branch.schema.properties?.[name], name)
+      ])
+    );
+    sections.push({
+      title: branch.label,
+      fields: buildFields(
+        {
+          properties,
+          // Under their prefixed names, so the constant seeding below can tell
+          // which of this branch's fields the schema actually requires.
+          required: requiredOf2(branch.schema).filter((name) => Object.hasOwn(byRealName, name)).map((name) => branchFieldName(prefix, index, name))
+        },
+        { optional: true }
+      )
+    });
+  });
+  return { title, sections };
 }
-function admitsNull(schema) {
-  if (nullExcludedBySiblings(schema)) {
-    return false;
-  }
-  if (hasOpaqueApplicator(schema)) {
-    return false;
-  }
-  if (schema.nullable === true) {
-    return true;
-  }
-  if (schema.type !== void 0) {
-    if (schema.anyOf !== void 0) {
-      return false;
-    }
-    return typeNamesNull(schema.type);
+function decodeFormValues(schema, values) {
+  const { base, branches } = resolveRootUnion(schema ?? {});
+  if (branches.length === 0) {
+    return applyConstants(base.properties ?? {}, values, requiredOf2(base));
   }
-  return schema.anyOf?.some((entry) => {
-    const branch = toBranch(entry);
-    if (branch === null || !typeNamesNull(branch.type)) {
-      return false;
+  const { variant, prefix } = generatedNames(base, branches);
+  const branchIndex = selectedBranchIndex(base, branches, values);
+  const branch = branches[branchIndex];
+  const generated = /* @__PURE__ */ new Set([variant]);
+  branches.forEach((_each, index) => {
+    for (const name of branchFields(base, branches, index)) {
+      generated.add(branchFieldName(prefix, index, name));
     }
-    const branchSchema = branch;
-    return !nullExcludedBySiblings(branchSchema) && !hasUnevaluatedComposition(branchSchema);
-  }) ?? false;
+  });
+  const decoded = Object.fromEntries([
+    ...Object.entries(values).filter(([name]) => !generated.has(name)),
+    ...branchFields(base, branches, branchIndex).map(
+      (name) => [name, values[branchFieldName(prefix, branchIndex, name)]]
+    ).filter(([, value]) => value !== void 0)
+  ]);
+  return applyConstants(
+    branch.schema.properties ?? {},
+    decoded,
+    requiredOf2(branch.schema)
+  );
 }
-function normalizeNullableUnion(schema) {
-  if (schema.anyOf?.length === 2) {
-    const branches = schema.anyOf.map(toBranch);
-    const nullBranch = branches.find((entry) => entry?.type === "null");
-    const branch = branches.find(
-      (entry) => entry !== null && entry.type !== "null"
-    );
-    if (nullBranch && branch && !wrapperCarriesConstraints(schema) && !hasUnevaluatedComposition(branch)) {
-      const type = branch.type ?? (isStringEnum(branch.enum) ? "string" : void 0);
-      if (isRenderableType(type)) {
-        const result = collapsed(schema, branch, type);
-        if (result !== null) {
-          return result;
-        }
-      }
-    }
-  }
-  if (Array.isArray(schema.type) && schema.type.length === 2 && schema.type.includes("null") && // This path keeps the schema's own keywords, but `collapsed` clears `anyOf`
-  // and the renderers ignore the other applicators — so a compound schema
-  // like `{ type: ["string", "null"], anyOf: [{ const: "a" }] }` would be
-  // widened into an unconstrained string field. Leave it for the JSON editor.
-  !hasUnevaluatedComposition(schema)) {
-    const type = schema.type.find((member) => member !== "null");
-    if (isRenderableType(type)) {
-      const result = collapsed(schema, void 0, type);
-      if (result !== null) {
-        return result;
-      }
-    }
-  }
-  return schema;
+function selectedBranchIndex(base, branches, values) {
+  const { variant } = generatedNames(base, branches);
+  const selected = Number(values[variant]);
+  return Number.isInteger(selected) && selected >= 0 && selected < branches.length ? selected : 0;
 }
-
-// src/utils/schemaToForm.ts
-function toSelectOptions(values, names) {
-  const useNames = names !== void 0 && names.length === values.length;
-  return values.map((val, index) => ({
-    label: useNames ? names[index] : String(val),
-    value: String(val)
-  }));
+function applyConstants(properties, values, required) {
+  const pinned = Object.entries(properties).filter(
+    ([name, schema]) => constOf(schema) !== void 0 && (required.includes(name) || Object.hasOwn(values, name) && values[name] !== void 0)
+  );
+  if (pinned.length === 0) return values;
+  return Object.fromEntries([
+    ...Object.entries(values),
+    ...pinned.map(([name, schema]) => [name, constOf(schema)])
+  ]);
 }
-function schemaToForm(schema, toolName) {
+function buildFields(schema, { optional = false } = {}) {
   const fields = [];
-  if (!schema || !schema.properties) {
-    return {
-      title: `Test Tool: ${toolName}`,
-      sections: [{ title: "Parameters", fields: [] }]
-    };
-  }
   const properties = schema.properties || {};
-  const required = schema.required || [];
+  const required = Array.isArray(schema.required) ? schema.required : [];
   for (const [key, prop] of Object.entries(properties)) {
     const property = normalizeNullableUnion(
       typeof prop === "object" && prop !== null ? prop : {}
@@ -17747,9 +18802,30 @@ function schemaToForm(schema, toolName) {
     const baseField = {
       name: key,
       label: property.title || key,
-      required: required.includes(key)
+      required: optional ? false : required.includes(key)
     };
     let field;
+    const pinned = property.const;
+    if (pinned !== void 0) {
+      fields.push({
+        type: "select",
+        ...baseField,
+        // Only a REQUIRED constant is pre-filled. `const` constrains a present
+        // value; it neither requires the property nor acts as a default, so an
+        // optional `dryRun: { const: true }` must stay omittable rather than
+        // being sent on every call. The single option is still there for a user
+        // who wants it.
+        ...required.includes(key) ? { initialValue: String(pinned) } : {},
+        // Never required: the one option may legitimately be the empty string,
+        // which ink-form's required gate can never accept — submission would
+        // not even reach `decodeFormValues`, which reapplies the constant. The
+        // value is fixed by the schema, and `missingRequiredFields` still
+        // validates the decoded call.
+        required: false,
+        options: [{ label: String(pinned), value: String(pinned) }]
+      });
+      continue;
+    }
     if (property.type === "array" && property.items?.enum) {
       field = {
         type: "select",
@@ -17760,6 +18836,7 @@ function schemaToForm(schema, toolName) {
       field = {
         type: "select",
         ...baseField,
+        /* v8 ignore next -- guarded by `isStringEnum(property.enum)` above */
         options: toSelectOptions(property.enum ?? [], property.enumNames)
       };
     } else {
@@ -17804,16 +18881,25 @@ function schemaToForm(schema, toolName) {
     }
     fields.push(field);
   }
-  const sections = [
-    {
-      title: "Parameters",
-      fields
-    }
-  ];
-  return {
-    title: `Test Tool: ${toolName}`,
-    sections
-  };
+  return fields;
+}
+function missingRequiredFields(schema, decoded, rawValues = {}) {
+  const { base, branches } = resolveRootUnion(schema ?? {});
+  const effective = branches.length === 0 ? base : branches[selectedBranchIndex(base, branches, rawValues)].schema;
+  const properties = effective.properties ?? {};
+  const required = Array.isArray(effective.required) ? effective.required : [];
+  return required.filter((name) => {
+    if (!Object.hasOwn(decoded, name)) return true;
+    const value = decoded[name];
+    if (value === null) {
+      const property = properties[name];
+      return typeof property !== "object" || property === null || !admitsNull(property);
+    }
+    if (value === "") {
+      return constOf(properties[name]) !== "";
+    }
+    return value === void 0;
+  });
 }
 
 // src/components/ToolTestModal.tsx
@@ -17826,8 +18912,8 @@ function ToolTestModal({
   onClose,
   onAuthRecoveryRequired
 }) {
-  const [state, setState] = useState19("form");
-  const [result, setResult] = useState19(null);
+  const [state, setState] = useState13("form");
+  const [result, setResult] = useState13(null);
   const scrollViewRef = React25.useRef(null);
   const [terminalDimensions, setTerminalDimensions] = React25.useState({
     width: process.stdout.columns || width,
@@ -17883,8 +18969,20 @@ function ToolTestModal({
     },
     { isActive: true }
   );
-  const handleFormSubmit = async (values) => {
+  const handleFormSubmit = async (rawValues) => {
     if (!inspectorClient || !tool) return;
+    const values = decodeFormValues(tool.inputSchema, rawValues);
+    const missing = missingRequiredFields(tool.inputSchema, values, rawValues);
+    if (missing.length > 0) {
+      setResult({
+        input: values,
+        output: null,
+        error: `Missing required argument${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}`,
+        duration: 0
+      });
+      setState("results");
+      return;
+    }
     setState("loading");
     const startTime = Date.now();
     try {
@@ -17996,7 +19094,7 @@ function ToolTestModal({
 }
 
 // src/components/ResourceTestModal.tsx
-import React26, { useState as useState20 } from "react";
+import React26, { useState as useState14 } from "react";
 import { Box as Box24, Text as Text21, useInput as useInput18 } from "ink";
 
 // src/utils/uriTemplateToForm.ts
@@ -18051,8 +19149,8 @@ function ResourceTestModal({
   onClose,
   onAuthRecoveryRequired
 }) {
-  const [state, setState] = useState20("form");
-  const [result, setResult] = useState20(null);
+  const [state, setState] = useState14("form");
+  const [result, setResult] = useState14(null);
   const scrollViewRef = React26.useRef(null);
   const [terminalDimensions, setTerminalDimensions] = React26.useState({
     width: process.stdout.columns || width,
@@ -18255,7 +19353,7 @@ function ResourceTestModal({
 }
 
 // src/components/PromptTestModal.tsx
-import React27, { useState as useState21 } from "react";
+import React27, { useState as useState15 } from "react";
 import { Box as Box25, Text as Text22, useInput as useInput19 } from "ink";
 
 // src/utils/promptArgsToForm.ts
@@ -18313,8 +19411,8 @@ function PromptTestModal({
   onClose,
   onAuthRecoveryRequired
 }) {
-  const [state, setState] = useState21("form");
-  const [result, setResult] = useState21(null);
+  const [state, setState] = useState15("form");
+  const [result, setResult] = useState15(null);
   const scrollViewRef = React27.useRef(null);
   const [terminalDimensions, setTerminalDimensions] = React27.useState({
     width: process.stdout.columns || width,
@@ -18483,7 +19581,7 @@ function PromptTestModal({
 }
 
 // src/components/DetailsModal.tsx
-import React28, { useRef as useRef12 } from "react";
+import React28, { useRef as useRef13 } from "react";
 import { Box as Box26, Text as Text23, useInput as useInput20 } from "ink";
 import { jsx as jsx15, jsxs as jsxs14 } from "react/jsx-runtime";
 function DetailsModal({
@@ -18493,7 +19591,7 @@ function DetailsModal({
   height,
   onClose
 }) {
-  const scrollViewRef = useRef12(null);
+  const scrollViewRef = useRef13(null);
   const [terminalDimensions, setTerminalDimensions] = React28.useState({
     width: process.stdout.columns || width,
     height: process.stdout.rows || height
@@ -18580,49 +19678,52 @@ function App({
   callbackUrlConfig
 }) {
   const { exit } = useApp();
-  useEffect20(() => {
+  useEffect13(() => {
     getTuiLogger().info(
       { serverNames: Object.keys(mcpServers) },
       "TUI started"
     );
   }, [mcpServers]);
-  const [selectedServer, setSelectedServer] = useState23(null);
-  const [activeTab, setActiveTab] = useState23("info");
-  const [focus, setFocus] = useState23("serverList");
-  const [tabCounts, setTabCounts] = useState23({});
-  const [oauthStatus, setOauthStatus] = useState23("idle");
-  const [oauthMessage, setOauthMessage] = useState23(null);
-  const [oauthRevision, setOauthRevision] = useState23(0);
-  const [pendingStepUp, setPendingStepUp] = useState23(null);
-  const pendingStepUpRef = useRef13(pendingStepUp);
-  useEffect20(() => {
+  const [selectedServer, setSelectedServer] = useState16(null);
+  const [activeTab, setActiveTab] = useState16("info");
+  const [focus, setFocus] = useState16("serverList");
+  const [tabCounts, setTabCounts] = useState16({});
+  const [oauthStatus, setOauthStatus] = useState16("idle");
+  const [oauthMessage, setOauthMessage] = useState16(null);
+  const [oauthWarningText, setOauthWarningText] = useState16(null);
+  const oauthMessageTone = oauthMessageToneFor(oauthMessage, oauthWarningText);
+  const [oauthRevision, setOauthRevision] = useState16(0);
+  const [pendingStepUp, setPendingStepUp] = useState16(null);
+  const pendingStepUpRef = useRef14(pendingStepUp);
+  useEffect13(() => {
     pendingStepUpRef.current = pendingStepUp;
   }, [pendingStepUp]);
-  const [connectError, setConnectError] = useState23(null);
-  const disconnectAttemptRef = useRef13(0);
-  const [disconnectError, setDisconnectError] = useState23(null);
-  const oauthInProgressRef = useRef13(false);
-  const callbackServerRef = useRef13(null);
-  const selectedServerRef = useRef13(null);
-  const mcpServersRef = useRef13(mcpServers);
-  const inspectorClientsRef = useRef13({});
-  const [toolTestModal, setToolTestModal] = useState23(null);
-  const [resourceTestModal, setResourceTestModal] = useState23(null);
-  const [promptTestModal, setPromptTestModal] = useState23(null);
-  const [detailsModal, setDetailsModal] = useState23(null);
-  const [inspectorClients, setInspectorClients] = useState23({});
-  const [managedToolsStates, setManagedToolsStates] = useState23({});
-  const [managedResourcesStates, setManagedResourcesStates] = useState23({});
-  const [managedResourceTemplatesStates, setManagedResourceTemplatesStates] = useState23({});
-  const [managedPromptsStates, setManagedPromptsStates] = useState23({});
-  const [messageLogStates, setMessageLogStates] = useState23({});
-  const [fetchRequestLogStates, setFetchRequestLogStates] = useState23({});
-  const [stderrLogStates, setStderrLogStates] = useState23({});
-  const [dimensions, setDimensions] = useState23({
+  const [connectError, setConnectError] = useState16(null);
+  const disconnectAttemptRef = useRef14(0);
+  const clearOAuthAttemptRef = useRef14(0);
+  const [disconnectError, setDisconnectError] = useState16(null);
+  const oauthInProgressRef = useRef14(false);
+  const callbackServerRef = useRef14(null);
+  const selectedServerRef = useRef14(null);
+  const mcpServersRef = useRef14(mcpServers);
+  const inspectorClientsRef = useRef14({});
+  const [toolTestModal, setToolTestModal] = useState16(null);
+  const [resourceTestModal, setResourceTestModal] = useState16(null);
+  const [promptTestModal, setPromptTestModal] = useState16(null);
+  const [detailsModal, setDetailsModal] = useState16(null);
+  const [inspectorClients, setInspectorClients] = useState16({});
+  const [managedToolsStates, setManagedToolsStates] = useState16({});
+  const [managedResourcesStates, setManagedResourcesStates] = useState16({});
+  const [managedResourceTemplatesStates, setManagedResourceTemplatesStates] = useState16({});
+  const [managedPromptsStates, setManagedPromptsStates] = useState16({});
+  const [messageLogStates, setMessageLogStates] = useState16({});
+  const [fetchRequestLogStates, setFetchRequestLogStates] = useState16({});
+  const [stderrLogStates, setStderrLogStates] = useState16({});
+  const [dimensions, setDimensions] = useState16({
     width: process.stdout.columns || 80,
     height: process.stdout.rows || 24
   });
-  useEffect20(() => {
+  useEffect13(() => {
     const updateDimensions = () => {
       setDimensions({
         width: process.stdout.columns || 80,
@@ -18637,8 +19738,8 @@ function App({
   const serverNames = Object.keys(mcpServers);
   const selectedServerEntry = selectedServer ? mcpServers[selectedServer] : null;
   const selectedServerConfig = selectedServerEntry?.config ?? null;
-  const redirectUrlProvidersRef = useRef13({});
-  useEffect20(() => {
+  const redirectUrlProvidersRef = useRef14({});
+  useEffect13(() => {
     const newClients = {};
     const newManagers = {};
     const newManagedResourcesStates = {};
@@ -18742,7 +19843,7 @@ function App({
     clientMetadataUrl,
     callbackUrlConfig
   ]);
-  useEffect20(() => {
+  useEffect13(() => {
     return () => {
       void callbackServerRef.current?.stop();
       callbackServerRef.current = null;
@@ -18782,27 +19883,28 @@ function App({
     fetchRequestLogStates,
     stderrLogStates
   ]);
-  useEffect20(() => {
+  useEffect13(() => {
     if (serverNames.length > 0 && selectedServer === null) {
       setSelectedServer(serverNames[0]);
     }
   }, []);
-  useEffect20(() => {
+  useEffect13(() => {
     setOauthStatus("idle");
     setOauthMessage(null);
     disconnectAttemptRef.current++;
+    clearOAuthAttemptRef.current++;
     setDisconnectError(null);
     const stepUp = pendingStepUpRef.current;
     if (stepUp && selectedServer && stepUp.serverName !== selectedServer) {
       setPendingStepUp(null);
     }
   }, [selectedServer]);
-  useEffect20(() => {
+  useEffect13(() => {
     selectedServerRef.current = selectedServer;
     mcpServersRef.current = mcpServers;
     inspectorClientsRef.current = inspectorClients;
   }, [selectedServer, mcpServers, inspectorClients]);
-  useEffect20(() => {
+  useEffect13(() => {
     if (activeTab === "auth" && selectedServerConfig && !isOAuthCapableServerConfig(selectedServerConfig)) {
       setActiveTab("info");
     }
@@ -18873,7 +19975,7 @@ function App({
     selectedInspectorClient,
     selectedManagedPromptsState
   );
-  const runOAuthAuthentication = useCallback11(
+  const runOAuthAuthentication = useCallback12(
     async (options) => {
       const serverName = options?.serverName ?? selectedServer;
       if (!serverName) {
@@ -18932,7 +20034,7 @@ function App({
     },
     [selectedServer, callbackUrlConfig]
   );
-  const presentStepUpForServer = useCallback11(
+  const presentStepUpForServer = useCallback12(
     (serverName, challenge, authorizationUrl, enterpriseManaged) => {
       const pending = pendingStepUpRef.current;
       if (pending && pending.serverName !== serverName) {
@@ -18961,7 +20063,7 @@ function App({
     },
     []
   );
-  const handleAuthRecoveryRequired = useCallback11(
+  const handleAuthRecoveryRequired = useCallback12(
     (serverName, error) => {
       const serverEntry = mcpServersRef.current[serverName];
       const settings = serverEntry?.settings;
@@ -19024,7 +20126,7 @@ function App({
     },
     [presentStepUpForServer, runOAuthAuthentication]
   );
-  const onAuthRecoveryRequired = useCallback11(
+  const onAuthRecoveryRequired = useCallback12(
     (error) => {
       if (selectedServer) {
         handleAuthRecoveryRequired(selectedServer, error);
@@ -19032,11 +20134,12 @@ function App({
     },
     [selectedServer, handleAuthRecoveryRequired]
   );
-  const handleConnect = useCallback11(async () => {
+  const handleConnect = useCallback12(async () => {
     if (!selectedServer || !selectedInspectorClient || !selectedServerConfig) {
       return;
     }
     disconnectAttemptRef.current++;
+    clearOAuthAttemptRef.current++;
     setDisconnectError(null);
     const finishConnect = async () => {
       await connectInspector();
@@ -19098,7 +20201,7 @@ function App({
     runOAuthAuthentication,
     handleAuthRecoveryRequired
   ]);
-  useEffect20(() => {
+  useEffect13(() => {
     const cleanups = [];
     for (const [serverName, client] of Object.entries(inspectorClients)) {
       const onAmbient = () => {
@@ -19143,7 +20246,7 @@ function App({
       }
     };
   }, [inspectorClients, handleAuthRecoveryRequired]);
-  const handleDisconnect = useCallback11(async () => {
+  const handleDisconnect = useCallback12(async () => {
     if (!selectedServer) return;
     const attempt = ++disconnectAttemptRef.current;
     const attemptServer = selectedServer;
@@ -19157,17 +20260,43 @@ function App({
       setDisconnectError(err instanceof Error ? err.message : String(err));
     }
   }, [selectedServer, disconnectInspector]);
-  const handleClearOAuth = useCallback11(async () => {
+  const handleClearOAuth = useCallback12(async () => {
     if (!selectedInspectorClient) return;
-    await selectedInspectorClient.clearOAuthTokens();
+    const attempt = ++clearOAuthAttemptRef.current;
+    const attemptServer = selectedServer;
+    const revocation = await selectedInspectorClient.clearOAuthTokens({
+      revoke: selectedServerEntry?.settings?.oauthRevokeOnClear !== false
+    });
+    if (clearOAuthAttemptRef.current !== attempt || selectedServerRef.current !== attemptServer) {
+      return;
+    }
     setOauthStatus("idle");
-    setOauthMessage(null);
+    if (revocation.status === "failed") {
+      const warning = `Cleared locally, but revoking the grant at the authorization server failed: ${revocation.detail}. It may still be valid there.`;
+      setOauthWarningText(warning);
+      setOauthMessage(warning);
+    } else {
+      setOauthMessage(null);
+    }
     setConnectError(null);
     if (inspectorStatus === "connected" || inspectorStatus === "connecting") {
-      await disconnectInspector();
+      try {
+        await disconnectInspector();
+      } catch (err) {
+        setDisconnectError(err instanceof Error ? err.message : String(err));
+      }
+      if (clearOAuthAttemptRef.current !== attempt || selectedServerRef.current !== attemptServer) {
+        return;
+      }
     }
     setOauthRevision((n) => n + 1);
-  }, [selectedInspectorClient, inspectorStatus, disconnectInspector]);
+  }, [
+    selectedInspectorClient,
+    selectedServer,
+    selectedServerEntry,
+    inspectorStatus,
+    disconnectInspector
+  ]);
   const currentServerState = useMemo4(() => {
     if (!selectedServer) return null;
     return {
@@ -19379,7 +20508,7 @@ function App({
       /* @__PURE__ */ jsx16(Box27, { paddingLeft: 2, children: /* @__PURE__ */ jsx16(Text24, { dimColor: true, children: JSON.stringify(message.message, null, 2) }) })
     ] })
   ] });
-  useEffect20(() => {
+  useEffect13(() => {
     if (!selectedServer) {
       return;
     }
@@ -19400,7 +20529,7 @@ function App({
     inspectorFetchRequests,
     inspectorStderrLogs
   ]);
-  useEffect20(() => {
+  useEffect13(() => {
     if (activeTab === "messages") {
       if (focus === "tabContentList" || focus === "tabContentDetails") {
         setFocus("messagesList");
@@ -19415,7 +20544,7 @@ function App({
       }
     }
   }, [activeTab]);
-  useEffect20(() => {
+  useEffect13(() => {
     if (activeTab === "logging" && selectedServer) {
       const client = inspectorClients[selectedServer];
       if (client && client.getServerType() !== "stdio") {
@@ -19744,6 +20873,7 @@ function App({
                               inspectorClient: selectedInspectorClient,
                               oauthStatus,
                               oauthMessage,
+                              oauthMessageTone,
                               oauthRevision,
                               pendingStepUp: pendingStepUp?.serverName === selectedServer ? {
                                 challenge: pendingStepUp.challenge,
@@ -19829,9 +20959,7 @@ function App({
                               width: contentWidth,
                               height: contentHeight,
                               focused: focus === "tabContentList" || focus === "tabContentDetails",
-                              onClearOAuth: () => {
-                                void handleClearOAuth();
-                              },
+                              onClearOAuth: handleClearOAuth,
                               connectionStatus: inspectorStatus
                             }
                           ) : null,