@google/gemini-cli 0.66.0-nightly.20261019.ged96faedf → 0.66.0-preview.0

package/bundle/{chunk-QCWGLPCO.js → chunk-D6WVFS5S.js}

@@ -28182,8 +28182,8 @@ var require_utils = __commonJS({
     var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
     var HOST_DELIM_RE = /[@/?#:]/g;
     var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
-    function reescapeHostDelimiters(host, isIP2) {
-      const re = isIP2 ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+    function reescapeHostDelimiters(host, isIP3) {
+      const re = isIP3 ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
       re.lastIndex = 0;
       return host.replace(re, (ch) => HOST_DELIMS[ch]);
     }
@@ -28665,7 +28665,7 @@ var require_fast_uri = __commonJS({
         fragment: void 0
       };
       let malformedAuthorityOrPort = false;
-      let isIP2 = false;
+      let isIP3 = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
           uri = options.scheme + ":" + uri;
@@ -28695,9 +28695,9 @@ var require_fast_uri = __commonJS({
           if (ipv4result === false) {
             const ipv6result = normalizeIPv6(parsed.host);
             parsed.host = ipv6result.host.toLowerCase();
-            isIP2 = ipv6result.isIPV6;
+            isIP3 = ipv6result.isIPV6;
           } else {
-            isIP2 = true;
+            isIP3 = true;
           }
         }
         if (parsed.scheme === void 0 && parsed.userinfo === void 0 && parsed.host === void 0 && parsed.port === void 0 && parsed.query === void 0 && !parsed.path) {
@@ -28714,7 +28714,7 @@ var require_fast_uri = __commonJS({
         }
         const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
         if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-          if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP2 === false && nonSimpleDomain(parsed.host)) {
+          if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP3 === false && nonSimpleDomain(parsed.host)) {
             try {
               parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
             } catch (e2) {
@@ -28728,7 +28728,7 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP2);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP3);
             }
           }
           if (parsed.path) {
@@ -221870,7 +221870,7 @@ var require_dump = __commonJS({
 var require_dns = __commonJS({
   "packages/core/node_modules/undici/lib/interceptor/dns.js"(exports2, module2) {
     "use strict";
-    var { isIP: isIP2 } = __require("node:net");
+    var { isIP: isIP3 } = __require("node:net");
     var { lookup: lookup3 } = __require("node:dns");
     var DecoratorHandler = require_decorator_handler();
     var { InvalidArgumentError, InformationalError } = require_errors6();
@@ -222169,7 +222169,7 @@ var require_dns = __commonJS({
       return (dispatch) => {
         return function dnsInterceptor(origDispatchOpts, handler) {
           const origin = origDispatchOpts.origin.constructor === URL ? origDispatchOpts.origin : new URL(origDispatchOpts.origin);
-          if (isIP2(origin.hostname) !== 0) {
+          if (isIP3(origin.hostname) !== 0) {
             return dispatch(origDispatchOpts, handler);
           }
           instance2.runLookup(origin, origDispatchOpts, (err2, newOrigin) => {
@@ -252829,12 +252829,27 @@ function parseResponseData(error40) {
   }
   return void 0;
 }
+var HTTP_401_REGEX = /(?:\bHTTP(?:\/\d(?:\.\d)?)?(?:\s+(?:status|error))?|(?<!\b(?:exit|exited)\s+(?:with\s+)?)\bstatus(?:code|\s*code)?)[:\s]+401\b|(?:\b401\b[^\w\r\n]{1,4}\bUnauthorized\b|\bUnauthorized\b[^\w\r\n]{1,4}\b401\b)/i;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function isAuthenticationError(error40) {
-  if (error40 && typeof error40 === "object" && "code" in error40) {
-    const errorCode = error40["code"];
-    if (typeof errorCode === "number" && errorCode === 401) {
+  const friendly = toFriendlyError(error40);
+  if (friendly instanceof UnauthorizedError) {
+    return true;
+  }
+  if (isRecord(error40)) {
+    const code = error40["code"] ?? error40["status"] ?? error40["statusCode"];
+    if (code === 401 || code === "401") {
       return true;
     }
+    const response = error40["response"];
+    if (isRecord(response)) {
+      const responseCode = response["status"] ?? response["statusCode"];
+      if (responseCode === 401 || responseCode === "401") {
+        return true;
+      }
+    }
   }
   if (error40 instanceof Error && error40.name === "UnauthorizedError") {
     return true;
@@ -252843,7 +252858,7 @@ function isAuthenticationError(error40) {
     return true;
   }
   const message = getErrorMessage(error40);
-  if (message.includes("401")) {
+  if (HTTP_401_REGEX.test(message)) {
     return true;
   }
   return false;
@@ -274170,14 +274185,14 @@ function safeJsonToMarkdown(text) {
     return text;
   }
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isArrayOfSimilarObjects(data) {
   if (data.length === 0) {
     return false;
   }
-  if (!data.every(isRecord)) return false;
+  if (!data.every(isRecord2)) return false;
   const firstKeys = Object.keys(data[0]).sort().join(",");
   return data.every((item) => Object.keys(item).sort().join(",") === firstKeys);
 }
@@ -274548,7 +274563,7 @@ var DeclarativeTool = class {
    * Type guard to check if an unknown value represents a ToolParameterSchema object.
    */
   isParameterSchema(obj) {
-    return isRecord(obj) && "type" in obj;
+    return isRecord2(obj) && "type" in obj;
   }
   /**
    * Adds the `wait_for_previous` parameter to the tool's schema.
@@ -274561,7 +274576,7 @@ var DeclarativeTool = class {
     const props = schema2.properties;
     let propertiesObj = {};
     if (props !== void 0) {
-      if (!isRecord(props)) {
+      if (!isRecord2(props)) {
         return schema2;
       }
       propertiesObj = props;
@@ -279070,7 +279085,7 @@ var KeychainService = class {
   async loadKeychainModule() {
     const moduleName = "@github/keytar";
     const module2 = await import(moduleName);
-    const potential = isRecord(module2) && module2["default"] || module2;
+    const potential = isRecord2(module2) && module2["default"] || module2;
     const result2 = KeychainSchema.safeParse(potential);
     if (result2.success) {
       return potential;
@@ -284008,7 +284023,7 @@ function isValidToolName(name3, options = {}) {
 }
 
 // packages/core/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "ed96faedf";
+var GIT_COMMIT_INFO = "b041de017";
 var CLI_VERSION = "0.66.0-nightly.20261013.g204db94ae";
 
 // packages/core/src/ide/detect-ide.ts
@@ -310412,8 +310427,8 @@ var BaseLlmClient = class {
     const parsed = JSON.parse(
       this.cleanJsonResponse(getResponseText(result2).trim(), model)
     );
-    const isRecord3 = (val) => typeof val === "object" && val !== null && !Array.isArray(val);
-    if (isRecord3(parsed)) {
+    const isRecord4 = (val) => typeof val === "object" && val !== null && !Array.isArray(val);
+    if (isRecord4(parsed)) {
       return parsed;
     }
     throw new Error("Invalid JSON response format from LLM");
@@ -316488,7 +316503,7 @@ function getSafeGitEnv(baseEnv = process.env) {
     GIT_SSH_COMMAND: gitSshCommand,
     GH_PROMPT_DISABLED: "1",
     GCM_INTERACTIVE: "never",
-    GIT_CONFIG_GLOBAL: devNullPath,
+    ...baseEnv["GIT_CONFIG_GLOBAL"] ? { GIT_CONFIG_GLOBAL: baseEnv["GIT_CONFIG_GLOBAL"] } : {},
     GIT_CONFIG_SYSTEM: devNullPath,
     GIT_CONFIG_NOSYSTEM: "1",
     GIT_CONFIG_COUNT: "7",
@@ -327149,14 +327164,15 @@ ${truncated}`;
     for (const key of gitConfigKeys) {
       baseEnv[key] = sourceEnv[key];
     }
+    if (!baseEnv["GIT_CONFIG_GLOBAL"]) {
+      delete baseEnv["GIT_CONFIG_GLOBAL"];
+    }
     let gitConfigCount = parseInt(baseEnv["GIT_CONFIG_COUNT"] || "0", 10);
     const devNullPath = os31.platform() === "win32" ? "NUL" : "/dev/null";
-    baseEnv["GIT_CONFIG_GLOBAL"] = devNullPath;
     baseEnv["GIT_CONFIG_SYSTEM"] = devNullPath;
     baseEnv["GIT_CONFIG_NOSYSTEM"] = "1";
     sanitizationConfig.allowedEnvironmentVariables.push(
       "GIT_CONFIG_COUNT",
-      "GIT_CONFIG_GLOBAL",
       "GIT_CONFIG_SYSTEM",
       "GIT_CONFIG_NOSYSTEM"
     );
@@ -329568,6 +329584,31 @@ function isAddressPrivate(address) {
     return true;
   }
 }
+function isEnterprisePrivateAddress(addressOrHost) {
+  const normalized2 = sanitizeHostname(addressOrHost).toLowerCase();
+  if (normalized2.endsWith(".internal") || normalized2.endsWith(".local")) {
+    return true;
+  }
+  if (normalized2 === "localhost" || normalized2.endsWith(".localhost")) {
+    return false;
+  }
+  try {
+    if (!import_ipaddr.default.isValid(normalized2)) {
+      return false;
+    }
+    let addr2 = import_ipaddr.default.parse(normalized2);
+    if (addr2 instanceof import_ipaddr.default.IPv6 && addr2.isIPv4MappedAddress()) {
+      addr2 = addr2.toIPv4Address();
+    }
+    if (isBenchmarkAddress(addr2)) {
+      return false;
+    }
+    const range2 = addr2.range();
+    return range2 === "private" || range2 === "carrierGradeNat" || range2 === "uniqueLocal";
+  } catch {
+    return false;
+  }
+}
 async function isPrivateIpAsync(url3) {
   let parsedUrl;
   try {
@@ -344872,6 +344913,7 @@ var import_google_auth_library5 = __toESM(require_src10(), 1);
 
 // packages/core/src/mcp/oauth-utils.ts
 import { lookup as lookup2 } from "node:dns/promises";
+import { isIP as isIP2 } from "node:net";
 var ResourceMismatchError = class extends Error {
   constructor(message) {
     super(message);
@@ -344892,6 +344934,7 @@ function isLoopbackUrl(urlStr) {
     return false;
   }
 }
+var PRIVATE_NETWORK_REMEDIATION_HINT = 'Set "oauth.allowPrivateNetwork": true in settings.json for this MCP server if it is on a trusted private network.';
 async function validateOAuthEndpointUrl(urlStr, options) {
   let resolvedUrl = urlStr.trim();
   if (options?.allowRelative && options.baseUri) {
@@ -344949,9 +344992,16 @@ async function validateOAuthEndpointUrl(urlStr, options) {
     return parsed.toString();
   }
   if (isAddressPrivate(hostname3)) {
-    throw new OAuthSecurityError(
-      `OAuth endpoint "${resolvedUrl}" points to private or reserved IP address which is blocked.`
-    );
+    const isEnterprisePrivate = isEnterprisePrivateAddress(hostname3);
+    if (!options?.allowPrivateNetwork || !isEnterprisePrivate) {
+      const hint = isEnterprisePrivate ? ` ${PRIVATE_NETWORK_REMEDIATION_HINT}` : "";
+      throw new OAuthSecurityError(
+        `OAuth endpoint "${resolvedUrl}" points to private or reserved IP address which is blocked.${hint}`
+      );
+    }
+    if (isIP2(hostname3) !== 0) {
+      return parsed.toString();
+    }
   }
   try {
     const addresses = await lookup2(hostname3, { all: true });
@@ -344962,9 +345012,13 @@ async function validateOAuthEndpointUrl(urlStr, options) {
     }
     for (const addr2 of addresses) {
       if (isAddressPrivate(addr2.address)) {
-        throw new OAuthSecurityError(
-          `OAuth endpoint "${resolvedUrl}" resolves to private network address "${addr2.address}" which is blocked.`
-        );
+        const isEnterprisePrivate = isEnterprisePrivateAddress(addr2.address);
+        if (!options?.allowPrivateNetwork || !isEnterprisePrivate) {
+          const hint = isEnterprisePrivate ? ` ${PRIVATE_NETWORK_REMEDIATION_HINT}` : "";
+          throw new OAuthSecurityError(
+            `OAuth endpoint "${resolvedUrl}" resolves to private network address "${addr2.address}" which is blocked.${hint}`
+          );
+        }
       }
     }
   } catch (error40) {
@@ -345019,7 +345073,8 @@ var OAuthUtils = class {
     try {
       const validatedUrl = await validateOAuthEndpointUrl(resourceMetadataUrl, {
         allowLoopback: options?.allowLoopback,
-        expectedOrigin: options?.expectedOrigin
+        expectedOrigin: options?.expectedOrigin,
+        allowPrivateNetwork: options?.allowPrivateNetwork
       });
       const response = await fetch(validatedUrl);
       if (!response.ok) {
@@ -345048,7 +345103,8 @@ var OAuthUtils = class {
       const validatedUrl = await validateOAuthEndpointUrl(
         authServerMetadataUrl,
         {
-          allowLoopback: options?.allowLoopback
+          allowLoopback: options?.allowLoopback,
+          allowPrivateNetwork: options?.allowPrivateNetwork
         }
       );
       const response = await fetch(validatedUrl);
@@ -345097,7 +345153,8 @@ var OAuthUtils = class {
    */
   static async discoverAuthorizationServerMetadata(authServerUrl, options) {
     const validatedBaseUrl = await validateOAuthEndpointUrl(authServerUrl, {
-      allowLoopback: options?.allowLoopback
+      allowLoopback: options?.allowLoopback,
+      allowPrivateNetwork: options?.allowPrivateNetwork
     });
     const authServerUrlObj = new URL(validatedBaseUrl);
     const base = `${authServerUrlObj.protocol}//${authServerUrlObj.host}`;
@@ -345148,14 +345205,15 @@ var OAuthUtils = class {
    * @param serverUrl The base URL of the server
    * @returns The discovered OAuth configuration or null if not available
    */
-  static async discoverOAuthConfig(serverUrl) {
+  static async discoverOAuthConfig(serverUrl, options) {
     try {
       const allowLoopback = isLoopbackUrl(serverUrl);
+      const allowPrivateNetwork = options?.allowPrivateNetwork;
       const expectedOrigin = new URL(serverUrl).origin;
       const wellKnownUrls = this.buildWellKnownUrls(serverUrl);
       let resourceMetadata = await this.fetchProtectedResourceMetadata(
         wellKnownUrls.protectedResource,
-        { allowLoopback, expectedOrigin }
+        { allowLoopback, expectedOrigin, allowPrivateNetwork }
       );
       if (!resourceMetadata) {
         const url3 = new URL(serverUrl);
@@ -345163,7 +345221,7 @@ var OAuthUtils = class {
           const rootBasedUrls = this.buildWellKnownUrls(serverUrl, true);
           resourceMetadata = await this.fetchProtectedResourceMetadata(
             rootBasedUrls.protectedResource,
-            { allowLoopback, expectedOrigin }
+            { allowLoopback, expectedOrigin, allowPrivateNetwork }
           );
         }
       }
@@ -345178,11 +345236,16 @@ var OAuthUtils = class {
           );
         }
       }
+      const authServerDiscoveryOptions = {
+        allowLoopback,
+        ...allowPrivateNetwork !== void 0 ? { allowPrivateNetwork } : {}
+      };
       if (resourceMetadata?.authorization_servers?.length) {
         const authServerUrl = resourceMetadata.authorization_servers[0];
-        const authServerMetadata2 = await this.discoverAuthorizationServerMetadata(authServerUrl, {
-          allowLoopback
-        });
+        const authServerMetadata2 = await this.discoverAuthorizationServerMetadata(
+          authServerUrl,
+          authServerDiscoveryOptions
+        );
         if (authServerMetadata2) {
           const config2 = this.metadataToOAuthConfig(authServerMetadata2);
           if (authServerMetadata2.registration_endpoint) {
@@ -345197,9 +345260,7 @@ var OAuthUtils = class {
       debugLogger.debug(`Trying OAuth discovery fallback at ${serverUrl}`);
       const authServerMetadata = await this.discoverAuthorizationServerMetadata(
         serverUrl,
-        {
-          allowLoopback
-        }
+        authServerDiscoveryOptions
       );
       if (authServerMetadata) {
         const config2 = this.metadataToOAuthConfig(authServerMetadata);
@@ -345242,12 +345303,13 @@ var OAuthUtils = class {
    * @param mcpServerUrl Optional MCP server URL to validate against the resource metadata
    * @returns The discovered OAuth configuration or null if not available
    */
-  static async discoverOAuthFromWWWAuthenticate(wwwAuthenticate, mcpServerUrl) {
+  static async discoverOAuthFromWWWAuthenticate(wwwAuthenticate, mcpServerUrl, options) {
     const resourceMetadataUri = this.parseWWWAuthenticateHeader(wwwAuthenticate);
     if (!resourceMetadataUri) {
       return null;
     }
     const allowLoopback = mcpServerUrl ? isLoopbackUrl(mcpServerUrl) : false;
+    const allowPrivateNetwork = options?.allowPrivateNetwork;
     const expectedOrigin = mcpServerUrl ? new URL(mcpServerUrl).origin : void 0;
     const validatedResourceMetadataUrl = await validateOAuthEndpointUrl(
       resourceMetadataUri,
@@ -345255,14 +345317,16 @@ var OAuthUtils = class {
         allowLoopback,
         expectedOrigin,
         allowRelative: true,
-        baseUri: mcpServerUrl
+        baseUri: mcpServerUrl,
+        allowPrivateNetwork
       }
     );
     const resourceMetadata = await this.fetchProtectedResourceMetadata(
       validatedResourceMetadataUrl,
       {
         allowLoopback,
-        expectedOrigin
+        expectedOrigin,
+        allowPrivateNetwork
       }
     );
     if (resourceMetadata && mcpServerUrl) {
@@ -345283,7 +345347,8 @@ var OAuthUtils = class {
     const authServerMetadata = await this.discoverAuthorizationServerMetadata(
       authServerUrl,
       {
-        allowLoopback
+        allowLoopback,
+        ...allowPrivateNetwork !== void 0 ? { allowPrivateNetwork } : {}
       }
     );
     if (authServerMetadata) {
@@ -345485,7 +345550,7 @@ var A2AAuthProviderFactory = class _A2AAuthProviderFactory {
         return provider;
       }
       case "oauth2": {
-        const { OAuth2AuthProvider } = await import("./oauth2-provider-RMF7U2UN.js");
+        const { OAuth2AuthProvider } = await import("./oauth2-provider-LVJMV7QY.js");
         const provider = new OAuth2AuthProvider(
           authConfig,
           options.agentName ?? "unknown",
@@ -349444,7 +349509,7 @@ function isNumberArray(value) {
 }
 function isTaskArray(value) {
   return Array.isArray(value) && value.every((item) => {
-    if (!isRecord(item)) return false;
+    if (!isRecord2(item)) return false;
     const id = item["id"];
     const desc = item["description"];
     return typeof id === "string" && typeof desc === "string";
@@ -349460,7 +349525,7 @@ function isSnapshotState(text) {
   }
   try {
     const parsed = JSON.parse(trimmed2);
-    if (!isRecord(parsed)) return false;
+    if (!isRecord2(parsed)) return false;
     const isSnap = Array.isArray(parsed["active_tasks"]) && Array.isArray(parsed["discovered_facts"]) && Array.isArray(parsed["constraints_and_preferences"]) && Array.isArray(parsed["recent_arc"]);
     if (!isSnap) {
       debugLogger.log(
@@ -349509,7 +349574,7 @@ var SnapshotGenerator = class {
     if (previousStateJson) {
       try {
         const parsed = JSON.parse(previousStateJson);
-        if (isRecord(parsed)) {
+        if (isRecord2(parsed)) {
           let loadedArc = [];
           if (isStringArray(parsed["recent_arc"])) {
             loadedArc = parsed["recent_arc"];
@@ -349608,7 +349673,7 @@ ${formatNodesForLlm(nodes)}`;
         promptId: this.env.promptId,
         abortSignal: new AbortController().signal
       });
-      if (isRecord(result2)) {
+      if (isRecord2(result2)) {
         patch = result2;
       }
     } catch {
@@ -349644,7 +349709,7 @@ ${formatNodesForLlm(nodes)}`;
     const newTasks = patch["new_tasks"];
     if (Array.isArray(newTasks)) {
       for (const t2 of newTasks) {
-        if (isRecord(t2)) {
+        if (isRecord2(t2)) {
           const desc = t2["description"];
           if (typeof desc === "string" && desc) {
             newState.active_tasks.push({
@@ -360311,11 +360376,11 @@ var AgentTool = class extends BaseDeclarativeTool {
   }
   mapParams(prompt, schema2) {
     const schemaObj = schema2;
-    if (!isRecord(schemaObj)) {
+    if (!isRecord2(schemaObj)) {
       return { prompt };
     }
     const properties = schemaObj["properties"];
-    if (isRecord(properties)) {
+    if (isRecord2(properties)) {
       const keys = Object.keys(properties);
       if (keys.length === 1) {
         return { [keys[0]]: prompt };
@@ -360432,11 +360497,11 @@ var DelegateInvocation = class extends BaseToolInvocation {
       return agentArgs;
     }
     const schemaObj = this.definition.inputConfig.inputSchema;
-    if (!isRecord(schemaObj)) {
+    if (!isRecord2(schemaObj)) {
       return agentArgs;
     }
     const properties = schemaObj["properties"];
-    if (isRecord(properties)) {
+    if (isRecord2(properties)) {
       const keys = Object.keys(properties);
       const primaryKey = keys.length === 1 ? keys[0] : "prompt";
       const value = agentArgs[primaryKey];
@@ -360993,8 +361058,8 @@ ${reminder}`;
         );
       }
       const parsed = JSON.parse(result2.text);
-      const isRecord3 = (val) => typeof val === "object" && val !== null && !Array.isArray(val);
-      if (isRecord3(parsed)) {
+      const isRecord4 = (val) => typeof val === "object" && val !== null && !Array.isArray(val);
+      if (isRecord4(parsed)) {
         return parsed;
       }
       throw new Error("Invalid JSON response format from Local LLM");
@@ -365998,7 +366063,7 @@ var realPathCache = /* @__PURE__ */ new Map();
 function parseTrustedFoldersJson(content) {
   return JSON.parse((0, import_strip_json_comments.default)(content));
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function clearRealPathCacheForTesting() {
@@ -366092,7 +366157,7 @@ Please fix the file manually before trying to update it.`
       const config2 = {};
       try {
         const parsed = parseTrustedFoldersJson(content);
-        if (isRecord2(parsed)) {
+        if (isRecord3(parsed)) {
           for (const [rawPath, value] of Object.entries(parsed)) {
             if (isTrustLevel(value)) {
               config2[rawPath] = value;
@@ -366139,7 +366204,7 @@ function loadTrustedFolders() {
     if (fs67.existsSync(userPath)) {
       const content = fs67.readFileSync(userPath, "utf-8");
       const parsed = parseTrustedFoldersJson(content);
-      if (!isRecord2(parsed)) {
+      if (!isRecord3(parsed)) {
         errors.push({
           message: "Trusted folders file is not a valid JSON object.",
           path: userPath
@@ -370245,7 +370310,7 @@ var PolicyEngine = class {
     let decision;
     const toolNamesToTry = toolCall.name ? getToolAliases(toolCall.name) : [];
     if (toolCall.name === AGENT_TOOL_NAME) {
-      if (isRecord(toolCall.args)) {
+      if (isRecord2(toolCall.args)) {
         const subagentName = toolCall.args["agent_name"];
         if (typeof subagentName === "string") {
           toolNamesToTry.push(subagentName);
@@ -376861,7 +376926,7 @@ async function parseTokenEndpointResponse(response, operationName, defaultErrorC
     scope: scope || void 0
   };
 }
-async function exchangeCodeForToken(config2, code, codeVerifier, redirectPort, resource) {
+async function exchangeCodeForToken(config2, code, codeVerifier, redirectPort, resource, options) {
   const redirectUri = getRedirectUri(config2, redirectPort);
   const params = new URLSearchParams({
     grant_type: "authorization_code",
@@ -376881,7 +376946,8 @@ async function exchangeCodeForToken(config2, code, codeVerifier, redirectPort, r
   }
   const allowLoopback = resource ? isLoopbackUrl(resource) : isLoopbackUrl(config2.tokenUrl);
   const validatedTokenUrl = await validateOAuthEndpointUrl(config2.tokenUrl, {
-    allowLoopback
+    allowLoopback,
+    allowPrivateNetwork: options?.allowPrivateNetwork
   });
   const response = await fetch(validatedTokenUrl, {
     method: "POST",
@@ -376897,7 +376963,7 @@ async function exchangeCodeForToken(config2, code, codeVerifier, redirectPort, r
     "no_access_token"
   );
 }
-async function refreshAccessToken(config2, refreshToken, tokenUrl, resource) {
+async function refreshAccessToken(config2, refreshToken, tokenUrl, resource, options) {
   const params = new URLSearchParams({
     grant_type: "refresh_token",
     refresh_token: refreshToken,
@@ -376917,7 +376983,8 @@ async function refreshAccessToken(config2, refreshToken, tokenUrl, resource) {
   }
   const allowLoopback = resource ? isLoopbackUrl(resource) : isLoopbackUrl(tokenUrl);
   const validatedTokenUrl = await validateOAuthEndpointUrl(tokenUrl, {
-    allowLoopback
+    allowLoopback,
+    allowPrivateNetwork: options?.allowPrivateNetwork
   });
   const response = await fetch(validatedTokenUrl, {
     method: "POST",
@@ -376949,7 +377016,8 @@ var MCPOAuthProvider = class {
     const validatedRegistrationUrl = await validateOAuthEndpointUrl(
       registrationUrl,
       {
-        allowLoopback
+        allowLoopback,
+        allowPrivateNetwork: config2.allowPrivateNetwork
       }
     );
     const redirectUri = getRedirectUri(config2, redirectPort);
@@ -376983,10 +377051,10 @@ var MCPOAuthProvider = class {
    * @param mcpServerUrl The MCP server URL
    * @returns OAuth configuration if discovered, null otherwise
    */
-  async discoverOAuthFromMCPServer(mcpServerUrl) {
-    return OAuthUtils.discoverOAuthConfig(mcpServerUrl);
+  async discoverOAuthFromMCPServer(mcpServerUrl, options) {
+    return OAuthUtils.discoverOAuthConfig(mcpServerUrl, options);
   }
-  async discoverAuthServerMetadataForRegistration(issuer, mcpServerUrl) {
+  async discoverAuthServerMetadataForRegistration(issuer, mcpServerUrl, options) {
     const allowLoopback = mcpServerUrl ? isLoopbackUrl(mcpServerUrl) : isLoopbackUrl(issuer);
     const authUrl = new URL7(issuer);
     const oidcPatterns = [
@@ -377026,7 +377094,10 @@ var MCPOAuthProvider = class {
       debugLogger.debug(`   Trying issuer URL: ${issuerCandidate}`);
       const metadata2 = await OAuthUtils.discoverAuthorizationServerMetadata(
         issuerCandidate,
-        { allowLoopback }
+        {
+          allowLoopback,
+          ...options?.allowPrivateNetwork !== void 0 ? { allowPrivateNetwork: options.allowPrivateNetwork } : {}
+        }
       );
       if (metadata2) {
         selectedIssuer = issuerCandidate;
@@ -377082,7 +377153,8 @@ var MCPOAuthProvider = class {
       },
       refreshToken,
       tokenUrl,
-      this.buildResourceParam(mcpServerUrl)
+      this.buildResourceParam(mcpServerUrl),
+      { allowPrivateNetwork: config2.allowPrivateNetwork }
     );
   }
   /**
@@ -377112,7 +377184,8 @@ var MCPOAuthProvider = class {
           if (wwwAuthenticate) {
             const discoveredConfig = await OAuthUtils.discoverOAuthFromWWWAuthenticate(
               wwwAuthenticate,
-              mcpServerUrl
+              mcpServerUrl,
+              { allowPrivateNetwork: config2.allowPrivateNetwork }
             );
             if (discoveredConfig) {
               config2 = {
@@ -377138,7 +377211,10 @@ var MCPOAuthProvider = class {
         );
       }
       if (!config2.authorizationUrl) {
-        const discoveredConfig = await this.discoverOAuthFromMCPServer(mcpServerUrl);
+        const discoveredConfig = await this.discoverOAuthFromMCPServer(
+          mcpServerUrl,
+          { allowPrivateNetwork: config2.allowPrivateNetwork }
+        );
         if (discoveredConfig) {
           config2 = {
             ...config2,
@@ -377159,6 +377235,19 @@ var MCPOAuthProvider = class {
         }
       }
     }
+    const allowLoopback = mcpServerUrl ? isLoopbackUrl(mcpServerUrl) : (config2.authorizationUrl ? isLoopbackUrl(config2.authorizationUrl) : false) || (config2.tokenUrl ? isLoopbackUrl(config2.tokenUrl) : false);
+    if (config2.authorizationUrl) {
+      await validateOAuthEndpointUrl(config2.authorizationUrl, {
+        allowLoopback,
+        allowPrivateNetwork: config2.allowPrivateNetwork
+      });
+    }
+    if (config2.tokenUrl) {
+      await validateOAuthEndpointUrl(config2.tokenUrl, {
+        allowLoopback,
+        allowPrivateNetwork: config2.allowPrivateNetwork
+      });
+    }
     const pkceParams = generatePKCEParams();
     const preferredPort = getPortFromUrl(config2.redirectUri);
     debugLogger.debug(
@@ -377171,89 +377260,96 @@ var MCPOAuthProvider = class {
       config2.issuer,
       requireIssInResponse
     );
-    const redirectPort = await callbackServer.port;
-    debugLogger.debug(`Callback server listening on port ${redirectPort}`);
-    if (!config2.clientId) {
-      let registrationUrl = config2.registrationUrl;
-      if (!registrationUrl) {
-        if (!config2.issuer) {
-          throw new Error("Cannot perform dynamic registration without issuer");
-        }
-        debugLogger.debug("\u2192 Attempting dynamic client registration...");
-        const { metadata: authServerMetadata } = await this.discoverAuthServerMetadataForRegistration(
-          config2.issuer,
-          mcpServerUrl
-        );
-        registrationUrl = authServerMetadata.registration_endpoint;
-      }
-      if (registrationUrl) {
-        const clientRegistration = await this.registerClient(
-          registrationUrl,
-          config2,
-          redirectPort,
-          mcpServerUrl
-        );
-        config2.clientId = clientRegistration.client_id;
-        if (clientRegistration.client_secret) {
-          config2.clientSecret = clientRegistration.client_secret;
+    callbackServer.response.catch(() => {
+    });
+    let code;
+    let redirectPort;
+    let flowConfig;
+    let resource;
+    try {
+      redirectPort = await callbackServer.port;
+      debugLogger.debug(`Callback server listening on port ${redirectPort}`);
+      if (!config2.clientId) {
+        let registrationUrl = config2.registrationUrl;
+        if (!registrationUrl) {
+          if (!config2.issuer) {
+            throw new Error(
+              "Cannot perform dynamic registration without issuer"
+            );
+          }
+          debugLogger.debug("\u2192 Attempting dynamic client registration...");
+          const { metadata: authServerMetadata } = await this.discoverAuthServerMetadataForRegistration(
+            config2.issuer,
+            mcpServerUrl,
+            { allowPrivateNetwork: config2.allowPrivateNetwork }
+          );
+          registrationUrl = authServerMetadata.registration_endpoint;
+        }
+        if (registrationUrl) {
+          const clientRegistration = await this.registerClient(
+            registrationUrl,
+            config2,
+            redirectPort,
+            mcpServerUrl
+          );
+          config2.clientId = clientRegistration.client_id;
+          if (clientRegistration.client_secret) {
+            config2.clientSecret = clientRegistration.client_secret;
+          }
+          debugLogger.debug("\u2713 Dynamic client registration successful");
+        } else {
+          throw new Error(
+            "No client ID provided and dynamic registration not supported"
+          );
         }
-        debugLogger.debug("\u2713 Dynamic client registration successful");
-      } else {
+      }
+      if (!config2.clientId || !config2.authorizationUrl || !config2.tokenUrl) {
         throw new Error(
-          "No client ID provided and dynamic registration not supported"
+          "Missing required OAuth configuration after discovery and registration"
         );
       }
-    }
-    if (!config2.clientId || !config2.authorizationUrl || !config2.tokenUrl) {
-      throw new Error(
-        "Missing required OAuth configuration after discovery and registration"
+      flowConfig = {
+        clientId: config2.clientId,
+        clientSecret: config2.clientSecret,
+        authorizationUrl: config2.authorizationUrl,
+        tokenUrl: config2.tokenUrl,
+        scopes: config2.scopes,
+        audiences: config2.audiences,
+        redirectUri: config2.redirectUri
+      };
+      resource = this.buildResourceParam(mcpServerUrl);
+      const authUrl = buildAuthorizationUrl(
+        flowConfig,
+        pkceParams,
+        redirectPort,
+        resource
       );
-    }
-    const allowLoopback = mcpServerUrl ? isLoopbackUrl(mcpServerUrl) : (config2.authorizationUrl ? isLoopbackUrl(config2.authorizationUrl) : false) || (config2.tokenUrl ? isLoopbackUrl(config2.tokenUrl) : false);
-    await validateOAuthEndpointUrl(config2.authorizationUrl, {
-      allowLoopback
-    });
-    await validateOAuthEndpointUrl(config2.tokenUrl, {
-      allowLoopback
-    });
-    const flowConfig = {
-      clientId: config2.clientId,
-      clientSecret: config2.clientSecret,
-      authorizationUrl: config2.authorizationUrl,
-      tokenUrl: config2.tokenUrl,
-      scopes: config2.scopes,
-      audiences: config2.audiences,
-      redirectUri: config2.redirectUri
-    };
-    const resource = this.buildResourceParam(mcpServerUrl);
-    const authUrl = buildAuthorizationUrl(
-      flowConfig,
-      pkceParams,
-      redirectPort,
-      resource
-    );
-    const userConsent = await getConsentForOauth(
-      `Authentication required for MCP Server: '${serverName}.'`
-    );
-    if (!userConsent) {
-      throw new FatalCancellationError("Authentication cancelled by user.");
-    }
-    displayMessage(`\u2192 Opening your browser for OAuth sign-in...
+      const userConsent = await getConsentForOauth(
+        `Authentication required for MCP Server: '${serverName}.'`
+      );
+      if (!userConsent) {
+        throw new FatalCancellationError("Authentication cancelled by user.");
+      }
+      displayMessage(`\u2192 Opening your browser for OAuth sign-in...
 
 If the browser does not open, copy and paste this URL into your browser:
 ${authUrl}
 
 \u{1F4A1} TIP: Triple-click to select the entire URL, then copy and paste it into your browser.
 \u26A0\uFE0F  Make sure to copy the COMPLETE URL - it may wrap across multiple lines.`);
-    try {
-      await openBrowserSecurely(authUrl);
+      try {
+        await openBrowserSecurely(authUrl);
+      } catch (error40) {
+        debugLogger.warn(
+          "Failed to open browser automatically:",
+          getErrorMessage(error40)
+        );
+      }
+      ({ code } = await callbackServer.response);
     } catch (error40) {
-      debugLogger.warn(
-        "Failed to open browser automatically:",
-        getErrorMessage(error40)
-      );
+      callbackServer.cancel?.(error40 instanceof Error ? error40 : void 0);
+      throw error40;
     }
-    const { code } = await callbackServer.response;
     debugLogger.debug(
       "\u2713 Authorization code received, exchanging for tokens..."
     );
@@ -377262,7 +377358,8 @@ ${authUrl}
       code,
       pkceParams.codeVerifier,
       redirectPort,
-      resource
+      resource,
+      { allowPrivateNetwork: config2.allowPrivateNetwork }
     );
     if (!tokenResponse.access_token) {
       throw new Error("No access token received from token endpoint");
@@ -377449,7 +377546,7 @@ var DynamicStoredOAuthProvider = class {
     if (this.isCachedTokenValid()) {
       return this.cachedToken;
     }
-    const oauthConfig = this.serverConfig.oauth?.enabled && this.serverConfig.oauth ? this.serverConfig.oauth : {};
+    const oauthConfig = this.serverConfig.oauth ?? {};
     const tokenMeta = await this.oauthProvider.getValidTokenWithMetadata(
       this.serverName,
       oauthConfig
@@ -378103,13 +378200,20 @@ async function handleAutomaticOAuth(mcpServerName, mcpServerConfig, wwwAuthentic
   try {
     debugLogger.log(`\u{1F510} '${mcpServerName}' requires OAuth authentication`);
     const serverUrl = mcpServerConfig.httpUrl || mcpServerConfig.url;
+    const discoveryOptions = {
+      allowPrivateNetwork: mcpServerConfig.oauth?.allowPrivateNetwork
+    };
     let oauthConfig = await OAuthUtils.discoverOAuthFromWWWAuthenticate(
       wwwAuthenticate,
-      serverUrl
+      serverUrl,
+      discoveryOptions
     );
     if (!oauthConfig && hasNetworkTransport(mcpServerConfig)) {
       const baseUrl = OAuthUtils.extractBaseUrl(serverUrl);
-      oauthConfig = await OAuthUtils.discoverOAuthConfig(baseUrl);
+      oauthConfig = await OAuthUtils.discoverOAuthConfig(
+        baseUrl,
+        discoveryOptions
+      );
     }
     if (!oauthConfig) {
       cliConfig.emitMcpDiagnostic(
@@ -378126,7 +378230,8 @@ async function handleAutomaticOAuth(mcpServerName, mcpServerConfig, wwwAuthentic
       issuer: oauthConfig.issuer,
       tokenUrl: oauthConfig.tokenUrl,
       scopes: oauthConfig.scopes || [],
-      authorizationResponseIssParameterSupported: mcpServerConfig.oauth?.authorizationResponseIssParameterSupported ?? oauthConfig.authorizationResponseIssParameterSupported
+      authorizationResponseIssParameterSupported: mcpServerConfig.oauth?.authorizationResponseIssParameterSupported ?? oauthConfig.authorizationResponseIssParameterSupported,
+      allowPrivateNetwork: mcpServerConfig.oauth?.allowPrivateNetwork
     };
     debugLogger.log(
       `Starting OAuth authentication for server '${mcpServerName}'...`
@@ -378582,14 +378687,15 @@ async function invokeMcpPrompt(mcpServerName, mcpClient, promptName, promptParam
 function hasNetworkTransport(config2) {
   return !!(config2.url || config2.httpUrl);
 }
-async function getStoredOAuthToken(serverName) {
+async function getStoredOAuthToken(serverName, oauthConfig) {
   const tokenStorage = new MCPOAuthTokenStorage();
   const credentials3 = await tokenStorage.getCredentials(serverName);
   if (!credentials3) return null;
   const authProvider = new MCPOAuthProvider(tokenStorage);
   return authProvider.getValidToken(serverName, {
+    ...oauthConfig,
     // Pass client ID if available
-    clientId: credentials3.clientId
+    clientId: oauthConfig?.clientId ?? credentials3.clientId
   });
 }
 function createSSETransportWithAuth(config2, accessToken) {
@@ -378609,8 +378715,11 @@ async function connectWithSSETransport(client, config2, accessToken) {
     timeout: config2.timeout ?? MCP_DEFAULT_TIMEOUT_MSEC
   });
 }
-async function showAuthRequiredMessage(serverName, cliConfig) {
-  const hasRejectedToken = !!await getStoredOAuthToken(serverName);
+async function showAuthRequiredMessage(serverName, cliConfig, oauthConfig) {
+  const hasRejectedToken = !!await getStoredOAuthToken(
+    serverName,
+    oauthConfig
+  );
   const message = hasRejectedToken ? `MCP server '${serverName}' rejected stored OAuth token. Please re-authenticate using: /mcp auth ${serverName}` : `MCP server '${serverName}' requires authentication using: /mcp auth ${serverName}`;
   cliConfig.emitMcpDiagnostic("info", message, void 0, serverName);
   throw new UnauthorizedError(message);
@@ -378736,7 +378845,7 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
         await connectWithSSETransport(
           mcpClient,
           mcpServerConfig,
-          await getStoredOAuthToken(mcpServerName)
+          await getStoredOAuthToken(mcpServerName, mcpServerConfig.oauth)
         );
         debugLogger.log(
           `MCP server '${mcpServerName}': Successfully connected using SSE transport.`
@@ -378761,7 +378870,11 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
       mcpServerRequiresOAuth.set(mcpServerName, true);
       const shouldTriggerOAuth = mcpServerConfig.oauth?.enabled;
       if (!shouldTriggerOAuth) {
-        await showAuthRequiredMessage(mcpServerName, cliConfig);
+        await showAuthRequiredMessage(
+          mcpServerName,
+          cliConfig,
+          mcpServerConfig.oauth
+        );
       }
       const errorString = String(error40);
       let wwwAuthenticate = extractWWWAuthenticateHeader(errorString);
@@ -378817,7 +378930,10 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
           cliConfig
         );
         if (oauthSuccess) {
-          const accessToken = await getStoredOAuthToken(mcpServerName);
+          const accessToken = await getStoredOAuthToken(
+            mcpServerName,
+            mcpServerConfig.oauth
+          );
           if (!accessToken) {
             throw new Error(
               `Failed to get OAuth token for server '${mcpServerName}'`
@@ -378840,7 +378956,11 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
       } else {
         const shouldTryDiscovery = mcpServerConfig.oauth?.enabled;
         if (!shouldTryDiscovery) {
-          await showAuthRequiredMessage(mcpServerName, cliConfig);
+          await showAuthRequiredMessage(
+            mcpServerName,
+            cliConfig,
+            mcpServerConfig.oauth
+          );
         }
         debugLogger.log(
           `\u{1F50D} Attempting OAuth discovery for '${mcpServerName}'...`
@@ -378850,7 +378970,13 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
             mcpServerConfig.httpUrl || mcpServerConfig.url
           );
           const baseUrl = `${serverUrl.protocol}//${serverUrl.host}`;
-          const oauthConfig = await OAuthUtils.discoverOAuthConfig(baseUrl);
+          const discoveryOptions = {
+            allowPrivateNetwork: mcpServerConfig.oauth?.allowPrivateNetwork
+          };
+          const oauthConfig = await OAuthUtils.discoverOAuthConfig(
+            baseUrl,
+            discoveryOptions
+          );
           if (oauthConfig) {
             debugLogger.log(
               `Discovered OAuth configuration from base URL for server '${mcpServerName}'`
@@ -378861,7 +378987,8 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
               issuer: oauthConfig.issuer,
               tokenUrl: oauthConfig.tokenUrl,
               scopes: oauthConfig.scopes || [],
-              authorizationResponseIssParameterSupported: mcpServerConfig.oauth?.authorizationResponseIssParameterSupported ?? oauthConfig.authorizationResponseIssParameterSupported
+              authorizationResponseIssParameterSupported: mcpServerConfig.oauth?.authorizationResponseIssParameterSupported ?? oauthConfig.authorizationResponseIssParameterSupported,
+              allowPrivateNetwork: mcpServerConfig.oauth?.allowPrivateNetwork
             };
             const authServerUrl = mcpServerConfig.httpUrl || mcpServerConfig.url;
             debugLogger.log(
@@ -378875,7 +379002,10 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
               oauthAuthConfig,
               authServerUrl
             );
-            const accessToken = await getStoredOAuthToken(mcpServerName);
+            const accessToken = await getStoredOAuthToken(
+              mcpServerName,
+              mcpServerConfig.oauth
+            );
             if (!accessToken) {
               throw new Error(
                 `Failed to get OAuth token for server '${mcpServerName}'`
@@ -407602,7 +407732,7 @@ export {
   SchemaValidator,
   jsonToMarkdown,
   safeJsonToMarkdown,
-  isRecord,
+  isRecord2 as isRecord,
   MessageBusType,
   QuestionType,
   isBackgroundExecutionData,
@@ -408251,6 +408381,7 @@ export {
   sanitizeHostname,
   isLoopbackHost,
   isAddressPrivate,
+  isEnterprisePrivateAddress,
   isPrivateIpAsync,
   isPrivateIp,
   validateUrlDestination,