@google/gemini-cli-a2a-server 0.30.0-nightly.20260218.ce84b3cb5 → 0.30.0-preview.1

package/dist/a2a-server.mjs

@@ -122445,7 +122445,8 @@ var init_types8 = __esm({
       secureModeEnabled: external_exports.boolean().optional(),
       strictModeDisabled: external_exports.boolean().optional(),
       mcpSetting: McpSettingSchema.optional(),
-      cliFeatureSetting: CliFeatureSettingSchema.optional()
+      cliFeatureSetting: CliFeatureSettingSchema.optional(),
+      adminControlsApplicable: external_exports.boolean().optional()
     });
   }
 });
@@ -131101,7 +131102,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname3);
-    return "0.30.0-nightly.20260218.ce84b3cb5";
+    return "0.30.0-preview.1";
   })();
   return versionPromise;
 }
@@ -208501,8 +208502,8 @@ var GIT_COMMIT_INFO, CLI_VERSION;
 var init_git_commit = __esm({
   "packages/core/dist/src/generated/git-commit.js"() {
     "use strict";
-    GIT_COMMIT_INFO = "ce84b3cb5";
-    CLI_VERSION = "0.30.0-nightly.20260218.ce84b3cb5";
+    GIT_COMMIT_INFO = "0114b3e58";
+    CLI_VERSION = "0.30.0-preview.1";
   }
 });
 
@@ -281585,12 +281586,7 @@ var init_ls = __esm({
               return 1;
             return a2.name.localeCompare(b.name);
           });
-          const directoryContent = entries2.map((entry) => {
-            if (entry.isDirectory) {
-              return `[DIR] ${entry.name}`;
-            }
-            return `${entry.name} (${entry.size} bytes)`;
-          }).join("\n");
+          const directoryContent = entries2.map((entry) => `${entry.isDirectory ? "[DIR] " : ""}${entry.name}`).join("\n");
           let resultMessage = `Directory listing for ${resolvedDirPath}:
 ${directoryContent}`;
           if (ignoredCount > 0) {
@@ -356206,97 +356202,6 @@ var init_pathCorrector = __esm({
   }
 });
 
-// node_modules/fast-levenshtein/levenshtein.js
-var require_levenshtein = __commonJS({
-  "node_modules/fast-levenshtein/levenshtein.js"(exports2, module2) {
-    (function() {
-      "use strict";
-      var collator;
-      try {
-        collator = typeof Intl !== "undefined" && typeof Intl.Collator !== "undefined" ? Intl.Collator("generic", { sensitivity: "base" }) : null;
-      } catch (err2) {
-        console.log("Collator could not be initialized and wouldn't be used");
-      }
-      var prevRow = [], str2Char = [];
-      var Levenshtein = {
-        /**
-         * Calculate levenshtein distance of the two strings.
-         *
-         * @param str1 String the first string.
-         * @param str2 String the second string.
-         * @param [options] Additional options.
-         * @param [options.useCollator] Use `Intl.Collator` for locale-sensitive string comparison.
-         * @return Integer the levenshtein distance (0 and above).
-         */
-        get: function(str1, str2, options) {
-          var useCollator = options && collator && options.useCollator;
-          var str1Len = str1.length, str2Len = str2.length;
-          if (str1Len === 0) return str2Len;
-          if (str2Len === 0) return str1Len;
-          var curCol, nextCol, i4, j, tmp;
-          for (i4 = 0; i4 < str2Len; ++i4) {
-            prevRow[i4] = i4;
-            str2Char[i4] = str2.charCodeAt(i4);
-          }
-          prevRow[str2Len] = str2Len;
-          var strCmp;
-          if (useCollator) {
-            for (i4 = 0; i4 < str1Len; ++i4) {
-              nextCol = i4 + 1;
-              for (j = 0; j < str2Len; ++j) {
-                curCol = nextCol;
-                strCmp = 0 === collator.compare(str1.charAt(i4), String.fromCharCode(str2Char[j]));
-                nextCol = prevRow[j] + (strCmp ? 0 : 1);
-                tmp = curCol + 1;
-                if (nextCol > tmp) {
-                  nextCol = tmp;
-                }
-                tmp = prevRow[j + 1] + 1;
-                if (nextCol > tmp) {
-                  nextCol = tmp;
-                }
-                prevRow[j] = curCol;
-              }
-              prevRow[j] = nextCol;
-            }
-          } else {
-            for (i4 = 0; i4 < str1Len; ++i4) {
-              nextCol = i4 + 1;
-              for (j = 0; j < str2Len; ++j) {
-                curCol = nextCol;
-                strCmp = str1.charCodeAt(i4) === str2Char[j];
-                nextCol = prevRow[j] + (strCmp ? 0 : 1);
-                tmp = curCol + 1;
-                if (nextCol > tmp) {
-                  nextCol = tmp;
-                }
-                tmp = prevRow[j + 1] + 1;
-                if (nextCol > tmp) {
-                  nextCol = tmp;
-                }
-                prevRow[j] = curCol;
-              }
-              prevRow[j] = nextCol;
-            }
-          }
-          return nextCol;
-        }
-      };
-      if (typeof define !== "undefined" && define !== null && define.amd) {
-        define(function() {
-          return Levenshtein;
-        });
-      } else if (typeof module2 !== "undefined" && module2 !== null && typeof exports2 !== "undefined" && module2.exports === exports2) {
-        module2.exports = Levenshtein;
-      } else if (typeof self !== "undefined" && typeof self.postMessage === "function" && typeof self.importScripts === "function") {
-        self.Levenshtein = Levenshtein;
-      } else if (typeof window !== "undefined" && window !== null) {
-        window.Levenshtein = Levenshtein;
-      }
-    })();
-  }
-});
-
 // packages/core/dist/src/tools/edit.js
 import * as fsPromises7 from "node:fs/promises";
 import * as path56 from "node:path";
