@poe-platform/safe-js 0.1.713 → 0.1.715

package/dist/safe-js/chunks/{chunk-YPVGFXBW.js → chunk-HYD4K4HN.js}

@@ -85,11 +85,15 @@ var HttpResponseMessages = class {
 };
 
 // packages/toolcraft-schema/src/json.ts
-function isJsonValue(value) {
+function isJsonValue(value, options = {}) {
+  const maxNodes = options.maxNodes ?? 1e4;
+  const maxDepth = options.maxDepth ?? 64;
+  if (!Number.isSafeInteger(maxNodes) || maxNodes < 1) throw new Error("maxNodes must be a positive safe integer");
+  if (!Number.isSafeInteger(maxDepth) || maxDepth < 0 || maxDepth > 256) throw new Error("maxDepth must be an integer between 0 and 256");
   const ancestors = /* @__PURE__ */ new Set();
   let nodes = 0;
   const visit = (item, depth) => {
-    if (++nodes > 1e4 || depth > 64) return false;
+    if (++nodes > maxNodes || depth > maxDepth) return false;
     if (item === null || typeof item === "string" || typeof item === "boolean") return true;
     if (typeof item === "number") return Number.isFinite(item);
     if (typeof item !== "object" || ancestors.has(item)) return false;
@@ -108,7 +112,7 @@ function isJsonValue(value) {
     ancestors.add(item);
     let valid = true;
     if (Array.isArray(item)) {
-      if (item.length > 1e4) valid = false;
+      if (item.length > maxNodes) valid = false;
       else for (let index = 0; index < item.length; index++) {
         const property = Object.getOwnPropertyDescriptor(item, String(index));
         if (property === void 0 || !("value" in property) || !visit(property.value, depth + 1)) {
@@ -198,8 +202,8 @@ function receivedType(value) {
   }
   return typeof value;
 }
-function issue(path4, expected, value, message, keyword = keywordFor(expected)) {
-  return { path: path4, expected, received: receivedType(value), message, keyword };
+function issue(path6, expected, value, message, keyword = keywordFor(expected)) {
+  return { path: path6, expected, received: receivedType(value), message, keyword };
 }
 function keywordFor(expected) {
   if (["null", "boolean", "object", "array", "number", "integer", "string"].includes(expected)) {
@@ -1030,41 +1034,41 @@ function evaluateArrayApplicators(graph, node, schema, value, context) {
   }
   return results;
 }
-function evaluateValidationKeywords(node, schema, value, path4) {
+function evaluateValidationKeywords(node, schema, value, path6) {
   const results = [];
   const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
   if (types.length > 0 && !types.some((type) => typeof type === "string" && typeMatches(type, value))) {
-    results.push(invalidResult(issue(path4, types.join(","), value, `must be ${types.join(",")}`)));
+    results.push(invalidResult(issue(path6, types.join(","), value, `must be ${types.join(",")}`)));
     return results;
   }
   if (schema.const !== void 0 && !deepEqual(schema.const, value)) {
-    results.push(invalidResult(issue(path4, "const", value, "must be equal to constant")));
+    results.push(invalidResult(issue(path6, "const", value, "must be equal to constant")));
   }
   if (Array.isArray(schema.enum) && !schema.enum.some((entry) => deepEqual(entry, value))) {
     results.push(
-      invalidResult(issue(path4, "enum", value, "must be equal to one of the allowed values"))
+      invalidResult(issue(path6, "enum", value, "must be equal to one of the allowed values"))
     );
   }
   if (typeof value === "number" && Number.isFinite(value)) {
-    evaluateNumberKeywords(schema, value, path4, results);
+    evaluateNumberKeywords(schema, value, path6, results);
   }
   if (typeof value === "string") {
-    evaluateStringKeywords(schema, value, path4, results);
+    evaluateStringKeywords(schema, value, path6, results);
   }
   if (Array.isArray(value)) {
-    evaluateArrayKeywords(schema, value, path4, results);
+    evaluateArrayKeywords(schema, value, path6, results);
   }
   if (isObject(value)) {
-    evaluateObjectKeywords(node, schema, value, path4, results);
+    evaluateObjectKeywords(node, schema, value, path6, results);
   }
   return results;
 }
-function evaluateNumberKeywords(schema, value, path4, results) {
+function evaluateNumberKeywords(schema, value, path6, results) {
   if (typeof schema.multipleOf === "number" && !isMultipleOf(value, schema.multipleOf)) {
     results.push(
       invalidResult(
         issue(
-          path4,
+          path6,
           `multiple of ${schema.multipleOf}`,
           value,
           `must be multiple of ${schema.multipleOf}`
@@ -1074,36 +1078,36 @@ function evaluateNumberKeywords(schema, value, path4, results) {
   }
   if (typeof schema.maximum === "number" && value > schema.maximum) {
     results.push(
-      invalidResult(issue(path4, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`))
+      invalidResult(issue(path6, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`))
     );
   }
   if (typeof schema.minimum === "number" && value < schema.minimum) {
     results.push(
-      invalidResult(issue(path4, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`))
+      invalidResult(issue(path6, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`))
     );
   }
   if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
     results.push(
       invalidResult(
-        issue(path4, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)
+        issue(path6, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)
       )
     );
   }
   if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
     results.push(
       invalidResult(
-        issue(path4, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)
+        issue(path6, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)
       )
     );
   }
 }
-function evaluateStringKeywords(schema, value, path4, results) {
+function evaluateStringKeywords(schema, value, path6, results) {
   const length = unicodeLength(value);
   if (typeof schema.maxLength === "number" && length > schema.maxLength) {
     results.push(
       invalidResult(
         issue(
-          path4,
+          path6,
           `length <= ${schema.maxLength}`,
           value,
           `must NOT have more than ${schema.maxLength} characters`
@@ -1115,7 +1119,7 @@ function evaluateStringKeywords(schema, value, path4, results) {
     results.push(
       invalidResult(
         issue(
-          path4,
+          path6,
           `length >= ${schema.minLength}`,
           value,
           `must NOT have fewer than ${schema.minLength} characters`
@@ -1126,17 +1130,17 @@ function evaluateStringKeywords(schema, value, path4, results) {
   if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value)) {
     results.push(
       invalidResult(
-        issue(path4, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)
+        issue(path6, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)
       )
     );
   }
 }
-function evaluateArrayKeywords(schema, value, path4, results) {
+function evaluateArrayKeywords(schema, value, path6, results) {
   if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
     results.push(
       invalidResult(
         issue(
-          path4,
+          path6,
           `items <= ${schema.maxItems}`,
           value,
           `must NOT have more than ${schema.maxItems} items`
@@ -1148,7 +1152,7 @@ function evaluateArrayKeywords(schema, value, path4, results) {
     results.push(
       invalidResult(
         issue(
-          path4,
+          path6,
           `items >= ${schema.minItems}`,
           value,
           `must NOT have fewer than ${schema.minItems} items`
@@ -1161,7 +1165,7 @@ function evaluateArrayKeywords(schema, value, path4, results) {
       for (let right = left + 1; right < value.length; right += 1) {
         if (deepEqual(value[left], value[right])) {
           results.push(
-            invalidResult(issue(path4, "unique items", value, "must NOT have duplicate items"))
+            invalidResult(issue(path6, "unique items", value, "must NOT have duplicate items"))
           );
           return;
         }
@@ -1169,13 +1173,13 @@ function evaluateArrayKeywords(schema, value, path4, results) {
     }
   }
 }
-function evaluateObjectKeywords(node, schema, value, path4, results) {
+function evaluateObjectKeywords(node, schema, value, path6, results) {
   const keys = Object.keys(value);
   if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
     results.push(
       invalidResult(
         issue(
-          path4,
+          path6,
           `properties <= ${schema.maxProperties}`,
           value,
           `must NOT have more than ${schema.maxProperties} properties`
@@ -1187,7 +1191,7 @@ function evaluateObjectKeywords(node, schema, value, path4, results) {
     results.push(
       invalidResult(
         issue(
-          path4,
+          path6,
           `properties >= ${schema.minProperties}`,
           value,
           `must NOT have fewer than ${schema.minProperties} properties`
@@ -1200,7 +1204,7 @@ function evaluateObjectKeywords(node, schema, value, path4, results) {
       if (typeof key2 === "string" && !Object.prototype.hasOwnProperty.call(value, key2)) {
         results.push(
           invalidResult(
-            issue([...path4, key2], "required", void 0, `must have required property '${key2}'`)
+            issue([...path6, key2], "required", void 0, `must have required property '${key2}'`)
           )
         );
       }
@@ -1209,24 +1213,24 @@ function evaluateObjectKeywords(node, schema, value, path4, results) {
   const dependentRequired = isObject(schema.dependentRequired) ? schema.dependentRequired : {};
   for (const [key2, dependencies] of Object.entries(dependentRequired)) {
     if (Object.prototype.hasOwnProperty.call(value, key2) && Array.isArray(dependencies)) {
-      addMissingDependencies(value, dependencies, path4, results);
+      addMissingDependencies(value, dependencies, path6, results);
     }
   }
   if (node.dialect === "draft7" && isObject(schema.dependencies)) {
     for (const [key2, dependencies] of Object.entries(schema.dependencies)) {
       if (Object.prototype.hasOwnProperty.call(value, key2) && Array.isArray(dependencies)) {
-        addMissingDependencies(value, dependencies, path4, results);
+        addMissingDependencies(value, dependencies, path6, results);
       }
     }
   }
 }
-function addMissingDependencies(value, dependencies, path4, results) {
+function addMissingDependencies(value, dependencies, path6, results) {
   for (const dependency of dependencies) {
     if (typeof dependency === "string" && !Object.prototype.hasOwnProperty.call(value, dependency)) {
       results.push(
         invalidResult(
           issue(
-            [...path4, dependency],
+            [...path6, dependency],
             "dependency",
             void 0,
             `must have property '${dependency}'`
@@ -3515,21 +3519,690 @@ var SubscriptionManager = class {
   }
 };
 
-// packages/mcp-oauth/src/client/auth-store-session-store.ts
+// packages/mcp-oauth/src/client/persistence-options.ts
+function snapshotOAuthPersistenceOptions(options) {
+  const file = options.fileStore, keychain = options.keychainStore, lock = keychain?.lock;
+  return {
+    ...options,
+    backend: options.backend,
+    env: options.env,
+    platform: options.platform,
+    backendEnvVar: options.backendEnvVar,
+    ...file === void 0 ? {} : { fileStore: {
+      ...file,
+      fs: file.fs,
+      filePath: file.filePath,
+      salt: file.salt,
+      defaultDirectory: file.defaultDirectory,
+      defaultFileName: file.defaultFileName,
+      throwOnInvalidDocument: file.throwOnInvalidDocument,
+      getHomeDirectory: file.getHomeDirectory?.bind(file),
+      getMachineIdentity: file.getMachineIdentity?.bind(file),
+      getRandomBytes: file.getRandomBytes?.bind(file)
+    } },
+    ...keychain === void 0 ? {} : { keychainStore: {
+      ...keychain,
+      service: keychain.service,
+      account: keychain.account,
+      runCommand: keychain.runCommand?.bind(keychain),
+      ...lock === void 0 ? {} : { lock: { ...lock, fs: lock.fs, directory: lock.directory } }
+    } }
+  };
+}
+
+// packages/mcp-oauth/src/client/scope.ts
+function normalizeOAuthScope(scope) {
+  if (scope === void 0) return void 0;
+  if (typeof scope !== "string" || [...scope].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) > 126 || char === '"' || char === "\\"))
+    throw new Error("Invalid OAuth scope syntax");
+  const normalized = [...new Set(scope.split(" ").filter(Boolean))].sort().join(" ");
+  return normalized || void 0;
+}
+
+// packages/mcp-oauth/src/client/cancellable-operation.ts
+async function waitForOAuthOperation(operation, signal) {
+  if (signal === void 0) return operation;
+  let abort;
+  try {
+    return await new Promise((resolve, reject) => {
+      abort = () => reject(signal.reason);
+      signal.addEventListener("abort", abort, { once: true });
+      operation.then(resolve, reject);
+      if (signal.aborted) abort();
+    });
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+
+// packages/mcp-oauth/src/client/bounded-json.ts
+function copyBoundedOAuthJson(value, message) {
+  const invalid = () => new Error(message);
+  let nodes = 0;
+  function copy(input, depth) {
+    if (++nodes > 2e4 || depth > 64) throw invalid();
+    if (input === null || typeof input === "boolean" || typeof input === "string") return input;
+    if (typeof input === "number" && Number.isFinite(input)) return input;
+    if (typeof input !== "object" || input === null) throw invalid();
+    const descriptors = Object.getOwnPropertyDescriptors(input);
+    if (Array.isArray(input)) {
+      const length = descriptors.length?.value;
+      if (length > 2e4) throw invalid();
+      const result2 = [];
+      for (let index = 0; index < length; index++) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === void 0 || !Object.hasOwn(descriptor, "value")) throw invalid();
+        result2.push(copy(descriptor.value, depth + 1));
+      }
+      return result2;
+    }
+    if (Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null) throw invalid();
+    return Object.fromEntries(Object.entries(descriptors).filter(([, descriptor]) => descriptor.enumerable).map(([key2, descriptor]) => {
+      if (!Object.hasOwn(descriptor, "value")) throw invalid();
+      return [key2, copy(descriptor.value, depth + 1)];
+    }));
+  }
+  let result;
+  try {
+    result = copy(value, 0);
+  } catch {
+    throw invalid();
+  }
+  if (Buffer.byteLength(JSON.stringify(result), "utf8") > 64 * 1024) throw invalid();
+  return result;
+}
+
+// packages/mcp-oauth/src/client/loopback-authorization.ts
+import http from "node:http";
+
+// packages/mcp-oauth/src/client/authorization-state.ts
 import crypto from "node:crypto";
-import path2 from "node:path";
+function createAuthorizationState(input) {
+  const payload = {
+    v: 1,
+    n: crypto.randomBytes(16).toString("base64url"),
+    i: input.issuer,
+    r: input.requireIssuer
+  };
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+}
+function parseAuthorizationState(value) {
+  if (value === null || value.length === 0) {
+    return null;
+  }
+  try {
+    const decoded = Buffer.from(value, "base64url").toString("utf8");
+    const parsed = JSON.parse(decoded);
+    if (!isObjectRecord(parsed)) {
+      return null;
+    }
+    const version = getOwnEntry(parsed, "v");
+    const nonce = getOwnEntry(parsed, "n");
+    const issuer = getOwnEntry(parsed, "i");
+    const requireIssuer = getOwnEntry(parsed, "r");
+    if (version !== 1 || typeof nonce !== "string" || nonce.length === 0 || typeof issuer !== "string" || issuer.length === 0 || typeof requireIssuer !== "boolean") {
+      return null;
+    }
+    return {
+      issuer,
+      requireIssuer
+    };
+  } catch {
+    return null;
+  }
+}
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getOwnEntry(record2, key2) {
+  return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
+}
+
+// packages/mcp-oauth/src/client/loopback-authorization.ts
+var authorizationErrorBrand = /* @__PURE__ */ Symbol.for("poe-platform.mcp-oauth.OAuthAuthorizationError");
+var oauthCallbackParameters = ["code", "state", "iss", "error", "error_description", "error_uri"];
+function snapshotLoopbackAuthorizationOptions(options) {
+  return {
+    ...options,
+    openBrowser: options.openBrowser?.bind(options),
+    readLine: options.readLine?.bind(options),
+    createServer: options.createServer?.bind(options),
+    callbackPath: options.callbackPath,
+    redirectUri: options.redirectUri,
+    signal: options.signal,
+    timeoutMs: options.timeoutMs,
+    landingPage: options.landingPage === void 0 ? void 0 : { ...options.landingPage, title: options.landingPage.title, body: options.landingPage.body }
+  };
+}
+var OAuthAuthorizationError = class extends Error {
+  constructor(error, errorDescription) {
+    super(`OAuth authorization failed: ${error} \u2014 ${errorDescription}`);
+    this.error = error;
+    this.errorDescription = errorDescription;
+    this.name = "OAuthAuthorizationError";
+    Object.defineProperty(this, authorizationErrorBrand, { value: true });
+  }
+  error;
+  errorDescription;
+  /** Recognize errors from separately bundled copies of this package. */
+  static is(value) {
+    return value instanceof Error && Object.getOwnPropertyDescriptor(value, authorizationErrorBrand)?.value === true;
+  }
+};
+async function createLoopbackAuthorizationSession(options = {}) {
+  options = snapshotLoopbackAuthorizationOptions(options);
+  options.signal?.throwIfAborted();
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)
+    throw new Error("OAuth authorization timeoutMs must be a positive supported timer interval");
+  const target = loopbackTarget(options);
+  const server = options.createServer ? options.createServer() : http.createServer();
+  const controller = new AbortController();
+  let closed = false;
+  let used = false;
+  const callerAbort = () => controller.abort(options.signal?.reason);
+  const teardown = () => {
+    if (closed) return;
+    closed = true;
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", callerAbort);
+    server.closeAllConnections?.();
+    server.close();
+  };
+  const timer = setTimeout(() => controller.abort(new Error("OAuth authorization timed out")), timeoutMs);
+  timer.unref?.();
+  controller.signal.addEventListener("abort", teardown, { once: true });
+  options.signal?.addEventListener("abort", callerAbort, { once: true });
+  if (options.signal?.aborted) callerAbort();
+  let port;
+  try {
+    port = await startServer(server, target.port, target.host, controller.signal);
+  } catch (error) {
+    controller.abort(error);
+    throw error;
+  }
+  const redirectUri = options.redirectUri ?? `http://127.0.0.1:${port}${target.callbackPath}`;
+  return {
+    redirectUri,
+    async waitForCode(authorizationUrl) {
+      controller.signal.throwIfAborted();
+      if (used) throw new Error("OAuth authorization session has already been used");
+      used = true;
+      try {
+        return await waitForAuthorizationCode(server, authorizationUrl, options, target.callbackPath, controller.signal);
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+    close() {
+      controller.abort(new Error("OAuth authorization session closed"));
+    }
+  };
+}
+function loopbackTarget(options) {
+  if (options.redirectUri !== void 0) {
+    let url;
+    try {
+      url = new URL(options.redirectUri);
+    } catch (cause) {
+      throw new Error("Invalid OAuth loopback redirect URI", { cause });
+    }
+    if (url.protocol !== "http:" || !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) || url.username || url.password || url.href.includes("#") || url.port === "0" || oauthCallbackParameters.some((name) => url.searchParams.has(name)) || [...options.redirectUri].some((char) => char.codePointAt(0) <= 32) || options.callbackPath !== void 0 && options.callbackPath !== url.pathname)
+      throw new Error("Invalid OAuth loopback redirect URI");
+    return { port: url.port ? Number(url.port) : 80, host: url.hostname === "[::1]" ? "::1" : url.hostname, callbackPath: url.pathname };
+  }
+  const callbackPath = options.callbackPath ?? "/callback";
+  const parsed = new URL(callbackPath, "http://127.0.0.1");
+  if (!callbackPath.startsWith("/") || parsed.origin !== "http://127.0.0.1" || parsed.pathname !== callbackPath || parsed.search || parsed.hash)
+    throw new Error("Invalid OAuth loopback callback path");
+  return { port: 0, host: "127.0.0.1", callbackPath };
+}
+async function startServer(server, port, host, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      server.off("error", handleError);
+      signal.removeEventListener("abort", aborted);
+    };
+    const handleError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const aborted = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    server.once("error", handleError);
+    signal.addEventListener("abort", aborted, { once: true });
+    try {
+      server.listen(port, host, () => {
+        cleanup();
+        if (signal.aborted) {
+          server.close();
+          reject(signal.reason);
+          return;
+        }
+        const address = server.address();
+        if (address === null || typeof address === "string") {
+          reject(new Error("OAuth listener has no TCP address"));
+          return;
+        }
+        resolve(address.port);
+      });
+    } catch (error) {
+      cleanup();
+      reject(error);
+    }
+  });
+}
+function waitForAuthorizationCode(server, authorizationUrl, options, callbackPath, signal) {
+  signal.throwIfAborted();
+  const expectedAuthorization = readExpectedAuthorizationCallback(authorizationUrl);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      server.off("request", request);
+      signal.removeEventListener("abort", aborted);
+      fn();
+    };
+    const aborted = () => settle(() => reject(signal.reason));
+    const request = (req, res) => {
+      let url;
+      try {
+        url = new URL(req.url ?? "/", "http://127.0.0.1");
+      } catch {
+        res.writeHead(400);
+        res.end("Invalid callback URL");
+        return;
+      }
+      if (url.pathname !== callbackPath) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      try {
+        const callbackParameters = readAuthorizationCallbackParameters(url);
+        validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
+        if (callbackParameters.error !== null)
+          throw new OAuthAuthorizationError(callbackParameters.error, callbackParameters.errorDescription ?? callbackParameters.error);
+        const code = validateAuthorizationCallbackParameters(callbackParameters, expectedAuthorization);
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(buildSuccessPage(options.landingPage));
+        settle(() => resolve(code));
+      } catch (error) {
+        res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8", "X-Content-Type-Options": "nosniff" });
+        res.end(error instanceof Error ? error.message : "Invalid OAuth callback");
+        settle(() => reject(error));
+      }
+    };
+    server.on("request", request);
+    signal.addEventListener("abort", aborted, { once: true });
+    if (options.readLine !== void 0) {
+      void Promise.resolve().then(() => settled ? void 0 : options.readLine()).then((input) => {
+        if (settled) return;
+        const callbackParameters = extractCallbackParametersFromInput(input);
+        if (callbackParameters === null) throw new Error("OAuth callback missing authorization code");
+        validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
+        if (callbackParameters.error !== null)
+          throw new OAuthAuthorizationError(callbackParameters.error, callbackParameters.errorDescription ?? callbackParameters.error);
+        const code = validateAuthorizationCallbackParameters(callbackParameters, expectedAuthorization);
+        settle(() => resolve(code));
+      }).catch((error) => settle(() => reject(error)));
+    }
+    if (options.openBrowser !== void 0) {
+      void Promise.resolve().then(() => settled ? void 0 : options.openBrowser(authorizationUrl)).catch((error) => settle(() => reject(error)));
+    }
+  });
+}
+function extractCallbackParametersFromInput(input) {
+  const trimmed = input.replaceAll("\r", "").replaceAll("\n", "").trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  let url;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    return {
+      code: trimmed,
+      error: null,
+      errorDescription: null,
+      state: null,
+      iss: null
+    };
+  }
+  return readAuthorizationCallbackParameters(url);
+}
+function readAuthorizationCallbackParameters(url) {
+  for (const parameter of oauthCallbackParameters) {
+    if (url.searchParams.getAll(parameter).length > 1)
+      throw new Error(`OAuth callback parameter '${parameter}' must occur only once`);
+  }
+  return {
+    code: url.searchParams.get("code"),
+    error: url.searchParams.get("error"),
+    errorDescription: url.searchParams.get("error_description"),
+    state: url.searchParams.get("state"),
+    iss: url.searchParams.get("iss")
+  };
+}
+function readExpectedAuthorizationCallback(authorizationUrl) {
+  const url = new URL(authorizationUrl);
+  const state = url.searchParams.get("state");
+  const parsedState = parseAuthorizationState(state);
+  return {
+    state,
+    issuer: parsedState?.issuer ?? null,
+    requireIssuer: parsedState?.requireIssuer ?? false
+  };
+}
+function validateAuthorizationCallbackParameters(callback, expected) {
+  validateAuthorizationCallbackBinding(callback, expected);
+  if (callback.code === null || callback.code.length === 0) {
+    throw new Error("OAuth callback missing authorization code");
+  }
+  return callback.code;
+}
+function validateAuthorizationCallbackBinding(callback, expected) {
+  if (expected.state !== null) {
+    if (callback.state === null || callback.state.length === 0) {
+      throw new Error("OAuth callback missing state");
+    }
+    if (callback.state !== expected.state) {
+      throw new Error("OAuth callback state mismatch");
+    }
+  }
+  if (expected.requireIssuer) {
+    if (callback.iss === null || callback.iss.length === 0) {
+      throw new Error("OAuth callback missing issuer");
+    }
+  }
+  if (callback.iss !== null && callback.iss.length > 0 && expected.issuer !== null && callback.iss !== expected.issuer) {
+    throw new Error("OAuth callback issuer mismatch");
+  }
+}
+function escapeHtml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function buildSuccessPage(landingPage) {
+  const title = landingPage?.title ?? "Connected";
+  const body = landingPage?.body ?? "You can close this tab and return to your terminal.";
+  return [
+    "<!DOCTYPE html>",
+    `<html><head><meta charset=utf-8><title>${escapeHtml(title)}</title></head>`,
+    '<body style="font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0">',
+    '<div style="text-align:center">',
+    `<h1>${escapeHtml(title)}</h1>`,
+    `<p style="color:#666">${escapeHtml(body)}</p>`,
+    "</div></body></html>"
+  ].join("");
+}
+
+// packages/mcp-oauth/src/client/token-auth-method.ts
+function normalizeOAuthTokenEndpointAuthMethod(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (value !== "none" && value !== "client_secret_post" && value !== "client_secret_basic")
+    throw new Error("Unsupported OAuth token endpoint authentication method");
+  return value;
+}
+
+// packages/mcp-oauth/src/client/client-registration.ts
+function parseOAuthClientRegistration(value) {
+  const invalid = () => new Error("Invalid OAuth client registration metadata");
+  const result = copyBoundedOAuthJson(value, "Invalid OAuth client registration metadata");
+  if (typeof result !== "object" || result === null || Array.isArray(result)) throw invalid();
+  const record2 = result;
+  if (!Object.hasOwn(record2, "client_id") || typeof record2.client_id !== "string" || record2.client_id.trim() === "")
+    throw new Error("OAuth client registration response missing client_id");
+  for (const key2 of [
+    "client_id",
+    "client_secret",
+    "token_endpoint_auth_method",
+    "application_type",
+    "client_name",
+    "client_uri",
+    "logo_uri",
+    "scope",
+    "tos_uri",
+    "policy_uri",
+    "jwks_uri",
+    "software_id",
+    "software_version",
+    "software_statement",
+    "registration_access_token",
+    "registration_client_uri",
+    "issuer"
+  ]) {
+    if (Object.hasOwn(record2, key2) && record2[key2] !== null && typeof record2[key2] !== "string") throw invalid();
+  }
+  if (typeof record2.client_secret === "string" && record2.client_secret.trim() === "") throw invalid();
+  for (const key2 of ["redirect_uris", "grant_types", "response_types", "contacts"]) {
+    const entry = record2[key2];
+    if (Object.hasOwn(record2, key2) && entry !== null && (!Array.isArray(entry) || entry.some((item) => typeof item !== "string"))) throw invalid();
+  }
+  for (const key2 of ["client_id_issued_at", "client_secret_expires_at"]) {
+    const entry = record2[key2];
+    if (Object.hasOwn(record2, key2) && entry !== null && (typeof entry !== "number" || !Number.isSafeInteger(entry) || entry < 0)) throw invalid();
+  }
+  try {
+    normalizeOAuthScope(Object.hasOwn(record2, "scope") && record2.scope !== null ? record2.scope : void 0);
+  } catch {
+    throw invalid();
+  }
+  return record2;
+}
+function normalizeStoredOAuthClient(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record2 = value;
+  const clientId = Object.hasOwn(record2, "clientId") ? record2.clientId : void 0;
+  const clientSecret = Object.hasOwn(record2, "clientSecret") ? record2.clientSecret : void 0;
+  if (typeof clientId !== "string" || clientId.trim() === "" || clientSecret !== void 0 && (typeof clientSecret !== "string" || clientSecret.trim() === "")) return null;
+  const client = { clientId: clientId.trim(), ...clientSecret === void 0 ? {} : { clientSecret: clientSecret.trim() } };
+  const requestedRedirectUri = Object.hasOwn(record2, "requestedRedirectUri") ? record2.requestedRedirectUri : void 0;
+  if (requestedRedirectUri !== void 0) {
+    try {
+      if (typeof requestedRedirectUri !== "string") throw new Error("Invalid redirect identity");
+      loopbackTarget({ redirectUri: requestedRedirectUri });
+    } catch {
+      throw new Error("Invalid stored OAuth registration redirect identity");
+    }
+    client.requestedRedirectUri = requestedRedirectUri;
+  }
+  const method = normalizeOAuthTokenEndpointAuthMethod(Object.hasOwn(record2, "tokenEndpointAuthMethod") ? record2.tokenEndpointAuthMethod : void 0);
+  if (Object.hasOwn(record2, "registration") && record2.registration !== void 0) {
+    const registration = parseOAuthClientRegistration(record2.registration);
+    const registeredSecret = Object.hasOwn(registration, "client_secret") ? registration.client_secret?.trim() : void 0;
+    if (registration.client_id.trim() !== client.clientId || registeredSecret !== client.clientSecret)
+      throw new Error("OAuth client registration does not match the client identity");
+    client.registration = registration;
+    const registrationMethod = normalizeOAuthTokenEndpointAuthMethod(Object.hasOwn(registration, "token_endpoint_auth_method") ? registration.token_endpoint_auth_method : void 0);
+    if (method !== void 0 && registrationMethod !== void 0 && method !== registrationMethod)
+      throw new Error("OAuth token endpoint authentication conflicts with the client registration");
+    if (registrationMethod !== void 0) client.tokenEndpointAuthMethod = registrationMethod;
+  }
+  if (method !== void 0) client.tokenEndpointAuthMethod = method;
+  const ownership = Object.hasOwn(record2, "registrationOwnership") ? record2.registrationOwnership : void 0;
+  if (ownership !== void 0) {
+    if (ownership !== "caller" || client.registration === void 0)
+      throw new Error("Invalid stored OAuth registration ownership");
+    client.registrationOwnership = "caller";
+  }
+  return client;
+}
+function registrationMatchesRedirect(client, requestedUri, fresh = false) {
+  if (client.requestedRedirectUri !== void 0) return client.requestedRedirectUri === requestedUri;
+  const redirects = client.registration?.redirect_uris;
+  if (redirects === void 0 || redirects === null || redirects.length === 0) return true;
+  return redirects.some((returnedUri) => {
+    if (returnedUri === requestedUri) return true;
+    if (!fresh) return false;
+    let returned, requested;
+    try {
+      returned = new URL(returnedUri);
+      requested = new URL(requestedUri);
+    } catch {
+      return false;
+    }
+    if (requested.protocol !== "http:" || returned.protocol !== "http:" || !["127.0.0.1", "[::1]", "localhost"].includes(requested.hostname)) return false;
+    const sameHost = returned.hostname === requested.hostname;
+    const normalizedIpv4 = requested.hostname === "127.0.0.1" && returned.hostname === "localhost" && returned.port === "";
+    if (!sameHost && !normalizedIpv4) return false;
+    returned.hostname = requested.hostname;
+    returned.port = requested.port;
+    return returned.href === requested.href;
+  });
+}
+
+// packages/mcp-oauth/src/client/auth-store-session-store.ts
+import crypto2 from "node:crypto";
+import path4 from "node:path";
 
 // packages/auth-store/src/encrypted-file-store.ts
-import { createCipheriv, createDecipheriv, randomBytes, randomUUID, scrypt } from "node:crypto";
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID as randomUUID2, scrypt } from "node:crypto";
 import { promises as fs } from "node:fs";
 import { homedir, hostname, userInfo } from "node:os";
-import path from "node:path";
+import path2 from "node:path";
 
 // packages/auth-store/src/error-codes.ts
 function hasOwnErrorCode(error, code) {
   return error instanceof Error && Object.prototype.hasOwnProperty.call(error, "code") && error.code === code;
 }
 
+// packages/auth-store/src/transaction-lock.ts
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+async function withSecretStoreFileLock(fs2, lockDirectory, operation, options = {}) {
+  options = { ...options, signal: options.signal, timeoutMs: options.timeoutMs };
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 2147483647)
+    throw new Error("Invalid secret-store transaction lock timeout");
+  options.signal?.throwIfAborted();
+  const deadline = performance.now() + timeoutMs;
+  const directory = path.resolve(lockDirectory);
+  await assertLockDirectoryPath(fs2, directory);
+  await fs2.mkdir(directory, { recursive: true, mode: 448 });
+  await assertLockDirectoryPath(fs2, directory);
+  const name = `${process.pid}-${randomUUID()}.claim`;
+  const claimPath = path.join(directory, name);
+  const temporaryPath = `${claimPath}.tmp`;
+  let claimed = true;
+  let temporaryCreated = false;
+  let outcome;
+  try {
+    try {
+      await fs2.writeFile(claimPath, JSON.stringify({ ticket: null }), { encoding: "utf8", flag: "wx", mode: 384 });
+    } catch (error) {
+      if (hasOwnErrorCode(error, "EEXIST")) claimed = false;
+      throw error;
+    }
+    const existing = await readClaims(fs2, directory, name);
+    const ticket = existing.reduce((max, claim) => Math.max(max, claim.ticket ?? 0), 0) + 1;
+    if (!Number.isSafeInteger(ticket)) throw new Error("Secret-store transaction lock ticket overflow");
+    temporaryCreated = true;
+    try {
+      await fs2.writeFile(temporaryPath, JSON.stringify({ ticket }), { encoding: "utf8", flag: "wx", mode: 384 });
+    } catch (error) {
+      if (hasOwnErrorCode(error, "EEXIST")) temporaryCreated = false;
+      throw error;
+    }
+    await fs2.rename(temporaryPath, claimPath);
+    temporaryCreated = false;
+    for (; ; ) {
+      options.signal?.throwIfAborted();
+      const peers = await readClaims(fs2, directory, name);
+      if (!peers.some((peer) => peer.ticket === null || peer.ticket < ticket || peer.ticket === ticket && peer.name < name)) break;
+      const remaining = deadline - performance.now();
+      if (remaining <= 0) throw new Error("Timed out waiting for secret-store transaction lock");
+      await new Promise((resolve, reject) => {
+        const abort = () => {
+          clearTimeout(timer);
+          options.signal?.removeEventListener("abort", abort);
+          reject(options.signal?.reason);
+        };
+        const timer = setTimeout(() => {
+          options.signal?.removeEventListener("abort", abort);
+          resolve();
+        }, Math.min(10, remaining));
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted) abort();
+      });
+    }
+    options.signal?.throwIfAborted();
+    outcome = { result: await operation() };
+  } catch (error) {
+    outcome = { error };
+  }
+  const cleanup = [];
+  for (const target of [...temporaryCreated ? [temporaryPath] : [], ...claimed ? [claimPath] : []]) {
+    try {
+      await fs2.unlink(target);
+    } catch (error) {
+      if (!hasOwnErrorCode(error, "ENOENT")) cleanup.push(error);
+    }
+  }
+  if (cleanup.length) throw new AggregateError([..."error" in outcome ? [outcome.error] : [], ...cleanup], "Secret-store transaction lock cleanup failed");
+  if ("error" in outcome) throw outcome.error;
+  return outcome.result;
+}
+async function assertNoSymbolicLink(fs2, target) {
+  try {
+    if ((await fs2.lstat(target)).isSymbolicLink()) throw new Error("Refusing secret-store transaction lock through symbolic link");
+  } catch (error) {
+    if (!hasOwnErrorCode(error, "ENOENT")) throw error;
+  }
+}
+async function assertLockDirectoryPath(fs2, directory) {
+  const root = path.parse(directory).root;
+  const segments = directory.slice(root.length).split(path.sep).filter(Boolean);
+  let current = root;
+  for (const [index, segment] of segments.entries()) {
+    current = path.join(current, segment);
+    if (index > 0 || segments.length === 1) await assertNoSymbolicLink(fs2, current);
+  }
+}
+async function readClaims(fs2, directory, ownName) {
+  const claims = [];
+  for (const name of await fs2.readdir(directory)) {
+    if (name === ownName || !name.endsWith(".claim")) continue;
+    const pidText = name.slice(0, name.indexOf("-"));
+    const pid = Number(pidText);
+    if (!Number.isSafeInteger(pid) || pid < 1 || String(pid) !== pidText) throw new Error("Malformed secret-store transaction lock owner");
+    const target = path.join(directory, name);
+    await assertNoSymbolicLink(fs2, target);
+    let alive = true;
+    try {
+      process.kill(pid, 0);
+    } catch (error) {
+      alive = !hasOwnErrorCode(error, "ESRCH");
+    }
+    if (!alive) {
+      try {
+        await fs2.unlink(target);
+      } catch (error) {
+        if (!hasOwnErrorCode(error, "ENOENT")) throw error;
+      }
+      continue;
+    }
+    let ticket = null;
+    let raw;
+    try {
+      raw = await fs2.readFile(target, "utf8");
+    } catch (error) {
+      if (hasOwnErrorCode(error, "ENOENT")) continue;
+      throw error;
+    }
+    try {
+      const value = JSON.parse(raw);
+      if (value !== null && typeof value === "object" && "ticket" in value && typeof value.ticket === "number" && Number.isSafeInteger(value.ticket) && value.ticket > 0) ticket = value.ticket;
+    } catch {
+    }
+    claims.push({ name, ticket });
+  }
+  return claims;
+}
+
 // packages/auth-store/src/encrypted-file-store.ts
 var derivedKeyCache = /* @__PURE__ */ new Map();
 var ENCRYPTION_ALGORITHM = "aes-256-gcm";
@@ -3546,6 +4219,7 @@ var EncryptedFileStore = class {
   getMachineIdentity;
   getRandomBytes;
   keyPromise = null;
+  throwOnInvalidDocument;
   constructor(input) {
     this.fs = input.fs ?? fs;
     this.salt = input.salt;
@@ -3555,7 +4229,7 @@ var EncryptedFileStore = class {
       const defaultFileName = input.defaultFileName ?? "credentials.enc";
       assertSafeDefaultDirectory(defaultDirectory);
       assertSafeDefaultFileName(defaultFileName);
-      this.filePath = path.join(
+      this.filePath = path2.join(
         homeDirectory,
         defaultDirectory,
         defaultFileName
@@ -3570,6 +4244,7 @@ var EncryptedFileStore = class {
     }
     this.getMachineIdentity = input.getMachineIdentity ?? defaultMachineIdentity;
     this.getRandomBytes = input.getRandomBytes ?? randomBytes;
+    this.throwOnInvalidDocument = input.throwOnInvalidDocument ?? false;
   }
   async get() {
     await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
@@ -3584,6 +4259,7 @@ var EncryptedFileStore = class {
     }
     const document = parseEncryptedDocument(rawDocument);
     if (!document) {
+      if (this.throwOnInvalidDocument) throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
       return null;
     }
     const key2 = await this.getEncryptionKey();
@@ -3592,6 +4268,7 @@ var EncryptedFileStore = class {
       const authTag = Buffer.from(document.authTag, "base64");
       const ciphertext = Buffer.from(document.ciphertext, "base64");
       if (iv.byteLength !== ENCRYPTION_IV_BYTES || authTag.byteLength !== ENCRYPTION_AUTH_TAG_BYTES) {
+        if (this.throwOnInvalidDocument) throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
         return null;
       }
       const decipher = createDecipheriv(ENCRYPTION_ALGORITHM, key2, iv);
@@ -3599,9 +4276,16 @@ var EncryptedFileStore = class {
       const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
       return plaintext.toString("utf8");
     } catch {
+      if (this.throwOnInvalidDocument) throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
       return null;
     }
   }
+  async withLock(operation, options = {}) {
+    options = { ...options, signal: options.signal, timeoutMs: options.timeoutMs };
+    await this.assertCredentialPathHasNoSymbolicLinks(`${this.filePath}.lock`);
+    if (this.fs.readdir === void 0) throw new Error("Secret-store transaction locks require filesystem readdir support");
+    return withSecretStoreFileLock(this.fs, `${this.filePath}.lock`, operation, options);
+  }
   async set(value) {
     await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
     const key2 = await this.getEncryptionKey();
@@ -3618,9 +4302,9 @@ var EncryptedFileStore = class {
       authTag: authTag.toString("base64"),
       ciphertext: ciphertext.toString("base64")
     };
-    await this.fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    await this.fs.mkdir(path2.dirname(this.filePath), { recursive: true });
     await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
-    const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID()}.tmp`;
+    const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID2()}.tmp`;
     let temporaryCreated = false;
     try {
       await this.assertCredentialPathHasNoSymbolicLinks(temporaryPath);
@@ -3650,7 +4334,7 @@ var EncryptedFileStore = class {
     }
   }
   async assertCredentialPathHasNoSymbolicLinks(targetPath) {
-    const resolvedPath = path.resolve(targetPath);
+    const resolvedPath = path2.resolve(targetPath);
     const protectedPaths = getProtectedCredentialPaths(
       resolvedPath,
       this.symbolicLinkCheckStartPath
@@ -3684,26 +4368,26 @@ var EncryptedFileStore = class {
 };
 function resolveDefaultDirectoryCheckStart(homeDirectory, defaultDirectory) {
   const [firstSegment] = defaultDirectory.split(/[\\/]+/).filter(Boolean);
-  return path.resolve(homeDirectory, firstSegment ?? ".");
+  return path2.resolve(homeDirectory, firstSegment ?? ".");
 }
 function getProtectedCredentialPaths(resolvedPath, symbolicLinkCheckStartPath) {
   if (symbolicLinkCheckStartPath === null) {
     return getExplicitProtectedCredentialPaths(resolvedPath);
   }
-  const resolvedStartPath = path.resolve(symbolicLinkCheckStartPath);
+  const resolvedStartPath = path2.resolve(symbolicLinkCheckStartPath);
   if (!isPathInsideOrEqual(resolvedPath, resolvedStartPath)) {
-    return [path.dirname(resolvedPath), resolvedPath];
+    return [path2.dirname(resolvedPath), resolvedPath];
   }
   const protectedPaths = [resolvedStartPath];
   let currentPath = resolvedStartPath;
-  for (const segment of path.relative(resolvedStartPath, resolvedPath).split(path.sep).filter(Boolean)) {
-    currentPath = path.join(currentPath, segment);
+  for (const segment of path2.relative(resolvedStartPath, resolvedPath).split(path2.sep).filter(Boolean)) {
+    currentPath = path2.join(currentPath, segment);
     protectedPaths.push(currentPath);
   }
   return protectedPaths;
 }
 function assertSafeDefaultDirectory(defaultDirectory) {
-  if (path.isAbsolute(defaultDirectory) || path.win32.isAbsolute(defaultDirectory)) {
+  if (path2.isAbsolute(defaultDirectory) || path2.win32.isAbsolute(defaultDirectory)) {
     throw new Error("defaultDirectory must be a relative path inside the home directory");
   }
   for (const segment of splitPathSegments(defaultDirectory)) {
@@ -3721,15 +4405,15 @@ function splitPathSegments(value) {
   return value.split("/").flatMap((segment) => segment.split("\\")).filter((segment) => segment.length > 0);
 }
 function getExplicitProtectedCredentialPaths(resolvedPath) {
-  const parsed = path.parse(resolvedPath);
-  const segments = resolvedPath.slice(parsed.root.length).split(path.sep).filter((segment) => segment.length > 0);
+  const parsed = path2.parse(resolvedPath);
+  const segments = resolvedPath.slice(parsed.root.length).split(path2.sep).filter((segment) => segment.length > 0);
   if (segments.length <= 1) {
     return [resolvedPath];
   }
   const protectedPaths = [];
   let currentPath = parsed.root;
   for (const [index, segment] of segments.entries()) {
-    currentPath = path.join(currentPath, segment);
+    currentPath = path2.join(currentPath, segment);
     if (index === 0) {
       continue;
     }
@@ -3738,8 +4422,8 @@ function getExplicitProtectedCredentialPaths(resolvedPath) {
   return protectedPaths;
 }
 function isPathInsideOrEqual(childPath, parentPath) {
-  const relativePath = path.relative(parentPath, childPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+  const relativePath = path2.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
 }
 async function removeIfPresent(fileSystem, filePath) {
   try {
@@ -3787,10 +4471,10 @@ function parseEncryptedDocument(raw) {
     if (!isRecord2(parsed)) {
       return null;
     }
-    const version = getOwnEntry(parsed, "version");
-    const iv = getOwnEntry(parsed, "iv");
-    const authTag = getOwnEntry(parsed, "authTag");
-    const ciphertext = getOwnEntry(parsed, "ciphertext");
+    const version = getOwnEntry2(parsed, "version");
+    const iv = getOwnEntry2(parsed, "iv");
+    const authTag = getOwnEntry2(parsed, "authTag");
+    const ciphertext = getOwnEntry2(parsed, "ciphertext");
     if (version !== ENCRYPTION_VERSION) {
       return null;
     }
@@ -3810,7 +4494,7 @@ function parseEncryptedDocument(raw) {
 function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function getOwnEntry(record2, key2) {
+function getOwnEntry2(record2, key2) {
   return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
 }
 function isNotFoundError(error) {
@@ -3822,16 +4506,24 @@ function isAlreadyExistsError(error) {
 
 // packages/auth-store/src/keychain-store.ts
 import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { promises as nodeFs } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import path3 from "node:path";
 var SECURITY_CLI = "security";
 var KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE = 44;
 var KeychainStore = class {
   runCommand;
   service;
   account;
+  lockFs;
+  lockDirectory;
   constructor(input) {
     this.runCommand = input.runCommand ?? runSecurityCommand;
     this.service = input.service.trim();
     this.account = input.account.trim();
+    this.lockFs = input.lock?.fs ?? nodeFs;
+    this.lockDirectory = input.lock?.directory ?? path3.join(homedir2(), ".auth-store", "keychain-locks");
     if (this.service.length === 0) {
       throw new Error("Keychain service must not be empty");
     }
@@ -3852,6 +4544,10 @@ var KeychainStore = class {
     }
     throw createSecurityCliFailure("read secret from macOS Keychain", result);
   }
+  async withLock(operation, options = {}) {
+    const identity = createHash("sha256").update(JSON.stringify([this.service, this.account])).digest("hex");
+    return withSecretStoreFileLock(this.lockFs, path3.join(this.lockDirectory, identity), operation, options);
+  }
   async set(value) {
     if (value.includes("\n") || value.includes("\r")) {
       throw new Error("Keychain secrets cannot contain line breaks");
@@ -3970,14 +4666,14 @@ function createSecurityCliFailure(operation, result) {
   return new Error(`Failed to ${operation}: security exited with code ${exitCode}`);
 }
 function getCommandExitCode(result) {
-  const value = getOwnEntry2(result, "exitCode");
+  const value = getOwnEntry3(result, "exitCode");
   return typeof value === "number" && Number.isInteger(value) ? value : 1;
 }
 function getCommandOutput(result, key2) {
-  const value = getOwnEntry2(result, key2);
+  const value = getOwnEntry3(result, key2);
   return typeof value === "string" ? value : "";
 }
-function getOwnEntry2(record2, key2) {
+function getOwnEntry3(record2, key2) {
   return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
 }
 
@@ -3999,7 +4695,7 @@ var storeFactories = {
   }
 };
 function createSecretStore(input) {
-  const backend = resolveBackend(input);
+  const backend = resolveSecretStoreBackend(input);
   const platform = input.platform ?? process.platform;
   if (backend === "keychain" && platform !== MACOS_PLATFORM) {
     throw new Error(
@@ -4009,7 +4705,7 @@ function createSecretStore(input) {
   const store = storeFactories[backend](input);
   return { backend, store };
 }
-function resolveBackend(input) {
+function resolveSecretStoreBackend(input) {
   const envVar = input.backendEnvVar ?? DEFAULT_BACKEND_ENV_VAR;
   const configuredBackend = input.backend ?? getOwnEnvValue(input.env, envVar) ?? getOwnEnvValue(process.env, envVar);
   const backend = configuredBackend?.trim();
@@ -4045,66 +4741,86 @@ var DEFAULT_CLIENT_FILE_SALT = "poe-code:mcp-oauth:clients:v1";
 var DEFAULT_CLIENT_FILE_DIRECTORY = ".poe-code/mcp-oauth/clients";
 var DEFAULT_CLIENT_KEYCHAIN_SERVICE = "poe-code-mcp-oauth-clients";
 var MAX_JS_DATE_MS = 864e13;
-function createAuthStoreSessionStore(options = {}) {
+function createAuthStoreSessionStore(options = {}, namespace) {
+  assertPersistenceNamespace(namespace);
+  options = snapshotPersistenceOptions(options);
   return {
+    async withLock(resource, operation, lockOptions) {
+      const store = createResourceSecretStore(resource, options, namespace);
+      if (store.withLock === void 0) throw new Error("OAuth secret-store backend does not support transaction locks");
+      return store.withLock(operation, lockOptions);
+    },
     async load(resource) {
-      const store = createResourceSecretStore(resource, options);
+      const store = createResourceSecretStore(resource, options, namespace);
       const value = await store.get();
       if (value === null) {
         return null;
       }
-      const parsed = JSON.parse(value);
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        throw new Error("Stored OAuth session must be valid JSON; reset the store explicitly to recover");
+      }
       if (isStoredOAuthSession(parsed)) {
         return parsed;
       }
       throw new Error("Stored OAuth session must match the expected shape");
     },
     async save(resource, session) {
-      const store = createResourceSecretStore(resource, options);
+      const store = createResourceSecretStore(resource, options, namespace);
       await store.set(JSON.stringify(session));
     },
     async clear(resource) {
-      const store = createResourceSecretStore(resource, options);
+      const store = createResourceSecretStore(resource, options, namespace);
       await store.delete();
     }
   };
 }
-function createAuthStoreClientStore(options) {
+function createAuthStoreClientStore(options, namespace) {
+  assertPersistenceNamespace(namespace);
+  options = snapshotPersistenceOptions(options);
   return {
     async load(issuer) {
-      const store = createIssuerSecretStore(issuer, options);
+      const store = createIssuerSecretStore(issuer, options, namespace);
       const value = await store.get();
       if (value === null) {
         return null;
       }
-      const parsed = JSON.parse(value);
-      const clientId = isObjectRecord(parsed) ? getOwnString(parsed, "clientId") : void 0;
-      if (clientId !== void 0) {
-        const client = { clientId };
-        if (isObjectRecord(parsed) && Object.prototype.hasOwnProperty.call(parsed, "clientSecret")) {
-          client.clientSecret = getOwnEntry3(parsed, "clientSecret");
-        }
-        return client;
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        throw new Error("Stored OAuth client must be valid JSON; reset the store explicitly to recover");
       }
+      if (isObjectRecord2(parsed) && typeof getOwnEntry4(parsed, "clientId") === "string")
+        return parsed;
       throw new Error("Stored OAuth client must be a JSON object with clientId");
     },
     async save(issuer, client) {
-      const store = createIssuerSecretStore(issuer, options);
+      const store = createIssuerSecretStore(issuer, options, namespace);
       await store.set(JSON.stringify(client));
     },
     async clear(issuer) {
-      const store = createIssuerSecretStore(issuer, options);
+      const store = createIssuerSecretStore(issuer, options, namespace);
       await store.delete();
     }
   };
 }
-function createNamedSecretStore(key2, options, defaults) {
-  const hash = crypto.createHash("sha256").update(key2).digest("hex");
+function snapshotPersistenceOptions(options) {
+  const snapshot = snapshotOAuthPersistenceOptions(options);
+  snapshot.backend = resolveSecretStoreBackend(snapshot);
+  return snapshot;
+}
+function createNamedSecretStore(key2, options, defaults, namespace) {
+  options = snapshotOAuthPersistenceOptions(options);
+  const hash = crypto2.createHash("sha256").update(namespace === void 0 ? key2 : JSON.stringify([namespace, key2])).digest("hex");
   const configuredFilePath = options.fileStore?.filePath;
-  const parsedFilePath = configuredFilePath === void 0 ? null : path2.parse(configuredFilePath);
+  const parsedFilePath = configuredFilePath === void 0 ? null : path4.parse(configuredFilePath);
   const fileStore = {
     ...options.fileStore,
-    filePath: parsedFilePath === null ? void 0 : path2.join(
+    throwOnInvalidDocument: true,
+    filePath: parsedFilePath === null ? void 0 : path4.join(
       parsedFilePath.dir,
       `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`
     ),
@@ -4119,70 +4835,67 @@ function createNamedSecretStore(key2, options, defaults) {
   };
   return createSecretStore({ ...options, fileStore, keychainStore }).store;
 }
-function createResourceSecretStore(resource, options) {
+function createResourceSecretStore(resource, options, namespace) {
   return createNamedSecretStore(canonicalizeResourceIndicator(resource), options, {
     salt: DEFAULT_FILE_SALT,
     directory: DEFAULT_FILE_DIRECTORY,
     service: DEFAULT_KEYCHAIN_SERVICE,
     accountPrefix: "provider"
-  });
+  }, namespace);
 }
-function createIssuerSecretStore(issuer, options) {
+function createIssuerSecretStore(issuer, options, namespace) {
   return createNamedSecretStore(issuer, options, {
     salt: DEFAULT_CLIENT_FILE_SALT,
     directory: DEFAULT_CLIENT_FILE_DIRECTORY,
     service: DEFAULT_CLIENT_KEYCHAIN_SERVICE,
     accountPrefix: "issuer"
-  });
+  }, namespace);
 }
-function isObjectRecord(value) {
+function assertPersistenceNamespace(namespace) {
+  if (namespace !== void 0 && (typeof namespace !== "string" || namespace.trim() === "" || Buffer.byteLength(namespace, "utf8") > 1024))
+    throw new Error("OAuth persistence namespace must be a nonempty string within 1024 bytes");
+}
+function isObjectRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function getOwnEntry3(record2, key2) {
+function getOwnEntry4(record2, key2) {
   return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
 }
 function getOwnString(record2, key2) {
-  const value = getOwnEntry3(record2, key2);
+  const value = getOwnEntry4(record2, key2);
   return typeof value === "string" ? value : void 0;
 }
 function isStoredOAuthSession(value) {
-  if (!isObjectRecord(value)) {
-    return false;
-  }
-  return isNonBlankOwnString(value, "resource") && isNonBlankOwnString(value, "authorizationServer") && isStoredOAuthClient(getOwnEntry3(value, "client")) && isStoredOAuthDiscovery(getOwnEntry3(value, "discovery")) && isStoredOAuthTokensOrMissing(getOwnEntry3(value, "tokens"));
-}
-function isStoredOAuthClient(value) {
-  if (!isObjectRecord(value) || !isNonBlankOwnString(value, "clientId")) {
+  if (!isObjectRecord2(value)) {
     return false;
   }
-  const clientSecret = getOwnEntry3(value, "clientSecret");
-  return clientSecret === void 0 || typeof clientSecret === "string" && clientSecret.trim().length > 0;
+  return isNonBlankOwnString(value, "resource") && isNonBlankOwnString(value, "authorizationServer") && normalizeStoredOAuthClient(getOwnEntry4(value, "client")) !== null && isStoredOAuthDiscovery(getOwnEntry4(value, "discovery")) && (getOwnEntry4(value, "requestedScope") === void 0 || isNonBlankOwnString(value, "requestedScope")) && (getOwnEntry4(value, "refreshState") === void 0 || getOwnEntry4(value, "refreshState") === "pending" && getOwnEntry4(value, "tokens") === void 0) && isStoredOAuthTokensOrMissing(getOwnEntry4(value, "tokens"));
 }
 function isStoredOAuthDiscovery(value) {
-  if (!isObjectRecord(value)) {
+  if (!isObjectRecord2(value)) {
     return false;
   }
-  return isNonBlankOwnString(value, "resourceMetadataUrl") && isObjectRecord(getOwnEntry3(value, "resourceMetadata")) && isObjectRecord(getOwnEntry3(value, "authorizationServerMetadata"));
+  return isNonBlankOwnString(value, "resourceMetadataUrl") && isObjectRecord2(getOwnEntry4(value, "resourceMetadata")) && isObjectRecord2(getOwnEntry4(value, "authorizationServerMetadata"));
 }
 function isStoredOAuthTokensOrMissing(value) {
   if (value === void 0) {
     return true;
   }
-  if (!isObjectRecord(value)) {
+  if (!isObjectRecord2(value)) {
     return false;
   }
   if (!isNonBlankOwnString(value, "accessToken") || getOwnString(value, "tokenType") !== "Bearer") {
     return false;
   }
-  const expiresAt = getOwnEntry3(value, "expiresAt");
+  const expiresAt = getOwnEntry4(value, "expiresAt");
   if (expiresAt !== null && (typeof expiresAt !== "number" || !Number.isSafeInteger(expiresAt) || expiresAt > MAX_JS_DATE_MS || !Number.isFinite(new Date(expiresAt).getTime()))) {
     return false;
   }
-  const refreshToken = getOwnEntry3(value, "refreshToken");
+  const refreshToken = getOwnEntry4(value, "refreshToken");
   if (refreshToken !== void 0 && (typeof refreshToken !== "string" || refreshToken.trim().length === 0)) {
     return false;
   }
-  const scope = getOwnEntry3(value, "scope");
+  const scope = getOwnEntry4(value, "scope");
   return scope === void 0 || typeof scope === "string" && scope.trim().length > 0;
 }
 function isNonBlankOwnString(record2, key2) {
@@ -4190,263 +4903,215 @@ function isNonBlankOwnString(record2, key2) {
   return value !== void 0 && value.trim().length > 0;
 }
 
-// packages/mcp-oauth/src/client/default-oauth-client-provider.ts
-import { isIP } from "node:net";
-
-// packages/mcp-oauth/src/http-fetch.ts
-async function fetchMcpResponse(fetchImplementation, input, init = {}) {
-  const response = await fetchImplementation(input, { ...init, redirect: "error" });
-  if (response.redirected || response.type === "opaqueredirect") {
-    void response.body?.cancel().catch(() => void 0);
-    throw new Error("MCP HTTP redirects are not allowed");
-  }
-  return response;
-}
-
-// packages/mcp-oauth/src/client/default-oauth-client-provider.ts
-import { URL as URL2 } from "node:url";
-
-// packages/mcp-oauth/src/client/loopback-authorization.ts
-import http from "node:http";
-
-// packages/mcp-oauth/src/client/authorization-state.ts
-import crypto2 from "node:crypto";
-function createAuthorizationState(input) {
-  const payload = {
-    v: 1,
-    n: crypto2.randomBytes(16).toString("base64url"),
-    i: input.issuer,
-    r: input.requireIssuer
+// packages/mcp-oauth/src/client/resource-bound-store.ts
+function createResourceBoundOAuthStores(options, namespace, identity) {
+  assertPersistenceNamespace(identity);
+  assertPersistenceNamespace(namespace);
+  const store = createNamedSecretStore(identity, options, {
+    salt: "poe-code:mcp-oauth:resources:v1",
+    directory: ".poe-code/mcp-oauth/resources",
+    service: "poe-code-mcp-oauth-resources",
+    accountPrefix: "resource"
+  }, namespace);
+  const result = {
+    initialGrantAllowed: true,
+    sessionStore: {},
+    clientStore: {},
+    async reset(resource, options2 = {}) {
+      options2.signal?.throwIfAborted();
+      let url;
+      try {
+        url = new URL(resource);
+      } catch {
+        throw new Error("OAuth reset resource must be an absolute HTTP URL");
+      }
+      if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.href.includes("#"))
+        throw new Error("OAuth reset resource must be an HTTP URL without credentials or fragment");
+      await replace({ version: 1, resource: canonicalizeResourceIndicator(url), generation: 1, session: null, clients: {} }, options2);
+    },
+    async importSession(value, options2 = {}) {
+      options2.signal?.throwIfAborted();
+      const session = copyBoundedOAuthJson(value, "Invalid OAuth import session");
+      try {
+        if (!isStoredOAuthSession(session) || session.tokens === void 0 || session.refreshState !== void 0)
+          throw new Error("Invalid session");
+        if (typeof session.discovery.resourceMetadata.resource !== "string") throw new Error("Invalid resource metadata");
+        const resource = new URL(session.resource), issuer = new URL(session.authorizationServer), advertisedResource = new URL(session.discovery.resourceMetadata.resource);
+        if ([resource, issuer, advertisedResource].some((url) => !["http:", "https:"].includes(url.protocol) || url.username || url.password || url.href.includes("#")) || issuer.href.includes("?") || session.discovery.authorizationServerMetadata.issuer !== session.authorizationServer || canonicalizeResourceIndicator(advertisedResource) !== canonicalizeResourceIndicator(resource))
+          throw new Error("Invalid binding");
+        session.client = normalizeStoredOAuthClient(session.client);
+        if (session.client.registration !== void 0) session.client.registrationOwnership = "caller";
+        if (session.client.registration?.issuer !== void 0 && session.client.registration.issuer !== null && session.client.registration.issuer !== session.authorizationServer) throw new Error("Invalid registration issuer");
+        new Headers({ Authorization: `Bearer ${session.tokens.accessToken}` });
+        session.resource = canonicalizeResourceIndicator(resource);
+      } catch {
+        throw new Error("Invalid OAuth import session or resource binding");
+      }
+      await replace({
+        version: 1,
+        resource: session.resource,
+        generation: 1,
+        session,
+        clients: { [session.authorizationServer]: session.client }
+      }, options2);
+    }
   };
-  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
-}
-function parseAuthorizationState(value) {
-  if (value === null || value.length === 0) {
-    return null;
-  }
-  try {
-    const decoded = Buffer.from(value, "base64url").toString("utf8");
-    const parsed = JSON.parse(decoded);
-    if (!isObjectRecord2(parsed)) {
-      return null;
+  async function replace(record2, options2) {
+    options2 = { ...options2, signal: options2.signal, timeoutMs: options2.timeoutMs };
+    options2.signal?.throwIfAborted();
+    const timeoutMs = options2.timeoutMs ?? 3e4;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)
+      throw new Error("OAuth replacement timeoutMs must be a positive supported timer interval");
+    if (store.withLock === void 0) throw new Error("OAuth resource identity backend must support transaction locks");
+    await store.withLock(async () => {
+      options2.signal?.throwIfAborted();
+      await store.set(JSON.stringify(record2));
+      result.initialGrantAllowed = false;
+    }, { signal: options2.signal, timeoutMs });
+  }
+  async function read() {
+    const raw = await store.get();
+    if (raw === null) return null;
+    let value;
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      throw new Error("Stored OAuth resource identity must be valid JSON; reset explicitly to recover");
     }
-    const version = getOwnEntry4(parsed, "v");
-    const nonce = getOwnEntry4(parsed, "n");
-    const issuer = getOwnEntry4(parsed, "i");
-    const requireIssuer = getOwnEntry4(parsed, "r");
-    if (version !== 1 || typeof nonce !== "string" || nonce.length === 0 || typeof issuer !== "string" || issuer.length === 0 || typeof requireIssuer !== "boolean") {
-      return null;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Invalid stored OAuth resource identity");
+    const record2 = value;
+    if (!["version", "resource", "generation", "session", "clients"].every((key2) => Object.hasOwn(record2, key2)) || record2.version !== 1 || typeof record2.resource !== "string" || record2.resource !== canonicalizeResourceIndicator(record2.resource) || !Number.isSafeInteger(record2.generation) || record2.generation < 0 || record2.session !== null && (!isStoredOAuthSession(record2.session) || record2.session.resource !== record2.resource) || typeof record2.clients !== "object" || record2.clients === null || Array.isArray(record2.clients))
+      throw new Error("Invalid stored OAuth resource identity; reset explicitly to recover");
+    let resourceUrl;
+    try {
+      resourceUrl = new URL(record2.resource);
+    } catch {
+      throw new Error("Invalid stored OAuth resource identity URL");
     }
-    return {
-      issuer,
-      requireIssuer
-    };
-  } catch {
-    return null;
-  }
-}
-function isObjectRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function getOwnEntry4(record2, key2) {
-  return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
-}
-
-// packages/mcp-oauth/src/client/loopback-authorization.ts
-async function createLoopbackAuthorizationSession(options = {}) {
-  const callbackPath = options.callbackPath ?? "/callback";
-  const server = options.createServer ? options.createServer() : http.createServer();
-  const port = await startServer(server);
-  const redirectUri = `http://127.0.0.1:${port}${callbackPath}`;
-  return {
-    redirectUri,
-    async waitForCode(authorizationUrl) {
-      return waitForAuthorizationCode(server, authorizationUrl, options, callbackPath);
+    if (!["http:", "https:"].includes(resourceUrl.protocol) || resourceUrl.username || resourceUrl.password || resourceUrl.href.includes("#"))
+      throw new Error("Invalid stored OAuth resource identity URL");
+    for (const [issuer, client] of Object.entries(record2.clients)) {
+      const normalized = normalizeStoredOAuthClient(client);
+      let url;
+      try {
+        url = new URL(issuer);
+      } catch {
+        throw new Error("Invalid stored OAuth resource client issuer");
+      }
+      if (normalized === null || !["http:", "https:"].includes(url.protocol) || url.username || url.password || url.href.includes("?") || url.href.includes("#"))
+        throw new Error("Invalid stored OAuth resource client");
+      Object.defineProperty(record2.clients, issuer, { value: normalized, enumerable: true, configurable: true, writable: true });
+    }
+    return record2;
+  }
+  async function reconcile(resource) {
+    resource = canonicalizeResourceIndicator(resource);
+    const existing = await read();
+    if (existing?.resource === resource) {
+      result.initialGrantAllowed = existing.generation === 0;
+      return existing;
+    }
+    const record2 = { version: 1, resource, generation: existing === null ? 0 : existing.generation + 1, session: null, clients: {} };
+    if (!Number.isSafeInteger(record2.generation)) throw new Error("OAuth resource identity generation limit exceeded");
+    await store.set(JSON.stringify(record2));
+    result.initialGrantAllowed = record2.generation === 0;
+    return record2;
+  }
+  result.sessionStore = {
+    async withLock(resource, operation, options2) {
+      options2 = { ...options2, signal: options2?.signal, timeoutMs: options2?.timeoutMs };
+      if (store.withLock === void 0) throw new Error("OAuth resource identity backend must support transaction locks");
+      return store.withLock(async () => {
+        options2.signal?.throwIfAborted();
+        await reconcile(resource);
+        options2.signal?.throwIfAborted();
+        return operation();
+      }, options2);
     },
-    close() {
-      server.closeAllConnections?.();
-      server.close();
+    async load(resource) {
+      const record2 = await read();
+      return record2?.resource === canonicalizeResourceIndicator(resource) ? record2.session : null;
+    },
+    async save(resource, session) {
+      const record2 = await reconcile(resource);
+      if (canonicalizeResourceIndicator(session.resource) !== record2.resource) throw new Error("OAuth session does not match its resource identity");
+      record2.session = session;
+      await store.set(JSON.stringify(record2));
+    },
+    async clear(resource) {
+      const record2 = await reconcile(resource);
+      record2.session = null;
+      record2.generation = Math.max(1, record2.generation);
+      result.initialGrantAllowed = false;
+      await store.set(JSON.stringify(record2));
     }
   };
+  result.clientStore = {
+    async load(issuer) {
+      const record2 = await read();
+      return record2 !== null && Object.hasOwn(record2.clients, issuer) ? record2.clients[issuer] : null;
+    },
+    async save(issuer, client) {
+      const record2 = await read();
+      if (record2 === null) throw new Error("OAuth resource identity must be bound before registering a client");
+      Object.defineProperty(record2.clients, issuer, { value: client, enumerable: true, configurable: true, writable: true });
+      await store.set(JSON.stringify(record2));
+    },
+    async clear(issuer) {
+      const record2 = await read();
+      if (record2 === null || !Object.hasOwn(record2.clients, issuer)) return;
+      delete record2.clients[issuer];
+      await store.set(JSON.stringify(record2));
+    }
+  };
+  return result;
 }
-async function startServer(server) {
-  return new Promise((resolve, reject) => {
-    const handleError = (error) => {
-      server.off("error", handleError);
-      reject(error);
-    };
-    server.once("error", handleError);
-    server.listen(0, "127.0.0.1", () => {
-      server.off("error", handleError);
-      const address = server.address();
-      resolve(address.port);
-    });
-  });
-}
-function waitForAuthorizationCode(server, authorizationUrl, options, callbackPath) {
-  const expectedAuthorization = readExpectedAuthorizationCallback(authorizationUrl);
+
+// packages/mcp-oauth/src/client/default-oauth-client-provider.ts
+import { isIP } from "node:net";
+
+// packages/mcp-oauth/src/http-fetch.ts
+async function fetchMcpResponse(fetchImplementation, input, init = {}) {
+  const signal = init.signal;
+  signal?.throwIfAborted();
   return new Promise((resolve, reject) => {
     let settled = false;
-    const settle = (fn) => {
-      if (!settled) {
-        settled = true;
-        fn();
-      }
+    const finish = (error, response) => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", abort);
+      if (response === void 0) reject(error);
+      else resolve(response);
     };
-    server.on("request", (req, res) => {
-      const url = new URL(req.url ?? "/", "http://127.0.0.1");
-      if (url.pathname !== callbackPath) {
-        res.writeHead(404);
-        res.end("Not found");
-        return;
-      }
-      const callbackParameters = {
-        code: url.searchParams.get("code"),
-        error: url.searchParams.get("error"),
-        errorDescription: url.searchParams.get("error_description"),
-        state: url.searchParams.get("state"),
-        iss: url.searchParams.get("iss")
-      };
-      try {
-        validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
-      } catch (error) {
-        res.writeHead(400);
-        res.end(error instanceof Error ? error.message : "Invalid OAuth callback");
-        settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-        return;
-      }
-      const authorizationError = callbackParameters.error;
-      if (authorizationError !== null) {
-        const description = callbackParameters.errorDescription ?? authorizationError;
-        res.writeHead(400);
-        res.end(`Authorization failed: ${description}`);
-        settle(() => reject(createAuthorizationError(authorizationError, description)));
-        return;
-      }
-      try {
-        const code = validateAuthorizationCallbackParameters(
-          callbackParameters,
-          expectedAuthorization
-        );
-        res.writeHead(200, { "Content-Type": "text/html" });
-        res.end(buildSuccessPage(options.landingPage));
-        settle(() => resolve(code));
-      } catch (error) {
-        res.writeHead(400);
-        res.end(error instanceof Error ? error.message : "Invalid OAuth callback");
-        settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-      }
-    });
-    if (options.readLine !== void 0) {
-      options.readLine().then((input) => {
-        const callbackParameters = extractCallbackParametersFromInput(input);
-        if (callbackParameters === null) {
-          settle(() => reject(new Error("OAuth callback missing authorization code")));
-          return;
-        }
-        try {
-          validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
-          if (callbackParameters.error !== null) {
-            const description = callbackParameters.errorDescription ?? callbackParameters.error;
-            throw createAuthorizationError(callbackParameters.error, description);
-          }
-          const code = validateAuthorizationCallbackParameters(
-            callbackParameters,
-            expectedAuthorization
-          );
-          settle(() => resolve(code));
-        } catch (error) {
-          settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-        }
-      }).catch((error) => {
-        settle(() => reject(error instanceof Error ? error : new Error(String(error))));
-      });
+    const abort = () => finish(signal?.reason);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) {
+      abort();
+      return;
     }
-    if (options.openBrowser !== void 0) {
-      options.openBrowser(authorizationUrl).catch((error) => {
-        settle(() => reject(error));
-      });
+    let pending;
+    try {
+      pending = fetchImplementation(input, { ...init, redirect: "error" });
+    } catch (error) {
+      finish(error);
+      return;
     }
+    void pending.then((response) => {
+      if (settled || signal?.aborted) {
+        void response.body?.cancel().catch(() => void 0);
+        if (!settled) abort();
+        return;
+      }
+      if (response.redirected || response.type === "opaqueredirect") {
+        void response.body?.cancel().catch(() => void 0);
+        finish(new Error("MCP HTTP redirects are not allowed"));
+      } else finish(void 0, response);
+    }, (error) => finish(error));
   });
 }
-function extractCallbackParametersFromInput(input) {
-  const trimmed = input.replaceAll("\r", "").replaceAll("\n", "").trim();
-  if (trimmed.length === 0) {
-    return null;
-  }
-  try {
-    const url = new URL(trimmed);
-    return {
-      code: url.searchParams.get("code"),
-      error: url.searchParams.get("error"),
-      errorDescription: url.searchParams.get("error_description"),
-      state: url.searchParams.get("state"),
-      iss: url.searchParams.get("iss")
-    };
-  } catch {
-    return {
-      code: trimmed,
-      error: null,
-      errorDescription: null,
-      state: null,
-      iss: null
-    };
-  }
-}
-function readExpectedAuthorizationCallback(authorizationUrl) {
-  const url = new URL(authorizationUrl);
-  const state = url.searchParams.get("state");
-  const parsedState = parseAuthorizationState(state);
-  return {
-    state,
-    issuer: parsedState?.issuer ?? null,
-    requireIssuer: parsedState?.requireIssuer ?? false
-  };
-}
-function validateAuthorizationCallbackParameters(callback, expected) {
-  validateAuthorizationCallbackBinding(callback, expected);
-  if (callback.code === null || callback.code.length === 0) {
-    throw new Error("OAuth callback missing authorization code");
-  }
-  return callback.code;
-}
-function validateAuthorizationCallbackBinding(callback, expected) {
-  if (expected.state !== null) {
-    if (callback.state === null || callback.state.length === 0) {
-      throw new Error("OAuth callback missing state");
-    }
-    if (callback.state !== expected.state) {
-      throw new Error("OAuth callback state mismatch");
-    }
-  }
-  if (expected.requireIssuer) {
-    if (callback.iss === null || callback.iss.length === 0) {
-      throw new Error("OAuth callback missing issuer");
-    }
-  }
-  if (callback.iss !== null && callback.iss.length > 0 && expected.issuer !== null && callback.iss !== expected.issuer) {
-    throw new Error("OAuth callback issuer mismatch");
-  }
-}
-function createAuthorizationError(error, description) {
-  return new Error(`OAuth authorization failed: ${error} \u2014 ${description}`);
-}
-function escapeHtml(text) {
-  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
-}
-function buildSuccessPage(landingPage) {
-  const title = landingPage?.title ?? "Connected";
-  const body = landingPage?.body ?? "You can close this tab and return to your terminal.";
-  return [
-    "<!DOCTYPE html>",
-    `<html><head><meta charset=utf-8><title>${escapeHtml(title)}</title></head>`,
-    '<body style="font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0">',
-    '<div style="text-align:center">',
-    `<h1>${escapeHtml(title)}</h1>`,
-    `<p style="color:#666">${escapeHtml(body)}</p>`,
-    "</div></body></html>"
-  ].join("");
-}
+
+// packages/mcp-oauth/src/client/default-oauth-client-provider.ts
+import { URL as URL2 } from "node:url";
 
 // packages/mcp-oauth/src/client/pkce.ts
 import crypto3 from "node:crypto";
@@ -4502,7 +5167,12 @@ async function readBoundedResponseText(response, maxBytes, readers, signal) {
 
 // packages/mcp-oauth/src/client/token-endpoint.ts
 var MAX_JS_DATE_MS2 = 864e13;
+var oauthErrorBrand = /* @__PURE__ */ Symbol.for("poe-platform.mcp-oauth.OAuthError");
 var OAuthError = class extends Error {
+  /** Recognize errors from separately bundled copies of this package. */
+  static is(value) {
+    return value instanceof Error && Object.getOwnPropertyDescriptor(value, oauthErrorBrand)?.value === true;
+  }
   error;
   errorDescription;
   errorUri;
@@ -4511,17 +5181,23 @@ var OAuthError = class extends Error {
   status;
   retryable;
   terminal;
-  constructor(shape, status) {
-    super(shape.error_description ?? shape.error);
+  /** True only when a complete OAuth error response establishes rejection. */
+  outcomeKnown;
+  constructor(shape, status, outcomeKnown = true) {
+    const description = Object.hasOwn(shape, "error_description") ? shape.error_description : void 0;
+    const uri = Object.hasOwn(shape, "error_uri") ? shape.error_uri : void 0;
+    super(description ?? (outcomeKnown ? shape.error : `OAuth HTTP response did not contain a valid error (HTTP ${status})`));
     this.name = "OAuthError";
+    Object.defineProperty(this, oauthErrorBrand, { value: true });
     this.error = shape.error;
-    this.errorDescription = shape.error_description;
-    this.errorUri = shape.error_uri;
-    this.error_description = shape.error_description;
-    this.error_uri = shape.error_uri;
+    this.errorDescription = description;
+    this.errorUri = uri;
+    this.error_description = description;
+    this.error_uri = uri;
     this.status = status;
     this.retryable = isRetryableOAuthError(this);
     this.terminal = !this.retryable;
+    this.outcomeKnown = outcomeKnown;
   }
 };
 function isRetryableOAuthError(error) {
@@ -4533,6 +5209,7 @@ async function exchangeAuthorizationCode(input) {
     tokenEndpoint: input.tokenEndpoint,
     clientId: input.clientId,
     clientSecret: input.clientSecret,
+    tokenEndpointAuthMethod: input.tokenEndpointAuthMethod,
     params: {
       grant_type: "authorization_code",
       code: input.code,
@@ -4541,6 +5218,7 @@ async function exchangeAuthorizationCode(input) {
       resource
     },
     fetch: input.fetch,
+    signal: input.signal,
     now: input.now
   });
 }
@@ -4550,29 +5228,37 @@ async function refreshAccessToken(input) {
     tokenEndpoint: input.tokenEndpoint,
     clientId: input.clientId,
     clientSecret: input.clientSecret,
+    tokenEndpointAuthMethod: input.tokenEndpointAuthMethod,
     params: {
       grant_type: "refresh_token",
       refresh_token: input.refreshToken,
       resource
     },
     fetch: input.fetch,
+    signal: input.signal,
     now: input.now
   });
 }
 async function requestTokens(input) {
-  const body = new URLSearchParams({
-    client_id: input.clientId,
-    ...input.params
-  });
-  if (input.clientSecret !== void 0) {
-    body.set("client_secret", input.clientSecret);
-  }
-  const signal = AbortSignal.timeout(3e4);
+  const method = normalizeOAuthTokenEndpointAuthMethod(input.tokenEndpointAuthMethod) ?? (input.clientSecret === void 0 ? "none" : "client_secret_post");
+  if (method !== "none" && (input.clientSecret === void 0 || input.clientSecret.trim() === ""))
+    throw new Error("OAuth token endpoint authentication requires a client secret");
+  const body = new URLSearchParams(input.params);
+  const headers = new Headers({ Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" });
+  if (method === "client_secret_basic") {
+    const encoded = new URLSearchParams({ credential: input.clientId }).toString().slice("credential=".length);
+    const encodedSecret = new URLSearchParams({ credential: input.clientSecret }).toString().slice("credential=".length);
+    headers.set("Authorization", `Basic ${Buffer.from(`${encoded}:${encodedSecret}`).toString("base64")}`);
+  } else {
+    body.set("client_id", input.clientId);
+    if (method === "client_secret_post") body.set("client_secret", input.clientSecret);
+  }
+  input.signal?.throwIfAborted();
+  const deadline = AbortSignal.timeout(3e4);
+  const signal = input.signal === void 0 ? deadline : AbortSignal.any([input.signal, deadline]);
   const response = await fetchMcpResponse(input.fetch, input.tokenEndpoint, {
     method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
+    headers,
     body: body.toString(),
     signal
   });
@@ -4582,6 +5268,11 @@ async function requestTokens(input) {
     throw new Error("OAuth token response missing access_token");
   }
   const normalizedAccessToken = accessToken.trim();
+  try {
+    new Headers({ Authorization: `Bearer ${normalizedAccessToken}` });
+  } catch {
+    throw new Error("OAuth token response access_token is not a valid HTTP header value");
+  }
   const tokenType = normalizeBearerTokenType(getOwnEntry5(payload, "token_type"));
   if (tokenType === null) {
     throw new Error("OAuth token response missing token_type=Bearer");
@@ -4592,15 +5283,22 @@ async function requestTokens(input) {
     if (typeof expiresIn !== "number" || !Number.isFinite(expiresIn) || !Number.isInteger(expiresIn) || expiresIn < 0) {
       throw new Error("OAuth token response has invalid expires_in");
     }
-    expiresAt = input.now() + expiresIn * 1e3;
+    const issuedAt = input.now();
+    if (!Number.isSafeInteger(issuedAt) || Math.abs(issuedAt) > MAX_JS_DATE_MS2)
+      throw new Error("OAuth token response has invalid expires_in");
+    expiresAt = issuedAt + expiresIn * 1e3;
     if (!Number.isSafeInteger(expiresAt) || expiresAt > MAX_JS_DATE_MS2 || !Number.isFinite(new Date(expiresAt).getTime())) {
       throw new Error("OAuth token response has invalid expires_in");
     }
   }
   const refreshToken = getOwnEntry5(payload, "refresh_token");
+  if (refreshToken !== void 0 && (typeof refreshToken !== "string" || refreshToken.trim().length === 0))
+    throw new Error("OAuth token response has invalid refresh_token");
   const scope = getOwnEntry5(payload, "scope");
   const normalizedRefreshToken = typeof refreshToken === "string" && refreshToken.trim().length > 0 ? refreshToken.trim() : void 0;
-  const normalizedScope = typeof scope === "string" && scope.trim().length > 0 ? scope.trim() : void 0;
+  const normalizedScope = normalizeOAuthScope(scope);
+  if (scope !== void 0 && normalizedScope === void 0)
+    throw new Error("Invalid OAuth scope syntax in token response");
   return {
     accessToken: normalizedAccessToken,
     refreshToken: normalizedRefreshToken === void 0 ? void 0 : normalizedRefreshToken,
@@ -4630,7 +5328,9 @@ async function readOAuthJsonObjectResponse(response, signal) {
   }
   const record2 = payload;
   if (!response.ok) {
-    throw new OAuthError(readOAuthError(record2, fallbackError.error), response.status);
+    const error = getOwnEntry5(record2, "error");
+    if (typeof error !== "string" || error.trim() === "") throw fallbackError;
+    throw new OAuthError(readOAuthError(record2), response.status);
   }
   return record2;
 }
@@ -4648,8 +5348,8 @@ function getOwnEntry5(record2, key2) {
   return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
 }
 function createFallbackOAuthError(status) {
-  const error = status === 503 ? "temporarily_unavailable" : "server_error";
-  return new OAuthError({ error }, status);
+  const error = status === 503 ? "temporarily_unavailable" : status >= 500 ? "server_error" : "invalid_response";
+  return new OAuthError({ error }, status, false);
 }
 function normalizeBearerTokenType(value) {
   if (typeof value !== "string") {
@@ -4658,6 +5358,56 @@ function normalizeBearerTokenType(value) {
   return value.toLowerCase() === "bearer" ? "Bearer" : null;
 }
 
+// packages/mcp-oauth/src/client/session-transaction.ts
+var queues = /* @__PURE__ */ new WeakMap();
+async function withOAuthSessionTransaction(store, resource, operation, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)
+    throw new Error("sessionLockTimeoutMs must be an integer from 1 to 2147483647 milliseconds");
+  options.signal?.throwIfAborted();
+  const started = performance.now();
+  const pending = queues.get(store) ?? /* @__PURE__ */ new Map();
+  queues.set(store, pending);
+  const previous = pending.get(resource) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => current);
+  pending.set(resource, tail);
+  let running;
+  try {
+    let timer;
+    let rejectWait;
+    const waiting = new Promise((resolve, reject) => {
+      rejectWait = reject;
+      previous.then(resolve, reject);
+    });
+    const abort = () => rejectWait(options.signal?.reason);
+    try {
+      timer = setTimeout(() => rejectWait(new Error("Timed out waiting for OAuth session transaction lock")), timeoutMs);
+      options.signal?.addEventListener("abort", abort, { once: true });
+      if (options.signal?.aborted) abort();
+      await waiting;
+    } finally {
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", abort);
+    }
+    options.signal?.throwIfAborted();
+    running = (async () => store.withLock === void 0 ? operation() : store.withLock(resource, operation, {
+      signal: options.signal,
+      timeoutMs: Math.max(0, timeoutMs - (performance.now() - started))
+    }))();
+    return await waitForOAuthOperation(running, options.signal);
+  } finally {
+    if (running === void 0) release();
+    else void running.then(release, release);
+    void tail.then(() => {
+      if (pending.get(resource) === tail) pending.delete(resource);
+    });
+  }
+}
+
 // packages/mcp-oauth/src/client/default-oauth-client-provider.ts
 var MAX_JS_DATE_MS3 = 864e13;
 function createOAuthClientProvider(options) {
@@ -4667,31 +5417,130 @@ function createOAuthClientProvider(options) {
   return createDefaultOAuthClientProvider(options);
 }
 function createDefaultOAuthClientProvider(options) {
-  const sessionStore = options.sessionStore ?? createAuthStoreSessionStore(options.authStore);
-  const clientStore = options.authStore === void 0 ? null : createAuthStoreClientStore(options.authStore);
-  const now = options.now ?? Date.now;
+  const clock = options.now?.bind(options) ?? Date.now;
+  const browser = snapshotLoopbackAuthorizationOptions(options.browser);
+  const clientMode = options.client.mode;
+  const interactiveEnabled = options.allowInteractive !== false;
+  const sessionLockTimeoutMs = options.sessionLockTimeoutMs;
+  loopbackTarget(browser);
+  assertPersistenceNamespace(options.persistenceNamespace);
+  const clientMetadata = getClientMetadata(options.client);
+  const requestedScope = clientMetadata?.scope;
+  const configuredClient = normalizeConfiguredClient(options.client);
+  const requestedTokenMethod = normalizeOAuthTokenEndpointAuthMethod(options.client.tokenEndpointAuthMethod);
+  const configuredTokenMethod = requestedTokenMethod ?? configuredClient?.tokenEndpointAuthMethod;
+  const resourceIdentity = options.resourceIdentity, persistenceNamespace = options.persistenceNamespace, selectedSessionStore = options.sessionStore;
+  const suppliedGrant = options.initialGrant;
+  const capturedGrant = suppliedGrant === void 0 ? void 0 : { resource: suppliedGrant.resource, tokens: snapshotInitialGrantTokens(suppliedGrant.tokens) };
+  const authStore = options.authStore === void 0 ? void 0 : snapshotOAuthPersistenceOptions(options.authStore);
+  if (resourceIdentity !== void 0 && selectedSessionStore !== void 0)
+    throw new Error("OAuth resourceIdentity requires native-owned persistence; custom stores own their resource trust policy");
+  const now = () => {
+    const timestamp = clock();
+    if (!Number.isSafeInteger(timestamp) || Math.abs(timestamp) > MAX_JS_DATE_MS3)
+      throw new Error("OAuth clock must return valid epoch milliseconds");
+    return timestamp;
+  };
   const registeredClients = /* @__PURE__ */ new Map();
-  const refreshPromises = /* @__PURE__ */ new Map();
-  const authorizationPromises = /* @__PURE__ */ new Map();
+  const resourceStores = resourceIdentity === void 0 ? void 0 : createResourceBoundOAuthStores(authStore ?? {}, persistenceNamespace, resourceIdentity);
+  const sessionStore = resourceStores?.sessionStore ?? selectedSessionStore ?? createAuthStoreSessionStore(authStore, persistenceNamespace);
+  const clientStore = resourceStores?.clientStore ?? (authStore === void 0 ? null : createAuthStoreClientStore(authStore, persistenceNamespace));
+  if (capturedGrant !== void 0) {
+    let resource;
+    try {
+      resource = new URL2(capturedGrant.resource);
+    } catch {
+      throw new Error("OAuth initial grant resource must be an absolute HTTP URL");
+    }
+    if (resource.protocol !== "http:" && resource.protocol !== "https:" || resource.username || resource.password || resource.href.includes("#"))
+      throw new Error("OAuth initial grant resource must be an HTTP URL without credentials or fragments");
+  }
+  const initialGrant = capturedGrant === void 0 ? void 0 : {
+    resource: canonicalizeResourceIndicator(capturedGrant.resource),
+    tokens: normalizeImportedTokens(capturedGrant.tokens, now),
+    client: configuredClient
+  };
+  if (initialGrant !== void 0 && (initialGrant.tokens === void 0 || initialGrant.client === null))
+    throw new Error("OAuth initial grant requires valid tokens and the original client ID");
+  if (initialGrant?.tokens !== void 0) {
+    if (requestedScope !== void 0 && initialGrant.tokens.scope !== requestedScope)
+      throw new Error("OAuth initial grant does not match the requested OAuth scope");
+    try {
+      new Headers({ Authorization: `Bearer ${initialGrant.tokens.accessToken}` });
+    } catch {
+      throw new Error("OAuth initial grant access token is not a valid HTTP header value");
+    }
+  }
+  let initialGrantConsumed = false;
   return {
+    async authenticate(input) {
+      input = { ...input, ...input.discover === void 0 ? {} : { discover: input.discover.bind(input) } };
+      input.signal?.throwIfAborted();
+      assertNoAccessTokenInUrl(input.requestUrl, "Protected resource request URL");
+      const resource = canonicalizeResourceIndicator(input.requestUrl);
+      let session = await ensureAuthorizedSession(resource, void 0, input.fetch, true, false, input.signal);
+      if (session?.tokens !== void 0 && !isExpired(session.tokens, now)) return { ...session.tokens };
+      if (session === null && !initialGrantConsumed && initialGrant?.resource === resource && initialGrant.tokens !== void 0 && !isExpired(initialGrant.tokens, now)) return { ...initialGrant.tokens };
+      if (input.discover === void 0) return;
+      const discovery = structuredClone(await waitForOAuthOperation(input.discover(), input.signal));
+      input.signal?.throwIfAborted();
+      assertRequestMatchesResource(resource, canonicalizeResourceIndicator(discovery.resource));
+      session = await ensureAuthorizedSession(resource, discovery, input.fetch, true, false, input.signal);
+      if (session?.tokens === void 0 || isExpired(session.tokens, now)) throw new Error("OAuth authentication did not establish a usable grant");
+      return { ...session.tokens };
+    },
     async authorizeRequest(input) {
+      input = { ...input };
       assertNoAccessTokenInUrl(input.requestUrl, "Protected resource request URL");
       const requestUrl = canonicalizeResourceIndicator(input.requestUrl);
-      const session = await ensureAuthorizedSession(requestUrl, void 0, input.fetch, false);
+      const session = await ensureAuthorizedSession(requestUrl, void 0, input.fetch, false, false, input.signal);
       const accessToken = session?.tokens?.accessToken;
+      if (session === null && !initialGrantConsumed && initialGrant?.resource === requestUrl && initialGrant.tokens !== void 0 && !isExpired(initialGrant.tokens, now)) {
+        input.headers.set("Authorization", `Bearer ${initialGrant.tokens.accessToken}`);
+        return { ...initialGrant.tokens };
+      }
       if (session === null || accessToken === void 0 || session.tokens === void 0 || isExpired(session.tokens, now)) {
         return;
       }
       assertRequestMatchesResource(requestUrl, session.resource);
       input.headers.set("Authorization", `Bearer ${accessToken}`);
+      return { ...session.tokens };
     },
     async handleUnauthorized(input) {
+      input = { ...input };
       try {
+        input.signal?.throwIfAborted();
+        const presented = input.presentedTokens == null ? input.presentedTokens : normalizeStoredTokens(input.presentedTokens);
+        if (input.presentedTokens != null && presented === void 0)
+          throw new Error("OAuth rejected-request provenance does not match its authorization header");
+        const challengeError = input.challenge?.params.error;
+        input = {
+          ...input,
+          discovery: structuredClone(input.discovery),
+          ...input.requestHeaders === void 0 ? {} : { requestHeaders: new Headers(input.requestHeaders) },
+          ...presented === void 0 ? {} : { presentedTokens: presented }
+        };
         assertNoAccessTokenInUrl(input.requestUrl, "Protected resource request URL");
         const requestUrl = canonicalizeResourceIndicator(input.requestUrl);
         const resource = canonicalizeResourceIndicator(input.discovery.resource);
         assertRequestMatchesResource(requestUrl, resource);
-        const forceRefresh = hasCachedAccessToken(await loadSession(resource)) && input.challenge?.params.error === "invalid_token";
+        const cached = await waitForOAuthOperation(loadSession(resource), input.signal);
+        const currentTokens = cached?.tokens ?? (!initialGrantConsumed && initialGrant?.resource === resource ? initialGrant.tokens : void 0);
+        let rejectedCurrentGrant = hasCachedAccessToken(cached) || !initialGrantConsumed && initialGrant?.resource === resource;
+        let presentedTokens = input.presentedTokens;
+        if (input.presentedTokens !== void 0) {
+          rejectedCurrentGrant = false;
+          if (input.presentedTokens !== null) {
+            const presented2 = input.presentedTokens;
+            const header = input.requestHeaders?.get("Authorization") ?? "";
+            const separator = header.indexOf(" ");
+            if (header.slice(0, separator).toLowerCase() !== "bearer" || header.slice(separator + 1).trim() !== presented2.accessToken)
+              throw new Error("OAuth rejected-request provenance does not match its authorization header");
+            presentedTokens = presented2;
+            rejectedCurrentGrant = currentTokens !== void 0 && sameTokenGrant(currentTokens, presented2);
+          }
+        }
+        const forceRefresh = rejectedCurrentGrant && (challengeError === "invalid_token" || input.presentedTokens !== void 0 && challengeError === void 0);
         const session = await ensureAuthorizedSession(
           resource,
           {
@@ -4700,13 +5549,16 @@ function createDefaultOAuthClientProvider(options) {
           },
           input.fetch,
           true,
-          forceRefresh
+          forceRefresh,
+          input.signal,
+          presentedTokens
         );
         if (session?.tokens?.accessToken === void 0) {
           return { action: "fail" };
         }
         return { action: "retry" };
       } catch (error) {
+        input.signal?.throwIfAborted();
         return {
           action: "fail",
           error: error instanceof Error ? error : new Error(String(error))
@@ -4714,203 +5566,248 @@ function createDefaultOAuthClientProvider(options) {
       }
     }
   };
-  async function ensureAuthorizedSession(resource, discovery, fetch2, allowInteractive, forceRefresh = false) {
-    const canonicalResource = canonicalizeResourceIndicator(resource);
-    let session = await loadSession(canonicalResource);
-    if (discovery !== void 0 && getOwnString2(
-      discovery.authorizationServerMetadata,
-      "issuer"
-    ) !== discovery.authorizationServer) {
-      throw new Error("OAuth discovery authorization-server issuer mismatch");
-    }
-    if (session !== null && (canonicalizeResourceIndicator(session.resource) !== canonicalResource || getOwnString2(session.discovery.authorizationServerMetadata, "issuer") !== session.authorizationServer || discovery !== void 0 && discovery.authorizationServer !== session.authorizationServer)) {
-      await clearSession(canonicalResource);
-      session = null;
-    }
-    const sessionDiscovery = resolveDiscovery(discovery, session);
-    if (session?.tokens !== void 0 && !forceRefresh && !isExpired(session.tokens, now)) {
-      return session;
+  async function ensureAuthorizedSession(resource, discovery, fetch2, allowInteractive, forceRefresh = false, signal, rejectedTokens) {
+    signal?.throwIfAborted();
+    if (discovery !== void 0) {
+      if (getOwnString2(discovery.authorizationServerMetadata, "issuer") !== discovery.authorizationServer)
+        throw new Error("OAuth discovery authorization-server issuer mismatch");
+      assertSecureOAuthFlowEndpoints(discovery.authorizationServerMetadata);
     }
-    if (session?.tokens?.refreshToken !== void 0 && sessionDiscovery !== void 0 && (forceRefresh || isExpired(session.tokens, now))) {
-      session = await refreshSession(canonicalResource, session, sessionDiscovery, fetch2);
-      if (session?.tokens !== void 0 && !isExpired(session.tokens, now)) {
+    const canonicalResource = canonicalizeResourceIndicator(resource);
+    return withOAuthSessionTransaction(sessionStore, canonicalResource, async () => {
+      let session = await loadSession(canonicalResource);
+      if (resourceStores !== void 0) {
+        registeredClients.clear();
+        if (!resourceStores.initialGrantAllowed) initialGrantConsumed = true;
+      }
+      if (session !== null) assertRegistrationIssuer(session.client, session.authorizationServer);
+      if (configuredClient !== null && discovery !== void 0) assertRegistrationIssuer(configuredClient, discovery.authorizationServer);
+      if (session !== null && initialGrant?.resource === canonicalResource) initialGrantConsumed = true;
+      signal?.throwIfAborted();
+      if (session !== null && (canonicalizeResourceIndicator(session.resource) !== canonicalResource || getOwnString2(session.discovery.authorizationServerMetadata, "issuer") !== session.authorizationServer || discovery !== void 0 && discovery.authorizationServer !== session.authorizationServer)) {
+        await clearSession(canonicalResource);
+        session = null;
+      }
+      if (session === null && discovery !== void 0 && !initialGrantConsumed && initialGrant?.resource === canonicalResource && initialGrant.tokens !== void 0 && initialGrant.client !== null) {
+        session = {
+          resource: canonicalResource,
+          authorizationServer: discovery.authorizationServer,
+          client: initialGrant.client,
+          tokens: initialGrant.tokens,
+          ...requestedScope === void 0 ? {} : { requestedScope },
+          discovery: toStoredDiscovery(discovery)
+        };
+        await saveSession(canonicalResource, session);
+        initialGrantConsumed = true;
+        signal?.throwIfAborted();
+      }
+      if (forceRefresh && rejectedTokens !== void 0 && (rejectedTokens === null || session?.tokens === void 0 || !sameTokenGrant(session.tokens, rejectedTokens)))
+        forceRefresh = false;
+      const sessionDiscovery = resolveDiscovery(discovery, session);
+      if ((clientMode === "static" || configuredClient !== null || initialGrant !== void 0) && session !== null && (session.tokens !== void 0 || session.refreshState === "pending")) {
+        const configured = configuredClient;
+        if (configured === null || configured.clientId !== session.client.clientId || configured.clientSecret !== session.client.clientSecret)
+          throw new Error("Stored session belongs to a different OAuth client; use separate persistence or explicitly reset it");
+      }
+      if (requestedScope !== void 0 && session?.tokens !== void 0 && normalizeOAuthScope(session.tokens.scope ?? session.requestedScope) !== requestedScope)
+        throw new Error("Stored session does not match the requested OAuth scope; authorize again or select separate persistence");
+      if (configuredTokenMethod !== void 0 && session !== null && (session.tokens !== void 0 || session.refreshState === "pending") && (session.client.tokenEndpointAuthMethod ?? (session.client.clientSecret === void 0 ? "none" : "client_secret_post")) !== configuredTokenMethod)
+        throw new Error("Stored session does not match the requested OAuth token endpoint authentication; select separate persistence or reset it");
+      if (session?.refreshState === "pending") {
+        if (!allowInteractive || !interactiveEnabled || sessionDiscovery === void 0)
+          throw new Error("OAuth refresh outcome is unknown; authorize again before using this resource");
+        return authorizeSession(canonicalResource, clearSessionTokens(session), sessionDiscovery, fetch2, signal);
+      }
+      if (session?.tokens !== void 0 && !forceRefresh && !isExpired(session.tokens, now)) {
         return session;
       }
-    }
-    if (forceRefresh && session?.tokens !== void 0) {
-      session = clearSessionTokens(session);
-      await saveSession(canonicalResource, session);
-    }
-    if (!allowInteractive || sessionDiscovery === void 0) {
-      return session;
-    }
-    return authorizeSession(canonicalResource, session, sessionDiscovery, fetch2);
+      if (session?.tokens?.refreshToken !== void 0 && sessionDiscovery !== void 0 && (forceRefresh || isExpired(session.tokens, now))) {
+        if (hasExpiredClientSecret(session.client, now)) {
+          if (!allowInteractive || !interactiveEnabled || clientMode === "static" || configuredClient?.registration !== void 0)
+            throw new Error("OAuth client secret has expired; authorize again or update the imported registration");
+          return authorizeSession(canonicalResource, clearSessionTokens(session), sessionDiscovery, fetch2, signal);
+        }
+        session = await refreshSession(canonicalResource, session, sessionDiscovery, fetch2, signal);
+        if (session?.tokens !== void 0 && !isExpired(session.tokens, now)) {
+          return session;
+        }
+      }
+      if (forceRefresh && session?.tokens !== void 0) {
+        session = clearSessionTokens(session);
+        await saveSession(canonicalResource, session);
+      }
+      if (!allowInteractive || sessionDiscovery === void 0) {
+        return session;
+      }
+      if (!interactiveEnabled) throw new Error("OAuth interactive authorization is disabled");
+      return authorizeSession(canonicalResource, session, sessionDiscovery, fetch2, signal);
+    }, { signal, timeoutMs: sessionLockTimeoutMs });
   }
-  async function refreshSession(resource, session, discovery, fetch2) {
+  async function refreshSession(resource, session, discovery, fetch2, signal) {
+    signal?.throwIfAborted();
     assertSecureOAuthFlowEndpoints(discovery.authorizationServerMetadata);
-    const inFlight = refreshPromises.get(resource);
-    if (inFlight !== void 0) {
-      return inFlight;
+    if (session.tokens?.refreshToken === void 0) {
+      return session;
     }
-    const promise = (async () => {
+    assertTokenEndpointAuthentication(session.client, discovery.authorizationServerMetadata);
+    const pendingSession = { ...clearSessionTokens(session), refreshState: "pending" };
+    await saveSession(resource, pendingSession);
+    signal?.throwIfAborted();
+    let refreshAttempted = false;
+    let refreshedTokens;
+    while (true) {
       try {
-        if (session.tokens?.refreshToken === void 0) {
-          return session;
+        refreshedTokens = await refreshAccessToken({
+          tokenEndpoint: requireOwnString(
+            discovery.authorizationServerMetadata,
+            "token_endpoint",
+            "Authorization server metadata"
+          ),
+          clientId: session.client.clientId,
+          clientSecret: session.client.clientSecret,
+          tokenEndpointAuthMethod: session.client.tokenEndpointAuthMethod,
+          refreshToken: session.tokens.refreshToken,
+          resource,
+          fetch: fetch2,
+          signal,
+          now
+        });
+        break;
+      } catch (error) {
+        signal?.throwIfAborted();
+        if (!(error instanceof OAuthError) || !error.outcomeKnown) throw error;
+        if (error.error === "invalid_grant") {
+          const clearedSession = clearSessionTokens(session);
+          await saveSession(resource, clearedSession);
+          return clearedSession;
+        }
+        if (shouldReRegisterStoredDynamicClient(
+          error,
+          await loadRegisteredClient(discovery.authorizationServer),
+          false
+        )) {
+          await clearRegisteredClient(discovery.authorizationServer);
+          await clearSession(resource);
+          return null;
         }
-        let refreshAttempted = false;
-        let refreshedTokens;
-        while (true) {
-          try {
-            refreshedTokens = await refreshAccessToken({
-              tokenEndpoint: requireOwnString(
-                discovery.authorizationServerMetadata,
-                "token_endpoint",
-                "Authorization server metadata"
-              ),
-              clientId: session.client.clientId,
-              clientSecret: session.client.clientSecret,
-              refreshToken: session.tokens.refreshToken,
-              resource,
-              fetch: fetch2,
-              now
-            });
-            break;
-          } catch (error) {
-            if (error instanceof OAuthError && error.error === "invalid_grant") {
-              const clearedSession = clearSessionTokens(session);
-              await saveSession(resource, clearedSession);
-              return clearedSession;
-            }
-            if (shouldReRegisterStoredDynamicClient(
-              error,
-              await loadRegisteredClient(discovery.authorizationServer),
-              false
-            )) {
-              await clearRegisteredClient(discovery.authorizationServer);
-              await clearSession(resource);
-              return null;
-            }
-            if (!refreshAttempted && isRetryableOAuthError(error)) {
-              refreshAttempted = true;
-              continue;
-            }
-            throw error;
-          }
+        if (!refreshAttempted && isRetryableOAuthError(error)) {
+          refreshAttempted = true;
+          continue;
         }
-        const updatedSession = {
-          ...session,
-          tokens: {
-            ...refreshedTokens,
-            refreshToken: refreshedTokens.refreshToken ?? session.tokens.refreshToken
-          },
-          discovery: toStoredDiscovery(discovery)
-        };
-        await saveSession(resource, updatedSession);
-        return updatedSession;
-      } finally {
-        refreshPromises.delete(resource);
+        await saveSession(resource, session);
+        throw error;
       }
-    })();
-    refreshPromises.set(resource, promise);
-    return promise;
-  }
-  async function authorizeSession(resource, existingSession, discovery, fetch2) {
-    const inFlight = authorizationPromises.get(resource);
-    if (inFlight !== void 0) {
-      return inFlight;
     }
-    const promise = (async () => {
-      assertS256PkceSupport(discovery.authorizationServerMetadata);
-      assertSecureOAuthFlowEndpoints(discovery.authorizationServerMetadata);
-      let currentSession = existingSession;
-      let transientRetryAttempted = false;
-      let reRegistrationAttempted = false;
-      while (true) {
-        const loopback = await createLoopbackAuthorizationSession({
-          openBrowser: options.browser.openBrowser,
-          readLine: options.browser.readLine,
-          createServer: options.browser.createServer,
-          landingPage: options.browser.landingPage
+    const updatedSession = {
+      ...session,
+      tokens: {
+        ...refreshedTokens,
+        refreshToken: refreshedTokens.refreshToken ?? session.tokens.refreshToken,
+        scope: refreshedTokens.scope ?? session.tokens.scope
+      },
+      discovery: toStoredDiscovery(discovery)
+    };
+    if (requestedScope !== void 0 && normalizeOAuthScope(updatedSession.tokens?.scope ?? session.requestedScope) !== requestedScope)
+      throw new Error("OAuth refresh response does not match the requested OAuth scope; authorize again");
+    await saveSession(resource, updatedSession);
+    return updatedSession;
+  }
+  async function authorizeSession(resource, existingSession, discovery, fetch2, signal) {
+    signal?.throwIfAborted();
+    assertS256PkceSupport(discovery.authorizationServerMetadata);
+    assertSecureOAuthFlowEndpoints(discovery.authorizationServerMetadata);
+    let currentSession = existingSession;
+    let transientRetryAttempted = false;
+    let reRegistrationAttempted = false;
+    while (true) {
+      const loopback = await createLoopbackAuthorizationSession({
+        ...browser,
+        signal: browser.signal === void 0 ? signal : signal === void 0 ? browser.signal : AbortSignal.any([signal, browser.signal])
+      });
+      let resolvedClient = null;
+      try {
+        resolvedClient = await resolveClient(
+          currentSession,
+          discovery,
+          loopback.redirectUri,
+          fetch2,
+          signal
+        );
+        assertTokenEndpointAuthentication(resolvedClient.client, discovery.authorizationServerMetadata);
+        const sessionWithoutTokens = {
+          resource,
+          authorizationServer: discovery.authorizationServer,
+          client: resolvedClient.client,
+          ...requestedScope === void 0 ? {} : { requestedScope },
+          discovery: toStoredDiscovery(discovery)
+        };
+        await saveSession(resource, sessionWithoutTokens);
+        const verifier = generateCodeVerifier();
+        const challenge = generateCodeChallenge(verifier);
+        const authorizationUrl = buildAuthorizationUrl({
+          metadata: discovery.authorizationServerMetadata,
+          resource,
+          clientId: resolvedClient.client.clientId,
+          redirectUri: loopback.redirectUri,
+          codeChallenge: challenge,
+          clientMetadata
         });
-        let resolvedClient = null;
-        try {
-          resolvedClient = await resolveClient(
-            currentSession,
-            discovery,
-            loopback.redirectUri,
-            fetch2
-          );
-          const sessionWithoutTokens = {
-            resource,
-            authorizationServer: discovery.authorizationServer,
-            client: resolvedClient.client,
-            discovery: toStoredDiscovery(discovery)
-          };
-          await saveSession(resource, sessionWithoutTokens);
-          const verifier = generateCodeVerifier();
-          const challenge = generateCodeChallenge(verifier);
-          const authorizationUrl = buildAuthorizationUrl({
-            metadata: discovery.authorizationServerMetadata,
-            resource,
-            clientId: resolvedClient.client.clientId,
-            redirectUri: loopback.redirectUri,
-            codeChallenge: challenge,
-            clientMetadata: getClientMetadata(options.client)
-          });
-          const code = await loopback.waitForCode(authorizationUrl);
-          const tokens = await exchangeAuthorizationCode({
-            tokenEndpoint: requireOwnString(
-              discovery.authorizationServerMetadata,
-              "token_endpoint",
-              "Authorization server metadata"
-            ),
-            clientId: resolvedClient.client.clientId,
-            clientSecret: resolvedClient.client.clientSecret,
-            code,
-            codeVerifier: verifier,
-            redirectUri: loopback.redirectUri,
-            resource,
-            fetch: fetch2,
-            now
-          });
-          const session = {
-            ...sessionWithoutTokens,
-            tokens
-          };
-          await saveSession(resource, session);
-          return session;
-        } catch (error) {
-          if (shouldReRegisterStoredDynamicClient(error, resolvedClient, reRegistrationAttempted)) {
-            reRegistrationAttempted = true;
-            await clearRegisteredClient(discovery.authorizationServer);
-            await clearSession(resource);
-            currentSession = null;
-            continue;
-          }
-          if (!transientRetryAttempted && isRetryableOAuthError(error)) {
-            transientRetryAttempted = true;
-            await clearSession(resource);
-            currentSession = null;
-            continue;
-          }
-          throw error;
-        } finally {
-          loopback.close();
+        const code = await loopback.waitForCode(authorizationUrl);
+        const tokens = await exchangeAuthorizationCode({
+          tokenEndpoint: requireOwnString(
+            discovery.authorizationServerMetadata,
+            "token_endpoint",
+            "Authorization server metadata"
+          ),
+          clientId: resolvedClient.client.clientId,
+          clientSecret: resolvedClient.client.clientSecret,
+          tokenEndpointAuthMethod: resolvedClient.client.tokenEndpointAuthMethod,
+          code,
+          codeVerifier: verifier,
+          redirectUri: loopback.redirectUri,
+          resource,
+          fetch: fetch2,
+          signal,
+          now
+        });
+        if (requestedScope !== void 0 && tokens.scope !== void 0 && normalizeOAuthScope(tokens.scope) !== requestedScope)
+          throw new Error("OAuth authorization response does not match the requested OAuth scope");
+        const session = {
+          ...sessionWithoutTokens,
+          tokens
+        };
+        await saveSession(resource, session);
+        return session;
+      } catch (error) {
+        signal?.throwIfAborted();
+        if (shouldReRegisterStoredDynamicClient(error, resolvedClient, reRegistrationAttempted)) {
+          reRegistrationAttempted = true;
+          await clearRegisteredClient(discovery.authorizationServer);
+          await clearSession(resource);
+          currentSession = null;
+          continue;
         }
+        if (!transientRetryAttempted && isRetryableOAuthError(error)) {
+          transientRetryAttempted = true;
+          await clearSession(resource);
+          currentSession = null;
+          continue;
+        }
+        throw error;
+      } finally {
+        loopback.close();
       }
-    })();
-    const finalPromise = promise.finally(() => {
-      authorizationPromises.delete(resource);
-    });
-    authorizationPromises.set(resource, finalPromise);
-    return finalPromise;
+    }
   }
-  async function resolveClient(existingSession, discovery, redirectUri, fetch2) {
-    const configuredClient = normalizeConfiguredClient(options.client);
-    if (options.client.mode === "static") {
+  async function resolveClient(existingSession, discovery, redirectUri, fetch2, parentSignal) {
+    parentSignal?.throwIfAborted();
+    if (clientMode === "static" || configuredClient !== null) {
       if (configuredClient === null) {
         throw new Error("OAuth client_id must not be blank");
       }
+      assertRegistrationIssuer(configuredClient, discovery.authorizationServer);
+      if (hasExpiredClientSecret(configuredClient, now))
+        throw new Error("OAuth client secret has expired; update the imported registration");
       return {
         kind: "static",
         fromStoredRegistration: false,
@@ -4921,14 +5818,22 @@ function createDefaultOAuthClientProvider(options) {
       discovery.authorizationServerMetadata,
       "registration_endpoint"
     );
-    if (registrationEndpoint === void 0 && configuredClient !== null) {
-      return {
-        kind: "static",
-        fromStoredRegistration: false,
-        client: configuredClient
-      };
+    let storedClient = await loadRegisteredClient(discovery.authorizationServer);
+    const importedClient = existingSession?.client.registrationOwnership === "caller" ? existingSession.client : storedClient?.registrationOwnership === "caller" ? storedClient : void 0;
+    if (importedClient !== void 0) {
+      assertRegistrationIssuer(importedClient, discovery.authorizationServer);
+      if (hasExpiredClientSecret(importedClient, now)) throw new Error("OAuth client secret has expired; update the imported registration");
+      if (!registrationMatchesRedirect(importedClient, redirectUri))
+        throw new Error("OAuth imported registration does not match the configured redirect URI; update its callback configuration");
+      return { kind: "static", fromStoredRegistration: false, client: importedClient };
+    }
+    if (storedClient !== null) {
+      assertRegistrationIssuer(storedClient, discovery.authorizationServer);
+      if (hasExpiredClientSecret(storedClient, now) || !registrationMatchesRedirect(storedClient, redirectUri)) {
+        await clearRegisteredClient(discovery.authorizationServer);
+        storedClient = null;
+      }
     }
-    const storedClient = await loadRegisteredClient(discovery.authorizationServer);
     if (storedClient !== null) {
       return {
         kind: "dynamic",
@@ -4937,7 +5842,7 @@ function createDefaultOAuthClientProvider(options) {
       };
     }
     if (registrationEndpoint === void 0) {
-      if (existingSession !== null && existingSession.client.clientId.length > 0) {
+      if (existingSession !== null && existingSession.client.clientId.length > 0 && !hasExpiredClientSecret(existingSession.client, now) && registrationMatchesRedirect(existingSession.client, redirectUri)) {
         return {
           kind: "dynamic",
           fromStoredRegistration: true,
@@ -4946,52 +5851,62 @@ function createDefaultOAuthClientProvider(options) {
       }
       throw new Error("Authorization server metadata is missing registration_endpoint");
     }
-    if (existingSession !== null && existingSession.client.clientId.length > 0) {
-      const isConfiguredStaticFallback = configuredClient !== null && existingSession.client.clientId === configuredClient.clientId && existingSession.client.clientSecret === configuredClient.clientSecret;
-      if (!isConfiguredStaticFallback) {
-        await saveRegisteredClient(discovery.authorizationServer, existingSession.client);
-        return {
-          kind: "dynamic",
-          fromStoredRegistration: true,
-          client: existingSession.client
-        };
-      }
+    if (existingSession !== null && existingSession.client.clientId.length > 0 && !hasExpiredClientSecret(existingSession.client, now) && registrationMatchesRedirect(existingSession.client, redirectUri)) {
+      await saveRegisteredClient(discovery.authorizationServer, existingSession.client);
+      return {
+        kind: "dynamic",
+        fromStoredRegistration: true,
+        client: existingSession.client
+      };
     }
+    const supported = getSupportedTokenAuthMethods(discovery.authorizationServerMetadata);
+    const registrationMethod = requestedTokenMethod ?? (supported === void 0 ? "none" : ["none", "client_secret_basic", "client_secret_post"].find((method) => supported.includes(method)));
+    if (registrationMethod === void 0 || supported !== void 0 && !supported.includes(registrationMethod))
+      throw new Error("Authorization server does not support the requested OAuth token endpoint authentication");
     const registrationBody = buildClientRegistrationBody(
-      getClientMetadata(options.client),
-      redirectUri
+      clientMetadata,
+      redirectUri,
+      registrationMethod
     );
-    const signal = AbortSignal.timeout(3e4);
+    const deadline = AbortSignal.timeout(3e4);
+    const signal = parentSignal === void 0 ? deadline : AbortSignal.any([parentSignal, deadline]);
     const response = await fetchMcpResponse(fetch2, registrationEndpoint, {
       method: "POST",
       headers: {
+        Accept: "application/json",
         "Content-Type": "application/json"
       },
       body: JSON.stringify(registrationBody),
       signal
     });
     const payload = await readOAuthJsonObjectResponse(response, signal);
-    const clientId = getOwnString2(payload, "client_id");
-    if (clientId === void 0 || clientId.trim().length === 0) {
-      throw new Error("OAuth client registration response missing client_id");
-    }
-    const clientSecret = getOwnString2(payload, "client_secret");
+    const registration = parseOAuthClientRegistration(payload);
+    const registeredSecret = getOwnString2(registration, "client_secret");
+    const responseMethod = normalizeOAuthTokenEndpointAuthMethod(getOwnEntry6(registration, "token_endpoint_auth_method")) ?? requestedTokenMethod ?? (supported === void 0 ? void 0 : normalizeOAuthTokenEndpointAuthMethod(registrationMethod));
     const registeredClient = {
-      clientId: clientId.trim(),
-      clientSecret: clientSecret !== void 0 && clientSecret.trim().length > 0 ? clientSecret.trim() : void 0
+      clientId: registration.client_id.trim(),
+      ...registeredSecret === void 0 ? {} : { clientSecret: registeredSecret.trim() },
+      ...responseMethod === void 0 ? {} : { tokenEndpointAuthMethod: responseMethod },
+      registration
     };
-    await saveRegisteredClient(discovery.authorizationServer, registeredClient);
+    assertRegistrationIssuer(registeredClient, discovery.authorizationServer);
+    if (hasExpiredClientSecret(registeredClient, now))
+      throw new Error("OAuth client secret has expired in the registration response");
+    if (!registrationMatchesRedirect(registeredClient, redirectUri, true))
+      throw new Error("OAuth registration response does not match the requested redirect URI");
+    const clientWithRedirect = { ...registeredClient, requestedRedirectUri: redirectUri };
+    await saveRegisteredClient(discovery.authorizationServer, clientWithRedirect);
     return {
       kind: "dynamic",
       fromStoredRegistration: false,
-      client: registeredClient
+      client: clientWithRedirect
     };
   }
   async function loadSession(resource) {
     return normalizeLoadedSession(await sessionStore.load(resource));
   }
   async function saveSession(resource, session) {
-    await sessionStore.save(resource, session);
+    await sessionStore.save(resource, structuredClone(session));
   }
   async function clearSession(resource) {
     await sessionStore.clear(resource);
@@ -5004,7 +5919,7 @@ function createDefaultOAuthClientProvider(options) {
       return null;
     }
     const client = await clientStore.load(issuer);
-    const normalizedClient = client === null ? null : normalizeStoredClient(client);
+    const normalizedClient = client === null ? null : normalizeStoredOAuthClient(client);
     if (client !== null && normalizedClient === null) {
       await clientStore.clear(issuer);
       return null;
@@ -5061,9 +5976,13 @@ function resolveDiscovery(discovery, session) {
     authorizationServerMetadata: metadata
   };
 }
+function sameTokenGrant(left, right) {
+  return left.accessToken === right.accessToken && left.refreshToken === right.refreshToken && left.tokenType === right.tokenType && left.expiresAt === right.expiresAt && left.scope === right.scope;
+}
 function clearSessionTokens(session) {
   const nextSession = { ...session };
   delete nextSession.tokens;
+  delete nextSession.refreshState;
   return nextSession;
 }
 function hasCachedAccessToken(session) {
@@ -5073,34 +5992,41 @@ function normalizeLoadedSession(session) {
   if (session === null) {
     return null;
   }
-  const client = normalizeStoredClient(getOwnEntry6(session, "client"));
+  const discovery = structuredClone(session.discovery);
+  const refreshState = getOwnEntry6(session, "refreshState");
+  if (refreshState !== void 0 && (refreshState !== "pending" || getOwnEntry6(session, "tokens") !== void 0))
+    throw new Error("Stored OAuth refresh state is invalid");
+  const client = normalizeStoredOAuthClient(getOwnEntry6(session, "client"));
   if (client === null) {
-    return { ...session, client: { clientId: "" }, tokens: void 0 };
-  }
-  return {
-    ...session,
-    client,
-    tokens: normalizeStoredTokens(getOwnEntry6(session, "tokens"))
-  };
-}
-function normalizeStoredClient(value) {
-  if (!isObjectRecord3(value)) {
-    return null;
+    return { ...session, discovery, client: { clientId: "" }, tokens: void 0 };
   }
-  const clientId = getOwnString2(value, "clientId");
-  if (clientId === void 0 || clientId.trim().length === 0) {
-    return null;
-  }
-  const normalizedClientId = clientId.trim();
-  const clientSecret = getOwnEntry6(value, "clientSecret");
-  if (clientSecret === void 0) {
-    return { clientId: normalizedClientId };
-  }
-  if (typeof clientSecret !== "string" || clientSecret.trim().length === 0) {
-    return null;
+  const tokens = normalizeStoredTokens(getOwnEntry6(session, "tokens"));
+  if (tokens !== void 0) {
+    try {
+      new Headers({ Authorization: `Bearer ${tokens.accessToken}` });
+    } catch {
+      throw new Error("Stored OAuth access token is not a valid HTTP header value");
+    }
   }
-  const normalizedClientSecret = clientSecret.trim();
-  return { clientId: normalizedClientId, clientSecret: normalizedClientSecret };
+  return { ...session, discovery, client, tokens };
+}
+function snapshotInitialGrantTokens(value) {
+  if (!isObjectRecord3(value)) return value;
+  const expiresAt = getOwnEntry6(value, "expiresAt"), expiresIn = getOwnEntry6(value, "expiresIn"), issuedAt = getOwnEntry6(value, "issuedAt");
+  return { ...value, expiresAt, expiresIn, issuedAt };
+}
+function normalizeImportedTokens(value, now) {
+  if (!isObjectRecord3(value)) return void 0;
+  const absolute = getOwnEntry6(value, "expiresAt");
+  const lifetime = getOwnEntry6(value, "expiresIn");
+  const issuedAt = getOwnEntry6(value, "issuedAt");
+  const snapshot = { ...value };
+  if (lifetime !== void 0 && (typeof lifetime !== "number" || !Number.isSafeInteger(lifetime) || lifetime < 0))
+    throw new Error("OAuth initial grant has invalid relative expiry");
+  if (issuedAt !== void 0 && (typeof issuedAt !== "number" || !Number.isSafeInteger(issuedAt) || Math.abs(issuedAt) > MAX_JS_DATE_MS3))
+    throw new Error("OAuth initial grant has invalid issuance time");
+  const expiresAt = absolute !== void 0 && absolute !== null ? absolute : lifetime === void 0 ? null : (issuedAt === void 0 ? now() : issuedAt) + lifetime * 1e3;
+  return normalizeStoredTokens({ ...snapshot, expiresAt });
 }
 function normalizeStoredTokens(value) {
   if (value === void 0 || !isObjectRecord3(value)) {
@@ -5110,10 +6036,10 @@ function normalizeStoredTokens(value) {
   const tokenType = getOwnString2(value, "tokenType");
   const expiresAt = getOwnEntry6(value, "expiresAt");
   const refreshToken = getOwnEntry6(value, "refreshToken");
-  const scope = getOwnString2(value, "scope");
+  const scope = getOwnEntry6(value, "scope");
   const normalizedAccessToken = accessToken?.trim();
   const normalizedRefreshToken = typeof refreshToken === "string" ? refreshToken.trim() : void 0;
-  const normalizedScope = scope?.trim();
+  const normalizedScope = normalizeOAuthScope(scope);
   if (accessToken === void 0 || normalizedAccessToken === void 0 || normalizedAccessToken.length === 0 || tokenType !== "Bearer" || !(expiresAt === null || typeof expiresAt === "number" && Number.isSafeInteger(expiresAt) && expiresAt <= MAX_JS_DATE_MS3 && Number.isFinite(new Date(expiresAt).getTime())) || refreshToken !== void 0 && (typeof refreshToken !== "string" || normalizedRefreshToken === void 0 || normalizedRefreshToken.length === 0)) {
     return void 0;
   }
@@ -5131,18 +6057,23 @@ function getClientMetadata(client) {
   }
   return {
     clientName: normalizeOptionalOAuthString(client.metadata.clientName),
-    scope: normalizeOptionalOAuthString(client.metadata.scope),
+    scope: normalizeOAuthScope(client.metadata.scope),
     softwareId: normalizeOptionalOAuthString(client.metadata.softwareId),
     softwareVersion: normalizeOptionalOAuthString(client.metadata.softwareVersion)
   };
 }
 function normalizeConfiguredClient(client) {
-  const clientId = normalizeOptionalOAuthString(client.clientId);
-  if (clientId === void 0) {
-    return null;
-  }
-  const clientSecret = normalizeOptionalOAuthString(client.clientSecret);
-  return clientSecret === void 0 ? { clientId } : { clientId, clientSecret };
+  const registration = client.registration === void 0 ? void 0 : parseOAuthClientRegistration(client.registration);
+  const clientId = normalizeOptionalOAuthString(client.clientId) ?? registration?.client_id.trim();
+  if (clientId === void 0) return null;
+  const clientSecret = normalizeOptionalOAuthString(client.clientSecret) ?? (registration === void 0 ? void 0 : getOwnString2(registration, "client_secret")?.trim());
+  return normalizeStoredOAuthClient({
+    clientId,
+    clientSecret,
+    registration,
+    ...registration === void 0 ? {} : { registrationOwnership: "caller" },
+    tokenEndpointAuthMethod: client.tokenEndpointAuthMethod
+  });
 }
 function normalizeOptionalOAuthString(value) {
   if (value === void 0) {
@@ -5213,18 +6144,20 @@ function isLoopbackHostname(hostname2) {
 }
 function assertSecureUrl(value, label) {
   const url = new URL2(value);
-  if (url.username !== "" || url.password !== "" || url.hash !== "") {
+  if (url.username !== "" || url.password !== "" || url.href.includes("#")) {
     throw new Error(`${label} must not include credentials or fragment`);
   }
   if (url.protocol === "https:") {
-    return;
+    return url;
   }
   if (url.protocol === "http:" && isLoopbackHostname(url.hostname)) {
-    return;
+    return url;
   }
   throw new Error(`${label} must use https unless it targets a loopback host`);
 }
 function assertSecureOAuthFlowEndpoints(metadata) {
+  const issuer = assertSecureUrl(requireOwnString(metadata, "issuer", "Authorization server metadata"), "Authorization server issuer");
+  if (issuer.href.includes("?")) throw new Error("Authorization server issuer must not include query or fragment");
   const authorizationEndpoint = requireOwnString(
     metadata,
     "authorization_endpoint",
@@ -5258,12 +6191,37 @@ function assertRequestMatchesResource(requestUrl, resource) {
     );
   }
 }
-function buildClientRegistrationBody(metadata, redirectUri) {
+function assertRegistrationIssuer(client, issuer) {
+  const registrationIssuer = client.registration === void 0 ? void 0 : getOwnString2(client.registration, "issuer");
+  if (registrationIssuer !== void 0 && registrationIssuer !== issuer)
+    throw new Error("OAuth client registration issuer does not match the authorization server");
+}
+function hasExpiredClientSecret(client, now) {
+  if (client.clientSecret === void 0 || client.tokenEndpointAuthMethod === "none" || client.registration === void 0) return false;
+  const expiry = getOwnEntry6(client.registration, "client_secret_expires_at");
+  return typeof expiry === "number" && expiry !== 0 && expiry <= now() / 1e3;
+}
+function getSupportedTokenAuthMethods(metadata) {
+  const value = getOwnEntry6(metadata, "token_endpoint_auth_methods_supported");
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value) || value.length > 128 || value.some((method) => typeof method !== "string"))
+    throw new Error("Invalid OAuth token endpoint authentication metadata");
+  return value;
+}
+function assertTokenEndpointAuthentication(client, metadata) {
+  const method = client.tokenEndpointAuthMethod ?? (client.clientSecret === void 0 ? "none" : "client_secret_post");
+  if (method !== "none" && client.clientSecret === void 0)
+    throw new Error("OAuth token endpoint authentication requires a client secret");
+  const supported = getSupportedTokenAuthMethods(metadata);
+  if (supported !== void 0 && !supported.includes(method))
+    throw new Error("Authorization server does not support the requested OAuth token endpoint authentication");
+}
+function buildClientRegistrationBody(metadata, redirectUri, tokenEndpointAuthMethod) {
   const body = {
     redirect_uris: [redirectUri],
     grant_types: ["authorization_code", "refresh_token"],
     response_types: ["code"],
-    token_endpoint_auth_method: "none"
+    token_endpoint_auth_method: tokenEndpointAuthMethod
   };
   const clientName = metadata === void 0 ? void 0 : getOwnString2(metadata, "clientName");
   const scope = metadata === void 0 ? void 0 : getOwnString2(metadata, "scope");
@@ -5300,7 +6258,7 @@ function shouldReRegisterStoredDynamicClient(error, client, alreadyAttempted) {
   if ("kind" in client) {
     return client.kind === "dynamic" && client.fromStoredRegistration;
   }
-  return true;
+  return client.registrationOwnership !== "caller";
 }
 
 // packages/mcp-oauth/src/server/jwks-token-verifier.ts
@@ -5369,7 +6327,7 @@ function getParameterHeaders(schema) {
   const names = /* @__PURE__ */ new Set();
   const ancestors = /* @__PURE__ */ new Set();
   let nodes = 0;
-  const visit = (value, path4, reachable, depth) => {
+  const visit = (value, path6, reachable, depth) => {
     if (++nodes > 1e4 || depth > 64)
       throw new Error("MCP header schema traversal limit exceeded");
     if (typeof value === "boolean") return;
@@ -5378,7 +6336,7 @@ function getParameterHeaders(schema) {
     try {
       if (Object.prototype.hasOwnProperty.call(value, "x-mcp-header")) {
         const name = value["x-mcp-header"];
-        if (!reachable || path4.length === 0 || typeof name !== "string" || name.length === 0 || [...name].some((character) => {
+        if (!reachable || path6.length === 0 || typeof name !== "string" || name.length === 0 || [...name].some((character) => {
           const code = character.charCodeAt(0);
           return !tokenPunctuation.has(character) && !(code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122);
         }))
@@ -5388,7 +6346,7 @@ function getParameterHeaders(schema) {
         const key2 = name.toLowerCase();
         if (names.has(key2)) throw new Error("Duplicate x-mcp-header name");
         names.add(key2);
-        headers.push({ name: `Mcp-Param-${name}`, path: [...path4], type: value.type });
+        headers.push({ name: `Mcp-Param-${name}`, path: [...path6], type: value.type });
       }
       for (const [keyword, child] of Object.entries(value)) {
         if (schemaMaps.has(keyword)) {
@@ -5396,17 +6354,17 @@ function getParameterHeaders(schema) {
           for (const [key2, nested] of Object.entries(child))
             visit(
               nested,
-              keyword === "properties" ? [...path4, key2] : path4,
+              keyword === "properties" ? [...path6, key2] : path6,
               reachable && keyword === "properties",
               depth + 1
             );
         } else if (schemaArrays.has(keyword)) {
           if (!Array.isArray(child)) throw new Error("Invalid schema array");
-          for (const nested of child) visit(nested, path4, false, depth + 1);
+          for (const nested of child) visit(nested, path6, false, depth + 1);
         } else if (schemaChildren.has(keyword)) {
           if (Array.isArray(child))
-            for (const nested of child) visit(nested, path4, false, depth + 1);
-          else visit(child, path4, false, depth + 1);
+            for (const nested of child) visit(nested, path6, false, depth + 1);
+          else visit(child, path6, false, depth + 1);
         }
       }
     } finally {
@@ -5433,6 +6391,21 @@ function createParameterHeaders(definitions, argumentsValue) {
 
 // packages/tiny-mcp-client/src/oauth-discovery.ts
 import { isIP as isIP2 } from "node:net";
+var metadataErrorBrand = /* @__PURE__ */ Symbol.for("poe-platform.tiny-mcp-client.OAuthMetadataError");
+var OAuthMetadataError = class extends Error {
+  constructor(phase, message, status) {
+    super(message);
+    this.phase = phase;
+    this.status = status;
+    this.name = "OAuthMetadataError";
+    Object.defineProperty(this, metadataErrorBrand, { value: true });
+  }
+  phase;
+  status;
+  static is(value) {
+    return value instanceof Error && Object.getOwnPropertyDescriptor(value, metadataErrorBrand)?.value === true;
+  }
+};
 function defaultOAuthMetadataFetch(input, init) {
   return fetch(input, init);
 }
@@ -5450,7 +6423,7 @@ function isLoopbackHostname2(hostname2) {
   return normalizedHostname === "localhost" || normalizedHostname === "::1" || normalizedHostname === "[::1]" || isIP2(normalizedHostname) === 4 && normalizedHostname.startsWith("127.");
 }
 function assertSecureUrl2(url, label) {
-  if (url.username !== "" || url.password !== "" || url.hash !== "") {
+  if (url.username !== "" || url.password !== "" || url.href.includes("#")) {
     throw new Error(`${label} must not include credentials or fragment`);
   }
   if (url.protocol === "https:") {
@@ -5468,9 +6441,13 @@ function validateProtectedResourceMetadata(value, resourceUrl) {
   if (typeof value.resource !== "string" || value.resource.length === 0) {
     throw new Error("Protected resource metadata must include a resource string");
   }
+  if (value.resource.includes("#")) {
+    throw new OAuthMetadataError("protected-resource", "Protected resource metadata resource must not include fragment");
+  }
   const normalizedResource = canonicalizeResourceIndicator(value.resource);
   if (normalizedResource !== resourceUrl) {
-    throw new Error(
+    throw new OAuthMetadataError(
+      "protected-resource",
       `Protected resource metadata resource mismatch: expected ${resourceUrl}, received ${value.resource}`
     );
   }
@@ -5492,7 +6469,8 @@ function validateAuthorizationServerMetadata(value, issuer) {
     throw new Error("Authorization server metadata must include issuer");
   }
   if (value.issuer !== issuer) {
-    throw new Error(
+    throw new OAuthMetadataError(
+      "authorization-server",
       `Authorization server metadata issuer mismatch: expected ${issuer}, received ${value.issuer}`
     );
   }
@@ -5515,11 +6493,6 @@ function validateAuthorizationServerMetadata(value, issuer) {
     } catch {
       throw new Error(`Authorization server metadata ${field} must be an absolute URL`);
     }
-    if (endpoint.username !== "" || endpoint.password !== "" || endpoint.hash !== "") {
-      throw new Error(
-        `Authorization server metadata ${field} must not include credentials or fragment`
-      );
-    }
     assertSecureUrl2(endpoint, `Authorization server metadata ${field}`);
   }
   if (!isStringArray(value.response_types_supported) || !value.response_types_supported.includes("code")) {
@@ -5534,11 +6507,12 @@ function validateAuthorizationServerMetadata(value, issuer) {
   }
   return value;
 }
-async function readJsonResponse(response, label, signal) {
+async function readJsonResponse(response, phase, signal) {
+  const label = phase === "protected-resource" ? "Protected resource metadata" : "Authorization server metadata";
   if (!response.ok) {
-    await response.body?.cancel().catch(() => void 0);
+    void response.body?.cancel().catch(() => void 0);
     const statusDescriptor = `${response.status} ${response.statusText}`.trim();
-    throw new Error(`${label} request failed (${statusDescriptor})`);
+    throw new OAuthMetadataError(phase, `${label} request failed (${statusDescriptor})`, response.status);
   }
   const text = await readBoundedResponseText(response, 1024 * 1024, void 0, signal);
   try {
@@ -5547,14 +6521,16 @@ async function readJsonResponse(response, label, signal) {
     throw new Error(`${label} response must be valid JSON`);
   }
 }
-async function fetchMetadata(fetch2, location, label) {
-  const signal = AbortSignal.timeout(1e4);
+async function fetchMetadata(fetch2, location, phase, parentSignal) {
+  parentSignal?.throwIfAborted();
+  const deadline = AbortSignal.timeout(1e4);
+  const signal = parentSignal === void 0 ? deadline : AbortSignal.any([deadline, parentSignal]);
   const response = await fetchMcpResponse(fetch2, location, {
     method: "GET",
     headers: { Accept: "application/json" },
     signal
   });
-  return readJsonResponse(response, label, signal);
+  return readJsonResponse(response, phase, signal);
 }
 function resolveWellKnownMetadataUrl(inputUrl, suffix) {
   const url = new URL(typeof inputUrl === "string" ? inputUrl : inputUrl.toString());
@@ -5563,7 +6539,7 @@ function resolveWellKnownMetadataUrl(inputUrl, suffix) {
   return url.toString();
 }
 function resolveProtectedResourceMetadataUrl(resourceUrl, resourceMetadataUrl) {
-  const resource = new URL(canonicalizeResourceIndicator(resourceUrl));
+  const resource = new URL(typeof resourceUrl === "string" ? resourceUrl : resourceUrl.toString());
   assertSecureUrl2(resource, "Protected resource URL");
   if (resourceMetadataUrl !== void 0) {
     const resolvedResourceMetadataUrl2 = new URL(
@@ -5582,7 +6558,7 @@ function resolveProtectedResourceMetadataUrl(resourceUrl, resourceMetadataUrl) {
 function validateAuthorizationServerIssuer(issuer) {
   const input = typeof issuer === "string" ? issuer : issuer.toString();
   const url = new URL(input);
-  if (url.search.length > 0 || url.hash.length > 0) {
+  if (url.href.includes("?") || url.href.includes("#")) {
     throw new Error("Authorization server issuer must not include query or fragment");
   }
   assertSecureUrl2(url, "Authorization server issuer");
@@ -5601,8 +6577,8 @@ function authorizationServerMetadataLocations(issuer) {
   ];
   const issuerUrl = new URL(issuer);
   if (issuerUrl.pathname !== "/") {
-    const path4 = issuerUrl.pathname.endsWith("/") ? issuerUrl.pathname.slice(0, -1) : issuerUrl.pathname;
-    issuerUrl.pathname = `${path4}/.well-known/openid-configuration`;
+    const path6 = issuerUrl.pathname.endsWith("/") ? issuerUrl.pathname.slice(0, -1) : issuerUrl.pathname;
+    issuerUrl.pathname = `${path6}/.well-known/openid-configuration`;
     locations.push(issuerUrl.toString());
   }
   return locations;
@@ -5616,11 +6592,6 @@ function validateCachedDiscovery(value, resource) {
   }
   const resourceMetadata = validateProtectedResourceMetadata(value.resourceMetadata, resource);
   const resourceMetadataLocation = new URL(value.resourceMetadataUrl);
-  if (resourceMetadataLocation.username !== "" || resourceMetadataLocation.password !== "" || resourceMetadataLocation.hash !== "") {
-    throw new Error(
-      "Cached OAuth discovery metadata location must not include credentials or fragment"
-    );
-  }
   assertSecureUrl2(resourceMetadataLocation, "Cached OAuth discovery metadata location");
   const issuer = validateAuthorizationServerIssuer(value.authorizationServer);
   if (!resourceMetadata.authorization_servers.includes(issuer)) {
@@ -5642,6 +6613,20 @@ function validateCachedDiscovery(value, resource) {
     authorizationServerMetadata
   });
 }
+async function waitForCache(operation, signal) {
+  if (signal === void 0) return operation;
+  let abort;
+  try {
+    return await new Promise((resolve, reject) => {
+      abort = () => reject(signal.reason);
+      signal.addEventListener("abort", abort, { once: true });
+      Promise.resolve(operation).then(resolve, reject);
+      if (signal.aborted) abort();
+    });
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
 var OAuthMetadataDiscovery = class {
   fetchImpl;
   cache;
@@ -5650,7 +6635,7 @@ var OAuthMetadataDiscovery = class {
     this.fetchImpl = fetch2;
     this.cache = cache;
   }
-  async discoverProtectedResource(resource, resourceMetadataUrl) {
+  async discoverProtectedResource(resource, resourceMetadataUrl, signal) {
     const locations = /* @__PURE__ */ new Set([resolveProtectedResourceMetadataUrl(resource, resourceMetadataUrl)]);
     if (resourceMetadataUrl === void 0) {
       locations.add(new URL("/.well-known/oauth-protected-resource", resource).toString());
@@ -5659,34 +6644,37 @@ var OAuthMetadataDiscovery = class {
     for (const location of locations) {
       try {
         const metadata = validateProtectedResourceMetadata(
-          await fetchMetadata(this.fetchImpl, location, "Protected resource metadata"),
+          await fetchMetadata(this.fetchImpl, location, "protected-resource", signal),
           resource
         );
         return { location, metadata };
       } catch (error) {
+        signal?.throwIfAborted();
         lastError = error;
       }
     }
     throw lastError;
   }
-  async discover(resourceUrl, { resourceMetadataUrl } = {}) {
+  async discover(resourceUrl, { resourceMetadataUrl, signal } = {}) {
+    signal?.throwIfAborted();
     const cacheKey = canonicalizeResourceIndicator(resourceUrl);
-    resolveProtectedResourceMetadataUrl(cacheKey, resourceMetadataUrl);
+    resolveProtectedResourceMetadataUrl(resourceUrl, resourceMetadataUrl);
     const memoryCachedResult = this.memoryCache.get(cacheKey);
     if (memoryCachedResult !== void 0 && resourceMetadataUrl === void 0) {
       return structuredClone(memoryCachedResult);
     }
-    const sharedCachedResult = await this.cache?.get(cacheKey);
+    const sharedCachedResult = resourceMetadataUrl === void 0 ? await waitForCache(this.cache?.get(cacheKey), signal) : void 0;
+    signal?.throwIfAborted();
     if (sharedCachedResult !== null && sharedCachedResult !== void 0 && resourceMetadataUrl === void 0) {
       try {
         const result = validateCachedDiscovery(sharedCachedResult, cacheKey);
         this.memoryCache.set(cacheKey, structuredClone(result));
         return result;
       } catch {
-        await this.cache?.delete?.(cacheKey);
+        await waitForCache(this.cache?.delete?.(cacheKey), signal);
       }
     }
-    const { location: resourceMetadataLocation, metadata: resourceMetadata } = await this.discoverProtectedResource(cacheKey, resourceMetadataUrl);
+    const { location: resourceMetadataLocation, metadata: resourceMetadata } = await this.discoverProtectedResource(cacheKey, resourceMetadataUrl, signal);
     const authorizationServerErrors = [];
     for (const authorizationServer of resourceMetadata.authorization_servers) {
       const normalizedAuthorizationServer = validateAuthorizationServerIssuer(authorizationServer);
@@ -5694,7 +6682,7 @@ var OAuthMetadataDiscovery = class {
       for (const authorizationServerMetadataUrl of metadataLocations) {
         try {
           const authorizationServerMetadata = validateAuthorizationServerMetadata(
-            await fetchMetadata(this.fetchImpl, authorizationServerMetadataUrl, "Authorization server metadata"),
+            await fetchMetadata(this.fetchImpl, authorizationServerMetadataUrl, "authorization-server", signal),
             normalizedAuthorizationServer
           );
           const result = {
@@ -5706,16 +6694,18 @@ var OAuthMetadataDiscovery = class {
             authorizationServerMetadata
           };
           this.memoryCache.set(cacheKey, structuredClone(result));
-          await this.cache?.set(cacheKey, structuredClone(result));
+          await waitForCache(this.cache?.set(cacheKey, structuredClone(result)), signal);
           return result;
         } catch (error) {
+          signal?.throwIfAborted();
           authorizationServerErrors.push(
             `${authorizationServerMetadataUrl}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
       }
     }
-    throw new Error(
+    throw new OAuthMetadataError(
+      "authorization-server",
       `Unable to load authorization server metadata for ${cacheKey}: ${authorizationServerErrors.join(
         "; "
       )}`
@@ -5877,7 +6867,11 @@ function parseBearerWwwAuthenticateHeader(headerValue) {
           if (parsedParam === null) {
             break;
           }
-          params[parsedParam.name.toLowerCase()] = parsedParam.value;
+          const parameterName = parsedParam.name.toLowerCase();
+          if (scheme.token.toLowerCase() === "bearer" && Object.hasOwn(params, parameterName)) {
+            throw new Error("Bearer challenge must not repeat authentication parameters");
+          }
+          params[parameterName] = parsedParam.value;
           index = skipOptionalWhitespace(headerValue, parsedParam.nextIndex);
           if (headerValue[index] !== ",") {
             break;
@@ -5919,6 +6913,7 @@ var inputResponseTypes = {
   "sampling/createMessage": "CreateMessageResult",
   "elicitation/create": "ElicitResult"
 };
+var MCP_PROTOCOL_VERSIONS = Object.freeze(["2025-03-26", "2025-06-18", "2025-11-25", "2026-07-28"]);
 var MCP_PROTOCOL_VERSION = "2025-03-26";
 var McpClient = class {
   currentState = "disconnected";
@@ -5962,6 +6957,8 @@ var McpClient = class {
   }
   async connect(transport, options = {}) {
     options.signal?.throwIfAborted();
+    if (this.options.protocolVersion !== void 0 && !MCP_PROTOCOL_VERSIONS.includes(this.options.protocolVersion))
+      throw new Error(`Unsupported protocolVersion; use ${MCP_PROTOCOL_VERSIONS.join(", ")}`);
     if (this.currentState !== "disconnected" && this.currentState !== "closed") {
       throw new Error("MCP client is already connected");
     }
@@ -5971,9 +6968,13 @@ var McpClient = class {
     this.currentInstructions = void 0;
     this.subscribedResourceUris.clear();
     this.activeProgressTokens.clear();
-    const transportClosedReason = transport.closed.then((closedEvent) => closedEvent.reason).catch(
+    const transportClosedReason = (transport.closeReason ?? transport.closed.then((closedEvent) => closedEvent.reason)).catch(
       (error) => error instanceof Error ? error : new Error(String(error))
     );
+    let primaryCloseReason;
+    void transportClosedReason.then((reason) => {
+      primaryCloseReason = reason;
+    });
     const messageLayer = new JsonRpcMessageLayer(
       transport.readable,
       transport.writable,
@@ -6090,7 +7091,7 @@ var McpClient = class {
       if (this.transport !== transport) {
         return;
       }
-      this.messageLayer?.dispose(closedEvent.reason);
+      this.messageLayer?.dispose(primaryCloseReason ?? closedEvent.reason);
       this.messageLayer = null;
       this.transport = null;
       this.currentState = "closed";
@@ -6130,7 +7131,7 @@ var McpClient = class {
       }
       let discovery;
       try {
-        if (this.options.protocolVersion !== "2025-03-26") discovery = await messageLayer.sendRequest("server/discover", {
+        if (this.options.protocolVersion === void 0 || this.options.protocolVersion === "2026-07-28") discovery = await messageLayer.sendRequest("server/discover", {
           _meta: {
             "io.modelcontextprotocol/protocolVersion": "2026-07-28",
             "io.modelcontextprotocol/clientCapabilities": capabilities
@@ -6138,6 +7139,7 @@ var McpClient = class {
         }, { signal: options.signal, timeoutMs: this.options.protocolVersion === "2026-07-28" ? this.options.requestTimeoutMs ?? 3e4 : Math.min(this.options.requestTimeoutMs ?? 3e4, 1e3) });
       } catch (error) {
         options.signal?.throwIfAborted();
+        if (this.options.protocolVersion === "2026-07-28") throw error;
         if (error instanceof McpError && [-32020, -32021, -32022].includes(error.code)) throw error;
       }
       if (discovery !== void 0) {
@@ -6181,7 +7183,7 @@ var McpClient = class {
         };
       }
       const initializeResultValue = await messageLayer.sendRequest("initialize", {
-        protocolVersion: MCP_PROTOCOL_VERSION,
+        protocolVersion: this.options.protocolVersion ?? MCP_PROTOCOL_VERSION,
         clientInfo: this.options.clientInfo,
         capabilities
       }, { signal: options.signal });
@@ -6189,12 +7191,14 @@ var McpClient = class {
         throw new McpError(ERROR_INVALID_REQUEST, "Invalid initialize result");
       }
       const initializeResult = initializeResultValue;
-      if (initializeResult.protocolVersion !== MCP_PROTOCOL_VERSION) {
+      if (initializeResult.protocolVersion === "2026-07-28" || !MCP_PROTOCOL_VERSIONS.includes(initializeResult.protocolVersion)) {
         throw new McpError(
           ERROR_INVALID_REQUEST,
           `Unsupported protocol version: ${initializeResult.protocolVersion}`
         );
       }
+      if (this.options.protocolVersion !== void 0 && initializeResult.protocolVersion !== this.options.protocolVersion)
+        throw new McpError(ERROR_INVALID_REQUEST, `Pinned protocol version ${this.options.protocolVersion} rejected: server selected ${initializeResult.protocolVersion}`);
       this.currentServerCapabilities = structuredClone(initializeResult.capabilities);
       this.currentServerInfo = structuredClone(initializeResult.serverInfo);
       this.currentInstructions = initializeResult.instructions;
@@ -6209,7 +7213,8 @@ var McpClient = class {
           async (params, context) => this.options.onElicitationRequest(params, context)
         );
       }
-      messageLayer.sendNotification("notifications/initialized");
+      if (transport.completeInitialization === void 0) messageLayer.sendNotification("notifications/initialized");
+      else await transport.completeInitialization({ signal: options.signal, timeoutMs: this.options.requestTimeoutMs ?? 3e4, protocolVersion: initializeResult.protocolVersion });
       this.currentState = "ready";
       return initializeResult;
     } catch (error) {
@@ -6247,6 +7252,7 @@ var McpClient = class {
     };
   }
   async callTool(params, options = {}) {
+    options = { ...options };
     const messageLayer = this.getMessageLayerOrThrow();
     const serverCapabilities = this.getServerCapabilitiesOrThrow();
     if (serverCapabilities.tools === void 0) {
@@ -6544,6 +7550,18 @@ var ERROR_INVALID_REQUEST = -32600;
 var ERROR_METHOD_NOT_FOUND = -32601;
 var ERROR_INVALID_PARAMS = -32602;
 var ERROR_INTERNAL = -32603;
+var HttpTransportError = class extends Error {
+  constructor(message, status, method, rpcMethod) {
+    super(message);
+    this.status = status;
+    this.method = method;
+    this.rpcMethod = rpcMethod;
+    this.name = "HttpTransportError";
+  }
+  status;
+  method;
+  rpcMethod;
+};
 function defaultStdioSpawn(command, args, options) {
   return spawn2(command, args, options);
 }
@@ -6649,23 +7667,41 @@ var StdioTransport = class _StdioTransport {
     }
   }
 };
+function snapshotHttpTransportHeaders(headers) {
+  try {
+    return new Headers(headers);
+  } catch {
+    throw new Error("Invalid HTTP transport headers");
+  }
+}
 var HttpTransport = class {
   readable;
   writable;
   closed;
+  closeReason;
+  resolveCloseReason;
   url;
+  mode;
+  legacyEndpoint;
+  legacyEndpointReady;
+  resolveLegacyEndpoint;
+  rejectLegacyEndpoint;
   headers;
   fetchImpl;
   readStream = new PassThrough();
   writeStream = new PassThrough();
   resolveClosed;
   sessionId;
+  legacyProtocolVersion;
+  initializationRequestId;
   lastEventId;
   getSseStreamStarted = false;
   disposed = false;
   oauthProvider;
   oauthMetadataDiscovery;
   inFlightFetchAbortControllers = /* @__PURE__ */ new Set();
+  inFlightOAuthAbortControllers = /* @__PURE__ */ new Set();
+  oauthRequestTokens = /* @__PURE__ */ new WeakMap();
   openResponseReaders = /* @__PURE__ */ new Set();
   modernRequests = /* @__PURE__ */ new Map();
   modernMode = false;
@@ -6674,6 +7710,7 @@ var HttpTransport = class {
   onWarning;
   constructor({
     url,
+    mode = "streamable-http",
     headers = {},
     fetch: fetchImpl = defaultHttpTransportFetch,
     oauth,
@@ -6683,9 +7720,17 @@ var HttpTransport = class {
   }) {
     if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes < 1)
       throw new Error("HTTP response byte limit must be a positive safe integer");
+    try {
+      const target = new URL(url);
+      if (!["http:", "https:"].includes(target.protocol) || target.username || target.password || target.href.includes("#"))
+        throw new Error("Invalid HTTP transport target");
+    } catch {
+      throw new Error("HTTP transport URL must be an absolute HTTP URL without credentials or fragment");
+    }
     this.maxResponseBytes = maxResponseBytes;
     this.url = url;
-    this.headers = headers;
+    this.mode = mode;
+    this.headers = snapshotHttpTransportHeaders(headers);
     this.fetchImpl = fetchImpl;
     this.onWarning = onWarning;
     this.oauthProvider = oauth === void 0 ? void 0 : createOAuthClientProvider(oauth);
@@ -6695,6 +7740,9 @@ var HttpTransport = class {
     });
     this.readable = this.readStream;
     this.writable = this.writeStream;
+    this.closeReason = new Promise((resolve) => {
+      this.resolveCloseReason = resolve;
+    });
     this.closed = new Promise((resolve) => {
       this.resolveClosed = resolve;
     });
@@ -6708,6 +7756,24 @@ var HttpTransport = class {
       this.dispose(error instanceof Error ? error : new Error(String(error)));
     });
   }
+  async completeInitialization(options) {
+    validateRequestTimer(options.timeoutMs, "timeoutMs");
+    const deadline = options.timeoutMs > 0 ? AbortSignal.timeout(Math.ceil(options.timeoutMs)) : void 0;
+    const signals = [options.signal, deadline].filter((signal2) => signal2 !== void 0);
+    const signal = signals.length === 0 ? new AbortController().signal : AbortSignal.any(signals);
+    signal.throwIfAborted();
+    if (options.protocolVersion !== void 0) this.legacyProtocolVersion = options.protocolVersion;
+    this.maybeOpenGetSseStream();
+    try {
+      await this.sendPost(serializeJsonRpcMessage({ jsonrpc: "2.0", method: "notifications/initialized" }), signal);
+      signal.throwIfAborted();
+      if (this.disposed) throw await this.closeReason;
+    } catch (error) {
+      if (error instanceof HttpTransportError)
+        throw new HttpTransportError(error.message, error.status, error.method, "notifications/initialized");
+      throw error;
+    }
+  }
   filterTools(tools, reset = true) {
     if (reset) this.toolParameterHeaders.clear();
     const accepted = [];
@@ -6729,8 +7795,13 @@ var HttpTransport = class {
       return;
     }
     this.disposed = true;
+    this.rejectLegacyEndpoint?.(reason);
+    this.rejectLegacyEndpoint = void 0;
+    this.resolveLegacyEndpoint = void 0;
+    this.resolveCloseReason?.(reason);
+    this.resolveCloseReason = void 0;
     this.toolParameterHeaders.clear();
-    this.abortInFlightFetches();
+    this.abortInFlightFetches(reason);
     this.cancelOpenResponseReaders();
     if (!this.writeStream.destroyed && !this.writeStream.writableEnded) {
       this.writeStream.end();
@@ -6766,12 +7837,14 @@ var HttpTransport = class {
     this.resolveClosed = void 0;
     resolveClosed?.({ reason: closeReason });
   }
-  abortInFlightFetches() {
-    for (const controller of this.modernRequests.values()) controller.abort();
+  abortInFlightFetches(reason) {
+    for (const controller of this.modernRequests.values()) controller.abort(reason);
     this.modernRequests.clear();
     for (const abortController of this.inFlightFetchAbortControllers) {
-      abortController.abort();
+      abortController.abort(reason);
     }
+    for (const controller of this.inFlightOAuthAbortControllers) controller.abort(reason);
+    this.inFlightOAuthAbortControllers.clear();
     this.inFlightFetchAbortControllers.clear();
   }
   cancelOpenResponseReaders() {
@@ -6806,7 +7879,11 @@ var HttpTransport = class {
       const parsed = parseJsonRpcMessage(line);
       const post = this.sendPost(line);
       if (parsed.type === "request" && parsed.message.method === "initialize" || parsed.type === "notification" && parsed.message.method === "notifications/initialized") {
-        await post;
+        try {
+          await post;
+        } catch (error) {
+          this.dispose(error instanceof Error ? error : new Error(String(error)));
+        }
       } else {
         void post.catch((error) => {
           this.dispose(error instanceof Error ? error : new Error(String(error)));
@@ -6814,28 +7891,39 @@ var HttpTransport = class {
       }
     }
   }
-  async sendPost(line) {
+  async sendPost(line, signal) {
+    signal?.throwIfAborted();
     const parsed = parseJsonRpcMessage(line);
     const message = parsed.type === "request" || parsed.type === "notification" ? parsed.message : void 0;
     const metadata = isObjectRecord5(message?.params) ? message.params._meta : void 0;
     const modern = isObjectRecord5(metadata) && typeof metadata["io.modelcontextprotocol/protocolVersion"] === "string";
     if (modern) this.modernMode = true;
-    if (parsed.type === "request" && parsed.message.method === "initialize")
+    if (parsed.type === "request" && parsed.message.method === "initialize") {
       this.modernMode = false;
+      this.initializationRequestId = parsed.message.id;
+      this.legacyProtocolVersion = MCP_PROTOCOL_VERSION;
+      if (isObjectRecord5(parsed.message.params) && typeof parsed.message.params.protocolVersion === "string")
+        this.legacyProtocolVersion = parsed.message.params.protocolVersion;
+    }
     if (this.modernMode && parsed.type === "notification" && parsed.message.method === "notifications/cancelled") {
       const requestId = isObjectRecord5(parsed.message.params) ? parsed.message.params.requestId : void 0;
       if (typeof requestId === "string" || typeof requestId === "number")
         this.modernRequests.get(requestId)?.abort();
       return;
     }
-    const controller = modern && parsed.type === "request" ? new AbortController() : void 0;
+    const controller = modern && parsed.type === "request" || signal !== void 0 ? new AbortController() : void 0;
+    const aborted = () => controller?.abort(signal?.reason);
+    signal?.addEventListener("abort", aborted, { once: true });
+    if (signal?.aborted) aborted();
     const id = parsed.type === "request" ? parsed.message.id : void 0;
     if (controller !== void 0 && id !== void 0) this.modernRequests.set(id, controller);
     try {
+      const postUrl = this.mode === "sse" ? await this.ensureLegacyEndpoint() : this.url;
       const hasSessionId = !modern && this.sessionId !== void 0;
       const response = await this.fetchWithOAuthRetry({
+        url: postUrl,
         method: "POST",
-        createHeaders: () => this.createPostHeaders(message, modern),
+        createHeaders: (signal2) => this.createPostHeaders(message, modern, signal2),
         body: line,
         controller
       });
@@ -6846,7 +7934,7 @@ var HttpTransport = class {
       if (hasSessionId && response.status === 404) {
         void response.body?.cancel().catch(() => void 0);
         this.sessionId = void 0;
-        this.dispose(new Error("HTTP transport session expired (404 response)"));
+        this.dispose(new HttpTransportError("HTTP transport session expired (404 response)", 404, "POST"));
         return;
       }
       if (await this.throwForPostHttpError(
@@ -6859,23 +7947,26 @@ var HttpTransport = class {
         void response.body?.cancel().catch(() => void 0);
         return;
       }
-      if (!modern) {
+      if (!modern && this.mode !== "sse") {
         this.captureSessionId(response);
-        this.maybeOpenGetSseStream();
+        if (message?.method !== "initialize") this.maybeOpenGetSseStream();
       }
-      if (controller !== void 0) await this.forwardResponseMessages(response, controller.signal, parsed.type === "request" ? new HttpResponseMessages(parsed.message) : void 0);
-      else
+      if (controller !== void 0 || message?.method === "initialize") {
+        await this.forwardResponseMessages(response, controller?.signal, controller === void 0 || parsed.type !== "request" ? void 0 : new HttpResponseMessages(parsed.message), message?.method === "initialize");
+        if (message?.method === "initialize") this.maybeOpenGetSseStream();
+      } else
         void this.forwardResponseMessages(response).catch((error) => {
           this.dispose(error instanceof Error ? error : new Error(String(error)));
         });
     } catch (error) {
       if (!controller?.signal.aborted) throw error;
     } finally {
+      signal?.removeEventListener("abort", aborted);
       if (id !== void 0 && this.modernRequests.get(id) === controller)
         this.modernRequests.delete(id);
     }
   }
-  async createPostHeaders(message, modern = false) {
+  async createPostHeaders(message, modern = false, signal) {
     const headers = new Headers(this.headers);
     headers.set("Accept", "application/json, text/event-stream");
     headers.set("Content-Type", "application/json");
@@ -6903,34 +7994,43 @@ var HttpTransport = class {
       }
     } else if (this.sessionId !== void 0) {
       headers.set("Mcp-Session-Id", this.sessionId);
-      headers.set("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
     }
-    return this.authorizeRequestHeaders(headers);
+    if (!modern && message?.method !== "initialize" && this.legacyProtocolVersion !== void 0)
+      headers.set("MCP-Protocol-Version", this.legacyProtocolVersion);
+    return this.authorizeRequestHeaders(headers, signal);
   }
-  async createGetHeaders() {
+  async createGetHeaders(signal) {
     const headers = new Headers(this.headers);
     headers.set("Accept", "text/event-stream");
     if (this.sessionId !== void 0) {
       headers.set("Mcp-Session-Id", this.sessionId);
-      headers.set("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
     }
+    if (this.legacyProtocolVersion !== void 0) headers.set("MCP-Protocol-Version", this.legacyProtocolVersion);
     if (this.lastEventId !== void 0) {
-      headers.set("Last-Event-ID", this.lastEventId);
+      if (this.lastEventId === "") headers.delete("Last-Event-ID");
+      else headers.set("Last-Event-ID", Buffer.from(this.lastEventId, "utf8").toString("latin1"));
     }
-    return this.authorizeRequestHeaders(headers);
+    return this.authorizeRequestHeaders(headers, signal);
   }
-  async createDeleteHeaders(sessionId) {
+  async createDeleteHeaders(sessionId, signal) {
     const headers = new Headers(this.headers);
     headers.set("Mcp-Session-Id", sessionId);
-    headers.set("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
-    return this.authorizeRequestHeaders(headers);
+    headers.set("MCP-Protocol-Version", this.legacyProtocolVersion ?? MCP_PROTOCOL_VERSION);
+    return this.authorizeRequestHeaders(headers, signal);
   }
-  async authorizeRequestHeaders(headers) {
-    await this.oauthProvider?.authorizeRequest?.({
+  async authorizeRequestHeaders(headers, signal) {
+    signal?.throwIfAborted();
+    const tokens = await this.oauthProvider?.authorizeRequest?.({
       requestUrl: new URL(this.url),
       headers,
-      fetch: this.fetchImpl
+      signal,
+      fetch: (url, init) => fetchMcpResponse(this.fetchImpl, url, {
+        ...init,
+        signal: signal === void 0 ? init?.signal : init?.signal == null ? signal : AbortSignal.any([signal, init.signal])
+      })
     });
+    if (tokens !== void 0) this.oauthRequestTokens.set(headers, { ...tokens });
+    signal?.throwIfAborted();
     return headers;
   }
   captureSessionId(response) {
@@ -6955,8 +8055,19 @@ var HttpTransport = class {
       this.dispose(error instanceof Error ? error : new Error(String(error)));
     });
   }
+  ensureLegacyEndpoint() {
+    if (this.legacyEndpointReady !== void 0) return this.legacyEndpointReady;
+    this.legacyEndpointReady = new Promise((resolve, reject) => {
+      this.resolveLegacyEndpoint = resolve;
+      this.rejectLegacyEndpoint = reject;
+    });
+    void this.consumeGetSseStream().catch((error) => {
+      this.dispose(error instanceof Error ? error : new Error(String(error)));
+    });
+    return this.legacyEndpointReady;
+  }
   async sendSessionTerminationRequest(sessionId, signal) {
-    const headers = await this.createDeleteHeaders(sessionId);
+    const headers = await this.createDeleteHeaders(sessionId, signal);
     signal.throwIfAborted();
     const response = await fetchMcpResponse(this.fetchImpl, this.url, {
       method: "DELETE",
@@ -6974,12 +8085,12 @@ var HttpTransport = class {
     const responseBody = (await readBoundedResponseText(response, this.maxResponseBytes, this.openResponseReaders, signal)).trim();
     const statusDescriptor = `${response.status} ${response.statusText}`.trim();
     const message = responseBody.length === 0 ? `HTTP transport DELETE failed (${statusDescriptor})` : `HTTP transport DELETE failed (${statusDescriptor}): ${responseBody}`;
-    throw new Error(message);
+    throw new HttpTransportError(message, response.status, "DELETE");
   }
   async consumeGetSseStream() {
     const response = await this.fetchWithOAuthRetry({
       method: "GET",
-      createHeaders: () => this.createGetHeaders()
+      createHeaders: (signal) => this.createGetHeaders(signal)
     });
     if (this.disposed) {
       void response.body?.cancel().catch(() => void 0);
@@ -6987,26 +8098,32 @@ var HttpTransport = class {
     }
     if (response.status === 405) {
       void response.body?.cancel().catch(() => void 0);
+      if (this.mode === "sse") throw new HttpTransportError("Legacy SSE GET failed (405)", 405, "GET");
       throw new HttpTransportGetSseNotSupportedError();
     }
     if (response.status === 404) {
       void response.body?.cancel().catch(() => void 0);
       this.sessionId = void 0;
-      throw new Error("HTTP transport session expired (GET 404 response)");
+      throw new HttpTransportError("HTTP transport session expired (GET 404 response)", 404, "GET");
     }
     if (!response.ok) {
       const responseBody = (await readBoundedResponseText(response, this.maxResponseBytes, this.openResponseReaders)).trim();
       const statusDescriptor = `${response.status} ${response.statusText}`.trim();
       const message = responseBody.length === 0 ? `HTTP transport GET failed (${statusDescriptor})` : `HTTP transport GET failed (${statusDescriptor}): ${responseBody}`;
-      throw new Error(message);
+      throw new HttpTransportError(message, response.status, "GET");
     }
     const contentType = response.headers.get("Content-Type");
     if (contentType === null) {
       void response.body?.cancel().catch(() => void 0);
+      if (this.mode === "sse") throw new Error("Legacy SSE GET returned an unsupported content type");
       return;
     }
     if (contentType.split(";")[0]?.trim().toLowerCase() === "text/event-stream") {
-      await this.forwardSseResponseMessages(response);
+      await this.forwardSseResponseMessages(response, void 0, void 0, { acceptEndpoint: this.mode === "sse" });
+      if (this.mode === "sse") {
+        if (!this.disposed) throw new Error("Legacy SSE stream ended");
+        return;
+      }
       this.getSseStreamStarted = false;
       if (!this.disposed && this.sessionId !== void 0 && this.lastEventId !== void 0) {
         this.maybeOpenGetSseStream();
@@ -7014,6 +8131,7 @@ var HttpTransport = class {
       return;
     }
     void response.body?.cancel().catch(() => void 0);
+    if (this.mode === "sse") throw new Error("Legacy SSE GET returned an unsupported content type");
   }
   async throwForPostHttpError(response, request, signal) {
     if (response.status < 400) {
@@ -7053,9 +8171,9 @@ var HttpTransport = class {
     }
     const statusDescriptor = `${response.status} ${response.statusText}`.trim();
     const message = responseBody.length === 0 ? `HTTP transport POST failed (${statusDescriptor})` : `HTTP transport POST failed (${statusDescriptor}): ${responseBody}`;
-    throw new Error(message);
+    throw new HttpTransportError(message, response.status, "POST");
   }
-  async maybeHandleUnauthorizedResponse(response) {
+  async maybeHandleUnauthorizedResponse(response, signal, requestHeaders, presentedTokens) {
     if (response.status !== 401 || this.oauthProvider === void 0) {
       return false;
     }
@@ -7063,10 +8181,10 @@ var HttpTransport = class {
     if (discoveryClient === void 0) {
       return false;
     }
-    const challenge = parseBearerWwwAuthenticateHeader(response.headers.get("WWW-Authenticate"));
-    const resourceMetadataUrl = challenge?.params.resource_metadata;
     try {
-      const discovery = await discoveryClient.discover(this.url, { resourceMetadataUrl });
+      const challenge = parseBearerWwwAuthenticateHeader(response.headers.get("WWW-Authenticate"));
+      const resourceMetadataUrl = challenge?.params.resource_metadata;
+      const discovery = await discoveryClient.discover(this.url, { resourceMetadataUrl, signal });
       const providerResponse = response.clone();
       let result;
       try {
@@ -7075,8 +8193,15 @@ var HttpTransport = class {
           response: providerResponse,
           challenge,
           discovery,
-          fetch: this.fetchImpl
+          signal,
+          requestHeaders: new Headers(requestHeaders),
+          presentedTokens,
+          fetch: (url, init) => fetchMcpResponse(this.fetchImpl, url, {
+            ...init,
+            signal: init?.signal == null ? signal : AbortSignal.any([signal, init.signal])
+          })
         });
+        signal.throwIfAborted();
       } finally {
         void providerResponse.body?.cancel().catch(() => void 0);
       }
@@ -7091,7 +8216,7 @@ var HttpTransport = class {
       throw error;
     }
   }
-  async forwardResponseMessages(response, signal, context) {
+  async forwardResponseMessages(response, signal, context, initialization = false) {
     if (response.status === 202) {
       void response.body?.cancel().catch(() => void 0);
       return;
@@ -7103,7 +8228,7 @@ var HttpTransport = class {
     }
     const normalizedContentType = contentType.split(";")[0]?.trim().toLowerCase();
     if (normalizedContentType === "text/event-stream") {
-      await this.forwardSseResponseMessages(response, signal, context);
+      await this.forwardSseResponseMessages(response, signal, context, { stopAfterInitialization: initialization });
       return;
     }
     if (normalizedContentType === "application/json") {
@@ -7113,11 +8238,11 @@ var HttpTransport = class {
     void response.body?.cancel().catch(() => void 0);
     throw new Error("HTTP transport POST returned an unsupported response content type");
   }
-  async forwardSseResponseMessages(response, signal, context) {
+  async forwardSseResponseMessages(response, signal, context, options = {}) {
     if (response.body === null) {
       return;
     }
-    const parser = new SseParser(this.maxResponseBytes);
+    const parser = new SseParser(this.maxResponseBytes, options.acceptEndpoint);
     const decoder = new TextDecoder("utf-8", { fatal: true });
     const reader = response.body.getReader();
     this.openResponseReaders.add(reader);
@@ -7138,19 +8263,19 @@ var HttpTransport = class {
         }
         const messages = parser.push(decoder.decode(value, { stream: true }));
         this.writeSseMessages(messages, context);
-        if (context?.completed) {
+        if (context?.completed || options.stopAfterInitialization && this.initializationRequestId === void 0) {
           void reader.cancel().catch(() => void 0);
           return;
         }
-        this.lastEventId = parser.lastEventId;
+        this.lastEventId = parser.lastEventId ?? this.lastEventId;
       }
       const trailingChunk = decoder.decode();
       if (trailingChunk.length > 0) {
         this.writeSseMessages(parser.push(trailingChunk), context);
-        this.lastEventId = parser.lastEventId;
+        this.lastEventId = parser.lastEventId ?? this.lastEventId;
       }
       this.writeSseMessages(parser.flush(), context);
-      this.lastEventId = parser.lastEventId;
+      this.lastEventId = parser.lastEventId ?? this.lastEventId;
       if (context !== void 0 && !context.completed) throw new Error("MCP HTTP stream ended before its final response");
     } catch (error) {
       void reader.cancel().catch(() => void 0);
@@ -7181,6 +8306,19 @@ var HttpTransport = class {
   }
   writeSseMessages(messages, context) {
     for (const message of messages) {
+      if (message.event === "endpoint") {
+        const endpoint = new URL(message.data, this.url);
+        const resource = new URL(this.url);
+        if (endpoint.protocol !== "http:" && endpoint.protocol !== "https:" || endpoint.origin !== resource.origin || endpoint.username || endpoint.password || endpoint.href.includes("#"))
+          throw new Error("Unsafe legacy SSE endpoint");
+        if (this.legacyEndpoint !== void 0 && this.legacyEndpoint !== endpoint.href)
+          throw new Error("Legacy SSE endpoint changed during the active connection");
+        this.legacyEndpoint = endpoint.href;
+        this.resolveLegacyEndpoint?.(endpoint.href);
+        this.resolveLegacyEndpoint = void 0;
+        this.rejectLegacyEndpoint = void 0;
+        continue;
+      }
       this.writeReadableLine(context?.validate(message.data, true) ?? message.data);
       if (context?.completed) return;
     }
@@ -7189,29 +8327,55 @@ var HttpTransport = class {
     if (this.disposed || this.readStream.destroyed || this.readStream.writableEnded) {
       return;
     }
+    if (this.initializationRequestId !== void 0) {
+      try {
+        const payload = JSON.parse(line);
+        for (const response of Array.isArray(payload) ? payload : [payload]) {
+          if (!isObjectRecord5(response) || response.id !== this.initializationRequestId || !isObjectRecord5(response.result)) continue;
+          const version = response.result.protocolVersion;
+          if (typeof version === "string" && version !== "2026-07-28" && MCP_PROTOCOL_VERSIONS.includes(version))
+            this.legacyProtocolVersion = version;
+          this.initializationRequestId = void 0;
+          this.maybeOpenGetSseStream();
+          break;
+        }
+      } catch {
+      }
+    }
     this.readStream.write(`${line}
 `);
   }
   async fetchWithOAuthRetry(input) {
-    const request = async () => this.fetchWithAbort(
-      this.url,
-      {
+    const controller = input.controller ?? new AbortController();
+    this.inFlightOAuthAbortControllers.add(controller);
+    const request = async () => {
+      controller.signal.throwIfAborted();
+      const headers = await input.createHeaders(controller.signal);
+      const headerSnapshot = new Headers(headers);
+      const tokens = this.oauthRequestTokens.get(headers) ?? null;
+      controller.signal.throwIfAborted();
+      const response = await this.fetchWithAbort(input.url ?? this.url, {
         method: input.method,
-        headers: await input.createHeaders(),
+        headers,
         body: input.body
-      },
-      input.controller
-    );
-    let response = await request();
-    if (await this.maybeHandleUnauthorizedResponse(response)) {
-      response = await request();
-    }
-    const oauthError = this.oauthProvider === void 0 ? null : this.readOAuthChallengeError(response);
-    if (oauthError !== null) {
-      void response.body?.cancel().catch(() => void 0);
-      throw oauthError;
+      }, controller);
+      return { response, headers: headerSnapshot, tokens };
+    };
+    try {
+      let attempt = await request();
+      if (await this.maybeHandleUnauthorizedResponse(attempt.response, controller.signal, attempt.headers, attempt.tokens)) attempt = await request();
+      const response = attempt.response;
+      try {
+        const oauthError = this.oauthProvider === void 0 ? null : this.readOAuthChallengeError(response);
+        if (oauthError !== null) throw oauthError;
+      } catch (error) {
+        void response.body?.cancel().catch(() => void 0);
+        throw error;
+      }
+      return response;
+    } finally {
+      this.inFlightOAuthAbortControllers.delete(controller);
     }
-    return response;
   }
   readOAuthChallengeError(response) {
     if (response.status !== 401 && response.status !== 403) {
@@ -7291,12 +8455,14 @@ async function* readLines(stream, maxLineBytes = 16 * 1024 * 1024) {
   if (parts.length > 0) yield normalizeLine(parts.join(""));
 }
 var SseParser = class {
-  constructor(maxEventBytes = 16 * 1024 * 1024) {
+  constructor(maxEventBytes = 16 * 1024 * 1024, acceptEndpoint = false) {
     this.maxEventBytes = maxEventBytes;
+    this.acceptEndpoint = acceptEndpoint;
     if (!Number.isSafeInteger(maxEventBytes) || maxEventBytes < 1)
       throw new Error("SSE event byte limit must be a positive safe integer");
   }
   maxEventBytes;
+  acceptEndpoint;
   buffer = "";
   skipLf = false;
   eventType;
@@ -7377,13 +8543,14 @@ var SseParser = class {
     if (this.hasEventId) {
       this._lastEventId = this.eventId;
     }
-    if (this.dataLines.length === 0 || eventType !== "message") {
+    if (this.dataLines.length === 0 || eventType !== "message" && !(this.acceptEndpoint && eventType === "endpoint")) {
       this.resetEvent();
       return;
     }
     const message = {
       data: this.dataLines.join("\n")
     };
+    if (eventType === "endpoint") message.event = "endpoint";
     if (this.hasEventId) {
       message.id = this.eventId;
     }
@@ -7402,12 +8569,14 @@ var SseParser = class {
       throw new Error(`SSE event exceeds ${this.maxEventBytes} bytes`);
   }
 };
+function validateRequestTimer(value, name) {
+  if (!Number.isFinite(value) || value < 0 || value > 2147483647)
+    throw new Error(`${name} must be a non-negative finite number no greater than 2147483647`);
+}
 var JsonRpcMessageLayer = class {
   constructor(input, output, requestTimeoutMs = 3e4, inputClosedReason, maxConcurrentRequests = 128) {
     this.maxConcurrentRequests = maxConcurrentRequests;
-    if (!Number.isFinite(requestTimeoutMs) || requestTimeoutMs < 0) {
-      throw new Error("requestTimeoutMs must be a non-negative finite number");
-    }
+    validateRequestTimer(requestTimeoutMs, "requestTimeoutMs");
     if (!Number.isSafeInteger(maxConcurrentRequests) || maxConcurrentRequests < 1)
       throw new Error("maxConcurrentRequests must be a positive safe integer");
     this.input = input;
@@ -7466,9 +8635,7 @@ var JsonRpcMessageLayer = class {
   sendRequest(method, params, options = {}) {
     if (this.disposedError !== void 0) throw this.disposedError;
     const timeoutMs = options.timeoutMs === null ? null : options.timeoutMs ?? this.requestTimeoutMs;
-    if (timeoutMs !== null && (!Number.isFinite(timeoutMs) || timeoutMs < 0)) {
-      throw new Error("timeoutMs must be a non-negative finite number");
-    }
+    if (timeoutMs !== null) validateRequestTimer(timeoutMs, "timeoutMs");
     if (this.exchangeControllers.size >= this.maxConcurrentRequests)
       throw new Error("JSON-RPC request capacity exceeded");
     if (params !== void 0 && !isJsonValue(params)) {
@@ -7487,6 +8654,7 @@ var JsonRpcMessageLayer = class {
       rejectAbort = reject;
     });
     const cancel = () => {
+      clearTimeout(deadline);
       if (currentRequestId !== void 0) this.cancelRequest(currentRequestId, controller.signal.reason);
       rejectAbort(controller.signal.reason);
     };
@@ -7498,6 +8666,15 @@ var JsonRpcMessageLayer = class {
       currentRequestId = id;
       onRequestId?.(id);
     } };
+    const deadline = timeoutMs === null ? void 0 : setTimeout(() => {
+      let reason = new Error(`JSON-RPC request "${method}" timed out after ${timeoutMs}ms`);
+      try {
+        if (currentRequestId !== void 0) options.onTimeout?.(currentRequestId);
+      } catch (error) {
+        reason = error;
+      }
+      controller.abort(reason);
+    }, timeoutMs);
     if (callerSignal?.aborted) forwardAbort();
     const work = (async () => {
       let retryParams = originalParams;
@@ -7570,6 +8747,7 @@ var JsonRpcMessageLayer = class {
       throw new McpError(ERROR_INTERNAL, "Unreachable MCP retry state");
     })();
     return Promise.race([work, aborted]).finally(() => {
+      clearTimeout(deadline);
       callerSignal?.removeEventListener("abort", forwardAbort);
       controller.signal.removeEventListener("abort", cancel);
       this.exchangeControllers.delete(controller);
@@ -7581,10 +8759,6 @@ var JsonRpcMessageLayer = class {
     }
     const id = this.nextRequestId;
     this.nextRequestId += 1;
-    const timeoutMs = options.timeoutMs === null ? null : options.timeoutMs ?? this.requestTimeoutMs;
-    if (timeoutMs !== null && (!Number.isFinite(timeoutMs) || timeoutMs < 0)) {
-      throw new Error("timeoutMs must be a non-negative finite number");
-    }
     if (options.onRequestId !== void 0) {
       options.onRequestId(id);
     }
@@ -7607,16 +8781,10 @@ var JsonRpcMessageLayer = class {
       message.params = params;
     }
     return new Promise((resolve, reject) => {
-      const timeout = timeoutMs === null ? void 0 : setTimeout(() => {
-        this.pendingRequests.delete(id);
-        options.onTimeout?.(id);
-        reject(new Error(`JSON-RPC request "${method}" timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      this.pendingRequests.set(id, { resolve, reject, timeout });
+      this.pendingRequests.set(id, { resolve, reject });
       try {
         this.output.write(serializeJsonRpcMessage(message));
       } catch (error) {
-        clearTimeout(timeout);
         this.pendingRequests.delete(id);
         reject(error);
       }
@@ -7628,7 +8796,6 @@ var JsonRpcMessageLayer = class {
       return false;
     }
     this.pendingRequests.delete(requestId);
-    clearTimeout(pending.timeout);
     pending.reject(reason);
     return true;
   }
@@ -7639,7 +8806,6 @@ var JsonRpcMessageLayer = class {
     this.disposedError = reason;
     for (const controller of this.exchangeControllers) controller.abort(reason);
     for (const pending of this.pendingRequests.values()) {
-      clearTimeout(pending.timeout);
       pending.reject(reason);
     }
     this.pendingRequests.clear();
@@ -7777,7 +8943,6 @@ var JsonRpcMessageLayer = class {
       return;
     }
     this.pendingRequests.delete(parsed.message.id);
-    clearTimeout(pending.timeout);
     if ("result" in parsed.message) {
       pending.resolve(parsed.message.result);
       return;
@@ -8113,7 +9278,7 @@ function parseJsonRpcPayload(parsed) {
 
 // packages/safe-js/src/modules/mcp-transport.ts
 import { spawn as spawn3 } from "node:child_process";
-import path3 from "node:path";
+import path5 from "node:path";
 function parseMcpConfig(source, directory) {
   const parsed = JSON.parse(source);
   const options = normalizeMcpOptions(parsed, [
@@ -8124,9 +9289,9 @@ function parseMcpConfig(source, directory) {
   ]);
   for (const server of Object.values(options.servers)) {
     if ("command" in server) {
-      server.cwd = path3.resolve(directory, server.cwd ?? ".");
+      server.cwd = path5.resolve(directory, server.cwd ?? ".");
       if (server.command.includes("/") || server.command.includes("\\")) {
-        server.command = path3.resolve(directory, server.command);
+        server.command = path5.resolve(directory, server.command);
       }
     }
   }
@@ -8591,4 +9756,4 @@ CC-BY-4.0. See https://creativecommons.org/licenses/by/4.0/legalcode for
 the full license text.
 
 */
-//# sourceMappingURL=chunk-YPVGFXBW.js.map
+//# sourceMappingURL=chunk-HYD4K4HN.js.map