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

package/bundle/{chunk-G3S7WMRG.js → chunk-BAGLLEOA.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) => {
@@ -252811,12 +252811,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;
@@ -252825,7 +252840,7 @@ function isAuthenticationError(error40) {
     return true;
   }
   const message = getErrorMessage(error40);
-  if (message.includes("401")) {
+  if (HTTP_401_REGEX.test(message)) {
     return true;
   }
   return false;
@@ -273896,14 +273911,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))
+  if (!data.every(isRecord2))
     return false;
   const firstKeys = Object.keys(data[0]).sort().join(",");
   return data.every((item) => Object.keys(item).sort().join(",") === firstKeys);
@@ -274281,7 +274296,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.
@@ -274294,7 +274309,7 @@ var DeclarativeTool = class {
     const props = schema2.properties;
     let propertiesObj = {};
     if (props !== void 0) {
-      if (!isRecord(props)) {
+      if (!isRecord2(props)) {
         return schema2;
       }
       propertiesObj = props;
@@ -278756,7 +278771,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;
@@ -283686,8 +283701,8 @@ function isValidToolName(name3, options = {}) {
 }
 
 // packages/core/dist/src/generated/git-commit.js
-var GIT_COMMIT_INFO = "ed96faedf";
-var CLI_VERSION = "0.66.0-nightly.20261019.ged96faedf";
+var GIT_COMMIT_INFO = "b041de017";
+var CLI_VERSION = "0.66.0-preview.0";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -307808,7 +307823,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname4);
-    return "0.66.0-nightly.20261019.ged96faedf";
+    return "0.66.0-preview.0";
   })();
   return versionPromise;
 }
@@ -309461,8 +309476,8 @@ var BaseLlmClient = class {
       }
     }, shouldRetryOnContent, "generateJson", role);
     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");
