toolcraft 0.0.309 → 0.0.311

package/node_modules/tiny-mcp-client/dist/index.js

@@ -279,8 +279,8 @@ function receivedType(value) {
   }
   return typeof value;
 }
-function issue(path3, expected, value, message, keyword = keywordFor(expected)) {
-  return { path: path3, expected, received: receivedType(value), message, keyword };
+function issue(path5, expected, value, message, keyword = keywordFor(expected)) {
+  return { path: path5, expected, received: receivedType(value), message, keyword };
 }
 function keywordFor(expected) {
   if (["null", "boolean", "object", "array", "number", "integer", "string"].includes(expected)) {
@@ -997,113 +997,113 @@ function evaluateArrayApplicators(graph, node, schema, value, context) {
   }
   return results;
 }
-function evaluateValidationKeywords(node, schema, value, path3) {
+function evaluateValidationKeywords(node, schema, value, path5) {
   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(path3, types.join(","), value, `must be ${types.join(",")}`)));
+    results.push(invalidResult(issue(path5, types.join(","), value, `must be ${types.join(",")}`)));
     return results;
   }
   if (schema.const !== void 0 && !deepEqual(schema.const, value)) {
-    results.push(invalidResult(issue(path3, "const", value, "must be equal to constant")));
+    results.push(invalidResult(issue(path5, "const", value, "must be equal to constant")));
   }
   if (Array.isArray(schema.enum) && !schema.enum.some((entry) => deepEqual(entry, value))) {
-    results.push(invalidResult(issue(path3, "enum", value, "must be equal to one of the allowed values")));
+    results.push(invalidResult(issue(path5, "enum", value, "must be equal to one of the allowed values")));
   }
   if (typeof value === "number" && Number.isFinite(value)) {
-    evaluateNumberKeywords(schema, value, path3, results);
+    evaluateNumberKeywords(schema, value, path5, results);
   }
   if (typeof value === "string") {
-    evaluateStringKeywords(schema, value, path3, results);
+    evaluateStringKeywords(schema, value, path5, results);
   }
   if (Array.isArray(value)) {
-    evaluateArrayKeywords(schema, value, path3, results);
+    evaluateArrayKeywords(schema, value, path5, results);
   }
   if (isObject(value)) {
-    evaluateObjectKeywords(node, schema, value, path3, results);
+    evaluateObjectKeywords(node, schema, value, path5, results);
   }
   return results;
 }
-function evaluateNumberKeywords(schema, value, path3, results) {
+function evaluateNumberKeywords(schema, value, path5, results) {
   if (typeof schema.multipleOf === "number" && !isMultipleOf(value, schema.multipleOf)) {
-    results.push(invalidResult(issue(path3, `multiple of ${schema.multipleOf}`, value, `must be multiple of ${schema.multipleOf}`)));
+    results.push(invalidResult(issue(path5, `multiple of ${schema.multipleOf}`, value, `must be multiple of ${schema.multipleOf}`)));
   }
   if (typeof schema.maximum === "number" && value > schema.maximum) {
-    results.push(invalidResult(issue(path3, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`)));
+    results.push(invalidResult(issue(path5, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`)));
   }
   if (typeof schema.minimum === "number" && value < schema.minimum) {
-    results.push(invalidResult(issue(path3, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`)));
+    results.push(invalidResult(issue(path5, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`)));
   }
   if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
-    results.push(invalidResult(issue(path3, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)));
+    results.push(invalidResult(issue(path5, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)));
   }
   if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
-    results.push(invalidResult(issue(path3, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)));
+    results.push(invalidResult(issue(path5, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)));
   }
 }
