@google/gemini-cli-a2a-server 0.21.0-nightly.20251208.7a7203757 → 0.21.0-nightly.20251209.ec9a8c7a7

package/dist/a2a-server.mjs

@@ -308225,7 +308225,8 @@ async function triggerPostAuthCallbacks(tokens) {
     client_secret: OAUTH_CLIENT_SECRET,
     refresh_token: tokens.refresh_token ?? void 0,
     // Ensure null is not passed
-    type: "authorized_user"
+    type: "authorized_user",
+    client_email: userAccountManager.getCachedGoogleAccount() ?? void 0
   };
   authEvents.emit("post_auth", jwtInput);
 }
@@ -308341,6 +308342,12 @@ async function initOauthClient(authType, config3) {
       writeToStderr("Failed to authenticate with user code.\n");
       throw new FatalAuthenticationError("Failed to authenticate with user code.");
     }
+    try {
+      await fetchAndCacheUserInfo(client);
+    } catch (error2) {
+      debugLogger.warn("Failed to retrieve Google Account ID during authentication:", getErrorMessage(error2));
+    }
+    await triggerPostAuthCallbacks(client.credentials);
   } else {
     const webLogin = await authWithWeb(client);
     coreEvents.emit(CoreEvent.UserFeedback, {
@@ -308388,6 +308395,7 @@ Please try running again with NO_BROWSER=true set.`
       severity: "info",
       message: "Authentication succeeded\n"
     });
+    await triggerPostAuthCallbacks(client.credentials);
   }
   return client;
 }
@@ -311504,6 +311512,37 @@ var SmartEditCorrectionEvent = class {
     return `Smart Edit Tool Correction: ${this.correction}`;
   }
 };
+var EVENT_STARTUP_STATS = "gemini_cli.startup_stats";
+var StartupStatsEvent = class {
+  "event.name";
+  "event.timestamp";
+  phases;
+  os_platform;
+  os_release;
+  is_docker;
+  constructor(phases, os_platform, os_release, is_docker) {
+    this["event.name"] = "startup_stats";
+    this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
+    this.phases = phases;
+    this.os_platform = os_platform;
+    this.os_release = os_release;
+    this.is_docker = is_docker;
+  }
+  toOpenTelemetryAttributes(config3) {
+    return {
+      ...getCommonAttributes(config3),
+      "event.name": EVENT_STARTUP_STATS,
+      "event.timestamp": this["event.timestamp"],
+      phases: JSON.stringify(this.phases),
+      os_platform: this.os_platform,
+      os_release: this.os_release,
+      is_docker: this.is_docker
+    };
+  }
+  toLogBody() {
+    return `Startup stats: ${this.phases.length} phases recorded.`;
+  }
+};
 var BaseAgentEvent = class {
   "event.timestamp";
   agent_id;
@@ -311858,8 +311897,8 @@ var Float64Vector = import_vector.default.Float64Vector;
 var PointerVector = import_vector.default.PointerVector;
 
 // packages/core/dist/src/generated/git-commit.js
-var GIT_COMMIT_INFO = "7a7203757";
-var CLI_VERSION = "0.21.0-nightly.20251208.7a7203757";
+var GIT_COMMIT_INFO = "ec9a8c7a7";
+var CLI_VERSION = "0.21.0-nightly.20251209.ec9a8c7a7";
 
 // packages/core/dist/src/ide/detect-ide.js
 var IDE_DEFINITIONS = {
@@ -314058,6 +314097,25 @@ var StartupProfiler = class _StartupProfiler {
         debugLogger.log("[STARTUP] Skipping phase without measure:", phase.name);
       }
     }
+    const startupPhases = [];
+    for (const phase of this.phases.values()) {
+      if (!phase.ended)
+        continue;
+      const measure = measures.find((m2) => m2.name === phase.name);
+      if (measure && phase.cpuUsage) {
+        startupPhases.push({
+          name: phase.name,
+          duration_ms: measure.duration,
+          cpu_usage_user_usec: phase.cpuUsage.user,
+          cpu_usage_system_usec: phase.cpuUsage.system,
+          start_time_usec: (performance2.timeOrigin + measure.startTime) * 1e3,
+          end_time_usec: (performance2.timeOrigin + measure.startTime + measure.duration) * 1e3
+        });
+      }
+    }
+    if (startupPhases.length > 0) {
+      logStartupStats(config3, new StartupStatsEvent(startupPhases, os6.platform(), os6.release(), fs27.existsSync("/.dockerenv")));
+    }
     for (const phaseName of this.phases.keys()) {
       const startMarkName = this.getStartMarkName(phaseName);
       const endMarkName = this.getEndMarkName(phaseName);
@@ -314105,6 +314163,7 @@ var telemetryInitialized = false;
 var callbackRegistered = false;
 var authListener = void 0;
 var telemetryBuffer = [];
+var activeTelemetryEmail;
 function bufferTelemetryEvent(fn) {
   if (telemetryInitialized) {
     fn();
@@ -314143,7 +314202,15 @@ function parseOtlpEndpoint(otlpEndpointSetting, protocol) {
   }
 }
 async function initializeTelemetry(config3, credentials) {
-  if (telemetryInitialized || !config3.getTelemetryEnabled()) {
+  if (!config3.getTelemetryEnabled()) {
+    return;
+  }
+  if (telemetryInitialized) {
+    if (credentials?.client_email && activeTelemetryEmail && credentials.client_email !== activeTelemetryEmail) {
+      const message = `Telemetry credentials have changed (from ${activeTelemetryEmail} to ${credentials.client_email}), but telemetry cannot be re-initialized in this process. Please restart the CLI to use the new account for telemetry.`;
+      debugLogger.error(message);
+      console.error(message);
+    }
     return;
   }
   if (config3.getTelemetryUseCollector() && config3.getTelemetryUseCliAuth()) {
@@ -314155,7 +314222,7 @@ async function initializeTelemetry(config3, credentials) {
       callbackRegistered = true;
       authListener = async (newCredentials) => {
         if (config3.getTelemetryEnabled() && config3.getTelemetryUseCliAuth()) {
-          debugLogger.log("Telemetry reinit with credentials: ", newCredentials);
+          debugLogger.log("Telemetry reinit with credentials.");
           await initializeTelemetry(config3, newCredentials);
         }
       };
@@ -314250,6 +314317,7 @@ async function initializeTelemetry(config3, credentials) {
       debugLogger.log("OpenTelemetry SDK started successfully.");
     }
     telemetryInitialized = true;
+    activeTelemetryEmail = credentials?.client_email;
     initializeMetrics(config3);
     void flushTelemetryBuffer();
   } catch (error2) {
@@ -314287,6 +314355,7 @@ async function shutdownTelemetry(config3, fromProcessExit = true) {
       authListener = void 0;
     }
     callbackRegistered = false;
+    activeTelemetryEmail = void 0;
   }
 }
 
@@ -314631,6 +314700,16 @@ function logHookCall(config3, event) {
     recordHookCallMetrics(config3, event.hook_event_name, event.hook_name, event.duration_ms, event.success);
   });
 }
+function logStartupStats(config3, event) {
+  bufferTelemetryEvent(() => {
+    const logger6 = import_api_logs.logs.getLogger(SERVICE_NAME);
+    const logRecord = {
+      body: event.toLogBody(),
+      attributes: event.toOpenTelemetryAttributes(config3)
+    };
+    logger6.emit(logRecord);
+  });
+}
 
 // packages/core/dist/src/utils/quotaErrorDetection.js
 function isApiError(error2) {
@@ -315004,7 +315083,7 @@ async function createContentGenerator(config3, gcConfig, sessionId2) {
     if (gcConfig.fakeResponses) {
       return FakeContentGenerator.fromFile(gcConfig.fakeResponses);
     }
-    const version4 = "0.21.0-nightly.20251208.7a7203757";
+    const version4 = "0.21.0-nightly.20251209.ec9a8c7a7";
     const customHeadersEnv = process.env["GEMINI_CLI_CUSTOM_HEADERS"] || void 0;
     const userAgent = `GeminiCLI/${version4} (${process.platform}; ${process.arch})`;
     const customHeadersMap = parseCustomHeaders(customHeadersEnv);
@@ -317884,7 +317963,7 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
   config;
   static Name = READ_FILE_TOOL_NAME;
   constructor(config3, messageBus) {
-    super(_ReadFileTool.Name, "ReadFile", `Reads and returns the content of a specified file. If the file is large, the content will be truncated. The tool's response will clearly indicate if truncation has occurred and will provide details on how to read more of the file using the 'offset' and 'limit' parameters. Handles text, images (PNG, JPG, GIF, WEBP, SVG, BMP), and PDF files. For text files, it can read specific line ranges.`, Kind.Read, {
+    super(_ReadFileTool.Name, "ReadFile", `Reads and returns the content of a specified file. If the file is large, the content will be truncated. The tool's response will clearly indicate if truncation has occurred and will provide details on how to read more of the file using the 'offset' and 'limit' parameters. Handles text, images (PNG, JPG, GIF, WEBP, SVG, BMP), audio files (MP3, WAV, AIFF, AAC, OGG, FLAC), and PDF files. For text files, it can read specific line ranges.`, Kind.Read, {
       properties: {
         file_path: {
           description: "The path to the file to read.",
@@ -352869,6 +352948,208 @@ function delay2(ms, signal) {
   });
 }
 
+// packages/core/dist/src/availability/errorClassification.js
+function classifyFailureKind(error2) {
+  if (error2 instanceof TerminalQuotaError) {
+    return "terminal";
+  }
+  if (error2 instanceof RetryableQuotaError) {
+    return "transient";
+  }
+  if (error2 instanceof ModelNotFoundError) {
+    return "not_found";
+  }
+  return "unknown";
+}
+
+// packages/core/dist/src/config/models.js
+var PREVIEW_GEMINI_MODEL = "gemini-3-pro-preview";
+var DEFAULT_GEMINI_MODEL = "gemini-2.5-pro";
+var DEFAULT_GEMINI_FLASH_MODEL = "gemini-2.5-flash";
+var DEFAULT_GEMINI_FLASH_LITE_MODEL = "gemini-2.5-flash-lite";
+var DEFAULT_GEMINI_MODEL_AUTO = "auto";
+var GEMINI_MODEL_ALIAS_PRO = "pro";
+var GEMINI_MODEL_ALIAS_FLASH = "flash";
+var GEMINI_MODEL_ALIAS_FLASH_LITE = "flash-lite";
+var DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
+var DEFAULT_THINKING_MODE = 8192;
+function resolveModel(requestedModel, previewFeaturesEnabled) {
+  switch (requestedModel) {
+    case DEFAULT_GEMINI_MODEL_AUTO:
+    case GEMINI_MODEL_ALIAS_PRO: {
+      return previewFeaturesEnabled ? PREVIEW_GEMINI_MODEL : DEFAULT_GEMINI_MODEL;
+    }
+    case GEMINI_MODEL_ALIAS_FLASH: {
+      return DEFAULT_GEMINI_FLASH_MODEL;
+    }
+    case GEMINI_MODEL_ALIAS_FLASH_LITE: {
+      return DEFAULT_GEMINI_FLASH_LITE_MODEL;
+    }
+    default: {
+      return requestedModel;
+    }
+  }
+}
+function getEffectiveModel(isInFallbackMode, requestedModel, previewFeaturesEnabled) {
+  const resolvedModel = resolveModel(requestedModel, previewFeaturesEnabled);
+  if (!isInFallbackMode) {
+    return resolvedModel;
+  }
+  if (resolvedModel.includes("lite")) {
+    return resolvedModel;
+  }
+  return DEFAULT_GEMINI_FLASH_MODEL;
+}
+function isGemini2Model(model) {
+  return /^gemini-2(\.|$)/.test(model);
+}
+
+// packages/core/dist/src/availability/policyCatalog.js
+var DEFAULT_ACTIONS = {
+  terminal: "prompt",
+  transient: "prompt",
+  not_found: "prompt",
+  unknown: "prompt"
+};
+var DEFAULT_STATE = {
+  terminal: "terminal",
+  transient: "terminal",
+  not_found: "terminal",
+  unknown: "terminal"
+};
+var DEFAULT_CHAIN = [
+  definePolicy({ model: DEFAULT_GEMINI_MODEL }),
+  definePolicy({ model: DEFAULT_GEMINI_FLASH_MODEL, isLastResort: true })
+];
+var PREVIEW_CHAIN = [
+  definePolicy({
+    model: PREVIEW_GEMINI_MODEL,
+    stateTransitions: { transient: "sticky_retry" },
+    actions: { transient: "silent" }
+  }),
+  definePolicy({ model: DEFAULT_GEMINI_MODEL }),
+  definePolicy({ model: DEFAULT_GEMINI_FLASH_MODEL, isLastResort: true })
+];
+function getModelPolicyChain(options2) {
+  if (options2.previewEnabled) {
+    return cloneChain(PREVIEW_CHAIN);
+  }
+  return cloneChain(DEFAULT_CHAIN);
+}
+function createDefaultPolicy(model, options2) {
+  return definePolicy({ model, isLastResort: options2?.isLastResort });
+}
+function definePolicy(config3) {
+  return {
+    model: config3.model,
+    isLastResort: config3.isLastResort,
+    actions: { ...DEFAULT_ACTIONS, ...config3.actions ?? {} },
+    stateTransitions: {
+      ...DEFAULT_STATE,
+      ...config3.stateTransitions ?? {}
+    }
+  };
+}
+function clonePolicy(policy) {
+  return {
+    ...policy,
+    actions: { ...policy.actions },
+    stateTransitions: { ...policy.stateTransitions }
+  };
+}
+function cloneChain(chain2) {
+  return chain2.map(clonePolicy);
+}
+
+// packages/core/dist/src/availability/policyHelpers.js
+function resolvePolicyChain(config3, preferredModel) {
+  const chain2 = getModelPolicyChain({
+    previewEnabled: !!config3.getPreviewFeatures(),
+    userTier: config3.getUserTier()
+  });
+  const activeModel = preferredModel ?? getEffectiveModel(config3.isInFallbackMode(), config3.getModel(), config3.getPreviewFeatures());
+  if (activeModel === "auto") {
+    return [...chain2];
+  }
+  if (chain2.some((policy) => policy.model === activeModel)) {
+    return [...chain2];
+  }
+  return [createDefaultPolicy(activeModel, { isLastResort: true })];
+}
+function buildFallbackPolicyContext(chain2, failedModel) {
+  const index = chain2.findIndex((policy) => policy.model === failedModel);
+  if (index === -1) {
+    return { failedPolicy: void 0, candidates: chain2 };
+  }
+  return {
+    failedPolicy: chain2[index],
+    candidates: [...chain2.slice(index + 1), ...chain2.slice(0, index)]
+  };
+}
+function resolvePolicyAction(failureKind, policy) {
+  return policy.actions?.[failureKind] ?? "prompt";
+}
+function createAvailabilityContextProvider(config3, modelGetter) {
+  return () => {
+    if (!config3.isModelAvailabilityServiceEnabled()) {
+      return void 0;
+    }
+    const service = config3.getModelAvailabilityService();
+    const currentModel = modelGetter();
+    const chain2 = resolvePolicyChain(config3, currentModel);
+    const policy = chain2.find((p) => p.model === currentModel);
+    return policy ? { service, policy } : void 0;
+  };
+}
+function selectModelForAvailability(config3, requestedModel) {
+  if (!config3.isModelAvailabilityServiceEnabled()) {
+    return void 0;
+  }
+  const chain2 = resolvePolicyChain(config3, requestedModel);
+  const selection = config3.getModelAvailabilityService().selectFirstAvailable(chain2.map((p) => p.model));
+  if (selection.selectedModel)
+    return selection;
+  const backupModel = chain2.find((p) => p.isLastResort)?.model ?? DEFAULT_GEMINI_MODEL;
+  return { selectedModel: backupModel, skipped: [] };
+}
+function applyModelSelection(config3, requestedModel, currentConfig, overrideScope, options2 = {}) {
+  const selection = selectModelForAvailability(config3, requestedModel);
+  if (!selection?.selectedModel) {
+    return { model: requestedModel, config: currentConfig };
+  }
+  const finalModel = selection.selectedModel;
+  let finalConfig = currentConfig;
+  if (finalModel !== requestedModel) {
+    const { generateContentConfig } = config3.modelConfigService.getResolvedConfig({
+      overrideScope,
+      model: finalModel
+    });
+    finalConfig = currentConfig ? { ...currentConfig, ...generateContentConfig } : generateContentConfig;
+  }
+  config3.setActiveModel(finalModel);
+  if (selection.attempts && options2.consumeAttempt !== false) {
+    config3.getModelAvailabilityService().consumeStickyAttempt(finalModel);
+  }
+  return {
+    model: finalModel,
+    config: finalConfig,
+    maxAttempts: selection.attempts
+  };
+}
+function applyAvailabilityTransition(getContext, failureKind) {
+  const context2 = getContext?.();
+  if (!context2)
+    return;
+  const transition = context2.policy.stateTransitions?.[failureKind];
+  if (!transition)
+    return;
+  if (transition === "terminal") {
+    context2.service.markTerminal(context2.policy.model, failureKind === "terminal" ? "quota" : "capacity");
+  } else if (transition === "sticky_retry") {
+    context2.service.markRetryOncePerTurn(context2.policy.model);
+  }
+}
+
 // packages/core/dist/src/utils/retry.js
 var DEFAULT_RETRY_OPTIONS = {
   maxAttempts: 3,
@@ -352934,7 +353215,7 @@ async function retryWithBackoff(fn, options2) {
     throw new Error("maxAttempts must be a positive number.");
   }
   const cleanOptions = options2 ? Object.fromEntries(Object.entries(options2).filter(([_, v]) => v != null)) : {};
-  const { maxAttempts, initialDelayMs, maxDelayMs, onPersistent429, authType, shouldRetryOnError, shouldRetryOnContent, retryFetchErrors, signal } = {
+  const { maxAttempts, initialDelayMs, maxDelayMs, onPersistent429, authType, shouldRetryOnError, shouldRetryOnContent, retryFetchErrors, signal, getAvailabilityContext } = {
     ...DEFAULT_RETRY_OPTIONS,
     shouldRetryOnError: isRetryableError,
     ...cleanOptions
@@ -352955,12 +353236,21 @@ async function retryWithBackoff(fn, options2) {
         currentDelay = Math.min(maxDelayMs, currentDelay * 2);
         continue;
       }
+      const successContext = getAvailabilityContext?.();
+      if (successContext) {
+        successContext.service.markHealthy(successContext.policy.model);
+      }
       return result;
     } catch (error2) {
       if (error2 instanceof Error && error2.name === "AbortError") {
         throw error2;
       }
       const classifiedError = classifyGoogleError(error2);
+      const failureKind = classifyFailureKind(classifiedError);
+      const appliedImmediate = failureKind === "terminal" || failureKind === "not_found";
+      if (appliedImmediate) {
+        applyAvailabilityTransition(getAvailabilityContext, failureKind);
+      }
       const errorCode = getErrorStatus(error2);
       if (classifiedError instanceof TerminalQuotaError || classifiedError instanceof ModelNotFoundError) {
         if (onPersistent429 && authType === AuthType2.LOGIN_WITH_GOOGLE) {
@@ -352992,6 +353282,9 @@ async function retryWithBackoff(fn, options2) {
               console.warn("Model fallback failed:", fallbackError);
             }
           }
+          if (!appliedImmediate) {
+            applyAvailabilityTransition(getAvailabilityContext, failureKind);
+          }
           throw classifiedError instanceof RetryableQuotaError ? classifiedError : error2;
         }
         if (classifiedError instanceof RetryableQuotaError) {
@@ -353009,6 +353302,9 @@ async function retryWithBackoff(fn, options2) {
         }
       }
       if (attempt >= maxAttempts || !shouldRetryOnError(error2, retryFetchErrors)) {
+        if (!appliedImmediate) {
+          applyAvailabilityTransition(getAvailabilityContext, failureKind);
+        }
         throw error2;
       }
       const errorStatus = getErrorStatus(error2);
@@ -353131,11 +353427,36 @@ var BaseLlmClient = class {
   }
   async _generateWithRetry(requestParams, promptId, maxAttempts, shouldRetryOnContent, errorContext) {
     const abortSignal = requestParams.config?.abortSignal;
+    const getAvailabilityContext = createAvailabilityContextProvider(this.config, () => requestParams.model);
+    const { model, config: newConfig, maxAttempts: availabilityMaxAttempts } = applyModelSelection(this.config, requestParams.model, requestParams.config);
+    requestParams.model = model;
+    if (newConfig) {
+      requestParams.config = newConfig;
+    }
+    if (abortSignal) {
+      requestParams.config = { ...requestParams.config, abortSignal };
+    }
     try {
-      const apiCall = () => this.contentGenerator.generateContent(requestParams, promptId);
+      const apiCall = () => {
+        if (this.config.isModelAvailabilityServiceEnabled()) {
+          const activeModel = this.config.getActiveModel();
+          if (activeModel !== requestParams.model) {
+            requestParams.model = activeModel;
+            const { generateContentConfig } = this.config.modelConfigService.getResolvedConfig({
+              model: activeModel
+            });
+            requestParams.config = {
+              ...requestParams.config,
+              ...generateContentConfig
+            };
+          }
+        }
+        return this.contentGenerator.generateContent(requestParams, promptId);
+      };
       return await retryWithBackoff(apiCall, {
         shouldRetryOnContent,
-        maxAttempts: maxAttempts ?? DEFAULT_MAX_ATTEMPTS
+        maxAttempts: availabilityMaxAttempts ?? maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+        getAvailabilityContext
       });
     } catch (error2) {
       if (abortSignal?.aborted) {
@@ -365758,48 +366079,6 @@ My setup is complete. I will provide my first command in the next turn.
   ];
 }
 
-// packages/core/dist/src/config/models.js
-var PREVIEW_GEMINI_MODEL = "gemini-3-pro-preview";
-var DEFAULT_GEMINI_MODEL = "gemini-2.5-pro";
-var DEFAULT_GEMINI_FLASH_MODEL = "gemini-2.5-flash";
-var DEFAULT_GEMINI_FLASH_LITE_MODEL = "gemini-2.5-flash-lite";
-var DEFAULT_GEMINI_MODEL_AUTO = "auto";
-var GEMINI_MODEL_ALIAS_PRO = "pro";
-var GEMINI_MODEL_ALIAS_FLASH = "flash";
-var GEMINI_MODEL_ALIAS_FLASH_LITE = "flash-lite";
-var DEFAULT_GEMINI_EMBEDDING_MODEL = "gemini-embedding-001";
-var DEFAULT_THINKING_MODE = 8192;
-function resolveModel(requestedModel, previewFeaturesEnabled) {
-  switch (requestedModel) {
-    case DEFAULT_GEMINI_MODEL_AUTO:
-    case GEMINI_MODEL_ALIAS_PRO: {
-      return previewFeaturesEnabled ? PREVIEW_GEMINI_MODEL : DEFAULT_GEMINI_MODEL;
-    }
-    case GEMINI_MODEL_ALIAS_FLASH: {
-      return DEFAULT_GEMINI_FLASH_MODEL;
-    }
-    case GEMINI_MODEL_ALIAS_FLASH_LITE: {
-      return DEFAULT_GEMINI_FLASH_LITE_MODEL;
-    }
-    default: {
-      return requestedModel;
-    }
-  }
-}
-function getEffectiveModel(isInFallbackMode, requestedModel, previewFeaturesEnabled) {
-  const resolvedModel = resolveModel(requestedModel, previewFeaturesEnabled);
-  if (!isInFallbackMode) {
-    return resolvedModel;
-  }
-  if (resolvedModel.includes("lite")) {
-    return resolvedModel;
-  }
-  return DEFAULT_GEMINI_FLASH_MODEL;
-}
-function isGemini2Model(model) {
-  return /^gemini-2(\.|$)/.test(model);
-}
-
 // packages/core/dist/src/utils/generateContentResponseUtilities.js
 function getResponseTextFromParts(parts2) {
   if (!parts2) {
@@ -367451,9 +367730,6 @@ var ChatRecordingService = class {
   }
 };
 
-// packages/core/dist/src/fallback/handler.js
-init_events();
-
 // packages/core/dist/src/utils/secure-browser-launcher.js
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify13 } from "node:util";
@@ -367539,89 +367815,8 @@ async function openBrowserSecurely(url5) {
   }
 }
 
-// packages/core/dist/src/availability/policyCatalog.js
-var DEFAULT_ACTIONS = {
-  terminal: "prompt",
-  transient: "prompt",
-  not_found: "prompt",
-  unknown: "prompt"
-};
-var DEFAULT_STATE = {
-  terminal: "terminal",
-  transient: "terminal",
-  not_found: "terminal",
-  unknown: "terminal"
-};
-var DEFAULT_CHAIN = [
-  definePolicy({ model: DEFAULT_GEMINI_MODEL }),
-  definePolicy({ model: DEFAULT_GEMINI_FLASH_MODEL, isLastResort: true })
-];
-var PREVIEW_CHAIN = [
-  definePolicy({
-    model: PREVIEW_GEMINI_MODEL,
-    stateTransitions: { transient: "sticky_retry" }
-  }),
-  definePolicy({ model: DEFAULT_GEMINI_MODEL }),
-  definePolicy({ model: DEFAULT_GEMINI_FLASH_MODEL, isLastResort: true })
-];
-function getModelPolicyChain(options2) {
-  if (options2.previewEnabled) {
-    return cloneChain(PREVIEW_CHAIN);
-  }
-  return cloneChain(DEFAULT_CHAIN);
-}
-function createDefaultPolicy(model, options2) {
-  return definePolicy({ model, isLastResort: options2?.isLastResort });
-}
-function definePolicy(config3) {
-  return {
-    model: config3.model,
-    isLastResort: config3.isLastResort,
-    actions: { ...DEFAULT_ACTIONS, ...config3.actions ?? {} },
-    stateTransitions: {
-      ...DEFAULT_STATE,
-      ...config3.stateTransitions ?? {}
-    }
-  };
-}
-function clonePolicy(policy) {
-  return {
-    ...policy,
-    actions: { ...policy.actions },
-    stateTransitions: { ...policy.stateTransitions }
-  };
-}
-function cloneChain(chain2) {
-  return chain2.map(clonePolicy);
-}
-
-// packages/core/dist/src/availability/policyHelpers.js
-function resolvePolicyChain(config3) {
-  const chain2 = getModelPolicyChain({
-    previewEnabled: !!config3.getPreviewFeatures(),
-    userTier: config3.getUserTier()
-  });
-  const activeModel = getEffectiveModel(config3.isInFallbackMode(), config3.getModel(), config3.getPreviewFeatures());
-  if (chain2.some((policy) => policy.model === activeModel)) {
-    return chain2;
-  }
-  return [createDefaultPolicy(activeModel, { isLastResort: true })];
-}
-function buildFallbackPolicyContext(chain2, failedModel) {
-  const index = chain2.findIndex((policy) => policy.model === failedModel);
-  if (index === -1) {
-    return { failedPolicy: void 0, candidates: chain2 };
-  }
-  return {
-    failedPolicy: chain2[index],
-    candidates: [...chain2.slice(index + 1), ...chain2.slice(0, index)]
-  };
-}
-function resolvePolicyAction(failureKind, policy) {
-  return policy.actions?.[failureKind] ?? "prompt";
-}
-
 // packages/core/dist/src/fallback/handler.js
+init_events();
 var UPGRADE_URL_PAGE = "https://goo.gle/set-up-gemini-code-assist";
 async function handleFallback(config3, failedModel, authType, error2) {
   if (config3.isModelAvailabilityServiceEnabled()) {
@@ -367660,6 +367855,7 @@ async function handlePolicyDrivenFallback(config3, failedModel, authType, error2
   }
   const chain2 = resolvePolicyChain(config3);
   const { failedPolicy, candidates } = buildFallbackPolicyContext(chain2, failedModel);
+  const failureKind = classifyFailureKind(error2);
   if (!candidates.length) {
     return null;
   }
@@ -367671,7 +367867,6 @@ async function handlePolicyDrivenFallback(config3, failedModel, authType, error2
   if (!fallbackModel || fallbackModel === failedModel || !selectedPolicy) {
     return null;
   }
-  const failureKind = classifyFailureKind(error2);
   const action = resolvePolicyAction(failureKind, selectedPolicy);
   if (action === "silent") {
     return processIntent(config3, "retry_always", failedModel, fallbackModel, authType, error2);
@@ -367691,7 +367886,7 @@ async function handlePolicyDrivenFallback(config3, failedModel, authType, error2
   }
   try {
     const intent = await handler(failedModel, fallbackModel, error2);
-    return await processIntent(config3, intent, failedModel, fallbackModel, authType);
+    return await processIntent(config3, intent, failedModel, fallbackModel, authType, error2);
   } catch (handlerError) {
     debugLogger.error("Fallback handler failed:", handlerError);
     return null;
@@ -367705,18 +367900,30 @@ async function handleUpgrade() {
   }
 }
 async function processIntent(config3, intent, failedModel, fallbackModel, authType, error2) {
+  const isAvailabilityEnabled = config3.isModelAvailabilityServiceEnabled();
   switch (intent) {
     case "retry_always":
-      if (failedModel === PREVIEW_GEMINI_MODEL && !(error2 instanceof TerminalQuotaError)) {
-        activatePreviewModelFallbackMode(config3);
+      if (isAvailabilityEnabled) {
+        config3.setActiveModel(fallbackModel);
       } else {
-        activateFallbackMode(config3, authType);
+        if (failedModel === PREVIEW_GEMINI_MODEL && !(error2 instanceof TerminalQuotaError)) {
+          activatePreviewModelFallbackMode(config3);
+        } else {
+          activateFallbackMode(config3, authType);
+        }
       }
       return true;
     case "retry_once":
+      if (isAvailabilityEnabled) {
+        config3.setActiveModel(fallbackModel);
+      }
       return true;
     case "stop":
-      activateFallbackMode(config3, authType);
+      if (isAvailabilityEnabled) {
+        config3.setActiveModel(fallbackModel);
+      } else {
+        activateFallbackMode(config3, authType);
+      }
       return false;
     case "retry_later":
       return false;
@@ -367741,18 +367948,6 @@ function activatePreviewModelFallbackMode(config3) {
     config3.setPreviewModelFallbackMode(true);
   }
 }
-function classifyFailureKind(error2) {
-  if (error2 instanceof TerminalQuotaError) {
-    return "terminal";
-  }
-  if (error2 instanceof RetryableQuotaError) {
-    return "transient";
-  }
-  if (error2 instanceof ModelNotFoundError) {
-    return "not_found";
-  }
-  return "unknown";
-}
 
 // packages/core/dist/src/core/geminiRequest.js
 function partListUnionToString(value) {
@@ -368103,19 +368298,45 @@ var GeminiChat = class {
     return streamWithRetries.call(this);
   }
   async makeApiCallAndProcessStream(model, generateContentConfig, requestContents, prompt_id) {
-    let effectiveModel = model;
     const contentsForPreviewModel = this.ensureActiveLoopHasThoughtSignatures(requestContents);
-    let lastModelToUse = model;
-    let lastConfig = generateContentConfig;
+    const { model: availabilityFinalModel, config: newAvailabilityConfig, maxAttempts: availabilityMaxAttempts } = applyModelSelection(this.config, model, generateContentConfig);
+    const abortSignal = generateContentConfig.abortSignal;
+    let lastModelToUse = availabilityFinalModel;
+    let currentGenerateContentConfig = newAvailabilityConfig ?? generateContentConfig;
+    if (abortSignal) {
+      currentGenerateContentConfig = {
+        ...currentGenerateContentConfig,
+        abortSignal
+      };
+    }
+    let lastConfig = currentGenerateContentConfig;
     let lastContentsToUse = requestContents;
+    const getAvailabilityContext = createAvailabilityContextProvider(this.config, () => lastModelToUse);
     const apiCall = async () => {
-      let modelToUse = getEffectiveModel(this.config.isInFallbackMode(), model, this.config.getPreviewFeatures());
-      if (this.config.isPreviewModelBypassMode() && modelToUse === PREVIEW_GEMINI_MODEL) {
-        modelToUse = DEFAULT_GEMINI_MODEL;
+      let modelToUse;
+      if (this.config.isModelAvailabilityServiceEnabled()) {
+        modelToUse = this.config.getActiveModel();
+        if (modelToUse !== lastModelToUse) {
+          const { generateContentConfig: newConfig } = this.config.modelConfigService.getResolvedConfig({
+            model: modelToUse
+          });
+          currentGenerateContentConfig = {
+            ...currentGenerateContentConfig,
+            ...newConfig
+          };
+          if (abortSignal) {
+            currentGenerateContentConfig.abortSignal = abortSignal;
+          }
+        }
+      } else {
+        modelToUse = getEffectiveModel(this.config.isInFallbackMode(), model, this.config.getPreviewFeatures());
+        if (this.config.isPreviewModelBypassMode() && modelToUse === PREVIEW_GEMINI_MODEL) {
+          modelToUse = DEFAULT_GEMINI_MODEL;
+        }
       }
-      effectiveModel = modelToUse;
+      lastModelToUse = modelToUse;
       const config3 = {
-        ...generateContentConfig,
+        ...currentGenerateContentConfig,
         // TODO(12622): Ensure we don't overrwrite these when they are
         // passed via config.
         systemInstruction: this.systemInstruction,
@@ -368180,20 +368401,21 @@ var GeminiChat = class {
         config: config3
       }, prompt_id);
     };
-    const onPersistent429Callback = async (authType, error2) => handleFallback(this.config, effectiveModel, authType, error2);
+    const onPersistent429Callback = async (authType, error2) => handleFallback(this.config, lastModelToUse, authType, error2);
     const streamResponse = await retryWithBackoff(apiCall, {
       onPersistent429: onPersistent429Callback,
       authType: this.config.getContentGeneratorConfig()?.authType,
       retryFetchErrors: this.config.getRetryFetchErrors(),
       signal: generateContentConfig.abortSignal,
-      maxAttempts: this.config.isPreviewModelFallbackMode() && model === PREVIEW_GEMINI_MODEL ? 1 : void 0
+      maxAttempts: availabilityMaxAttempts ?? (this.config.isPreviewModelFallbackMode() && model === PREVIEW_GEMINI_MODEL ? 1 : void 0),
+      getAvailabilityContext
     });
     const originalRequest = {
       model: lastModelToUse,
       config: lastConfig,
       contents: lastContentsToUse
     };
-    return this.processStreamResponse(effectiveModel, streamResponse, originalRequest);
+    return this.processStreamResponse(lastModelToUse, streamResponse, originalRequest);
   }
   /**
    * Returns the chat history.
@@ -370129,6 +370351,9 @@ var GeminiClient = class {
     return getEffectiveModel(this.config.isInFallbackMode(), configModel, this.config.getPreviewFeatures());
   }
   async *sendMessageStream(request3, signal, prompt_id, turns = MAX_TURNS, isInvalidStreamRetry = false) {
+    if (!isInvalidStreamRetry) {
+      this.config.resetTurn();
+    }
     const hooksEnabled = this.config.getEnableHooks();
     const messageBus = this.config.getMessageBus();
     if (hooksEnabled && messageBus) {
@@ -370213,9 +370438,11 @@ var GeminiClient = class {
       const router = await this.config.getModelRouterService();
       const decision = await router.route(routingContext);
       modelToUse = decision.model;
-      this.currentSequenceModel = modelToUse;
-      yield { type: GeminiEventType.ModelInfo, value: modelToUse };
     }
+    const { model: finalModel } = applyModelSelection(this.config, modelToUse, void 0, void 0, { consumeAttempt: false });
+    modelToUse = finalModel;
+    this.currentSequenceModel = modelToUse;
+    yield { type: GeminiEventType.ModelInfo, value: modelToUse };
     const resultStream = turn.run({ model: modelToUse }, request3, linkedSignal);
     for await (const event of resultStream) {
       if (this.loopDetector.addAndCheck(event)) {
@@ -370280,10 +370507,29 @@ var GeminiClient = class {
     try {
       const userMemory = this.config.getUserMemory();
       const systemInstruction = getCoreSystemPrompt(this.config, userMemory);
+      const { model, config: newConfig, maxAttempts: availabilityMaxAttempts } = applyModelSelection(this.config, currentAttemptModel, currentAttemptGenerateContentConfig, modelConfigKey.overrideScope);
+      currentAttemptModel = model;
+      if (newConfig) {
+        currentAttemptGenerateContentConfig = newConfig;
+      }
+      const getAvailabilityContext = createAvailabilityContextProvider(this.config, () => currentAttemptModel);
       const apiCall = () => {
-        const modelConfigToUse = this.config.isInFallbackMode() ? fallbackModelConfig : desiredModelConfig;
-        currentAttemptModel = modelConfigToUse.model;
-        currentAttemptGenerateContentConfig = modelConfigToUse.generateContentConfig;
+        let modelConfigToUse = desiredModelConfig;
+        if (!this.config.isModelAvailabilityServiceEnabled()) {
+          modelConfigToUse = this.config.isInFallbackMode() ? fallbackModelConfig : desiredModelConfig;
+          currentAttemptModel = modelConfigToUse.model;
+          currentAttemptGenerateContentConfig = modelConfigToUse.generateContentConfig;
+        } else {
+          const active = this.config.getActiveModel();
+          if (active !== currentAttemptModel) {
+            currentAttemptModel = active;
+            const newConfig2 = this.config.modelConfigService.getResolvedConfig({
+              ...modelConfigKey,
+              model: currentAttemptModel
+            });
+            currentAttemptGenerateContentConfig = newConfig2.generateContentConfig;
+          }
+        }
         const requestConfig = {
           ...currentAttemptGenerateContentConfig,
           abortSignal,
@@ -370301,7 +370547,9 @@ var GeminiClient = class {
       );
       const result = await retryWithBackoff(apiCall, {
         onPersistent429: onPersistent429Callback,
-        authType: this.config.getContentGeneratorConfig()?.authType
+        authType: this.config.getContentGeneratorConfig()?.authType,
+        maxAttempts: availabilityMaxAttempts,
+        getAvailabilityContext
       });
       return result;
     } catch (error2) {
@@ -381789,7 +382037,7 @@ async function getClientMetadata() {
     clientMetadataPromise = (async () => ({
       ideName: "IDE_UNSPECIFIED",
       pluginType: "GEMINI",
-      ideVersion: "0.21.0-nightly.20251208.7a7203757",
+      ideVersion: "0.21.0-nightly.20251209.ec9a8c7a7",
       platform: getPlatform(),
       updateChannel: await getReleaseChannel(__dirname5)
     }))();
@@ -384752,6 +385000,7 @@ var Config = class {
   folderTrust;
   ideMode;
   inFallbackMode = false;
+  _activeModel;
   maxSessionTurns;
   listSessions;
   deleteSession;
@@ -384859,6 +385108,7 @@ var Config = class {
     this.fileDiscoveryService = params.fileDiscoveryService ?? null;
     this.bugCommand = params.bugCommand;
     this.model = params.model;
+    this._activeModel = params.model;
     this.enableModelAvailabilityService = params.enableModelAvailabilityService ?? false;
     this.enableAgents = params.enableAgents ?? false;
     this.experimentalJitContext = params.experimentalJitContext ?? false;
@@ -385068,10 +385318,23 @@ var Config = class {
   setModel(newModel) {
     if (this.model !== newModel || this.inFallbackMode) {
       this.model = newModel;
+      this._activeModel = newModel;
       coreEvents.emitModelChanged(newModel);
     }
     this.setFallbackMode(false);
   }
+  getActiveModel() {
+    return this._activeModel ?? this.model;
+  }
+  setActiveModel(model) {
+    if (this._activeModel !== model) {
+      this._activeModel = model;
+      coreEvents.emitModelChanged(model);
+    }
+  }
+  resetTurn() {
+    this.modelAvailabilityService.resetTurn();
+  }
   isInFallbackMode() {
     return this.inFallbackMode;
   }
@@ -386430,6 +386693,8 @@ var Task = class _Task {
   completedToolCalls;
   skipFinalTrueAfterInlineEdit = false;
   modelInfo;
+  currentPromptId;
+  promptCount = 0;
   // For tool waiting logic
   pendingToolCalls = /* @__PURE__ */ new Map();
   //toolCallId --> status
@@ -387031,8 +387296,7 @@ var Task = class _Task {
     yield* this.geminiClient.sendMessageStream(
       llmParts,
       aborted3,
-      /*prompt_id*/
-      ""
+      completedToolCalls[0]?.request.prompt_id ?? ""
     );
   }
   async *acceptUserMessage(requestContext, aborted3) {
@@ -387052,6 +387316,7 @@ var Task = class _Task {
       }
     }
     if (hasContentForLlm) {
+      this.currentPromptId = this.config.getSessionId() + "########" + this.promptCount++;
       logger.info("[Task] Sending new parts to LLM.");
       const stateChange = {
         kind: "state-change" /* StateChangeEvent */
@@ -387060,8 +387325,7 @@ var Task = class _Task {
       yield* this.geminiClient.sendMessageStream(
         llmParts,
         aborted3,
-        /*prompt_id*/
-        ""
+        this.currentPromptId
       );
     } else if (anyConfirmationHandled) {
       logger.info(