@@ -314750,7 +314765,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",
@@ -325066,12 +325081,14 @@ ${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");
+    sanitizationConfig.allowedEnvironmentVariables.push("GIT_CONFIG_COUNT", "GIT_CONFIG_SYSTEM", "GIT_CONFIG_NOSYSTEM");
     const defaultGitOverrides = [
       ["credential.helper", ""],
       ["core.fsmonitor", ""],
@@ -327289,6 +327306,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 {
@@ -342049,6 +342091,7 @@ var import_google_auth_library5 = __toESM(require_src10(), 1);
 
 // packages/core/dist/src/mcp/oauth-utils.js
 import { lookup as lookup2 } from "node:dns/promises";
+import { isIP as isIP2 } from "node:net";
 var ResourceMismatchError = class extends Error {
   constructor(message) {
     super(message);
@@ -342069,6 +342112,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) {
@@ -342112,7 +342156,14 @@ 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 });
@@ -342121,7 +342172,11 @@ 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) {
@@ -342168,7 +342223,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) {
@@ -342193,7 +342249,8 @@ var OAuthUtils = class {
   static async fetchAuthorizationServerMetadata(authServerMetadataUrl, options) {
     try {
       const validatedUrl = await validateOAuthEndpointUrl(authServerMetadataUrl, {
-        allowLoopback: options?.allowLoopback
+        allowLoopback: options?.allowLoopback,
+        allowPrivateNetwork: options?.allowPrivateNetwork
       });
       const response = await fetch(validatedUrl);
       if (!response.ok) {
@@ -342239,7 +342296,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}`;
@@ -342266,17 +342324,18 @@ 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 });
+      let resourceMetadata = await this.fetchProtectedResourceMetadata(wellKnownUrls.protectedResource, { allowLoopback, expectedOrigin, allowPrivateNetwork });
       if (!resourceMetadata) {
         const url3 = new URL(serverUrl);
         if (url3.pathname && url3.pathname !== "/") {
           const rootBasedUrls = this.buildWellKnownUrls(serverUrl, true);
-          resourceMetadata = await this.fetchProtectedResourceMetadata(rootBasedUrls.protectedResource, { allowLoopback, expectedOrigin });
+          resourceMetadata = await this.fetchProtectedResourceMetadata(rootBasedUrls.protectedResource, { allowLoopback, expectedOrigin, allowPrivateNetwork });
         }
       }
       if (resourceMetadata) {
@@ -342285,11 +342344,13 @@ var OAuthUtils = class {
           throw new ResourceMismatchError(`Protected resource ${resourceMetadata.resource} does not match expected ${expectedResource}`);
         }
       }
+      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) {
@@ -342299,9 +342360,7 @@ var OAuthUtils = class {
         }
       }
       debugLogger.debug(`Trying OAuth discovery fallback at ${serverUrl}`);
-      const authServerMetadata = await this.discoverAuthorizationServerMetadata(serverUrl, {
-        allowLoopback
-      });
+      const authServerMetadata = await this.discoverAuthorizationServerMetadata(serverUrl, authServerDiscoveryOptions);
       if (authServerMetadata) {
         const config2 = this.metadataToOAuthConfig(authServerMetadata);
         if (authServerMetadata.registration_endpoint) {
@@ -342338,22 +342397,25 @@ 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, {
       allowLoopback,
       expectedOrigin,
       allowRelative: true,
-      baseUri: mcpServerUrl
+      baseUri: mcpServerUrl,
+      allowPrivateNetwork
     });
     const resourceMetadata = await this.fetchProtectedResourceMetadata(validatedResourceMetadataUrl, {
       allowLoopback,
-      expectedOrigin
+      expectedOrigin,
+      allowPrivateNetwork
     });
     if (resourceMetadata && mcpServerUrl) {
       const expectedResource = this.buildResourceParameter(mcpServerUrl);
@@ -342366,7 +342428,8 @@ var OAuthUtils = class {
     }
     const authServerUrl = resourceMetadata.authorization_servers[0];
     const authServerMetadata = await this.discoverAuthorizationServerMetadata(authServerUrl, {
-      allowLoopback
+      allowLoopback,
+      ...allowPrivateNetwork !== void 0 ? { allowPrivateNetwork } : {}
     });
     if (authServerMetadata) {
       return this.metadataToOAuthConfig(authServerMetadata);
@@ -342550,7 +342613,7 @@ var A2AAuthProviderFactory = class _A2AAuthProviderFactory {
         return provider;
       }
       case "oauth2": {
-        const { OAuth2AuthProvider } = await import("./oauth2-provider-VT6UHLKR.js");
+        const { OAuth2AuthProvider } = await import("./oauth2-provider-O2MBVTUX.js");
         const provider = new OAuth2AuthProvider(authConfig, options.agentName ?? "unknown", agentCard, options.agentCardUrl);
         await provider.initialize();
         return provider;
@@ -346171,7 +346234,7 @@ function isNumberArray(value) {
 }
 function isTaskArray(value) {
   return Array.isArray(value) && value.every((item) => {
-    if (!isRecord(item))
+    if (!isRecord2(item))
       return false;
     const id = item["id"];
     const desc = item["description"];
@@ -346188,7 +346251,7 @@ function isSnapshotState(text) {
   }
   try {
     const parsed = JSON.parse(trimmed2);
-    if (!isRecord(parsed))
+    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) {
@@ -346233,7 +346296,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"];
@@ -346330,7 +346393,7 @@ ${formatNodesForLlm(nodes)}`;
         promptId: this.env.promptId,
         abortSignal: new AbortController().signal
       });
-      if (isRecord(result2)) {
+      if (isRecord2(result2)) {
         patch = result2;
       }
     } catch {
@@ -346362,7 +346425,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({
@@ -355774,11 +355837,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 };
@@ -355860,11 +355923,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];
@@ -356352,8 +356415,8 @@ ${reminder}`;
         throw new Error("Invalid response from Local Gemini API: No text found");
       }
       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");
@@ -361321,7 +361384,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() {
@@ -361414,7 +361477,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;
@@ -361457,7 +361520,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
@@ -365150,7 +365213,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);
@@ -371222,7 +371285,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",
@@ -371242,7 +371305,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",
@@ -371254,7 +371318,7 @@ async function exchangeCodeForToken(config2, code, codeVerifier, redirectPort, r
   });
   return parseTokenEndpointResponse(response, "Token exchange", "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,
@@ -371274,7 +371338,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",
@@ -371304,7 +371369,8 @@ var MCPOAuthProvider = class {
   async registerClient(registrationUrl, config2, redirectPort, mcpServerUrl) {
     const allowLoopback = mcpServerUrl ? isLoopbackUrl(mcpServerUrl) : isLoopbackUrl(registrationUrl);
     const validatedRegistrationUrl = await validateOAuthEndpointUrl(registrationUrl, {
-      allowLoopback
+      allowLoopback,
+      allowPrivateNetwork: config2.allowPrivateNetwork
     });
     const redirectUri = getRedirectUri(config2, redirectPort);
     const registrationRequest = {
@@ -371335,10 +371401,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 = [
@@ -371374,7 +371440,10 @@ var MCPOAuthProvider = class {
     let discoveredMetadata = null;
     for (const issuerCandidate of attemptedIssuers) {
       debugLogger.debug(`   Trying issuer URL: ${issuerCandidate}`);
-      const metadata2 = await OAuthUtils.discoverAuthorizationServerMetadata(issuerCandidate, { allowLoopback });
+      const metadata2 = await OAuthUtils.discoverAuthorizationServerMetadata(issuerCandidate, {
+        allowLoopback,
+        ...options?.allowPrivateNetwork !== void 0 ? { allowPrivateNetwork: options.allowPrivateNetwork } : {}
+      });
       if (metadata2) {
         selectedIssuer = issuerCandidate;
         discoveredMetadata = metadata2;
@@ -371422,7 +371491,7 @@ var MCPOAuthProvider = class {
       clientSecret: config2.clientSecret,
       scopes: config2.scopes,
       audiences: config2.audiences
-    }, refreshToken, tokenUrl, this.buildResourceParam(mcpServerUrl));
+    }, refreshToken, tokenUrl, this.buildResourceParam(mcpServerUrl), { allowPrivateNetwork: config2.allowPrivateNetwork });
   }
   /**
    * Perform the full OAuth authorization code flow with PKCE.
@@ -371449,7 +371518,7 @@ var MCPOAuthProvider = class {
         if (response.status === 401 || response.status === 307) {
           const wwwAuthenticate = response.headers.get("www-authenticate");
           if (wwwAuthenticate) {
-            const discoveredConfig = await OAuthUtils.discoverOAuthFromWWWAuthenticate(wwwAuthenticate, mcpServerUrl);
+            const discoveredConfig = await OAuthUtils.discoverOAuthFromWWWAuthenticate(wwwAuthenticate, mcpServerUrl, { allowPrivateNetwork: config2.allowPrivateNetwork });
             if (discoveredConfig) {
               config2 = {
                 ...config2,
@@ -371472,7 +371541,7 @@ var MCPOAuthProvider = class {
         debugLogger.debug(`Failed to check endpoint for authentication requirements: ${getErrorMessage(error40)}`);
       }
       if (!config2.authorizationUrl) {
-        const discoveredConfig = await this.discoverOAuthFromMCPServer(mcpServerUrl);
+        const discoveredConfig = await this.discoverOAuthFromMCPServer(mcpServerUrl, { allowPrivateNetwork: config2.allowPrivateNetwork });
         if (discoveredConfig) {
           config2 = {
             ...config2,
@@ -371491,74 +371560,91 @@ 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(`Starting callback server for "${serverName}" (expected issuer: ${config2.issuer || "none"})...`);
     const requireIssInResponse = config2.authorizationResponseIssParameterSupported ?? Boolean(config2.issuer);
     const callbackServer = startCallbackServer(pkceParams.state, preferredPort, 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;
-        }
-        debugLogger.debug("\u2713 Dynamic client registration successful");
-      } else {
-        throw new Error("No client ID provided and dynamic registration not supported");
-      }
-    }
-    if (!config2.clientId || !config2.authorizationUrl || !config2.tokenUrl) {
-      throw new Error("Missing required OAuth configuration after discovery and registration");
-    }
-    const allowLoopback = mcpServerUrl ? isLoopbackUrl(mcpServerUrl) : (config2.authorizationUrl ? isLoopbackUrl(config2.authorizationUrl) : false) || (config2.tokenUrl ? isLoopbackUrl(config2.tokenUrl) : false);
-    await validateOAuthEndpointUrl(config2.authorizationUrl, {
-      allowLoopback
+    callbackServer.response.catch(() => {
     });
-    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...
+    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");
+        }
+      }
+      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 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...");
-    const tokenResponse = await exchangeCodeForToken(flowConfig, code, pkceParams.codeVerifier, redirectPort, resource);
+    const tokenResponse = await exchangeCodeForToken(flowConfig, code, pkceParams.codeVerifier, redirectPort, resource, { allowPrivateNetwork: config2.allowPrivateNetwork });
     if (!tokenResponse.access_token) {
       throw new Error("No access token received from token endpoint");
     }
@@ -371703,7 +371789,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);
     if (!tokenMeta?.accessToken) {
       this.cachedToken = void 0;
@@ -372230,10 +372316,13 @@ async function handleAutomaticOAuth(mcpServerName, mcpServerConfig, wwwAuthentic
   try {
     debugLogger.log(`\u{1F510} '${mcpServerName}' requires OAuth authentication`);
     const serverUrl = mcpServerConfig.httpUrl || mcpServerConfig.url;
-    let oauthConfig = await OAuthUtils.discoverOAuthFromWWWAuthenticate(wwwAuthenticate, serverUrl);
+    const discoveryOptions = {
+      allowPrivateNetwork: mcpServerConfig.oauth?.allowPrivateNetwork
+    };
+    let oauthConfig = await OAuthUtils.discoverOAuthFromWWWAuthenticate(wwwAuthenticate, 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("error", `Could not configure OAuth for '${mcpServerName}' - please authenticate manually with /mcp auth ${mcpServerName}`, void 0, mcpServerName);
@@ -372245,7 +372334,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}'...`);
     const authProvider = new MCPOAuthProvider(new MCPOAuthTokenStorage());
@@ -372575,15 +372665,16 @@ 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) {
@@ -372603,8 +372694,8 @@ 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);
@@ -372704,7 +372795,7 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
       const logMessage = httpReturned404 ? `HTTP returned 404, trying SSE transport...` : `HTTP connection failed, attempting SSE fallback...`;
       debugLogger.log(`MCP server '${mcpServerName}': ${logMessage}`);
       try {
-        await connectWithSSETransport(mcpClient, mcpServerConfig, await getStoredOAuthToken(mcpServerName));
+        await connectWithSSETransport(mcpClient, mcpServerConfig, await getStoredOAuthToken(mcpServerName, mcpServerConfig.oauth));
         debugLogger.log(`MCP server '${mcpServerName}': Successfully connected using SSE transport.`);
         return mcpClient;
       } catch (sseFallbackError) {
@@ -372722,7 +372813,7 @@ 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);
@@ -372763,7 +372854,7 @@ async function connectToMcpServer(clientVersion, mcpServerName, mcpServerConfig,
         debugLogger.log(`Received 401 with www-authenticate header: ${wwwAuthenticate}`);
         const oauthSuccess = await handleAutomaticOAuth(mcpServerName, mcpServerConfig, wwwAuthenticate, 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}'`);
           }
@@ -372775,13 +372866,16 @@ 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}'...`);
         if (hasNetworkTransport(mcpServerConfig)) {
           const serverUrl = new URL(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}'`);
             const oauthAuthConfig = {
@@ -372790,13 +372884,14 @@ 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(`Starting OAuth authentication for server '${mcpServerName}'...`);
             const authProvider = new MCPOAuthProvider(new MCPOAuthTokenStorage());
             await authProvider.authenticate(mcpServerName, 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}'`);
             }
@@ -400534,7 +400629,7 @@ export {
   SchemaValidator,
   jsonToMarkdown,
   safeJsonToMarkdown,
-  isRecord,
+  isRecord2 as isRecord,
   MessageBusType,
   QuestionType,
   isBackgroundExecutionData,
@@ -401183,6 +401278,7 @@ export {
   sanitizeHostname,
   isLoopbackHost,
   isAddressPrivate,
+  isEnterprisePrivateAddress,
   isPrivateIpAsync,
   isPrivateIp,
   validateUrlDestination,