@@ -356368,7 +356273,7 @@ async function calculateFlexibleReplacement(context2) {
       const firstLineInMatch = window2[0];
       const indentationMatch = firstLineInMatch.match(/^([ \t]*)/);
       const indentation = indentationMatch ? indentationMatch[1] : "";
-      const newBlockWithIndent = applyIndentation(replaceLines, indentation);
+      const newBlockWithIndent = replaceLines.map((line) => `${indentation}${line}`);
       sourceLines.splice(i4, searchLinesStripped.length, newBlockWithIndent.join("\n"));
       i4 += replaceLines.length;
     } else {
@@ -356411,7 +356316,7 @@ async function calculateRegexReplacement(context2) {
   }
   const indentation = match2[1] || "";
   const newLines = normalizedReplace.split("\n");
-  const newBlockWithIndent = applyIndentation(newLines, indentation).join("\n");
+  const newBlockWithIndent = newLines.map((line) => `${indentation}${line}`).join("\n");
   const modifiedCode = currentContent.replace(flexibleRegex, newBlockWithIndent);
   return {
     newContent: restoreTrailingNewline(currentContent, modifiedCode),
@@ -356452,10 +356357,6 @@ async function calculateReplacement(config3, context2) {
     logEditStrategy(config3, event);
     return regexResult;
   }
-  let fuzzyResult;
-  if (ENABLE_FUZZY_MATCH_RECOVERY && (fuzzyResult = await calculateFuzzyReplacement(config3, context2))) {
-    return fuzzyResult;
-  }
   return {
     newContent: currentContent,
     occurrences: 0,
@@ -356487,109 +356388,7 @@ function getErrorReplaceResult(params, occurrences, expectedReplacements, finalO
   }
   return error2;
 }
-function stripWhitespace(str2) {
-  return str2.replace(/\s/g, "");
-}
-function applyIndentation(lines, targetIndentation) {
-  if (lines.length === 0)
-    return [];
-  const referenceLine = lines[0];
-  const refIndentMatch = referenceLine.match(/^([ \t]*)/);
-  const refIndent = refIndentMatch ? refIndentMatch[1] : "";
-  return lines.map((line) => {
-    if (line.trim() === "") {
-      return "";
-    }
-    if (line.startsWith(refIndent)) {
-      return targetIndentation + line.slice(refIndent.length);
-    }
-    return targetIndentation + line.trimStart();
-  });
-}
-function getFuzzyMatchFeedback(editData) {
-  if (editData.strategy === "fuzzy" && editData.matchRanges && editData.matchRanges.length > 0) {
-    const ranges = editData.matchRanges.map((r3) => r3.start === r3.end ? `${r3.start}` : `${r3.start}-${r3.end}`).join(", ");
-    return `Applied fuzzy match at line${editData.matchRanges.length > 1 ? "s" : ""} ${ranges}.`;
-  }
-  return null;
-}
-async function calculateFuzzyReplacement(config3, context2) {
-  const { currentContent, params } = context2;
-  const { old_string, new_string } = params;
-  if (old_string.length < 10) {
-    return null;
-  }
-  const normalizedCode = currentContent.replace(/\r\n/g, "\n");
-  const normalizedSearch = old_string.replace(/\r\n/g, "\n");
-  const normalizedReplace = new_string.replace(/\r\n/g, "\n");
-  const sourceLines = normalizedCode.match(/.*(?:\n|$)/g)?.slice(0, -1) ?? [];
-  const searchLines = normalizedSearch.match(/.*(?:\n|$)/g)?.slice(0, -1).map((l2) => l2.trimEnd());
-  if (sourceLines.length * Math.pow(old_string.length, 2) > 4e8) {
-    return null;
-  }
-  if (!searchLines || searchLines.length === 0) {
-    return null;
-  }
-  const N = searchLines.length;
-  const candidates = [];
-  const searchBlock = searchLines.join("\n");
-  for (let i4 = 0; i4 <= sourceLines.length - N; i4++) {
-    const windowLines = sourceLines.slice(i4, i4 + N);
-    const windowText = windowLines.map((l2) => l2.trimEnd()).join("\n");
-    const lengthDiff = Math.abs(windowText.length - searchBlock.length);
-    if (lengthDiff / searchBlock.length > FUZZY_MATCH_THRESHOLD / WHITESPACE_PENALTY_FACTOR) {
-      continue;
-    }
-    const d_raw = import_fast_levenshtein.default.get(windowText, searchBlock);
-    const d_norm = import_fast_levenshtein.default.get(stripWhitespace(windowText), stripWhitespace(searchBlock));
-    const weightedDist = d_norm + (d_raw - d_norm) * WHITESPACE_PENALTY_FACTOR;
-    const score = weightedDist / searchBlock.length;
-    if (score <= FUZZY_MATCH_THRESHOLD) {
-      candidates.push({ index: i4, score });
-    }
-  }
-  if (candidates.length === 0) {
-    return null;
-  }
-  candidates.sort((a2, b) => a2.score - b.score || a2.index - b.index);
-  const selectedMatches = [];
-  for (const candidate of candidates) {
-    const overlaps = selectedMatches.some((m2) => Math.abs(m2.index - candidate.index) < N);
-    if (!overlaps) {
-      selectedMatches.push(candidate);
-    }
-  }
-  if (selectedMatches.length > 0) {
-    const event = new EditStrategyEvent("fuzzy");
-    logEditStrategy(config3, event);
-    const matchRanges = selectedMatches.map((m2) => ({ start: m2.index + 1, end: m2.index + N })).sort((a2, b) => a2.start - b.start);
-    selectedMatches.sort((a2, b) => b.index - a2.index);
-    const newLines = normalizedReplace.split("\n");
-    for (const match2 of selectedMatches) {
-      const firstLineMatch = sourceLines[match2.index];
-      const indentationMatch = firstLineMatch.match(/^([ \t]*)/);
-      const indentation = indentationMatch ? indentationMatch[1] : "";
-      const indentedReplaceLines = applyIndentation(newLines, indentation);
-      let replacementText = indentedReplaceLines.join("\n");
-      if (sourceLines[match2.index + N - 1].endsWith("\n")) {
-        replacementText += "\n";
-      }
-      sourceLines.splice(match2.index, N, replacementText);
-    }
-    let modifiedCode = sourceLines.join("");
-    modifiedCode = restoreTrailingNewline(currentContent, modifiedCode);
-    return {
-      newContent: modifiedCode,
-      occurrences: selectedMatches.length,
-      finalOldString: normalizedSearch,
-      finalNewString: normalizedReplace,
-      strategy: "fuzzy",
-      matchRanges
-    };
-  }
-  return null;
-}
-var import_fast_levenshtein, ENABLE_FUZZY_MATCH_RECOVERY, FUZZY_MATCH_THRESHOLD, WHITESPACE_PENALTY_FACTOR, EditToolInvocation, EditTool;
+var EditToolInvocation, EditTool;
 var init_edit = __esm({
   "packages/core/dist/src/tools/edit.js"() {
     "use strict";
@@ -356612,12 +356411,8 @@ var init_edit = __esm({
     init_pathCorrector();
     init_tool_names();
     init_debugLogger();
-    import_fast_levenshtein = __toESM(require_levenshtein(), 1);
     init_coreTools();
     init_resolver();
-    ENABLE_FUZZY_MATCH_RECOVERY = true;
-    FUZZY_MATCH_THRESHOLD = 0.1;
-    WHITESPACE_PENALTY_FACTOR = 0.1;
     EditToolInvocation = class extends BaseToolInvocation {
       config;
       constructor(config3, params, messageBus, toolName, displayName) {
@@ -356692,9 +356487,7 @@ var init_edit = __esm({
           occurrences: secondAttemptResult.occurrences,
           isNewFile: false,
           error: void 0,
-          originalLineEnding,
-          strategy: secondAttemptResult.strategy,
-          matchRanges: secondAttemptResult.matchRanges
+          originalLineEnding
         };
       }
       /**
@@ -356785,9 +356578,7 @@ var init_edit = __esm({
             occurrences: replacementResult.occurrences,
             isNewFile: false,
             error: void 0,
-            originalLineEnding,
-            strategy: replacementResult.strategy,
-            matchRanges: replacementResult.matchRanges
+            originalLineEnding
           };
         }
         if (this.config.getDisableLLMCorrection()) {
@@ -356948,10 +356739,6 @@ var init_edit = __esm({
           const llmSuccessMessageParts = [
             editData.isNewFile ? `Created new file: ${this.params.file_path} with provided content.` : `Successfully modified file: ${this.params.file_path} (${editData.occurrences} replacements).`
           ];
-          const fuzzyFeedback = getFuzzyMatchFeedback(editData);
-          if (fuzzyFeedback) {
-            llmSuccessMessageParts.push(fuzzyFeedback);
-          }
           if (this.params.modified_by_user) {
             llmSuccessMessageParts.push(`User modified the \`new_string\` content to be: ${this.params.new_string}.`);
           }
@@ -375121,11 +374908,102 @@ var init_tool_modifier = __esm({
   }
 });
 
+// node_modules/fast-levenshtein/levenshtein.js
+var require_levenshtein = __commonJS({
+  "node_modules/fast-levenshtein/levenshtein.js"(exports2, module2) {
+    (function() {
+      "use strict";
+      var collator;
+      try {
+        collator = typeof Intl !== "undefined" && typeof Intl.Collator !== "undefined" ? Intl.Collator("generic", { sensitivity: "base" }) : null;
+      } catch (err2) {
+        console.log("Collator could not be initialized and wouldn't be used");
+      }
+      var prevRow = [], str2Char = [];
+      var Levenshtein = {
+        /**
+         * Calculate levenshtein distance of the two strings.
+         *
+         * @param str1 String the first string.
+         * @param str2 String the second string.
+         * @param [options] Additional options.
+         * @param [options.useCollator] Use `Intl.Collator` for locale-sensitive string comparison.
+         * @return Integer the levenshtein distance (0 and above).
+         */
+        get: function(str1, str2, options) {
+          var useCollator = options && collator && options.useCollator;
+          var str1Len = str1.length, str2Len = str2.length;
+          if (str1Len === 0) return str2Len;
+          if (str2Len === 0) return str1Len;
+          var curCol, nextCol, i4, j, tmp;
+          for (i4 = 0; i4 < str2Len; ++i4) {
+            prevRow[i4] = i4;
+            str2Char[i4] = str2.charCodeAt(i4);
+          }
+          prevRow[str2Len] = str2Len;
+          var strCmp;
+          if (useCollator) {
+            for (i4 = 0; i4 < str1Len; ++i4) {
+              nextCol = i4 + 1;
+              for (j = 0; j < str2Len; ++j) {
+                curCol = nextCol;
+                strCmp = 0 === collator.compare(str1.charAt(i4), String.fromCharCode(str2Char[j]));
+                nextCol = prevRow[j] + (strCmp ? 0 : 1);
+                tmp = curCol + 1;
+                if (nextCol > tmp) {
+                  nextCol = tmp;
+                }
+                tmp = prevRow[j + 1] + 1;
+                if (nextCol > tmp) {
+                  nextCol = tmp;
+                }
+                prevRow[j] = curCol;
+              }
+              prevRow[j] = nextCol;
+            }
+          } else {
+            for (i4 = 0; i4 < str1Len; ++i4) {
+              nextCol = i4 + 1;
+              for (j = 0; j < str2Len; ++j) {
+                curCol = nextCol;
+                strCmp = str1.charCodeAt(i4) === str2Char[j];
+                nextCol = prevRow[j] + (strCmp ? 0 : 1);
+                tmp = curCol + 1;
+                if (nextCol > tmp) {
+                  nextCol = tmp;
+                }
+                tmp = prevRow[j + 1] + 1;
+                if (nextCol > tmp) {
+                  nextCol = tmp;
+                }
+                prevRow[j] = curCol;
+              }
+              prevRow[j] = nextCol;
+            }
+          }
+          return nextCol;
+        }
+      };
+      if (typeof define !== "undefined" && define !== null && define.amd) {
+        define(function() {
+          return Levenshtein;
+        });
+      } else if (typeof module2 !== "undefined" && module2 !== null && typeof exports2 !== "undefined" && module2.exports === exports2) {
+        module2.exports = Levenshtein;
+      } else if (typeof self !== "undefined" && typeof self.postMessage === "function" && typeof self.importScripts === "function") {
+        self.Levenshtein = Levenshtein;
+      } else if (typeof window !== "undefined" && window !== null) {
+        window.Levenshtein = Levenshtein;
+      }
+    })();
+  }
+});
+
 // packages/core/dist/src/utils/tool-utils.js
 function getToolSuggestion(unknownToolName, allToolNames, topN = 3) {
   const matches = allToolNames.map((toolName) => ({
     name: toolName,
-    distance: import_fast_levenshtein2.default.get(unknownToolName, toolName)
+    distance: import_fast_levenshtein.default.get(unknownToolName, toolName)
   }));
   matches.sort((a2, b) => a2.distance - b.distance);
   const topNResults = matches.slice(0, topN);
@@ -375139,13 +375017,13 @@ function getToolSuggestion(unknownToolName, allToolNames, topN = 3) {
     return ` Did you mean ${suggestedNames}?`;
   }
 }
-var import_fast_levenshtein2;
+var import_fast_levenshtein;
 var init_tool_utils = __esm({
   "packages/core/dist/src/utils/tool-utils.js"() {
     "use strict";
     init_src2();
     init_shell_utils();
-    import_fast_levenshtein2 = __toESM(require_levenshtein(), 1);
+    import_fast_levenshtein = __toESM(require_levenshtein(), 1);
     init_types2();
     init_types3();
     init_tool_names();
@@ -378053,34 +377931,8 @@ function renderCoreMandates(options) {
 - **Source Control:** Do not stage or commit changes unless specifically requested by the user.
 
 ## Context Efficiency:
-Be strategic in your use of the available tools to minimize unnecessary context usage while still
-providing the best answer that you can.
-
-Consider the following when estimating the cost of your approach:
-<estimating_context_usage>
-- The agent passes the full history with each subsequent message. The larger context is early in the session, the more expensive each subsequent turn is.
-- Unnecessary turns are generally more expensive than other types of wasted context.
-- You can reduce context usage by limiting the outputs of tools but take care not to cause more token consumption via additional turns required to recover from a tool failure or compensate for a misapplied optimization strategy.
-</estimating_context_usage>
-
-Use the following guidelines to optimize your search and read patterns.
-<guidelines>
-- Combine turns whenever possible by utilizing parallel searching and reading and by requesting enough context by passing context, before, or after to ${GREP_TOOL_NAME}, to enable you to skip using an extra turn reading the file.
-- Prefer using tools like ${GREP_TOOL_NAME} to identify points of interest instead of reading lots of files individually.
-- If you need to read multiple ranges in a file, do so parallel, in as few turns as possible.
-- It is more important to reduce extra turns, but please also try to minimize unnecessarily large file reads and search results, when doing so doesn't result in extra turns. Do this by always providing conservative limits and scopes to tools like ${READ_FILE_TOOL_NAME} and ${GREP_TOOL_NAME}.
-- ${READ_FILE_TOOL_NAME} fails if old_string is ambiguous, causing extra turns. Take care to read enough with ${READ_FILE_TOOL_NAME} and ${GREP_TOOL_NAME} to make the edit unambiguous.
-- You can compensate for the risk of missing results with scoped or limited searches by doing multiple searches in parallel.
-- Your primary goal is still to do your best quality work. Efficiency is an important, but secondary concern.
-</guidelines>
-
-<examples>
-- **Searching:** utilize search tools like ${GREP_TOOL_NAME} and ${GLOB_TOOL_NAME} with a conservative result count (\`total_max_matches\`) and a narrow scope (\`include\` and \`exclude\` parameters).
-- **Searching and editing:** utilize search tools like ${GREP_TOOL_NAME} with a conservative result count and a narrow scope. Use \`context\`, \`before\`, and/or \`after\` to request enough context to avoid the need to read the file before editing matches.
-- **Understanding:** minimize turns needed to understand a file. It's most efficient to read small files in their entirety.
-- **Large files:** utilize search tools like ${GREP_TOOL_NAME} and/or ${READ_FILE_TOOL_NAME} called in parallel with an offset and a limit to reduce the impact on context. Minmize extra turns, unless unavoidable due to the file being too large.
-- **Navigating:** read the minimum required to not require additional turns spent reading the file.
-</examples>
+- Always scope and limit your searches to avoid context window exhaustion and ensure high-signal results. Use include to target relevant files and strictly limit results using total_max_matches and max_matches_per_file, especially during the research phase.
+- For broad discovery, use names_only=true or max_matches_per_file=1 to identify files without retrieving their context.
 
 ## Engineering Standards
 - **Contextual Precedence:** Instructions found in ${formattedFilenames} files are foundational mandates. They take absolute precedence over the general workflows and tool defaults described in this system prompt.
@@ -397435,16 +397287,13 @@ function sanitizeAdminSettings(settings) {
     }
   };
 }
-function isGaxiosError(error2) {
-  return typeof error2 === "object" && error2 !== null && "status" in error2 && typeof error2.status === "number";
-}
 async function fetchAdminControls(server, cachedSettings, adminControlsEnabled, onSettingsChanged) {
   if (!server || !server.projectId || !adminControlsEnabled) {
     stopAdminControlsPolling();
     currentSettings = void 0;
     return {};
   }
-  if (cachedSettings) {
+  if (cachedSettings && Object.keys(cachedSettings).length !== 0) {
     currentSettings = cachedSettings;
     startAdminControlsPolling(server, server.projectId, onSettingsChanged);
     return cachedSettings;
@@ -397453,20 +397302,18 @@ async function fetchAdminControls(server, cachedSettings, adminControlsEnabled,
     const rawSettings = await server.fetchAdminControls({
       project: server.projectId
     });
+    if (rawSettings.adminControlsApplicable !== true) {
+      stopAdminControlsPolling();
+      currentSettings = void 0;
+      return {};
+    }
     const sanitizedSettings = sanitizeAdminSettings(rawSettings);
     currentSettings = sanitizedSettings;
     startAdminControlsPolling(server, server.projectId, onSettingsChanged);
     return sanitizedSettings;
   } catch (e3) {
-    if (isGaxiosError(e3) && e3.status === 403) {
-      stopAdminControlsPolling();
-      currentSettings = void 0;
-      return {};
-    }
     debugLogger.error("Failed to fetch admin controls: ", e3);
-    currentSettings = {};
-    startAdminControlsPolling(server, server.projectId, onSettingsChanged);
-    return {};
+    throw e3;
   }
 }
 async function fetchAdminControlsOnce(server, adminControlsEnabled) {
@@ -397477,13 +397324,13 @@ async function fetchAdminControlsOnce(server, adminControlsEnabled) {
     const rawSettings = await server.fetchAdminControls({
       project: server.projectId
     });
-    return sanitizeAdminSettings(rawSettings);
-  } catch (e3) {
-    if (isGaxiosError(e3) && e3.status === 403) {
+    if (rawSettings.adminControlsApplicable !== true) {
       return {};
     }
+    return sanitizeAdminSettings(rawSettings);
+  } catch (e3) {
     debugLogger.error("Failed to fetch admin controls: ", e3 instanceof Error ? e3.message : e3);
-    return {};
+    throw e3;
   }
 }
 function startAdminControlsPolling(server, project, onSettingsChanged) {
@@ -397493,17 +397340,17 @@ function startAdminControlsPolling(server, project, onSettingsChanged) {
       const rawSettings = await server.fetchAdminControls({
         project
       });
+      if (rawSettings.adminControlsApplicable !== true) {
+        stopAdminControlsPolling();
+        currentSettings = void 0;
+        return;
+      }
       const newSettings = sanitizeAdminSettings(rawSettings);
       if (!isDeepStrictEqual(newSettings, currentSettings)) {
         currentSettings = newSettings;
         onSettingsChanged(newSettings);
       }
     } catch (e3) {
-      if (isGaxiosError(e3) && e3.status === 403) {
-        stopAdminControlsPolling();
-        currentSettings = void 0;
-        return;
-      }
       debugLogger.error("Failed to poll admin controls: ", e3);
     }
   }, 5 * 60 * 1e3);