-function evaluateStringKeywords(schema, value, path3, results) {
+function evaluateStringKeywords(schema, value, path5, results) {
   const length = unicodeLength(value);
   if (typeof schema.maxLength === "number" && length > schema.maxLength) {
-    results.push(invalidResult(issue(path3, `length <= ${schema.maxLength}`, value, `must NOT have more than ${schema.maxLength} characters`)));
+    results.push(invalidResult(issue(path5, `length <= ${schema.maxLength}`, value, `must NOT have more than ${schema.maxLength} characters`)));
   }
   if (typeof schema.minLength === "number" && length < schema.minLength) {
-    results.push(invalidResult(issue(path3, `length >= ${schema.minLength}`, value, `must NOT have fewer than ${schema.minLength} characters`)));
+    results.push(invalidResult(issue(path5, `length >= ${schema.minLength}`, value, `must NOT have fewer than ${schema.minLength} characters`)));
   }
   if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value)) {
-    results.push(invalidResult(issue(path3, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)));
+    results.push(invalidResult(issue(path5, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)));
   }
 }
-function evaluateArrayKeywords(schema, value, path3, results) {
+function evaluateArrayKeywords(schema, value, path5, results) {
   if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
-    results.push(invalidResult(issue(path3, `items <= ${schema.maxItems}`, value, `must NOT have more than ${schema.maxItems} items`)));
+    results.push(invalidResult(issue(path5, `items <= ${schema.maxItems}`, value, `must NOT have more than ${schema.maxItems} items`)));
   }
   if (typeof schema.minItems === "number" && value.length < schema.minItems) {
-    results.push(invalidResult(issue(path3, `items >= ${schema.minItems}`, value, `must NOT have fewer than ${schema.minItems} items`)));
+    results.push(invalidResult(issue(path5, `items >= ${schema.minItems}`, value, `must NOT have fewer than ${schema.minItems} items`)));
   }
   if (schema.uniqueItems === true) {
     for (let left = 0; left < value.length; left += 1) {
       for (let right = left + 1; right < value.length; right += 1) {
         if (deepEqual(value[left], value[right])) {
-          results.push(invalidResult(issue(path3, "unique items", value, "must NOT have duplicate items")));
+          results.push(invalidResult(issue(path5, "unique items", value, "must NOT have duplicate items")));
           return;
         }
       }
     }
   }
 }
-function evaluateObjectKeywords(node, schema, value, path3, results) {
+function evaluateObjectKeywords(node, schema, value, path5, results) {
   const keys = Object.keys(value);
   if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
-    results.push(invalidResult(issue(path3, `properties <= ${schema.maxProperties}`, value, `must NOT have more than ${schema.maxProperties} properties`)));
+    results.push(invalidResult(issue(path5, `properties <= ${schema.maxProperties}`, value, `must NOT have more than ${schema.maxProperties} properties`)));
   }
   if (typeof schema.minProperties === "number" && keys.length < schema.minProperties) {
-    results.push(invalidResult(issue(path3, `properties >= ${schema.minProperties}`, value, `must NOT have fewer than ${schema.minProperties} properties`)));
+    results.push(invalidResult(issue(path5, `properties >= ${schema.minProperties}`, value, `must NOT have fewer than ${schema.minProperties} properties`)));
   }
   if (Array.isArray(schema.required)) {
     for (const key2 of schema.required) {
       if (typeof key2 === "string" && !Object.prototype.hasOwnProperty.call(value, key2)) {
-        results.push(invalidResult(issue([...path3, key2], "required", void 0, `must have required property '${key2}'`)));
+        results.push(invalidResult(issue([...path5, key2], "required", void 0, `must have required property '${key2}'`)));
       }
     }
   }
   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, path3, results);
+      addMissingDependencies(value, dependencies, path5, 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, path3, results);
+        addMissingDependencies(value, dependencies, path5, results);
       }
     }
   }
 }
