@modelcontextprotocol/inspector 2.4.0 → 2.6.0

package/clients/cli/build/index.js

@@ -390,6 +390,495 @@ async function deleteStoreFile(filePath) {
   }
 }
 
+// ../../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 mergedProperties = propertiesOf(merged);
+  if (requiredOf(merged).some((name) => !Object.hasOwn(mergedProperties, name))) {
+    return false;
+  }
+  const properties = Object.values(mergedProperties);
+  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 constOf = (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 = constOf(discriminatorProperty);
+    if (value !== void 0) return value;
+  }
+  const constants = Object.keys(properties).map((name) => constOf(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;
@@ -429,16 +918,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;
 }
@@ -675,6 +1238,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;
 }
@@ -3460,6 +4026,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);
@@ -3650,6 +4235,292 @@ var NodeOAuthStorage = class extends OAuthStorageBase {
   }
 };
 
+// ../../core/auth/revocation.ts
+import { selectClientAuthMethod } from "@modelcontextprotocol/client";
+import {
+  OAuthClientInformationSchema as OAuthClientInformationSchema2,
+  OAuthTokensSchema as OAuthTokensSchema2
+} from "@modelcontextprotocol/core";
+var DEFAULT_REVOCATION_TIMEOUT_MS = 5e3;
+var MIN_REVOCATION_REQUEST_BUDGET_MS = 5;
+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 = Math.max(
+    0,
+    Math.round(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 OAuthTokensSchema2.parseAsync(raw);
+}
+async function parseClient(raw) {
+  return raw === void 0 || raw === null ? void 0 : await OAuthClientInformationSchema2.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 = performance.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 - performance.now();
+    if (remainingMs <= MIN_REVOCATION_REQUEST_BUDGET_MS) {
+      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 aggregateOutcomes(outcomes);
+}
+
 // src/clear-stored-auth-for-relogin.ts
 function normalizeServerUrl(serverUrl) {
   try {
@@ -3658,16 +4529,56 @@ function normalizeServerUrl(serverUrl) {
     return serverUrl;
   }
 }
-async function clearStoredAuthForRelogin(serverUrl) {
-  if (!serverUrl?.trim()) return;
+async function clearStoredAuthForRelogin(serverUrl, options) {
+  if (!serverUrl?.trim()) return void 0;
   const raw = serverUrl.trim();
   const normalized = normalizeServerUrl(raw);
   const storage = new NodeOAuthStorage();
-  await storage.clear(raw);
-  if (normalized !== raw) {
-    await storage.clear(normalized);
+  const keys = normalized === raw ? [raw] : [normalized, raw];
+  const plans = [];
+  for (const key of keys) {
+    plans.push(
+      await clearAndPlanRevocation({
+        serverUrl: key,
+        storage,
+        enabled: options?.revoke !== false
+      })
+    );
   }
   resetNodeOAuthStorageCache();
+  return options?.revoke === false ? void 0 : sendPlans(plans, options?.budgetMs ?? DEFAULT_REVOCATION_TIMEOUT_MS);
+}
+async function sendPlans(plans, budgetMs) {
+  const fetchFn = createProxyFetch() ?? fetch;
+  const deadlineAt = performance.now() + budgetMs;
+  let reported;
+  let lastSkip;
+  for (const plan of plans) {
+    const remainingMs = deadlineAt - performance.now();
+    const needsNetwork = plan.outcome === void 0;
+    if (needsNetwork && remainingMs <= MIN_REVOCATION_REQUEST_BUDGET_MS) {
+      const exhausted = {
+        status: "failed",
+        detail: `the ${budgetMs}ms revocation budget was exhausted before "${plan.serverUrl}" was attempted`
+      };
+      if (reported?.status !== "failed") reported = exhausted;
+      continue;
+    }
+    const outcome = await executeOAuthRevocation(plan, {
+      fetchFn,
+      timeoutMs: needsNetwork ? remainingMs : void 0
+    });
+    if (outcome.status === "skipped" && outcome.reason === "no_tokens") {
+      lastSkip = outcome;
+      continue;
+    }
+    if (outcome.status === "failed") {
+      if (reported?.status !== "failed") reported = outcome;
+    } else {
+      reported ??= outcome;
+    }
+  }
+  return reported ?? lastSkip;
 }
 
 // ../../core/mcp/inspectorClient.ts
@@ -3830,6 +4741,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;
@@ -3921,6 +4846,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
@@ -4028,14 +4976,661 @@ function buildClientExtensions(input) {
       map[ext.key] = ext.advertisement ? structuredClone(ext.advertisement) : {};
     }
   }
-  const uiAdvertisement = map[UI_EXTENSION_KEY];
-  if (input.appElicitation && uiAdvertisement) {
-    map[UI_EXTENSION_KEY] = { ...uiAdvertisement, elicitation: {} };
+  const uiAdvertisement = map[UI_EXTENSION_KEY];
+  if (input.appElicitation && uiAdvertisement) {
+    map[UI_EXTENSION_KEY] = { ...uiAdvertisement, elicitation: {} };
+  }
+  if (input.enterpriseManaged) {
+    map[EMA_EXTENSION_KEY] = {};
+  }
+  return map;
+}
+
+// ../../core/mcp/skillsSchemas.ts
+import { z as z2 } from "zod/v4";
+import { ResourceSchema } from "@modelcontextprotocol/core";
+var SKILLS_EXTENSION_KEY = "io.modelcontextprotocol/skills";
+var SKILLS_LIST_METHOD = "skills/list";
+var SKILLS_GET_METHOD = "skills/get";
+var RESOURCES_DIRECTORY_READ_METHOD = "resources/directory/read";
+var DYNAMIC_RESOURCES = "dynamic";
+var SkillFrontmatterSchema = z2.looseObject({
+  name: z2.string().optional(),
+  description: z2.string().optional()
+});
+var SkillResourceSchema = z2.looseObject({
+  uri: z2.string(),
+  digest: z2.string().optional(),
+  size: z2.number().optional()
+});
+var SkillEntrySchema = z2.looseObject({
+  uri: z2.string(),
+  frontmatter: SkillFrontmatterSchema,
+  resources: z2.union([
+    z2.literal(DYNAMIC_RESOURCES),
+    z2.array(SkillResourceSchema)
+  ])
+});
+var ListSkillsResultSchema = z2.looseObject({
+  skills: z2.array(SkillEntrySchema),
+  nextCursor: z2.string().optional()
+});
+var ModernListSkillsResultSchema = ListSkillsResultSchema.extend({
+  resultType: z2.literal("complete"),
+  // A non-negative INTEGER, matching the codec: `ttlMs: -1` or `0.5` is an
+  // envelope violation, and accepting it here would hide exactly the kind of
+  // defect this schema exists to surface.
+  ttlMs: z2.int().min(0),
+  cacheScope: z2.enum(["public", "private"])
+});
+var GetSkillEnvelopeSchema = z2.looseObject({
+  skill: SkillEntrySchema
+});
+var ModernGetSkillEnvelopeSchema = GetSkillEnvelopeSchema.extend({
+  resultType: z2.literal("complete")
+});
+var GetSkillResultSchema = GetSkillEnvelopeSchema.transform(
+  (result) => result.skill
+);
+var DirectoryChildSchema = ResourceSchema;
+var DirectoryReadResultSchema = z2.looseObject({
+  resources: z2.array(DirectoryChildSchema),
+  nextCursor: z2.string().optional()
+});
+var ModernDirectoryReadResultSchema = DirectoryReadResultSchema.extend(
+  { resultType: z2.literal("complete") }
+);
+
+// ../../core/mcp/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var H0 = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function sha256Bytes(bytes) {
+  const message = new Uint8Array(bytes);
+  const bitLength = message.length * 8;
+  const withLength = message.length + 9;
+  const padded = new Uint8Array(Math.ceil(withLength / 64) * 64);
+  padded.set(message);
+  padded[message.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(padded.length - 4, bitLength >>> 0);
+  const h = new Uint32Array(H0);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i = 0; i < 16; i += 1) w[i] = view.getUint32(offset + i * 4);
+    for (let i = 16; i < 64; i += 1) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let i = 0; i < 64; i += 1) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + S1 + ch + K[i] + w[i] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  const digest = new Uint8Array(32);
+  const out = new DataView(digest.buffer);
+  for (let i = 0; i < 8; i += 1) out.setUint32(i * 4, h[i]);
+  return digest;
+}
+
+// ../../core/mcp/skillFile.ts
+import { parse as parseYaml } from "yaml";
+function splitSkillFile(text) {
+  if (!/^---[ \t]*\r?\n/.test(text)) return { body: text };
+  const rest = text.slice(text.indexOf("\n") + 1);
+  const close = rest.search(/^---[ \t]*\r?$/m);
+  if (close === -1) return { body: text };
+  const frontmatter = rest.slice(0, close).replace(/\r?\n$/, "");
+  const after = rest.slice(close);
+  const newline = after.indexOf("\n");
+  if (newline === -1) return { frontmatter, body: "" };
+  return { frontmatter, body: after.slice(newline + 1).replace(/^\r?\n/, "") };
+}
+function hasContent(yamlText) {
+  return yamlText.split("\n").some((line) => line.trim() !== "" && !line.trimStart().startsWith("#"));
+}
+var MAX_FRONTMATTER_DEPTH = 64;
+function jsonGraphError(value, seen = /* @__PURE__ */ new Set(), depth = 0) {
+  if (typeof value !== "object" || value === null) return void 0;
+  if (depth > MAX_FRONTMATTER_DEPTH) {
+    return `Frontmatter nests deeper than ${MAX_FRONTMATTER_DEPTH} levels, which cannot be compared field by field.`;
+  }
+  const node = value;
+  if (seen.has(node)) {
+    return "Frontmatter contains a cyclic YAML alias, which has no JSON equivalent and cannot be compared against the listing.";
+  }
+  seen.add(node);
+  const members = Array.isArray(node) ? node : Object.values(node);
+  for (const member of members) {
+    const error = jsonGraphError(member, seen, depth + 1);
+    if (error) return error;
+  }
+  seen.delete(node);
+  return void 0;
+}
+function parseSkillFrontmatter(yamlText) {
+  let parsed;
+  try {
+    parsed = parseYaml(yamlText);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+  if (parsed === null || parsed === void 0) {
+    return hasContent(yamlText) ? { error: "Frontmatter is not a YAML mapping of fields." } : { fields: {} };
+  }
+  if (typeof parsed !== "object" || Array.isArray(parsed)) {
+    return {
+      error: "Frontmatter is not a YAML mapping of fields."
+    };
+  }
+  const graphError = jsonGraphError(parsed, /* @__PURE__ */ new Set(), 0);
+  if (graphError) return { error: graphError };
+  return { fields: parsed };
+}
+
+// ../../core/mcp/skills.ts
+var SKILL_MAX_RESOURCE_ENTRIES = 512;
+var SKILL_MAX_TOTAL_BYTES = 16 * 1024 * 1024;
+var SKILL_MAX_CATALOG_SKILLS = 256;
+var SKILL_MAX_CATALOG_BYTES = 64 * 1024 * 1024;
+var SKILL_FILE_SUFFIX = "/SKILL.md";
+var DIGEST_PATTERN = /^sha256:[0-9a-f]{64}$/;
+var SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SKILL_NAME_MAX_LENGTH = 64;
+var SKILL_DESCRIPTION_MAX_LENGTH = 1024;
+function codePointLength(value) {
+  return [...value].length;
+}
+function getSkillsExtension(capabilities) {
+  const declared = capabilities?.extensions?.[SKILLS_EXTENSION_KEY];
+  if (typeof declared !== "object" || declared === null) return void 0;
+  const directoryRead = declared.directoryRead === true;
+  return { directoryRead };
+}
+function normalizeSkillUri(uri) {
+  let parsed;
+  try {
+    parsed = new URL(uri);
+  } catch {
+    return void 0;
+  }
+  if (!parsed.pathname.startsWith("/")) return void 0;
+  return canonicalizePercentEncoding(parsed.href);
+}
+function canonicalizePercentEncoding(value) {
+  return value.replace(/%[0-9a-fA-F]{2}/g, (escape) => {
+    const char = String.fromCharCode(Number.parseInt(escape.slice(1), 16));
+    return /[A-Za-z0-9\-._~]/.test(char) ? char : escape.toUpperCase();
+  });
+}
+function skillNameFromUri(uri) {
+  const normalized = normalizeSkillUri(uri);
+  if (normalized === void 0 || !normalized.endsWith(SKILL_FILE_SUFFIX)) {
+    return void 0;
+  }
+  const path5 = normalized.slice(0, -SKILL_FILE_SUFFIX.length);
+  const segment = path5.slice(path5.lastIndexOf("/") + 1);
+  return segment.length > 0 ? segment : void 0;
+}
+function skillUriIdentity(uri) {
+  return normalizeSkillUri(uri) ?? uri;
+}
+function skillDisplayName(entry) {
+  const declared = entry.frontmatter.name?.trim();
+  if (declared) return declared;
+  return skillNameFromUri(entry.uri) ?? entry.uri;
+}
+function checkSkillConformance(entry) {
+  const issues = [];
+  const rawName = entry.frontmatter.name;
+  const declaredName = rawName?.trim() ? rawName : void 0;
+  const uriName = skillNameFromUri(entry.uri);
+  if (!declaredName) {
+    issues.push({
+      code: "missing-name",
+      severity: "error",
+      message: "frontmatter.name is required but missing or empty."
+    });
+  } else if (codePointLength(declaredName) > SKILL_NAME_MAX_LENGTH || !SKILL_NAME_PATTERN.test(declaredName)) {
+    issues.push({
+      code: "malformed-name",
+      severity: "error",
+      message: `frontmatter.name "${declaredName}" is not a valid Agent Skills name: 1\u2013${SKILL_NAME_MAX_LENGTH} lowercase alphanumerics and hyphens, with no leading, trailing or consecutive hyphen.`
+    });
+  }
+  const rawDescription = entry.frontmatter.description;
+  if (!rawDescription?.trim()) {
+    issues.push({
+      code: "missing-description",
+      severity: "error",
+      message: "frontmatter.description is required but missing or empty."
+    });
+  } else if (codePointLength(rawDescription) > SKILL_DESCRIPTION_MAX_LENGTH) {
+    issues.push({
+      code: "malformed-description",
+      severity: "error",
+      message: `frontmatter.description is ${codePointLength(rawDescription)} characters, above the ${SKILL_DESCRIPTION_MAX_LENGTH}-character limit.`
+    });
+  }
+  if (uriName === void 0) {
+    issues.push({
+      code: "malformed-uri",
+      severity: "error",
+      message: `Skill URI must be a hierarchical URI ending with "${SKILL_FILE_SUFFIX}" and carrying a non-empty path segment before it.`
+    });
+  } else if (declaredName && uriName !== declaredName) {
+    issues.push({
+      code: "name-path-mismatch",
+      severity: "error",
+      message: `URI path segment "${uriName}" does not match frontmatter.name "${declaredName}".`
+    });
+  }
+  if (entry.resources === DYNAMIC_RESOURCES) {
+    issues.push({
+      code: "dynamic-resources",
+      severity: "warning",
+      message: 'resources is "dynamic": the file set is generated, so no digest is advertised and integrity cannot be verified.'
+    });
+    return issues;
+  }
+  if (entry.resources.length > SKILL_MAX_RESOURCE_ENTRIES) {
+    issues.push({
+      code: "resource-limit-exceeded",
+      severity: "warning",
+      message: `Skill declares ${entry.resources.length} resource entries, above the ${SKILL_MAX_RESOURCE_ENTRIES}-entry interoperability limit; a host is only required to support up to it.`
+    });
+  }
+  const totalBytes = totalSkillBytes(entry.resources);
+  if (totalBytes > SKILL_MAX_TOTAL_BYTES) {
+    issues.push({
+      code: "size-limit-exceeded",
+      severity: "warning",
+      message: `Skill resources total ${totalBytes} bytes, above the ${SKILL_MAX_TOTAL_BYTES}-byte (16 MiB) interoperability limit; a host is only required to support up to it.`
+    });
+  }
+  const entryIdentity = skillUriIdentity(entry.uri);
+  if (!entry.resources.some(
+    (resource) => skillUriIdentity(resource.uri) === entryIdentity
+  )) {
+    issues.push({
+      code: "manifest-missing-self",
+      severity: "error",
+      message: `Manifest does not list the skill's own entry file (${entry.uri}); a manifest must be the complete file set.`
+    });
+  }
+  const seenUris = /* @__PURE__ */ new Set();
+  const normalizedEntryUri = normalizeSkillUri(entry.uri);
+  const root = normalizedEntryUri !== void 0 && normalizedEntryUri.endsWith(SKILL_FILE_SUFFIX) ? `${normalizedEntryUri.slice(0, -SKILL_FILE_SUFFIX.length)}/` : void 0;
+  for (const resource of entry.resources) {
+    const identity2 = skillUriIdentity(resource.uri);
+    if (seenUris.has(identity2)) {
+      issues.push({
+        code: "duplicate-resource",
+        severity: "error",
+        message: "Manifest lists this URI more than once; entries must be unique.",
+        resourceUri: resource.uri
+      });
+    }
+    seenUris.add(identity2);
+    if (root !== void 0) {
+      const normalized = normalizeSkillUri(resource.uri);
+      if (normalized === void 0 || !normalized.startsWith(root)) {
+        issues.push({
+          code: "resource-outside-skill-root",
+          severity: "error",
+          message: `Manifest entry does not resolve inside the skill root "${root}".`,
+          resourceUri: resource.uri
+        });
+      }
+    }
+    if (resource.digest === void 0) {
+      issues.push({
+        code: "missing-digest",
+        severity: "error",
+        message: "Manifest entry declares no digest, which is required \u2014 and without it the file cannot be verified.",
+        resourceUri: resource.uri
+      });
+    } else if (!DIGEST_PATTERN.test(resource.digest)) {
+      issues.push({
+        code: "malformed-digest",
+        severity: "error",
+        message: `Digest "${resource.digest}" is not "sha256:" followed by 64 lowercase hex characters.`,
+        resourceUri: resource.uri
+      });
+    }
+    if (resource.size === void 0) {
+      issues.push({
+        code: "missing-size",
+        severity: "error",
+        message: "Manifest entry declares no size, which is required \u2014 and without it the entry is excluded from the 16 MiB total and its length cannot be cross-checked.",
+        resourceUri: resource.uri
+      });
+    } else if (!isUsableSize(resource.size)) {
+      issues.push({
+        code: "malformed-size",
+        severity: "error",
+        message: `Size ${resource.size} is not a non-negative integer byte length.`,
+        resourceUri: resource.uri
+      });
+    }
+  }
+  return issues;
+}
+function isUsableSize(size) {
+  return size !== void 0 && Number.isSafeInteger(size) && size >= 0;
+}
+function totalSkillBytes(resources) {
+  return resources.reduce(
+    (sum, r) => sum + (isUsableSize(r.size) ? r.size : 0),
+    0
+  );
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value === null || typeof value !== "object") return value;
+  return sortKeys(value);
+}
+function sortKeys(value) {
+  return Object.fromEntries(
+    Object.entries(value).map(([key, member]) => [key, canonicalize(member)]).sort(([x], [y]) => x.localeCompare(y))
+  );
+}
+function toHex(bytes) {
+  let out = "";
+  for (const byte of bytes) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+async function sha256Digest(bytes) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) return `sha256:${toHex(sha256Bytes(bytes))}`;
+  const copy = new Uint8Array(bytes);
+  const hash = await subtle.digest("SHA-256", copy.buffer);
+  return `sha256:${toHex(new Uint8Array(hash))}`;
+}
+function textToBytes(text) {
+  return new TextEncoder().encode(text);
+}
+function bytesToText(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function base64ToBytes(blob) {
+  const binary = atob(blob);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function skillFileBytes(contents) {
+  if (typeof contents.text === "string") return textToBytes(contents.text);
+  if (typeof contents.blob === "string") return base64ToBytes(contents.blob);
+  throw new Error("resources/read returned neither text nor blob content.");
+}
+async function verifySkillResource(resource, bytes) {
+  const expectedSize = resource.size;
+  if (expectedSize !== void 0 && expectedSize !== bytes.byteLength) {
+    return {
+      status: "mismatch",
+      expectedSize,
+      actualSize: bytes.byteLength,
+      ...resource.digest !== void 0 ? { expectedDigest: resource.digest } : {},
+      reason: `Manifest declares ${expectedSize} bytes but the fetched file is ${bytes.byteLength}.`
+    };
+  }
+  const expectedDigest = resource.digest;
+  if (expectedDigest === void 0) {
+    return {
+      status: "unverifiable",
+      reason: "The manifest entry advertises no digest."
+    };
+  }
+  if (!DIGEST_PATTERN.test(expectedDigest)) {
+    return {
+      status: "unverifiable",
+      expectedDigest,
+      reason: 'The advertised digest is not "sha256:" followed by 64 lowercase hex characters.'
+    };
+  }
+  const actualDigest = await sha256Digest(bytes);
+  return {
+    status: actualDigest === expectedDigest ? "verified" : "mismatch",
+    actualDigest,
+    expectedDigest,
+    ...expectedSize !== void 0 ? { expectedSize, actualSize: bytes.byteLength } : {}
+  };
+}
+function jsonLikeEqual(a, b) {
+  if (typeof a === "number" || typeof b === "number") {
+    if (typeof a === "number" && typeof b === "number") {
+      return Number.isFinite(a) && Number.isFinite(b) ? a === b : Object.is(a, b);
+    }
+    return false;
+  }
+  if (a === null || b === null) return a === b;
+  if (typeof a !== "object" || typeof b !== "object") return Object.is(a, b);
+  const aArray = Array.isArray(a);
+  if (aArray !== Array.isArray(b)) return false;
+  if (aArray) {
+    const x2 = a;
+    const y2 = b;
+    return x2.length === y2.length && x2.every((v, i) => jsonLikeEqual(v, y2[i]));
+  }
+  const x = a;
+  const y = b;
+  const keys = Object.keys(x);
+  return keys.length === Object.keys(y).length && keys.every((k) => Object.hasOwn(y, k) && jsonLikeEqual(x[k], y[k]));
+}
+function displayValue(value) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    return String(value);
   }
-  if (input.enterpriseManaged) {
-    map[EMA_EXTENSION_KEY] = {};
+  return JSON.stringify(
+    canonicalize(value),
+    (_key, member) => typeof member === "number" && !Number.isFinite(member) ? `<${String(member)}>` : member
+  );
+}
+function checkSkillFrontmatterMatch(entry, skillFileText) {
+  const { frontmatter } = splitSkillFile(skillFileText);
+  if (frontmatter === void 0) {
+    return [
+      {
+        code: "frontmatter-absent",
+        severity: "error",
+        message: "The served SKILL.md carries no YAML frontmatter block, so the listing's frontmatter cannot be the file's.",
+        resourceUri: entry.uri
+      }
+    ];
   }
-  return map;
+  const listedError = jsonGraphError(entry.frontmatter);
+  if (listedError) {
+    return [
+      {
+        code: "frontmatter-unparsable",
+        severity: "error",
+        message: `The listing's own frontmatter cannot be compared: ${listedError}`,
+        resourceUri: entry.uri
+      }
+    ];
+  }
+  const parsed = parseSkillFrontmatter(frontmatter);
+  if ("error" in parsed) {
+    return [
+      {
+        code: "frontmatter-unparsable",
+        severity: "error",
+        message: `The served SKILL.md's frontmatter is not valid YAML: ${parsed.error}`,
+        resourceUri: entry.uri
+      }
+    ];
+  }
+  const issues = [];
+  const fields = [
+    .../* @__PURE__ */ new Set([
+      ...Object.keys(entry.frontmatter),
+      ...Object.keys(parsed.fields)
+    ])
+  ].sort();
+  for (const field of fields) {
+    const listed = entry.frontmatter[field];
+    const served = parsed.fields[field];
+    if (listed === void 0) {
+      issues.push({
+        code: "frontmatter-mismatch",
+        severity: "error",
+        message: `The served SKILL.md declares "${field}" but the listing's frontmatter omits it.`,
+        resourceUri: entry.uri
+      });
+      continue;
+    }
+    if (served === void 0) {
+      issues.push({
+        code: "frontmatter-mismatch",
+        severity: "error",
+        message: `The listing declares "${field}" but the served SKILL.md omits it.`,
+        resourceUri: entry.uri
+      });
+      continue;
+    }
+    if (!jsonLikeEqual(listed, served)) {
+      issues.push({
+        code: "frontmatter-mismatch",
+        severity: "error",
+        message: `Field "${field}" differs: the listing says ${displayValue(listed)} but the served SKILL.md says ${displayValue(served)}.`,
+        resourceUri: entry.uri
+      });
+    }
+  }
+  return issues;
+}
+var COLLISION_SAMPLE = 3;
+function checkSkillNameCollisions(entries) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const name = entry.frontmatter.name;
+    if (typeof name !== "string" || name.trim() === "") continue;
+    const group = byName.get(name);
+    if (group) group.push(entry);
+    else byName.set(name, [entry]);
+  }
+  const issues = /* @__PURE__ */ new Map();
+  for (const [name, group] of byName) {
+    const identities = new Set(group.map((e) => skillUriIdentity(e.uri)));
+    if (identities.size < 2) continue;
+    const uris = [...identities].sort();
+    for (const entry of group) {
+      const self = skillUriIdentity(entry.uri);
+      const sample = [];
+      for (const uri of uris) {
+        if (uri === self) continue;
+        sample.push(uri);
+        if (sample.length === COLLISION_SAMPLE) break;
+      }
+      const unshown = identities.size - 1 - sample.length;
+      const others = unshown > 0 ? `${sample.join(", ")}, and ${unshown} more` : sample.join(", ");
+      const subject = identities.size === 2 ? "Another skill in this listing also declares" : `${identities.size - 1} other skills in this listing also declare`;
+      issues.set(self, {
+        code: "duplicate-name",
+        severity: "warning",
+        message: `${subject} the name "${name}" (${others}). This is legal \u2014 a consumer must tell them apart by their URIs rather than collapsing or preferring one.`
+      });
+    }
+  }
+  return issues;
 }
 
 // ../../core/mcp/appElicitation.ts
