chore(core): remove redundant isModelAvailabilityServiceEnabled toggle and clean up dead code (#15207)

Author: adamfweidman

docs/get-started/configuration.md

@@ -798,11 +798,6 @@ their corresponding top-level category object in your `settings.json` file.
   - **Default:** `false`
   - **Requires restart:** Yes
 
-- **`experimental.isModelAvailabilityServiceEnabled`** (boolean):
-  - **Description:** Enable model routing using new availability service.
-  - **Default:** `false`
-  - **Requires restart:** Yes
-
 - **`experimental.jitContext`** (boolean):
   - **Description:** Enable Just-In-Time (JIT) context loading.
   - **Default:** `false`

packages/cli/src/config/config.ts

@@ -643,8 +643,6 @@ export async function loadCliConfig(
     extensionLoader: extensionManager,
     enableExtensionReloading: settings.experimental?.extensionReloading,
     enableAgents: settings.experimental?.enableAgents,
-    enableModelAvailabilityService:
-      settings.experimental?.isModelAvailabilityServiceEnabled,
     experimentalJitContext: settings.experimental?.jitContext,
     noBrowser: !!process.env['NO_BROWSER'],
     summarizeToolOutput: settings.model?.summarizeToolOutput,

packages/cli/src/config/settingsSchema.test.ts

@@ -354,21 +354,6 @@ describe('SettingsSchema', () => {
       expect(setting.showInDialog).toBe(false);
       expect(setting.description).toBe('Enable local and remote subagents.');
     });
-
-    it('should have isModelAvailabilityServiceEnabled setting in schema', () => {
-      const setting =
-        getSettingsSchema().experimental.properties
-          .isModelAvailabilityServiceEnabled;
-      expect(setting).toBeDefined();
-      expect(setting.type).toBe('boolean');
-      expect(setting.category).toBe('Experimental');
-      expect(setting.default).toBe(false);
-      expect(setting.requiresRestart).toBe(true);
-      expect(setting.showInDialog).toBe(false);
-      expect(setting.description).toBe(
-        'Enable model routing using new availability service.',
-      );
-    });
   });
 
   it('has JSON schema definitions for every referenced ref', () => {

packages/cli/src/config/settingsSchema.ts

@@ -1323,15 +1323,6 @@ const SETTINGS_SCHEMA = {
           'Enables extension loading/unloading within the CLI session.',
         showInDialog: false,
       },
-      isModelAvailabilityServiceEnabled: {
-        type: 'boolean',
-        label: 'Enable Model Availability Service',
-        category: 'Experimental',
-        requiresRestart: true,
-        default: false,
-        description: 'Enable model routing using new availability service.',
-        showInDialog: false,
-      },
       jitContext: {
         type: 'boolean',
         label: 'JIT Context Loading',

packages/core/src/availability/policyHelpers.test.ts

@@ -119,7 +119,6 @@ describe('policyHelpers', () => {
       overrides: Partial<Config> = {},
     ): Config => {
       const defaults = {
-        isModelAvailabilityServiceEnabled: () => true,
         getModelAvailabilityService: () => mockAvailabilityService,
         setActiveModel: vi.fn(),
         modelConfigService: mockModelConfigService,
@@ -131,15 +130,6 @@ describe('policyHelpers', () => {
       vi.clearAllMocks();
     });
 
-    it('returns requested model if availability service is disabled', () => {
-      const config = createExtendedMockConfig({
-        isModelAvailabilityServiceEnabled: () => false,
-      });
-      const result = applyModelSelection(config, 'gemini-pro');
-      expect(result.model).toBe('gemini-pro');
-      expect(config.setActiveModel).not.toHaveBeenCalled();
-    });
-
     it('returns requested model if it is available', () => {
       const config = createExtendedMockConfig();
       mockAvailabilityService.selectFirstAvailable.mockReturnValue({

packages/core/src/availability/policyHelpers.ts

@@ -117,9 +117,6 @@ export function createAvailabilityContextProvider(
   modelGetter: () => string,
 ): () => RetryAvailabilityContext | undefined {
   return () => {
-    if (!config.isModelAvailabilityServiceEnabled()) {
-      return undefined;
-    }
     const service = config.getModelAvailabilityService();
     const currentModel = modelGetter();
 
@@ -138,11 +135,7 @@ export function createAvailabilityContextProvider(
 export function selectModelForAvailability(
   config: Config,
   requestedModel: string,
-): ModelSelectionResult | undefined {
-  if (!config.isModelAvailabilityServiceEnabled()) {
-    return undefined;
-  }
-
+): ModelSelectionResult {
   const chain = resolvePolicyChain(config, requestedModel);
   const selection = config
     .getModelAvailabilityService()

packages/core/src/config/config.ts

@@ -326,7 +326,6 @@ export interface ConfigParameters {
       } & { disabled?: string[] });
   previewFeatures?: boolean;
   enableAgents?: boolean;
-  enableModelAvailabilityService?: boolean;
   experimentalJitContext?: boolean;
 }
 
@@ -449,7 +448,6 @@ export class Config {
 
   private previewModelFallbackMode = false;
   private previewModelBypassMode = false;
-  private readonly enableModelAvailabilityService: boolean;
   private readonly enableAgents: boolean;
 
   private readonly experimentalJitContext: boolean;
@@ -513,7 +511,6 @@ export class Config {
     this.bugCommand = params.bugCommand;
     this.model = params.model;
     this._activeModel = params.model;
-    this.enableModelAvailabilityService = true;
     this.enableAgents = params.enableAgents ?? false;
     this.experimentalJitContext = params.experimentalJitContext ?? false;
     this.modelAvailabilityService = new ModelAvailabilityService();
@@ -1309,10 +1306,6 @@ export class Config {
     return this.enableExtensionReloading;
   }
 
-  isModelAvailabilityServiceEnabled(): boolean {
-    return this.enableModelAvailabilityService;
-  }
-
   isAgentsEnabled(): boolean {
     return this.enableAgents;
   }

packages/core/src/core/baseLlmClient.test.ts

@@ -111,8 +111,9 @@ describe('BaseLlmClient', () => {
           .fn()
           .mockImplementation(({ model }) => makeResolvedModelConfig(model)),
       } as unknown as ModelConfigService,
-      isModelAvailabilityServiceEnabled: vi.fn().mockReturnValue(false),
-      getModelAvailabilityService: vi.fn(),
+      getModelAvailabilityService: vi
+        .fn()
+        .mockReturnValue(createAvailabilityServiceMock()),
       setActiveModel: vi.fn(),
       getPreviewFeatures: vi.fn().mockReturnValue(false),
       getUserTier: vi.fn().mockReturnValue(undefined),
@@ -614,10 +615,6 @@ describe('BaseLlmClient', () => {
     let jsonOptions: GenerateJsonOptions;
 
     beforeEach(() => {
-      mockConfig.isModelAvailabilityServiceEnabled = vi
-        .fn()
-        .mockReturnValue(true);
-
       mockAvailabilityService = createAvailabilityServiceMock({
         selectedModel: 'test-model',
         skipped: [],
@@ -647,23 +644,6 @@ describe('BaseLlmClient', () => {
       };
     });
 
-    it('should preserve legacy behavior when availability is disabled', async () => {
-      mockConfig.isModelAvailabilityServiceEnabled = vi
-        .fn()
-        .mockReturnValue(false);
-      mockGenerateContent.mockResolvedValue(
-        createMockResponse('Some text response'),
-      );
-
-      await client.generateContent(contentOptions);
-
-      expect(
-        mockAvailabilityService.selectFirstAvailable,
-      ).not.toHaveBeenCalled();
-      expect(mockConfig.setActiveModel).not.toHaveBeenCalled();
-      expect(mockAvailabilityService.markHealthy).not.toHaveBeenCalled();
-    });
-
     it('should mark model as healthy on success', async () => {
       const successfulModel = 'gemini-pro';
       vi.mocked(mockAvailabilityService.selectFirstAvailable).mockReturnValue({

packages/core/src/core/baseLlmClient.ts

@@ -264,22 +264,20 @@ export class BaseLlmClient {
 
     try {
       const apiCall = () => {
-        // If availability is enabled, ensure we use the current active model
+        // Ensure we use the current active model
         // in case a fallback occurred in a previous attempt.
-        if (this.config.isModelAvailabilityServiceEnabled()) {
-          const activeModel = this.config.getActiveModel();
-          if (activeModel !== requestParams.model) {
-            requestParams.model = activeModel;
-            // Re-resolve config if model changed during retry
-            const { generateContentConfig } =
-              this.config.modelConfigService.getResolvedConfig({
-                model: activeModel,
-              });
-            requestParams.config = {
-              ...requestParams.config,
-              ...generateContentConfig,
-            };
-          }
+        const activeModel = this.config.getActiveModel();
+        if (activeModel !== requestParams.model) {
+          requestParams.model = activeModel;
+          // Re-resolve config if model changed during retry
+          const { generateContentConfig } =
+            this.config.modelConfigService.getResolvedConfig({
+              model: activeModel,
+            });
+          requestParams.config = {
+            ...requestParams.config,
+            ...generateContentConfig,
+          };
         }
         return this.contentGenerator.generateContent(requestParams, promptId);
       };

packages/core/src/core/client.test.ts

@@ -265,11 +265,12 @@ describe('Gemini Client (client.ts)', () => {
       },
       isInteractive: vi.fn().mockReturnValue(false),
       getExperiments: () => {},
-      isModelAvailabilityServiceEnabled: vi.fn().mockReturnValue(false),
       getActiveModel: vi.fn().mockReturnValue('test-model'),
       setActiveModel: vi.fn(),
       resetTurn: vi.fn(),
-      getModelAvailabilityService: vi.fn(),
+      getModelAvailabilityService: vi
+        .fn()
+        .mockReturnValue(createAvailabilityServiceMock()),
     } as unknown as Config;
     mockConfig.getHookSystem = vi
       .fn()
@@ -2006,9 +2007,6 @@ ${JSON.stringify(
         vi.mocked(mockConfig.getModelAvailabilityService).mockReturnValue(
           mockAvailabilityService,
         );
-        vi.mocked(mockConfig.isModelAvailabilityServiceEnabled).mockReturnValue(
-          true,
-        );
         vi.mocked(mockConfig.setActiveModel).mockClear();
         mockRouterService.route.mockResolvedValue({
           model: 'model-a',
@@ -2611,14 +2609,14 @@ ${JSON.stringify(
       const abortSignal = new AbortController().signal;
 
       await client.generateContent(
-        { model: DEFAULT_GEMINI_FLASH_MODEL },
+        { model: 'test-model' },
         contents,
         abortSignal,
       );
 
       expect(mockContentGenerator.generateContent).toHaveBeenCalledWith(
         {
-          model: DEFAULT_GEMINI_FLASH_MODEL,
+          model: 'test-model',
           config: {
             abortSignal,
             systemInstruction: getCoreSystemPrompt({} as unknown as Config, ''),
@@ -2632,50 +2630,18 @@ ${JSON.stringify(
     });
 
     it('should use current model from config for content generation', async () => {
-      const initialModel = client['config'].getModel();
+      const initialModel = 'test-model';
       const contents = [{ role: 'user', parts: [{ text: 'test' }] }];
-      const currentModel = initialModel + '-changed';
-
-      vi.spyOn(client['config'], 'getModel').mockReturnValueOnce(currentModel);
 
       await client.generateContent(
-        { model: DEFAULT_GEMINI_FLASH_MODEL },
+        { model: initialModel },
         contents,
         new AbortController().signal,
       );
 
-      expect(mockContentGenerator.generateContent).not.toHaveBeenCalledWith({
-        model: initialModel,
-        config: expect.any(Object),
-        contents,
-      });
       expect(mockContentGenerator.generateContent).toHaveBeenCalledWith(
-        {
-          model: DEFAULT_GEMINI_FLASH_MODEL,
-          config: expect.any(Object),
-          contents,
-        },
-        'test-session-id',
-      );
-    });
-
-    it('should use the Flash model when fallback mode is active', async () => {
-      const contents = [{ role: 'user', parts: [{ text: 'hello' }] }];
-      const abortSignal = new AbortController().signal;
-      const requestedModel = 'gemini-2.5-pro'; // A non-flash model
-
-      // Mock config to be in fallback mode
-      vi.spyOn(client['config'], 'isInFallbackMode').mockReturnValue(true);
-
-      await client.generateContent(
-        { model: requestedModel },
-        contents,
-        abortSignal,
-      );
-
-      expect(mockGenerateContentFn).toHaveBeenCalledWith(
         expect.objectContaining({
-          model: DEFAULT_GEMINI_FLASH_MODEL,
+          model: initialModel,
         }),
         'test-session-id',
       );