-function addMissingDependencies(value, dependencies, path3, results) {
+function addMissingDependencies(value, dependencies, path5, results) {
   for (const dependency of dependencies) {
     if (typeof dependency === "string" && !Object.prototype.hasOwnProperty.call(value, dependency)) {
-      results.push(invalidResult(issue([...path3, dependency], "dependency", void 0, `must have property '${dependency}'`)));
+      results.push(invalidResult(issue([...path5, dependency], "dependency", void 0, `must have property '${dependency}'`)));
     }
   }
 }
@@ -3397,19 +3397,168 @@ var SubscriptionManager = class {
 
 // ../mcp-oauth/dist/client/auth-store-session-store.js
 import crypto from "node:crypto";
-import path2 from "node:path";
+import path4 from "node:path";
 
 // ../auth-store/dist/encrypted-file-store.js
-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";
 
 // ../auth-store/dist/error-codes.js
 function hasOwnErrorCode(error, code) {
   return error instanceof Error && Object.prototype.hasOwnProperty.call(error, "code") && error.code === code;
 }
 
+// ../auth-store/dist/transaction-lock.js
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+async function withSecretStoreFileLock(fs2, lockDirectory, operation, options = {}) {
+  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;
+}
+
 // ../auth-store/dist/encrypted-file-store.js
 var derivedKeyCache = /* @__PURE__ */ new Map();
 var ENCRYPTION_ALGORITHM = "aes-256-gcm";
@@ -3435,7 +3584,7 @@ var EncryptedFileStore = class {
       const defaultFileName = input.defaultFileName ?? "credentials.enc";
       assertSafeDefaultDirectory(defaultDirectory);
       assertSafeDefaultFileName(defaultFileName);
-      this.filePath = path.join(homeDirectory, defaultDirectory, defaultFileName);
+      this.filePath = path2.join(homeDirectory, defaultDirectory, defaultFileName);
       this.symbolicLinkCheckStartPath = resolveDefaultDirectoryCheckStart(homeDirectory, defaultDirectory);
     } else {
       this.filePath = input.filePath;
@@ -3475,6 +3624,12 @@ var EncryptedFileStore = class {
       return null;
     }
   }
+  async withLock(operation, options = {}) {
+    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();
@@ -3491,9 +3646,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);
@@ -3523,7 +3678,7 @@ var EncryptedFileStore = class {
     }
   }
   async assertCredentialPathHasNoSymbolicLinks(targetPath) {
-    const resolvedPath = path.resolve(targetPath);
+    const resolvedPath = path2.resolve(targetPath);
     const protectedPaths = getProtectedCredentialPaths(resolvedPath, this.symbolicLinkCheckStartPath);
     for (const currentPath of protectedPaths) {
       try {
@@ -3554,26 +3709,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)) {
@@ -3591,15 +3746,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;
     }
@@ -3608,8 +3763,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 {
@@ -3692,16 +3847,24 @@ function isAlreadyExistsError(error) {
 
 // ../auth-store/dist/keychain-store.js
 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");
     }
@@ -3719,6 +3882,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");
@@ -3904,6 +4071,12 @@ var DEFAULT_CLIENT_KEYCHAIN_SERVICE = "poe-code-mcp-oauth-clients";
 var MAX_JS_DATE_MS = 864e13;
 function createAuthStoreSessionStore(options = {}) {
   return {
+    async withLock(resource, operation, lockOptions) {
+      const store = createResourceSecretStore(resource, options);
+      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 value = await store.get();
@@ -3958,10 +4131,10 @@ function createAuthStoreClientStore(options) {
 function createNamedSecretStore(key2, options, defaults) {
   const hash = crypto.createHash("sha256").update(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(parsedFilePath.dir, `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`),
+    filePath: parsedFilePath === null ? void 0 : path4.join(parsedFilePath.dir, `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`),
     salt: options.fileStore?.salt ?? defaults.salt,
     defaultDirectory: options.fileStore?.defaultDirectory || defaults.directory,
     defaultFileName: parsedFilePath === null ? `${hash}.enc` : `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`
@@ -4003,7 +4176,7 @@ 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"));
+  return isNonBlankOwnString(value, "resource") && isNonBlankOwnString(value, "authorizationServer") && isStoredOAuthClient(getOwnEntry3(value, "client")) && isStoredOAuthDiscovery(getOwnEntry3(value, "discovery")) && (getOwnEntry3(value, "refreshState") === void 0 || getOwnEntry3(value, "refreshState") === "pending" && getOwnEntry3(value, "tokens") === void 0) && isStoredOAuthTokensOrMissing(getOwnEntry3(value, "tokens"));
 }
 function isStoredOAuthClient(value) {
   if (!isObjectRecord(value) || !isNonBlankOwnString(value, "clientId")) {
@@ -4432,7 +4605,9 @@ var OAuthError = class extends Error {
   status;
   retryable;
   terminal;
-  constructor(shape, status) {
+  /** True only when a complete OAuth error response establishes rejection. */
+  outcomeKnown;
+  constructor(shape, status, outcomeKnown = true) {
     super(shape.error_description ?? shape.error);
     this.name = "OAuthError";
     this.error = shape.error;
@@ -4443,6 +4618,7 @@ var OAuthError = class extends Error {
     this.status = status;
     this.retryable = isRetryableOAuthError(this);
     this.terminal = !this.retryable;
+    this.outcomeKnown = outcomeKnown;
   }
 };
 function isRetryableOAuthError(error) {
@@ -4557,7 +4733,8 @@ 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");
+    throw new OAuthError(readOAuthError(record2, fallbackError.error), response.status, typeof error === "string" && error.trim().length > 0);
   }
   return record2;
 }
@@ -4576,7 +4753,7 @@ function getOwnEntry5(record2, key2) {
 }
 function createFallbackOAuthError(status) {
   const error = status === 503 ? "temporarily_unavailable" : "server_error";
-  return new OAuthError({ error }, status);
+  return new OAuthError({ error }, status, false);
 }
 function normalizeBearerTokenType(value) {
   if (typeof value !== "string") {
@@ -4585,6 +4762,55 @@ function normalizeBearerTokenType(value) {
   return value.toLowerCase() === "bearer" ? "Bearer" : null;
 }
 
+// ../mcp-oauth/dist/client/session-transaction.js
+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);
+  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();
+    return store.withLock === void 0 ? await operation() : await store.withLock(resource, operation, {
+      signal: options.signal,
+      timeoutMs: Math.max(0, timeoutMs - (performance.now() - started))
+    });
+  } finally {
+    release();
+    void tail.then(() => {
+      if (pending.get(resource) === tail)
+        pending.delete(resource);
+    });
+  }
+}
+
 // ../mcp-oauth/dist/client/default-oauth-client-provider.js
 var MAX_JS_DATE_MS3 = 864e13;
 function createOAuthClientProvider(options) {
@@ -4599,8 +4825,6 @@ function createDefaultOAuthClientProvider(options) {
   const clientStore = options.authStore === void 0 ? null : createAuthStoreClientStore(options.authStore);
   const now = options.now ?? Date.now;
   const registeredClients = /* @__PURE__ */ new Map();
-  const refreshPromises = /* @__PURE__ */ new Map();
-  const authorizationPromises = /* @__PURE__ */ new Map();
   if (options.initialGrant !== void 0) {
     let resource;
     try {
@@ -4634,13 +4858,14 @@ function createDefaultOAuthClientProvider(options) {
       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;
+        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) {
       try {
@@ -4648,11 +4873,28 @@ function createDefaultOAuthClientProvider(options) {
         const requestUrl = canonicalizeResourceIndicator(input.requestUrl);
         const resource = canonicalizeResourceIndicator(input.discovery.resource);
         assertRequestMatchesResource(requestUrl, resource);
-        const forceRefresh = (hasCachedAccessToken(await loadSession(resource)) || !initialGrantConsumed && initialGrant?.resource === resource) && input.challenge?.params.error === "invalid_token";
+        const cached = await loadSession(resource);
+        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 presented = normalizeStoredTokens(input.presentedTokens);
+            const header = input.requestHeaders?.get("Authorization") ?? "";
+            const separator = header.indexOf(" ");
+            if (presented === void 0 || header.slice(0, separator).toLowerCase() !== "bearer" || header.slice(separator + 1).trim() !== presented.accessToken)
+              throw new Error("OAuth rejected-request provenance does not match its authorization header");
+            presentedTokens = presented;
+            rejectedCurrentGrant = currentTokens !== void 0 && sameTokenGrant(currentTokens, presented);
+          }
+        }
+        const challengeError = input.challenge?.params.error;
+        const forceRefresh = rejectedCurrentGrant && (challengeError === "invalid_token" || input.presentedTokens !== void 0 && challengeError === void 0);
         const session = await ensureAuthorizedSession(resource, {
           ...input.discovery,
           resource
-        }, input.fetch, true, forceRefresh, input.signal);
+        }, input.fetch, true, forceRefresh, input.signal, presentedTokens);
         if (session?.tokens?.accessToken === void 0) {
           return { action: "fail" };
         }
@@ -4666,204 +4908,196 @@ function createDefaultOAuthClientProvider(options) {
       }
     }
   };
-  async function ensureAuthorizedSession(resource, discovery, fetch2, allowInteractive, forceRefresh = false, signal) {
+  async function ensureAuthorizedSession(resource, discovery, fetch2, allowInteractive, forceRefresh = false, signal, rejectedTokens) {
     signal?.throwIfAborted();
     const canonicalResource = canonicalizeResourceIndicator(resource);
-    let session = await loadSession(canonicalResource);
-    if (session !== null && initialGrant?.resource === canonicalResource)
-      initialGrantConsumed = true;
-    signal?.throwIfAborted();
-    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;
-    }
-    if (session === null && discovery !== void 0 && !initialGrantConsumed && initialGrant?.resource === canonicalResource && initialGrant.tokens !== void 0 && initialGrant.client !== null) {
-      assertSecureOAuthFlowEndpoints(discovery.authorizationServerMetadata);
-      session = {
-        resource: canonicalResource,
-        authorizationServer: discovery.authorizationServer,
-        client: initialGrant.client,
-        tokens: initialGrant.tokens,
-        discovery: toStoredDiscovery(discovery)
-      };
-      await saveSession(canonicalResource, session);
-      initialGrantConsumed = true;
+    return withOAuthSessionTransaction(sessionStore, canonicalResource, async () => {
+      let session = await loadSession(canonicalResource);
+      if (session !== null && initialGrant?.resource === canonicalResource)
+        initialGrantConsumed = true;
       signal?.throwIfAborted();
-    }
-    const sessionDiscovery = resolveDiscovery(discovery, session);
-    if (session?.tokens !== void 0 && !forceRefresh && !isExpired(session.tokens, now)) {
-      return session;
-    }
-    if (session?.tokens?.refreshToken !== void 0 && sessionDiscovery !== void 0 && (forceRefresh || isExpired(session.tokens, now))) {
-      session = await refreshSession(canonicalResource, session, sessionDiscovery, fetch2, signal);
-      if (session?.tokens !== void 0 && !isExpired(session.tokens, now)) {
+      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;
+      }
+      if (session === null && discovery !== void 0 && !initialGrantConsumed && initialGrant?.resource === canonicalResource && initialGrant.tokens !== void 0 && initialGrant.client !== null) {
+        assertSecureOAuthFlowEndpoints(discovery.authorizationServerMetadata);
+        session = {
+          resource: canonicalResource,
+          authorizationServer: discovery.authorizationServer,
+          client: initialGrant.client,
+          tokens: initialGrant.tokens,
+          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 (session?.refreshState === "pending") {
+        if (!allowInteractive || options.allowInteractive === false || 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;
-    }
-    if (options.allowInteractive === false)
-      throw new Error("OAuth interactive authorization is disabled");
-    return authorizeSession(canonicalResource, session, sessionDiscovery, fetch2, signal);
+      if (session?.tokens?.refreshToken !== void 0 && sessionDiscovery !== void 0 && (forceRefresh || isExpired(session.tokens, now))) {
+        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 (options.allowInteractive === false)
+        throw new Error("OAuth interactive authorization is disabled");
+      return authorizeSession(canonicalResource, session, sessionDiscovery, fetch2, signal);
+    }, { signal, timeoutMs: options.sessionLockTimeoutMs });
   }
   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 () => {
+    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;
-        }
-        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,
-              signal,
-              now
-            });
-            break;
-          } catch (error) {
-            signal?.throwIfAborted();
-            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;
-          }
+        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,
+          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;
+        }
+        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;
+    }
+    const updatedSession = {
+      ...session,
+      tokens: {
+        ...refreshedTokens,
+        refreshToken: refreshedTokens.refreshToken ?? session.tokens.refreshToken
+      },
+      discovery: toStoredDiscovery(discovery)
+    };
+    await saveSession(resource, updatedSession);
+    return updatedSession;
   }
   async function authorizeSession(resource, existingSession, discovery, fetch2, signal) {
     signal?.throwIfAborted();
-    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,
-          redirectUri: options.browser.redirectUri,
-          signal: options.browser.signal === void 0 ? signal : signal === void 0 ? options.browser.signal : AbortSignal.any([signal, options.browser.signal]),
-          timeoutMs: options.browser.timeoutMs
+    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,
+        redirectUri: options.browser.redirectUri,
+        signal: options.browser.signal === void 0 ? signal : signal === void 0 ? options.browser.signal : AbortSignal.any([signal, options.browser.signal]),
+        timeoutMs: options.browser.timeoutMs
+      });
+      let resolvedClient = null;
+      try {
+        resolvedClient = await resolveClient(currentSession, discovery, loopback.redirectUri, fetch2, signal);
+        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)
         });
-        let resolvedClient = null;
-        try {
-          resolvedClient = await resolveClient(currentSession, discovery, loopback.redirectUri, fetch2, signal);
-          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,
-            signal,
-            now
-          });
-          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 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,
+          signal,
+          now
+        });
+        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, parentSignal) {
     parentSignal?.throwIfAborted();
@@ -5014,9 +5248,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) {
@@ -5026,6 +5264,9 @@ function normalizeLoadedSession(session) {
   if (session === null) {
     return null;
   }
+  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 = normalizeStoredClient(getOwnEntry6(session, "client"));
   if (client === null) {
     return { ...session, client: { clientId: "" }, tokens: void 0 };
@@ -5298,7 +5539,7 @@ function getParameterHeaders(schema) {
   const names = /* @__PURE__ */ new Set();
   const ancestors = /* @__PURE__ */ new Set();
   let nodes = 0;
-  const visit = (value, path3, reachable, depth) => {
+  const visit = (value, path5, reachable, depth) => {
     if (++nodes > 1e4 || depth > 64)
       throw new Error("MCP header schema traversal limit exceeded");
     if (typeof value === "boolean")
@@ -5309,7 +5550,7 @@ function getParameterHeaders(schema) {
     try {
       if (Object.prototype.hasOwnProperty.call(value, "x-mcp-header")) {
         const name = value["x-mcp-header"];
-        if (!reachable || path3.length === 0 || typeof name !== "string" || name.length === 0 || [...name].some((character) => {
+        if (!reachable || path5.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);
         }))
@@ -5320,25 +5561,25 @@ function getParameterHeaders(schema) {
         if (names.has(key2))
           throw new Error("Duplicate x-mcp-header name");
         names.add(key2);
-        headers.push({ name: `Mcp-Param-${name}`, path: [...path3], type: value.type });
+        headers.push({ name: `Mcp-Param-${name}`, path: [...path5], type: value.type });
       }
       for (const [keyword, child] of Object.entries(value)) {
         if (schemaMaps.has(keyword)) {
           if (!isRecord3(child))
             throw new Error("Invalid schema map");
           for (const [key2, nested] of Object.entries(child))
-            visit(nested, keyword === "properties" ? [...path3, key2] : path3, reachable && keyword === "properties", depth + 1);
+            visit(nested, keyword === "properties" ? [...path5, key2] : path5, 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, path3, false, depth + 1);
+            visit(nested, path5, false, depth + 1);
         } else if (schemaChildren.has(keyword)) {
           if (Array.isArray(child))
             for (const nested of child)
-              visit(nested, path3, false, depth + 1);
+              visit(nested, path5, false, depth + 1);
           else
-            visit(child, path3, false, depth + 1);
+            visit(child, path5, false, depth + 1);
         }
       }
     } finally {
@@ -5536,8 +5777,8 @@ function authorizationServerMetadataLocations(issuer) {
   ];
   const issuerUrl = new URL(issuer);
   if (issuerUrl.pathname !== "/") {
-    const path3 = issuerUrl.pathname.endsWith("/") ? issuerUrl.pathname.slice(0, -1) : issuerUrl.pathname;
-    issuerUrl.pathname = `${path3}/.well-known/openid-configuration`;
+    const path5 = issuerUrl.pathname.endsWith("/") ? issuerUrl.pathname.slice(0, -1) : issuerUrl.pathname;
+    issuerUrl.pathname = `${path5}/.well-known/openid-configuration`;
     locations.push(issuerUrl.toString());
   }
   return locations;
@@ -6789,6 +7030,7 @@ var HttpTransport = class {
   oauthMetadataDiscovery;
   inFlightFetchAbortControllers = /* @__PURE__ */ new Set();
   inFlightOAuthAbortControllers = /* @__PURE__ */ new Set();
+  oauthRequestTokens = /* @__PURE__ */ new WeakMap();
   openResponseReaders = /* @__PURE__ */ new Set();
   modernRequests = /* @__PURE__ */ new Map();
   modernMode = false;
@@ -7059,7 +7301,7 @@ var HttpTransport = class {
   }
   async authorizeRequestHeaders(headers, signal) {
     signal?.throwIfAborted();
-    await this.oauthProvider?.authorizeRequest?.({
+    const tokens = await this.oauthProvider?.authorizeRequest?.({
       requestUrl: new URL(this.url),
       headers,
       signal,
@@ -7068,6 +7310,7 @@ var HttpTransport = class {
         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;
   }
@@ -7211,7 +7454,7 @@ var HttpTransport = class {
     const message = responseBody.length === 0 ? `HTTP transport POST failed (${statusDescriptor})` : `HTTP transport POST failed (${statusDescriptor}): ${responseBody}`;
     throw new HttpTransportError(message, response.status, "POST");
   }
-  async maybeHandleUnauthorizedResponse(response, signal) {
+  async maybeHandleUnauthorizedResponse(response, signal, requestHeaders, presentedTokens) {
     if (response.status !== 401 || this.oauthProvider === void 0) {
       return false;
     }
@@ -7232,6 +7475,8 @@ var HttpTransport = class {
           challenge,
           discovery,
           signal,
+          requestHeaders: new Headers(requestHeaders),
+          presentedTokens,
           fetch: (url, init) => fetchMcpResponse(this.fetchImpl, url, {
             ...init,
             signal: init?.signal == null ? signal : AbortSignal.any([signal, init.signal])
@@ -7372,16 +7617,20 @@ var HttpTransport = class {
     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();
-      return this.fetchWithAbort(input.url ?? this.url, {
+      const response = await this.fetchWithAbort(input.url ?? this.url, {
         method: input.method,
         headers,
         body: input.body
       }, controller);
+      return { response, headers: headerSnapshot, tokens };
     };
     try {
-      let response = await request();
-      if (await this.maybeHandleUnauthorizedResponse(response, controller.signal)) response = await request();
+      let attempt = await request();
+      if (await this.maybeHandleUnauthorizedResponse(attempt.response, controller.signal, attempt.headers, attempt.tokens)) attempt = await request();
+      const response = attempt.response;
       const oauthError = this.oauthProvider === void 0 ? null : this.readOAuthChallengeError(response);
       if (oauthError !== null) {
         void response.body?.cancel().catch(() => void 0);