@@ -4125,7 +5720,7 @@ import {
   ListResourcesResultSchema,
   ListResourceTemplatesResultSchema,
   ListPromptsResultSchema,
-  ResourceSchema,
+  ResourceSchema as ResourceSchema2,
   ResourceTemplateSchema,
   PromptSchema
 } from "@modelcontextprotocol/core";
@@ -4148,8 +5743,8 @@ function validateToolOutput(provider, tool, result) {
 }
 
 // ../../core/mcp/listSalvage.ts
-import { z as z2 } from "zod/v4";
-import { SdkError, SdkErrorCode } from "@modelcontextprotocol/client";
+import { z as z3 } from "zod/v4";
+import { SdkError as SdkError2, SdkErrorCode as SdkErrorCode2 } from "@modelcontextprotocol/client";
 import { ToolSchema } from "@modelcontextprotocol/core";
 var LIST_MAX_PAGES = 64;
 function listPaginationExceeded(method) {
@@ -4158,26 +5753,26 @@ 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]: z2.array(z2.unknown()) });
+  return resultSchema.extend({ [itemsKey]: z3.array(z3.unknown()) });
 }
 function nextCursorOf(page) {
   if (typeof page !== "object" || page === null) return void 0;
   const value = page.nextCursor;
   return typeof value === "string" ? value : void 0;
 }
-var ModernResultEnvelopeSchema = z2.looseObject({
-  resultType: z2.literal("complete"),
+var ModernResultEnvelopeSchema = z3.looseObject({
+  resultType: z3.literal("complete"),
   // A non-negative INTEGER, matching the codec: `ttlMs: -1` or `0.5` is an
   // envelope violation the strict path rejects, and accepting it here on the
   // strength of an unrelated bad entry would hide it.
-  ttlMs: z2.int().min(0),
-  cacheScope: z2.enum(["public", "private"])
+  ttlMs: z3.int().min(0),
+  cacheScope: z3.enum(["public", "private"])
 });
 function rawItemsOf(page, itemsKey) {
   if (typeof page !== "object" || page === null) return void 0;
@@ -4246,9 +5841,9 @@ var LegacyToolWireSchema = ToolSchema.extend({
   outputSchema: ToolSchema.shape.inputSchema.optional()
 });
 var ModernToolWireSchema = ToolSchema.extend({
-  inputSchema: z2.looseObject({
-    type: z2.literal("object"),
-    $schema: z2.string().optional()
+  inputSchema: z3.looseObject({
+    type: z3.literal("object"),
+    $schema: z3.string().optional()
   })
 });
 function stripExecution(tool) {
@@ -4262,10 +5857,10 @@ function eraToolItemSchema(wire, normalize) {
 
 // ../../core/mcp/taskNotificationSchemas.ts
 import { NotificationSchema } from "@modelcontextprotocol/core";
-import { z as z3 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 var TasksListChangedNotificationSchema = NotificationSchema.extend({
-  method: z3.literal("notifications/tasks/list_changed"),
-  params: z3.record(z3.string(), z3.unknown()).optional()
+  method: z4.literal("notifications/tasks/list_changed"),
+  params: z4.record(z4.string(), z4.unknown()).optional()
 });
 
 // ../../core/mcp/uriTemplate.ts
@@ -4471,6 +6066,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));
@@ -4859,6 +6500,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 path5 = url.pathname.slice(RFC8414_WELL_KNOWN.length);
+  if (path5 !== "" && !path5.startsWith("/")) return [];
+  if (path5 === "") return [new URL(OIDC_WELL_KNOWN, url.origin).href];
+  return [
+    new URL(`${OIDC_WELL_KNOWN}${path5}`, url.origin).href,
+    new URL(`${path5}${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 = () => {
 };
@@ -5091,8 +6841,8 @@ var BaseOAuthClientProvider = class {
     );
   }
   async saveClientInformation(clientInformation, options) {
-    const registrationKind = options && "registrationKind" in options ? options.registrationKind : "dcr";
     const issuer = options && "issuer" in options ? options.issuer : void 0;
+    const registrationKind = options && "registrationKind" in options ? options.registrationKind : await this.resolveSdkRegistrationKind(clientInformation, issuer);
     await this.storage.saveClientInformation(
       this.serverUrl,
       clientInformation,
@@ -5102,6 +6852,70 @@ var BaseOAuthClientProvider = class {
       }
     );
   }
+  /**
+   * Resolve the registration kind for a save that carries no explicit one — that
+   * is, one the SDK made. SDK v2's `saveClientInformation` contract passes only
+   * `{ issuer }`, so the mechanism cannot be handed to us; treating every such
+   * save as DCR is what relabeled a CIMD registration `Dynamic (DCR)` in
+   * Connection Info the moment the SDK bound it to an issuer (#2242).
+   *
+   * Two cases reach here, and they are told apart by whether a registration
+   * already exists for this issuer:
+   *
+   * - **A back-stamp.** A registration is already stored for this issuer under
+   *   this `client_id`, and the SDK is only adding the `issuer` to it. Its
+   *   recorded kind is the answer — kind and credential are written and cleared
+   *   together, so a stored registration always has one.
+   * - **A new registration.** Nothing is stored for this issuer, so this save
+   *   creates it. SDK v2 `auth()` reaches its URL-based-client-ID branch — rather
+   *   than `registerClient` — exactly when the AS advertises
+   *   `client_id_metadata_document_supported` and a `clientMetadataUrl` is
+   *   configured, and it persists the AS metadata via `saveDiscoveryState`
+   *   *before* it reads or writes client information. So the branch it took is
+   *   not inferred here, it is read back from the state it just wrote.
+   *
+   * This is why the check is not "the `client_id` looks like our metadata URL".
+   * RFC 7591 §3.2 makes a dynamically issued `client_id` opaque, so an AS may
+   * mint that very URL from `POST /register`; the URL comparison only decides
+   * whether CIMD is *in play* for this connection, and the two cases above decide
+   * what actually happened (#2242, Copilot).
+   *
+   * Consequences worth stating, since each was a defect on the way here:
+   *
+   * - An existing DCR whose `client_id` happens to be the metadata URL stays
+   *   `dcr` — it takes the back-stamp path and its recorded kind says so.
+   * - `invalidateCredentials("client")`, which SDK `auth()` calls on
+   *   `invalid_client` before retrying, clears the registration and its kind. The
+   *   retry therefore takes the new-registration path and is answered from
+   *   discovery state, which that clear does not touch.
+   * - A second AS behind one resource gets its own answer, since discovery state
+   *   describes the issuer the SDK actually resolved. One that does not advertise
+   *   CIMD is `dcr` even when it mints the metadata URL as its `client_id`.
+   * - A transient failure in our own CIMD preflight costs nothing: the SDK's own
+   *   discovery is what this reads.
+   */
+  async resolveSdkRegistrationKind(clientInformation, issuer) {
+    const clientMetadataUrl = this.clientMetadataUrl?.trim();
+    if (!clientMetadataUrl || clientInformation.client_id !== clientMetadataUrl) {
+      return "dcr";
+    }
+    const stored = await this.storage.getClientInformation(
+      this.serverUrl,
+      false,
+      issuer
+    );
+    if (stored?.client_id === clientMetadataUrl) {
+      const storedKind = await this.storage.getClientRegistrationKind(
+        this.serverUrl,
+        issuer
+      );
+      return storedKind === "cimd" ? "cimd" : "dcr";
+    }
+    const discovery = await this.storage.getDiscoveryState(this.serverUrl);
+    const metadata = discovery?.authorizationServerMetadata;
+    if (issuer !== void 0 && metadata?.issuer !== issuer) return "dcr";
+    return metadata?.client_id_metadata_document_supported === true ? "cimd" : "dcr";
+  }
   async saveScope(scope) {
     await this.storage.saveScope(this.serverUrl, scope);
     this.cachedScope = scope;
@@ -5277,7 +7091,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";
@@ -5326,7 +7140,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 {
@@ -5347,7 +7161,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}`
@@ -5401,7 +7215,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);
@@ -5657,7 +7471,7 @@ async function discoverResourceAsMetadata(resourceAsUrl, fetchFn) {
 
 // ../../core/auth/ema/wire.ts
 import { discoverAndRequestJwtAuthGrant } from "@modelcontextprotocol/client";
-import { OAuthTokensSchema as OAuthTokensSchema2 } from "@modelcontextprotocol/core";
+import { OAuthTokensSchema as OAuthTokensSchema3 } from "@modelcontextprotocol/core";
 async function exchangeIdJag(params) {
   const issuer = normalizeIdpIssuer(params.idp.issuer);
   const resource = params.resource.trim();
@@ -5736,7 +7550,7 @@ async function redeemIdJagForAccessToken(params) {
       "EMA leg 3 (resource AS JWT bearer grant)"
     );
   }
-  return OAuthTokensSchema2.parse(await response.json());
+  return OAuthTokensSchema3.parse(await response.json());
 }
 
 // ../../core/auth/ema/emaFlow.ts
@@ -5980,35 +7794,49 @@ import { discoverOAuthProtectedResourceMetadata as discoverOAuthProtectedResourc
 async function ensureCimdClientRegistration(params) {
   const clientMetadataUrl = params.provider.clientMetadataUrl?.trim();
   if (!clientMetadataUrl) return;
-  const existing = await params.provider.clientInformation();
-  if (existing?.client_id) return;
-  let resourceMetadata;
-  try {
-    resourceMetadata = await discoverOAuthProtectedResourceMetadata2(
-      params.serverUrl,
-      { resourceMetadataUrl: params.resourceMetadataUrl },
-      // The same fetch the AS-metadata leg below uses. On web that is
-      // `createRemoteFetch`, which proxies through the backend to sidestep
-      // CORS — on the global `fetch` this leg would fail in the browser, be
-      // swallowed by the catch, and leave CIMD probing the wrong
-      // authorization server (Copilot).
-      params.fetchFn
-    );
-  } catch {
-    resourceMetadata = void 0;
+  let metadata = (await params.provider.discoveryState())?.authorizationServerMetadata;
+  if (!metadata) {
+    let resourceMetadata;
+    try {
+      resourceMetadata = await discoverOAuthProtectedResourceMetadata2(
+        params.serverUrl,
+        { resourceMetadataUrl: params.resourceMetadataUrl },
+        // The same fetch the AS-metadata leg below uses. On web that is
+        // `createRemoteFetch`, which proxies through the backend to sidestep
+        // CORS — on the global `fetch` this leg would fail in the browser, be
+        // swallowed by the catch, and leave CIMD probing the wrong
+        // authorization server (Copilot).
+        params.fetchFn
+      );
+    } catch {
+      resourceMetadata = void 0;
+    }
+    try {
+      metadata = await discoverAuthorizationServerMetadataForServer(
+        params.serverUrl,
+        resourceMetadata,
+        params.fetchFn
+      );
+    } catch {
+      return;
+    }
   }
-  const metadata = await discoverAuthorizationServerMetadataForServer(
-    params.serverUrl,
-    resourceMetadata,
-    params.fetchFn
-  );
+  const issuer = metadata?.issuer;
   if (!metadata?.client_id_metadata_document_supported) return;
-  const clientInformation = {
-    client_id: clientMetadataUrl
-  };
-  await params.provider.saveClientInformation(clientInformation, {
-    registrationKind: "cimd"
-  });
+  const existing = await params.provider.clientInformation(
+    issuer ? { issuer } : void 0
+  );
+  if (existing?.client_id) return;
+  await params.provider.saveClientInformation(
+    { client_id: clientMetadataUrl },
+    {
+      registrationKind: "cimd",
+      // An AS metadata document without an `issuer` is malformed (RFC 8414 §2),
+      // but the type allows it; fall back to the unkeyed slot rather than
+      // inventing a key.
+      ...issuer && { issuer }
+    }
+  );
 }
 
 // ../../core/auth/ema/transportProvider.ts
@@ -6035,11 +7863,26 @@ var EmaTransportOAuthProvider = class {
   state() {
     return this.inner.state();
   }
-  clientInformation() {
-    return this.inner.clientInformation();
+  // SEP-2352: `ctx` carries the authorization-server `issuer` the SDK resolved,
+  // and the inner provider keys registrations by it. Dropping it here made every
+  // EMA read and write land on the unkeyed slot — and, since #2242, left
+  // `resolveSdkRegistrationKind` with no issuer to check, so a CIMD registration
+  // made over an EMA connection was recorded as DCR (Copilot).
+  clientInformation(ctx) {
+    return this.inner.clientInformation(ctx);
+  }
+  saveClientInformation(clientInformation, ctx) {
+    return this.inner.saveClientInformation(clientInformation, ctx);
+  }
+  // Without these the SDK persists no discovery state for an EMA connection, so
+  // it re-discovers on every call, cannot perform its SEP-2352 callback-leg
+  // authorization-server binding check (it warns as much), and — since #2242 —
+  // leaves the registration-kind resolver nothing to read back.
+  saveDiscoveryState(state) {
+    return this.inner.saveDiscoveryState(state);
   }
-  saveClientInformation(clientInformation) {
-    return this.inner.saveClientInformation(clientInformation);
+  discoveryState() {
+    return this.inner.discoveryState();
   }
   async tokens() {
     const stored = await this.inner.tokens();
@@ -6108,8 +7951,11 @@ function issuerMismatchTitle() {
   return "Authorization server mismatch";
 }
 var MAX_DISPLAYED_ISSUER_LENGTH = 120;
+function truncateUrlForDisplay(url) {
+  return url.length > MAX_DISPLAYED_ISSUER_LENGTH ? `${url.slice(0, MAX_DISPLAYED_ISSUER_LENGTH)}\u2026` : url;
+}
 function truncateIssuerForDisplay(issuer) {
-  return issuer.length > MAX_DISPLAYED_ISSUER_LENGTH ? `${issuer.slice(0, MAX_DISPLAYED_ISSUER_LENGTH)}\u2026` : issuer;
+  return truncateUrlForDisplay(issuer);
 }
 function issuerMismatchMessage(options) {
   const target = options.serverName ? `"${options.serverName}"` : "this server";
@@ -6465,14 +8311,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();
@@ -6799,10 +8672,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() {
@@ -6959,6 +8833,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
@@ -7003,6 +8895,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;
@@ -7367,7 +9260,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();
@@ -7604,6 +9498,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"
@@ -7625,9 +9526,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;
@@ -7734,6 +9638,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) {
@@ -7753,6 +9658,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),
@@ -8443,6 +10349,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();
@@ -9229,10 +11136,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
@@ -9259,7 +11169,13 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       throw new Error("Client is not connected");
     }
     const result = await this.client.request(
-      { method: "tasks/list", params: cursor ? { cursor } : {} },
+      {
+        method: "tasks/list",
+        // `!== undefined`, not truthiness: a cursor is opaque and `""` is a
+        // legal value a server may hand back. Dropping it asks for page one
+        // again, so a caller walking pages would loop on the first page.
+        params: cursor !== void 0 ? { cursor } : {}
+      },
       ListTasksResultSchema,
       this.getRequestOptions()
     );
@@ -10853,7 +12769,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     const effectiveMeta = this.mergeMeta(metadata);
     const params = {
       ...effectiveMeta ? { _meta: effectiveMeta } : {},
-      ...cursor ? { cursor } : {}
+      // `!== undefined`, not truthiness: a cursor is opaque and `""` is a
+      // legal value a server may hand back. Dropping it asks for page one
+      // again, so a caller walking pages would loop on the first page.
+      ...cursor !== void 0 ? { cursor } : {}
     };
     const response = await this.invokeMcpClient(
       () => this.client.request(
@@ -10881,7 +12800,7 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
       method: "resources/list",
       itemsKey: "resources",
       resultSchema: ListResourcesResultSchema,
-      itemSchema: ResourceSchema,
+      itemSchema: ResourceSchema2,
       metadata: options?.metadata,
       aggregate: async () => [
         ...(await this.client.listResources(
@@ -10983,7 +12902,10 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
     const effectiveMeta = this.mergeMeta(metadata);
     const params = {
       ...effectiveMeta ? { _meta: effectiveMeta } : {},
-      ...cursor ? { cursor } : {}
+      // `!== undefined`, not truthiness: a cursor is opaque and `""` is a
+      // legal value a server may hand back. Dropping it asks for page one
+      // again, so a caller walking pages would loop on the first page.
+      ...cursor !== void 0 ? { cursor } : {}
     };
     const response = await this.invokeMcpClient(
       () => this.client.request(
@@ -11029,51 +12951,203 @@ var InspectorClient = class _InspectorClient extends InspectorClientEventTarget
    * @param metadata Optional metadata to include in the request
    * @returns Object containing prompts array and optional nextCursor
    */
-  async listPrompts(cursor, metadata) {
+  async listPrompts(cursor, metadata) {
+    if (!this.client) {
+      throw new Error("Client is not connected");
+    }
+    const effectiveMeta = this.mergeMeta(metadata);
+    const params = {
+      ...effectiveMeta ? { _meta: effectiveMeta } : {},
+      // `!== undefined`, not truthiness: a cursor is opaque and `""` is a
+      // legal value a server may hand back. Dropping it asks for page one
+      // again, so a caller walking pages would loop on the first page.
+      ...cursor !== void 0 ? { cursor } : {}
+    };
+    const response = await this.invokeMcpClient(
+      () => this.client.request(
+        { method: "prompts/list", params },
+        ListPromptsResultSchema,
+        this.getRequestOptions(this.progressTokenOf(metadata))
+      )
+    );
+    return {
+      prompts: response.prompts || [],
+      nextCursor: response.nextCursor
+    };
+  }
+  /**
+   * Aggregate ALL pages of `prompts/list` via the SDK's high-level
+   * cache-aware `client.listPrompts()`. See {@link listAllTools} for the
+   * `cacheMode` semantics; this is the path the managed prompt list uses on
+   * refresh.
+   */
+  async listAllPrompts(options) {
+    if (!this.client) {
+      throw new Error("Client is not connected");
+    }
+    const prompts = await this.listAllSalvaging({
+      method: "prompts/list",
+      itemsKey: "prompts",
+      resultSchema: ListPromptsResultSchema,
+      itemSchema: PromptSchema,
+      metadata: options?.metadata,
+      aggregate: async () => [
+        ...(await this.client.listPrompts(
+          this.aggregateListParams(options?.metadata),
+          this.getCacheableRequestOptions(options?.cacheMode)
+        )).prompts
+      ]
+    });
+    return { prompts };
+  }
+  /**
+   * The Skills extension (SEP-2640) the server declared, or `undefined` when it
+   * declared none. Gates the Skills tab and the skills store the same way
+   * {@link isTasksExtensionNegotiated} gates Tasks — but deliberately without an
+   * era check: `skills/*` are not spec method names in either codec, so a
+   * legacy-era server that declares the extension is serving it (#2234).
+   */
+  getSkillsExtension() {
+    return getSkillsExtension(this.capabilities);
+  }
+  /**
+   * One page of `skills/list` (SEP-2640).
+   *
+   * An ordinary `client.request` with an explicit result schema — the SDK's era
+   * gate skips methods neither codec defines, and `assertCapabilityForMethod`
+   * falls through to a no-op for them, so this is all the extension needs. The
+   * raw-wire path modern `tasks/*` uses would be wrong here: it exists for spec
+   * names the 2026 codec deleted, and taking it would bypass the SDK's response
+   * correlation for nothing (#2234).
+   */
+  async listSkills(cursor, metadata) {
+    if (!this.client) {
+      throw new Error("Client is not connected");
+    }
+    const effectiveMeta = this.mergeMeta(metadata);
+    const params = {
+      ...effectiveMeta ? { _meta: effectiveMeta } : {},
+      // `!== undefined`, not truthiness: a cursor is opaque and the empty
+      // string is a legal value. Dropping `""` would silently re-request page
+      // one, which the store then reports as a repeated-cursor failure — a
+      // conforming server made to look broken.
+      ...cursor !== void 0 ? { cursor } : {}
+    };
+    const resultSchema = this.isModernEra() ? ModernListSkillsResultSchema : ListSkillsResultSchema;
+    const response = await this.invokeMcpClient(
+      () => this.client.request(
+        { method: SKILLS_LIST_METHOD, params },
+        resultSchema,
+        this.getRequestOptions(this.progressTokenOf(metadata))
+      ),
+      { method: SKILLS_LIST_METHOD }
+    );
+    return {
+      skills: response.skills,
+      nextCursor: response.nextCursor
+    };
+  }
+  /**
+   * One skill entry by URI (`skills/get`, SEP-2640). The result envelope is
+   * required — `GetSkillEnvelopeSchema` requires `{ skill }` and rejects an entry
+   * returned inline, so a non-conforming shape fails here rather than being
+   * silently normalized past the conformance checks.
+   */
+  async getSkill(uri, metadata) {
+    return (await this.getSkillResult(uri, metadata)).skill;
+  }
+  /**
+   * `skills/get` as the server sent it — the `{ skill }` envelope **and any
+   * other members it carried**.
+   *
+   * Separate from {@link getSkill} because the callers differ: the UIs want the
+   * entry, while the CLI prints the result and must not reshape it. SEP-2640
+   * explicitly leaves open whether this result carries `ttlMs` / `cacheScope`,
+   * so a server may send them — and unwrapping to the entry discards exactly
+   * those (Copilot).
+   */
+  async getSkillResult(uri, metadata) {
+    if (!this.client) {
+      throw new Error("Client is not connected");
+    }
+    const effectiveMeta = this.mergeMeta(metadata);
+    const params = {
+      uri,
+      ...effectiveMeta ? { _meta: effectiveMeta } : {}
+    };
+    const resultSchema = this.isModernEra() ? ModernGetSkillEnvelopeSchema : GetSkillEnvelopeSchema;
+    try {
+      return await this.invokeMcpClient(
+        () => this.client.request(
+          { method: SKILLS_GET_METHOD, params },
+          resultSchema,
+          this.getRequestOptions(this.progressTokenOf(metadata))
+        ),
+        { method: SKILLS_GET_METHOD }
+      );
+    } catch (err) {
+      if (isClientDecodeRejection(err)) {
+        this.markResponseRejected(
+          SKILLS_GET_METHOD,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+      throw err;
+    }
+  }
+  /**
+   * One page of `resources/directory/read` (SEP-2640): the direct children of
+   * a directory resource.
+   *
+   * **Gated on the server's own declaration, and the gate throws rather than
+   * asks.** SEP-2640 is explicit that *"clients MUST NOT call
+   * `resources/directory/read` against a server that has not declared
+   * `directoryRead: true`"*, so this refuses locally instead of sending a call
+   * the spec forbids and letting the server answer `-32601`. Refusing here also
+   * keeps the Protocol tab honest: a request we were never allowed to make
+   * should not appear in the exchange log as a server-side failure.
+   *
+   * Not recursive — the SEP says clients descend by calling the method again on
+   * a child directory, so the walking is the caller's, not this method's.
+   */
+  async readResourceDirectory(uri, cursor, metadata) {
     if (!this.client) {
       throw new Error("Client is not connected");
     }
+    const extension = this.getSkillsExtension();
+    if (!extension?.directoryRead) {
+      throw new Error(
+        `Server did not declare directoryRead in ${SKILLS_EXTENSION_KEY}; ${RESOURCES_DIRECTORY_READ_METHOD} must not be called.`
+      );
+    }
     const effectiveMeta = this.mergeMeta(metadata);
     const params = {
+      uri,
       ...effectiveMeta ? { _meta: effectiveMeta } : {},
-      ...cursor ? { cursor } : {}
-    };
-    const response = await this.invokeMcpClient(
-      () => this.client.request(
-        { method: "prompts/list", params },
-        ListPromptsResultSchema,
-        this.getRequestOptions(this.progressTokenOf(metadata))
-      )
-    );
-    return {
-      prompts: response.prompts || [],
-      nextCursor: response.nextCursor
+      // `!== undefined` for the same reason `listSkills` uses it: a cursor is
+      // opaque and `""` is a legal value, so truthiness would silently re-ask
+      // for page one.
+      ...cursor !== void 0 ? { cursor } : {}
     };
-  }
-  /**
-   * Aggregate ALL pages of `prompts/list` via the SDK's high-level
-   * cache-aware `client.listPrompts()`. See {@link listAllTools} for the
-   * `cacheMode` semantics; this is the path the managed prompt list uses on
-   * refresh.
-   */
-  async listAllPrompts(options) {
-    if (!this.client) {
-      throw new Error("Client is not connected");
+    const resultSchema = this.isModernEra() ? ModernDirectoryReadResultSchema : DirectoryReadResultSchema;
+    try {
+      return await this.invokeMcpClient(
+        () => this.client.request(
+          { method: RESOURCES_DIRECTORY_READ_METHOD, params },
+          resultSchema,
+          this.getRequestOptions(this.progressTokenOf(metadata))
+        ),
+        { method: RESOURCES_DIRECTORY_READ_METHOD }
+      );
+    } catch (err) {
+      if (isClientDecodeRejection(err)) {
+        this.markResponseRejected(
+          RESOURCES_DIRECTORY_READ_METHOD,
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+      throw err;
     }
-    const prompts = await this.listAllSalvaging({
-      method: "prompts/list",
-      itemsKey: "prompts",
-      resultSchema: ListPromptsResultSchema,
-      itemSchema: PromptSchema,
-      metadata: options?.metadata,
-      aggregate: async () => [
-        ...(await this.client.listPrompts(
-          this.aggregateListParams(options?.metadata),
-          this.getCacheableRequestOptions(options?.cacheMode)
-        )).prompts
-      ]
-    });
-    return { prompts };
   }
   /**
    * Get a prompt by name
@@ -11448,6 +13522,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;
@@ -11459,10 +13534,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;
@@ -11544,8 +13627,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*
@@ -11579,6 +13688,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({
@@ -11635,7 +13748,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 }
       );
     }
@@ -11680,7 +13793,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 }
       );
     }
@@ -11951,10 +14064,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
@@ -12048,7 +14174,30 @@ var EXIT_CODES = {
   AUTH_REQUIRED: 3,
   UNREACHABLE: 4,
   TOOL_ERROR: 5,
-  SCHEMA_UNPORTABLE: 6
+  SCHEMA_UNPORTABLE: 6,
+  /**
+   * `--verify` found a SEP-2640 violation: a conformance error, a digest or
+   * size mismatch, or a manifest file that could not be read (#2248).
+   *
+   * Its own code rather than reusing `SCHEMA_UNPORTABLE`, for the reason that
+   * one exists at all: a CI job that fails on an unportable tool schema and a
+   * CI job that fails on a tampered skill digest are different jobs, and
+   * collapsing them would make `if [ $? -eq 6 ]` ambiguous.
+   */
+  SKILL_NONCONFORMANT: 7,
+  /**
+   * `--verify` could not check the whole catalog: the read bounds stopped the
+   * walk before it finished (#2248).
+   *
+   * Distinct from `SKILL_NONCONFORMANT` because the server has broken no
+   * **MUST** — SEP-2640 states the 512-entry and 16 MiB limits as SHOULD NOT,
+   * with hosts free to support more — so exiting 7 would call a conforming
+   * server nonconformant. It is still non-zero, because reporting success for
+   * a manifest whose unread entries were never fetched is a false pass. A CI
+   * job that wants to tolerate oversized catalogs can allow 8 and still fail
+   * on 7.
+   */
+  SKILL_INCOMPLETE: 8
 };
 var CliExitCodeError = class extends Error {
   constructor(exitCode, message, envelope) {
@@ -12556,6 +14705,15 @@ async function consumeMethodOutcome(outcome, args) {
     for (const line of outcome.lines) {
       await awaitableLog(JSON.stringify(line) + "\n");
     }
+    if (outcome.summary) await awaitableError(`${outcome.summary}
+`);
+    if (outcome.exitCode) {
+      throw new CliExitCodeError(outcome.exitCode, outcome.summary ?? "", {
+        // The envelope's `code` follows the exit code, so a caller reading one
+        // never has to reconcile it against the other.
+        code: outcome.exitCode === EXIT_CODES.SKILL_INCOMPLETE ? "skills_incomplete" : "skills_nonconformant"
+      });
+    }
     return;
   }
   await new Promise((resolve7) => {
@@ -13121,7 +15279,7 @@ var ManagedRequestorTasksState = class extends TypedEventTarget {
       const page = result.tasks.filter((t) => !this.dismissedTaskIds.has(t.taskId)).map(
         (t) => this.cancelledTaskIds.has(t.taskId) ? { ...t, status: "cancelled" } : t
       );
-      this.tasks = cursor ? [...this.tasks, ...page] : page;
+      this.tasks = cursor === void 0 ? page : [...this.tasks, ...page];
       cursor = result.nextCursor;
       pageCount++;
       if (pageCount >= MAX_PAGES) {
@@ -13129,7 +15287,7 @@ var ManagedRequestorTasksState = class extends TypedEventTarget {
           `Maximum pagination limit (${MAX_PAGES} pages) reached while listing requestor tasks`
         );
       }
-    } while (cursor);
+    } while (cursor !== void 0);
     this.dispatchTypedEvent("tasksChange", this.tasks);
     return this.getTasks();
   }
@@ -13182,6 +15340,146 @@ var ManagedRequestorTasksState = class extends TypedEventTarget {
   }
 };
 
+// ../../core/mcp/state/managedSkillsState.ts
+var REPEATED_CURSOR_MESSAGE = "Server repeated a pagination cursor in skills/list; stopped to avoid an infinite walk.";
+var SKILLS_MAX_PAGES = LIST_MAX_PAGES;
+var SKILLS_PAGE_LIMIT_MESSAGE = `skills/list exceeded ${SKILLS_MAX_PAGES} pages without the server's pagination converging`;
+var ManagedSkillsState = class extends TypedEventTarget {
+  skills = [];
+  pageCount = 0;
+  error = null;
+  client = null;
+  unsubscribe = null;
+  // Overlap guard, held as the generation whose walk is in flight (or `null`).
+  // See `refresh` for why this is not a boolean.
+  runningGeneration = null;
+  // Session counter, advanced by `reset` (disconnect) and by `destroy`. A walk
+  // captures it and abandons its writes when it no longer matches.
+  generation = 0;
+  constructor(client) {
+    super();
+    this.client = client;
+    const onConnect = () => {
+      void this.refresh().catch(() => {
+      });
+    };
+    const onStatusChange = () => {
+      if (isTerminalStatus(this.client?.getStatus())) {
+        this.reset();
+      }
+    };
+    this.client.addEventListener("connect", onConnect);
+    this.client.addEventListener("statusChange", onStatusChange);
+    this.unsubscribe = () => {
+      if (this.client) {
+        this.client.removeEventListener("connect", onConnect);
+        this.client.removeEventListener("statusChange", onStatusChange);
+      }
+      this.client = null;
+    };
+  }
+  /** Defensive copy of the current list. */
+  getSkills() {
+    return [...this.skills];
+  }
+  getPagination() {
+    return { pageCount: this.pageCount };
+  }
+  /** The last walk's failure, or `null` when it succeeded. */
+  getError() {
+    return this.error;
+  }
+  // Compared by identity rather than message: two distinct failures with the
+  // same text are still two events, and a re-render on a repeat failure is
+  // cheap next to silently coalescing them.
+  setError(value) {
+    if (this.error === value) return;
+    this.error = value;
+    this.dispatchTypedEvent("errorChange", value);
+  }
+  reset() {
+    this.generation += 1;
+    this.skills = [];
+    this.pageCount = 0;
+    this.dispatchTypedEvent("skillsChange", this.getSkills());
+    this.dispatchTypedEvent("paginationChange", this.getPagination());
+    this.setError(null);
+  }
+  /**
+   * Walk every page of `skills/list` and commit the result.
+   *
+   * A failure is recorded as observable state (`getError`) AND re-thrown: the
+   * state drives the panel's error rendering, while the rejection is what a
+   * caller's auth-recovery wrapper keys off to detect a 401 and start a
+   * re-authorization. The connect-time load, which has no such caller, catches
+   * it above.
+   */
+  async refresh(metadata) {
+    const client = this.client;
+    if (!client || client.getStatus() !== "connected") return this.getSkills();
+    if (!client.getSkillsExtension()) {
+      this.applyPages([], 0);
+      return this.getSkills();
+    }
+    const generation = this.generation;
+    const isCurrent = () => this.generation === generation;
+    if (this.runningGeneration === generation) return this.getSkills();
+    this.runningGeneration = generation;
+    try {
+      const collected = [];
+      const seen = /* @__PURE__ */ new Set();
+      let cursor;
+      let pages = 0;
+      for (; ; ) {
+        const page = await client.listSkills(cursor, metadata);
+        if (!isCurrent()) return this.getSkills();
+        collected.push(...page.skills);
+        pages += 1;
+        if (page.nextCursor === void 0) break;
+        if (pages >= SKILLS_MAX_PAGES) {
+          throw new Error(SKILLS_PAGE_LIMIT_MESSAGE);
+        }
+        if (seen.has(page.nextCursor)) {
+          throw new Error(REPEATED_CURSOR_MESSAGE);
+        }
+        seen.add(page.nextCursor);
+        cursor = page.nextCursor;
+      }
+      this.setError(null);
+      this.applyPages(collected, pages);
+      return this.getSkills();
+    } catch (err) {
+      if (isCurrent()) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.setError(error);
+        if (isClientDecodeRejection(err)) {
+          client.markResponseRejected?.(SKILLS_LIST_METHOD, error.message);
+        }
+      }
+      throw err;
+    } finally {
+      if (this.runningGeneration === generation) {
+        this.runningGeneration = null;
+      }
+    }
+  }
+  applyPages(skills, pageCount) {
+    this.skills = skills;
+    this.pageCount = pageCount;
+    this.dispatchTypedEvent("skillsChange", this.getSkills());
+    this.dispatchTypedEvent("paginationChange", this.getPagination());
+  }
+  /** Unsubscribe from the client and drop the list; idempotent. */
+  destroy() {
+    this.generation += 1;
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    this.skills = [];
+    this.pageCount = 0;
+    this.error = null;
+  }
+};
+
 // ../../core/mcp/apps.ts
 import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
 function getAppResourceUri(tool) {
@@ -13252,13 +15550,241 @@ async function collectAppInfo(client, tool, metadata) {
   }
 }
 
+// src/handlers/skills-verify.ts
+function summarizeSkillVerification(reports) {
+  const failed = reports.filter((report) => report.outcome === "failed").length;
+  const incomplete = reports.filter(
+    (report) => report.outcome === "incomplete"
+  ).length;
+  const files = reports.reduce((sum, report) => sum + report.files.length, 0);
+  const mismatched = reports.reduce(
+    (sum, report) => sum + report.files.filter((file) => file.status === "mismatch").length,
+    0
+  );
+  const skillWord = reports.length === 1 ? "skill" : "skills";
+  const fileWord = files === 1 ? "file" : "files";
+  const incompleteClause = incomplete === 0 ? "" : ` ${incomplete} of ${reports.length} ${skillWord} could not be fully checked: the read bounds stopped the walk.`;
+  const headline = failed === 0 ? incomplete === 0 ? `Verified ${reports.length} ${skillWord} and ${files} ${fileWord}: no conformance errors.` : `Checked ${reports.length} ${skillWord} and ${files} ${fileWord}: no conformance errors in what was read.` : `${failed} of ${reports.length} ${skillWord} failed verification (${mismatched} digest/size mismatch across ${files} ${fileWord}).`;
+  return `${headline}${incompleteClause}`;
+}
+
+// ../../core/mcp/skillsVerification.ts
+function reasonOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function boundedManifest(declared) {
+  const kept = [];
+  let bytes = 0;
+  for (const resource of declared) {
+    if (kept.length >= SKILL_MAX_RESOURCE_ENTRIES) break;
+    const size = typeof resource.size === "number" && Number.isSafeInteger(resource.size) && resource.size >= 0 ? resource.size : 0;
+    if (bytes + size > SKILL_MAX_TOTAL_BYTES) break;
+    bytes += size;
+    kept.push(resource);
+  }
+  return kept;
+}
+function contentsFor(result, uri) {
+  const contents = result?.contents;
+  if (!Array.isArray(contents)) return void 0;
+  const wanted = skillUriIdentity(uri);
+  for (const block of contents) {
+    if (typeof block !== "object" || block === null) continue;
+    const got = block.uri;
+    if (typeof got !== "string") continue;
+    if (skillUriIdentity(got) === wanted) return block;
+  }
+  return void 0;
+}
+function utf8Length(value) {
+  let total = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 128) {
+      total += 1;
+    } else if (code < 2048) {
+      total += 2;
+    } else if (code >= 55296 && code <= 56319) {
+      const next = i + 1 < value.length ? value.charCodeAt(i + 1) : 0;
+      if (next >= 56320 && next <= 57343) {
+        total += 4;
+        i += 1;
+      } else {
+        total += 3;
+      }
+    } else {
+      total += 3;
+    }
+  }
+  return total;
+}
+function responseBytes(result) {
+  const contents = result?.contents;
+  if (!Array.isArray(contents)) return 0;
+  let total = 0;
+  for (const block of contents) {
+    if (typeof block !== "object" || block === null) continue;
+    const { text, blob } = block;
+    if (typeof text === "string") total += utf8Length(text);
+    if (typeof blob === "string") total += blob.length;
+  }
+  return total;
+}
+async function verifySkills(client, entries, metadata) {
+  const collisions = checkSkillNameCollisions(entries);
+  const reports = [];
+  let walkedSkills = 0;
+  let catalogBytes = 0;
+  for (const entry of entries) {
+    const withinBudget = walkedSkills < SKILL_MAX_CATALOG_SKILLS && catalogBytes <= SKILL_MAX_CATALOG_BYTES;
+    let entryBytes;
+    const files = [];
+    const declared = entry.resources === DYNAMIC_RESOURCES ? [] : entry.resources;
+    const manifest = withinBudget ? boundedManifest(declared) : [];
+    let incomplete = !withinBudget ? `Not read: this run already reached its catalog budget of ${SKILL_MAX_CATALOG_SKILLS} skills / ${SKILL_MAX_CATALOG_BYTES} bytes. Nothing about this skill's files has been checked \u2014 verify it on its own with \`--method skills/get --uri\` to get a verdict.` : manifest.length < declared.length ? `Only ${manifest.length} of ${declared.length} manifest entries were read: the skill exceeds the ${SKILL_MAX_RESOURCE_ENTRIES}-entry / ${SKILL_MAX_TOTAL_BYTES}-byte interoperability limits, so the rest were not fetched and cannot be reported on.` : void 0;
+    let receivedBytes = 0;
+    const entryIdentity = skillUriIdentity(entry.uri);
+    let selfAttempted = false;
+    for (const [index, resource] of manifest.entries()) {
+      if (skillUriIdentity(resource.uri) === entryIdentity) {
+        selfAttempted = true;
+      }
+      let charged = 0;
+      try {
+        const invocation = await client.readResource(resource.uri, metadata);
+        charged = responseBytes(invocation.result);
+        const contents = contentsFor(invocation.result, resource.uri);
+        if (!contents) {
+          files.push({
+            uri: resource.uri,
+            status: "read-error",
+            reason: "resources/read returned no content block for this URI, so there are no bytes that can be checked against its digest."
+          });
+        } else {
+          let bytes;
+          try {
+            bytes = skillFileBytes(contents);
+          } catch (err) {
+            files.push({
+              uri: resource.uri,
+              status: "read-error",
+              reason: reasonOf(err)
+            });
+          }
+          if (bytes) {
+            charged = Math.max(charged, bytes.byteLength);
+            if (skillUriIdentity(resource.uri) === entryIdentity)
+              entryBytes = bytes;
+            const verification = await verifySkillResource(resource, bytes);
+            files.push({ uri: resource.uri, ...verification });
+          }
+        }
+      } catch (err) {
+        if (err instanceof AuthRecoveryRequiredError) throw err;
+        files.push({
+          uri: resource.uri,
+          status: "read-error",
+          reason: reasonOf(err)
+        });
+      }
+      receivedBytes += charged;
+      if (receivedBytes > SKILL_MAX_TOTAL_BYTES) {
+        if (index < manifest.length - 1) {
+          incomplete = `Stopped after ${index + 1} of ${declared.length} manifest entries: the files actually served exceed the ${SKILL_MAX_TOTAL_BYTES}-byte interoperability limit, whatever sizes the manifest declared.`;
+        }
+        break;
+      }
+    }
+    if (withinBudget && !selfAttempted) {
+      const fail = (reason) => files.push({ uri: entry.uri, status: "read-error", reason });
+      try {
+        const invocation = await client.readResource(entry.uri, metadata);
+        const contents = contentsFor(invocation.result, entry.uri);
+        if (!contents) {
+          fail(
+            "resources/read returned no content block for this skill's own SKILL.md, so its frontmatter cannot be checked against the listing."
+          );
+        } else {
+          try {
+            entryBytes = skillFileBytes(contents);
+          } catch (err) {
+            fail(reasonOf(err));
+          }
+        }
+        const declaredSelf = declared.find(
+          (resource) => skillUriIdentity(resource.uri) === entryIdentity
+        );
+        if (declaredSelf && entryBytes !== void 0) {
+          files.push({
+            // The DECLARED spelling, not the entry's. They can differ — a
+            // manifest may write its self-entry in a normalized-equivalent
+            // form — and a consumer matching rows against the manifest then
+            // finds nothing, while a normalized "extra files" filter suppresses
+            // it as already covered. The result was a verdict that existed in
+            // the report and appeared nowhere on screen (Copilot).
+            uri: declaredSelf.uri,
+            ...await verifySkillResource(declaredSelf, entryBytes)
+          });
+        }
+      } catch (err) {
+        if (err instanceof AuthRecoveryRequiredError) throw err;
+        fail(reasonOf(err));
+      }
+    }
+    if (withinBudget) {
+      walkedSkills += 1;
+      catalogBytes += receivedBytes;
+    }
+    const entryText = entryBytes === void 0 ? void 0 : bytesToText(entryBytes);
+    const collision = collisions.get(skillUriIdentity(entry.uri));
+    const conformance = [
+      ...checkSkillConformance(entry),
+      ...collision ? [collision] : []
+    ];
+    const frontmatter = entryText === void 0 ? [] : checkSkillFrontmatterMatch(entry, entryText);
+    const hasError = [...conformance, ...frontmatter].some(
+      (issue) => issue.severity === "error"
+    );
+    const fileFailed = files.some(
+      (file) => file.status === "mismatch" || file.status === "read-error"
+    );
+    reports.push({
+      uri: entry.uri,
+      name: skillDisplayName(entry),
+      conformance,
+      frontmatter,
+      files,
+      ...incomplete ? { incomplete } : {},
+      ok: !hasError && !fileFailed,
+      outcome: hasError || fileFailed ? "failed" : incomplete !== void 0 ? "incomplete" : "verified"
+    });
+  }
+  return reports;
+}
+function allSkillsVerified(reports) {
+  return reports.every((report) => report.outcome === "verified");
+}
+function anySkillFailed(reports) {
+  return reports.some((report) => report.outcome === "failed");
+}
+
 // src/handlers/run-method.ts
+function assertSkillsSupported(inspectorClient, method) {
+  if (!inspectorClient.getSkillsExtension()) {
+    throw new CliExitCodeError(
+      EXIT_CODES.USAGE,
+      `Server does not declare the ${SKILLS_EXTENSION_KEY} extension, so ${method} is not available.`,
+      { code: "skills_unsupported" }
+    );
+  }
+}
 async function runMethod(inspectorClient, args) {
   let managedToolsState = null;
   let managedResourcesState = null;
   let managedResourceTemplatesState = null;
   let managedPromptsState = null;
   let managedTasksState = null;
+  let managedSkillsState = null;
   try {
     let result;
     let appInfo;
@@ -13477,6 +16003,73 @@ async function runMethod(inspectorClient, args) {
       result = await inspectorClient.getRequestorTaskResult(
         args.taskId
       );
+    } else if (args.method === "skills/list") {
+      assertSkillsSupported(inspectorClient, args.method);
+      managedSkillsState = new ManagedSkillsState(inspectorClient);
+      const skills = await managedSkillsState.refresh(args.metadata);
+      if (args.verify) {
+        const reports = await verifySkills(
+          inspectorClient,
+          skills,
+          args.metadata
+        );
+        return {
+          kind: "ndjson",
+          lines: reports,
+          summary: summarizeSkillVerification(reports),
+          // Three outcomes, three exit codes: a broken MUST is 7, a walk the
+          // read bounds cut short is 8, and everything checked and passing is
+          // 0. Collapsing the middle case into either of the others reports
+          // something untrue about the server (Copilot).
+          ...allSkillsVerified(reports) ? {} : {
+            exitCode: anySkillFailed(reports) ? EXIT_CODES.SKILL_NONCONFORMANT : EXIT_CODES.SKILL_INCOMPLETE
+          }
+        };
+      }
+      result = { skills };
+    } else if (args.method === "skills/get") {
+      if (!args.uri) {
+        throw new Error(
+          "URI is required for skills/get method. Use --uri to specify the skill URI."
+        );
+      }
+      assertSkillsSupported(inspectorClient, args.method);
+      const envelope = await inspectorClient.getSkillResult(
+        args.uri,
+        args.metadata
+      );
+      const skill = envelope.skill;
+      if (args.verify) {
+        const reports = await verifySkills(
+          inspectorClient,
+          [skill],
+          args.metadata
+        );
+        return {
+          kind: "ndjson",
+          lines: reports,
+          summary: summarizeSkillVerification(reports),
+          // Three outcomes, three exit codes: a broken MUST is 7, a walk the
+          // read bounds cut short is 8, and everything checked and passing is
+          // 0. Collapsing the middle case into either of the others reports
+          // something untrue about the server (Copilot).
+          ...allSkillsVerified(reports) ? {} : {
+            exitCode: anySkillFailed(reports) ? EXIT_CODES.SKILL_NONCONFORMANT : EXIT_CODES.SKILL_INCOMPLETE
+          }
+        };
+      }
+      result = envelope;
+    } else if (args.method === "resources/directory/read") {
+      if (!args.uri) {
+        throw new Error(
+          "URI is required for resources/directory/read. Use --uri to specify the directory URI."
+        );
+      }
+      result = await inspectorClient.readResourceDirectory(
+        args.uri,
+        args.cursor,
+        args.metadata
+      );
     } else if (args.method === "roots/list") {
       result = { roots: inspectorClient.getRoots() };
     } else if (args.method === "roots/set") {
@@ -13511,6 +16104,7 @@ async function runMethod(inspectorClient, args) {
     managedResourcesState?.destroy();
     managedResourceTemplatesState?.destroy();
     managedPromptsState?.destroy();
+    managedSkillsState?.destroy();
     managedTasksState?.destroy();
   }
 }
@@ -13525,7 +16119,13 @@ var ONE_SHOT_METHODS = [
   "resources/templates/list",
   "prompts/list",
   "prompts/get",
-  "logging/setLevel"
+  "logging/setLevel",
+  // SEP-2640. All three are ordinary one-shot request/response calls — no
+  // stream, no long-lived subscription — so they belong here alongside the
+  // other list verbs rather than being reachable only from the session CLI.
+  "skills/list",
+  "skills/get",
+  "resources/directory/read"
 ];
 function isOneShotMethod(method) {
   return ONE_SHOT_METHODS.includes(method);
@@ -13970,7 +16570,7 @@ function createCliOAuthNavigation(options = {}) {
 }
 
 // ../../core/client/config-parse.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 function isAbsoluteHttpUrl(value) {
   let url;
   try {
@@ -13987,11 +16587,11 @@ function isRealHost(hostname) {
   const labels = hostname.split(".");
   return labels.length >= 2 && labels.every((label) => label !== "");
 }
-var HttpUrlStringSchema = z4.string().min(1).superRefine((val, ctx) => {
+var HttpUrlStringSchema = z5.string().min(1).superRefine((val, ctx) => {
   const trimmed = val.trim();
   if (!isAbsoluteHttpUrl(trimmed)) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       message: `Invalid URL: "${trimmed}" \u2014 must be an http(s) URL (e.g. https://idp.example.com)`
     });
   }
@@ -14023,7 +16623,7 @@ function refineCimdMetadataUrl(val, ctx, required) {
   if (trimmed === "") {
     if (required) {
       ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
+        code: z5.ZodIssueCode.custom,
         message: "CIMD client metadata URL is required when CIMD is enabled"
       });
     }
@@ -14032,25 +16632,25 @@ function refineCimdMetadataUrl(val, ctx, required) {
   const error = getCimdClientMetadataUrlError(trimmed);
   if (error) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       message: error
     });
   }
 }
-var CimdConfigSchema = z4.object({
-  enabled: z4.boolean(),
-  clientMetadataUrl: z4.string()
+var CimdConfigSchema = z5.object({
+  enabled: z5.boolean(),
+  clientMetadataUrl: z5.string()
 }).superRefine((data, ctx) => {
   refineCimdMetadataUrl(data.clientMetadataUrl, ctx, data.enabled === true);
 });
-var EnterpriseManagedAuthIdpConfigSchema = z4.object({
+var EnterpriseManagedAuthIdpConfigSchema = z5.object({
   issuer: HttpUrlStringSchema,
-  clientId: z4.string().min(1),
-  clientSecret: z4.string().optional()
+  clientId: z5.string().min(1),
+  clientSecret: z5.string().optional()
 });
-var ClientConfigSchema = z4.object({
-  enterpriseManagedAuth: z4.object({
-    enabled: z4.boolean().optional(),
+var ClientConfigSchema = z5.object({
+  enterpriseManagedAuth: z5.object({
+    enabled: z5.boolean().optional(),
     idp: EnterpriseManagedAuthIdpConfigSchema
   }).optional(),
   cimd: CimdConfigSchema.optional()
@@ -14518,14 +17118,22 @@ var validLogLevels = Object.values(
   LoggingLevelSchema.enum
 );
 var CLI_CLIENT_NAME = "inspector-cli";
-async function callMethod(serverConfig, serverSettings, args, clientConfig, cliAuthOverrides, callbackUrlConfig, storedAuthOnly, relogin) {
+async function callMethod(serverConfig, serverSettings, args, clientConfig, cliAuthOverrides, callbackUrlConfig, storedAuthOnly, relogin, revoke) {
   if (relogin) {
     if (!("url" in serverConfig && serverConfig.url)) {
       throw new Error(
         "--relogin requires an HTTP/SSE server URL (no OAuth store entry for stdio)"
       );
     }
-    await clearStoredAuthForRelogin(serverConfig.url);
+    const revocation = await clearStoredAuthForRelogin(serverConfig.url, {
+      revoke: revoke && serverSettings?.oauthRevokeOnClear !== false
+    });
+    if (revocation?.status === "failed") {
+      process.stderr.write(
+        `Warning: could not revoke the OAuth grant at the authorization server (${revocation.detail}); it may still be valid there.
+`
+      );
+    }
   }
   const clientIdentity = {
     name: CLI_CLIENT_NAME,
@@ -14646,7 +17254,13 @@ function findStoredToken(servers, serverUrl) {
 }
 async function refreshStoredAuthToken(serverUrl, statePath, deps = {}) {
   const refresh = deps.refresh ?? refreshAuthorization;
-  const discover = deps.discover ?? discoverAuthorizationServerMetadata4;
+  const storedAuthFetch = withRfc8414OidcCompat(createProxyFetch() ?? fetch);
+  const discover = deps.discover ?? ((authorizationServerUrl, options) => discoverAuthorizationServerMetadata4(authorizationServerUrl, {
+    ...options,
+    // A caller-supplied fetch is left alone — it is theirs to compose. The
+    // walker below passes no options, so in practice this is ours.
+    fetchFn: options?.fetchFn ?? storedAuthFetch
+  }));
   const snapshot = await readOAuthSnapshot(statePath);
   const servers = snapshot.servers;
   const found = findStoredServerState(servers, serverUrl);
@@ -14684,7 +17298,8 @@ async function refreshStoredAuthToken(serverUrl, statePath, deps = {}) {
       metadata,
       clientInformation,
       refreshToken,
-      resource: new URL(serverUrl)
+      resource: new URL(serverUrl),
+      fetchFn: storedAuthFetch
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -14814,7 +17429,13 @@ async function parseArgs(argv) {
     "Tool argument as key=value pair",
     parseKeyValuePair2,
     {}
-  ).option("--uri <uri>", "URI of the resource (for resources/read method)").option(
+  ).option(
+    "--uri <uri>",
+    "URI of the resource (resources/read, resources/directory/read) or of the skill (skills/get)"
+  ).option(
+    "--cursor <cursor>",
+    "Opaque pagination cursor (for resources/directory/read; pass back the nextCursor from the previous page)."
+  ).option(
     "--prompt-name <promptName>",
     "Name of the prompt (for prompts/get method)"
   ).option(
@@ -14866,6 +17487,9 @@ async function parseArgs(argv) {
   ).option(
     "--strict",
     "Report tool-schema portability problems in full (path, issue, suggested fix) on stderr, and exit 6 if any is error-severity. Use with --method tools/list. Without it, a one-line count is printed instead."
+  ).option(
+    "--verify",
+    "Run the SEP-2640 conformance and digest checks over the skills returned, emit one JSON report per skill on stdout, and exit 7 if any fails or 8 if any could not be fully checked within the read bounds. Use with --method skills/list or --method skills/get."
   ).option(
     "--connect-timeout <ms>",
     `Connection timeout in ms (default ${DEFAULT_CONNECT_TIMEOUT_MS} for ad-hoc --server-url / target invocations; 0 = no timeout).`,
@@ -14912,6 +17536,9 @@ async function parseArgs(argv) {
   ).option(
     "--relogin",
     "Delete stored OAuth for this server URL from the shared store before connect (HTTP/SSE URL keys only); interactive login runs only if the server requires auth. Rejected for stdio (no URL-keyed store entry)"
+  ).option(
+    "--no-revoke",
+    "Requires --relogin. Skips the RFC 7009 revocation request that would otherwise end the grant at the authorization server when the local state is deleted. Also skipped when the server entry sets oauth.revokeOnClear to false."
   ).option(
     "--wait-for-auth <sec>",
     "Poll the OAuth state file until a token for --server-url appears (or the timeout elapses), then proceed as if --use-stored-auth were set. Use after handing off to a human to complete OAuth in a browser.",
@@ -14953,6 +17580,9 @@ async function parseArgs(argv) {
       );
     }
   }
+  if (options.revoke === false && !options.relogin) {
+    throw new Error("--no-revoke requires --relogin (it has no other effect).");
+  }
   if (options.strict) {
     if (options.method !== "tools/list") {
       throw new Error("--strict requires --method tools/list.");
@@ -14963,6 +17593,13 @@ async function parseArgs(argv) {
       );
     }
   }
+  if (options.verify) {
+    if (options.method !== "skills/list" && options.method !== "skills/get") {
+      throw new Error(
+        "--verify requires --method skills/list or --method skills/get."
+      );
+    }
+  }
   const oauthStatePath = getStateFilePath();
   if (options.listStoredAuth) {
     const servers = await readOAuthServers(oauthStatePath);
@@ -15126,6 +17763,8 @@ async function parseArgs(argv) {
     toolMeta: options.toolMetadata,
     appInfo: options.appInfo === true,
     strict: options.strict === true,
+    verify: options.verify === true,
+    cursor: options.cursor,
     format: options.format
   };
   return {
@@ -15138,7 +17777,10 @@ async function parseArgs(argv) {
     clientMetadataUrl: options.clientMetadataUrl,
     callbackUrl: options.callbackUrl,
     storedAuthOnly: options.storedAuthOnly === true,
-    relogin: options.relogin === true
+    relogin: options.relogin === true,
+    // Commander's `--no-revoke` defaults this to true; only an explicit
+    // `--no-revoke` makes it false.
+    revoke: options.revoke !== false
   };
 }
 async function runCli(argv) {
@@ -15154,7 +17796,8 @@ async function runCli(argv) {
     clientMetadataUrl,
     callbackUrl,
     storedAuthOnly,
-    relogin
+    relogin,
+    revoke
   } = parsed;
   const clientConfig = await loadRunnerClientConfig({ clientConfigPath });
   let callbackUrlConfig;
@@ -15178,7 +17821,8 @@ async function runCli(argv) {
     },
     callbackUrlConfig,
     storedAuthOnly === true,
-    relogin === true
+    relogin === true,
+    revoke !== false
   );
 }