feat(core): extend cross-auth fast models to agents

docs/users/features/sub-agents.md

@@ -134,7 +134,7 @@ Subagents are configured using Markdown files with YAML frontmatter. This format
 ---
 name: agent-name
 description: Brief description of when and how to use this agent
-model: inherit # Optional: inherit or model-id
+model: inherit # Optional: inherit, fast, modelId, or authType:modelId
 approvalMode: auto-edit # Optional: default, plan, auto-edit, yolo
 tools:         # Optional: allowlist of tools
   - tool1
@@ -151,10 +151,48 @@ Multiple paragraphs are supported.
 
 Use the optional `model` frontmatter field to control which model a subagent uses:
 
-- `inherit`: Use the same model as the main conversation
-- Omit the field: Same as `inherit`
-- `glm-5`: Use that model ID with the main conversation's auth type
-- `openai:gpt-4o`: Use a different provider (resolves credentials from env vars)
+- `inherit`: Use the same model as the main conversation.
+- Omit the field: Same as `inherit`.
+- `fast`: Use the configured `fastModel`. If no valid fast model is configured,
+  the subagent falls back to `inherit`.
+- `glm-5`: Use that model ID. Qwen Code first checks the main conversation's
+  auth type; if the model is not available there, it can resolve the model from
+  another configured provider.
+- `openai:gpt-4o`: Use an explicit provider and model ID. This is useful when a
+  subagent should run on a model registered under a different auth type from the
+  main conversation.
+
+For example:
+
+```
+---
+name: fast-reviewer
+description: Reviews small diffs with the configured fast model
+model: fast
+tools:
+  - read_file
+  - grep_search
+---
+```
+
+```
+---
+name: openai-researcher
+description: Uses an OpenAI-compatible provider for research tasks
+model: openai:gpt-4o
+tools:
+  - read_file
+  - grep_search
+  - glob
+---
+```
+
+The `fast` selector uses the same `fastModel` setting configured in
+`settings.json` or with `/model --fast`. That setting may itself refer to a
+model under another configured auth type, such as `openai:deepseek-v4-flash`.
+When the selector resolves to another auth type, Qwen Code creates a dedicated
+runtime provider for that subagent request and sends the provider only the bare
+model ID.
 
 #### Permission Mode
 
@@ -620,6 +658,10 @@ Always follow these standards:
 
 - **Tool Restrictions**: Use `tools` to limit which tools a subagent can access, or `disallowedTools` to block specific tools while inheriting everything else
 - **Permission Mode**: Subagents inherit their parent's permission mode by default. Plan-mode sessions cannot escalate to auto-edit through delegated agents. Privileged modes (auto-edit, yolo) are blocked in untrusted folders.
+- **Provider Selection**: A subagent with `model: authType:modelId`, or
+  `model: fast` where `fastModel` resolves to another auth type, sends that
+  subagent's model requests to the selected provider. Make sure that provider is
+  appropriate for the subagent's task and data.
 - **Sandboxing**: All tool execution follows the same security model as direct tool use
 - **Audit Trail**: All Subagents actions are logged and visible in real-time
 - **Access Control**: Project and user-level separation provides appropriate boundaries

packages/cli/src/ui/AppContainer.tsx

@@ -1899,20 +1899,16 @@ export const AppContainer = (props: AppContainerProps) => {
       const fullHistory = geminiClient.getChat().getHistory(true);
       const conversationHistory =
         fullHistory.length > 40 ? fullHistory.slice(-40) : fullHistory;
-      const fastModel = config.getFastModel();
       generatePromptSuggestion(config, conversationHistory, ac.signal, {
         enableCacheSharing: settings.merged.ui?.enableCacheSharing === true,
-        model: fastModel,
       })
         .then((result) => {
           if (ac.signal.aborted) return;
           if (result.suggestion) {
             setPromptSuggestion(result.suggestion);
             // Start speculation if enabled (runs in background)
             if (settings.merged.ui?.enableSpeculation) {
-              startSpeculation(config, result.suggestion, ac.signal, {
-                model: fastModel,
-              })
+              startSpeculation(config, result.suggestion, ac.signal)
                 .then((state) => {
                   speculationRef.current = state;
                 })

packages/cli/src/ui/commands/recapCommand.ts

@@ -63,12 +63,12 @@ export const recapCommand: SlashCommand = {
     if (context.executionMode === 'interactive') {
       const item: HistoryItemAwayRecap = {
         type: 'away_recap',
-        text: recap.text,
+        text: recap,
       };
       context.ui.addItem(item, Date.now());
       return;
     }
 
-    return { type: 'message', messageType: 'info', content: recap.text };
+    return { type: 'message', messageType: 'info', content: recap };
   },
 };

packages/cli/src/ui/hooks/useAwaySummary.test.ts

@@ -54,10 +54,7 @@ describe('useAwaySummary', () => {
     const recordSlashCommand = vi.fn();
     const config = makeConfig(recordSlashCommand);
     const addItem = vi.fn();
-    generateSessionRecapMock.mockResolvedValue({
-      text: 'recap text',
-      modelUsed: 'fast',
-    });
+    generateSessionRecapMock.mockResolvedValue('recap text');
 
     // Mount blurred to set the away-start timestamp.
     const { rerender } = renderHook(
@@ -104,10 +101,7 @@ describe('useAwaySummary', () => {
     const recordSlashCommand = vi.fn();
     const config = makeConfig(recordSlashCommand);
     const addItem = vi.fn();
-    generateSessionRecapMock.mockResolvedValue({
-      text: 'should not appear',
-      modelUsed: 'fast',
-    });
+    generateSessionRecapMock.mockResolvedValue('should not appear');
 
     const historyWithRecentRecap: HistoryItem[] = [
       ...THREE_USER_HISTORY,

packages/cli/src/ui/hooks/useAwaySummary.ts

@@ -150,7 +150,7 @@ export function useAwaySummary(options: UseAwaySummaryOptions): void {
         if (!isIdleRef.current) return;
         const item: HistoryItemAwayRecap = {
           type: 'away_recap',
-          text: recap.text,
+          text: recap,
         };
         addItem(item, Date.now());
 

packages/core/src/config/config.test.ts

@@ -867,7 +867,7 @@ describe('Server Config (config.ts)', () => {
   });
 
   describe('model switching with different credentials (OpenAI)', () => {
-    it('keeps getFastModel current-auth-only for direct runtime callers', () => {
+    it('returns a bare fast model selector when the model is configured under another auth type', () => {
       const config = new Config({
         ...baseParams,
         authType: AuthType.USE_ANTHROPIC,
@@ -893,11 +893,10 @@ describe('Server Config (config.ts)', () => {
         },
       });
 
-      expect(config.getFastModel()).toBeUndefined();
-      expect(config.getFastModelForSideQuery()).toBe('deepseek-v4-flash');
+      expect(config.getFastModel()).toBe('deepseek-v4-flash');
     });
 
-    it('returns an authType-qualified fast model selector for side queries', () => {
+    it('returns an authType-qualified fast model selector', () => {
       const config = new Config({
         ...baseParams,
         authType: AuthType.USE_ANTHROPIC,
@@ -923,11 +922,10 @@ describe('Server Config (config.ts)', () => {
         },
       });
 
-      expect(config.getFastModel()).toBeUndefined();
-      expect(config.getFastModelForSideQuery()).toBe('openai:shared-model');
+      expect(config.getFastModel()).toBe('openai:shared-model');
     });
 
-    it('returns a bare fast model for getFastModel when authType-qualified selector matches the current auth type', () => {
+    it('keeps authType-qualified selectors when the auth type matches the current auth type', () => {
       const config = new Config({
         ...baseParams,
         authType: AuthType.USE_OPENAI,
@@ -945,10 +943,7 @@ describe('Server Config (config.ts)', () => {
         },
       });
 
-      expect(config.getFastModel()).toBe('deepseek-v4-flash');
-      expect(config.getFastModelForSideQuery()).toBe(
-        'openai:deepseek-v4-flash',
-      );
+      expect(config.getFastModel()).toBe('openai:deepseek-v4-flash');
     });
 
     it('accepts runtime fast models for authType-qualified selectors', () => {
@@ -979,10 +974,7 @@ describe('Server Config (config.ts)', () => {
       });
       config.getModelsConfig().detectAndCaptureRuntimeModel();
 
-      expect(config.getFastModel()).toBe('runtime-fast-model');
-      expect(config.getFastModelForSideQuery()).toBe(
-        'openai:runtime-fast-model',
-      );
+      expect(config.getFastModel()).toBe('openai:runtime-fast-model');
     });
 
     it('returns undefined when the fast model is not configured for any auth type', () => {
@@ -1004,7 +996,6 @@ describe('Server Config (config.ts)', () => {
       });
 
       expect(config.getFastModel()).toBeUndefined();
-      expect(config.getFastModelForSideQuery()).toBeUndefined();
     });
 
     it('returns undefined when the fast model selector is malformed', () => {
@@ -1026,7 +1017,6 @@ describe('Server Config (config.ts)', () => {
       });
 
       expect(config.getFastModel()).toBeUndefined();
-      expect(config.getFastModelForSideQuery()).toBeUndefined();
     });
 
     it('returns undefined when fastModel points back to the fast selector', () => {
@@ -1048,7 +1038,6 @@ describe('Server Config (config.ts)', () => {
       });
 
       expect(config.getFastModel()).toBeUndefined();
-      expect(config.getFastModelForSideQuery()).toBeUndefined();
     });
 
     it('should refresh auth when switching to model with different envKey', async () => {

packages/core/src/config/config.ts

@@ -1861,52 +1861,35 @@ export class Config {
   }
 
   /**
-   * Returns the fast model if one is configured and valid for the current auth
-   * type, otherwise returns undefined. Direct runtime paths use this as a
-   * cheaper alternative to the main session model, so it intentionally stays
-   * current-auth-only.
+   * Returns the configured fast model selector when it resolves to an available
+   * model. Bare selectors stay bare and authType-qualified selectors keep their
+   * authType prefix so selector-aware runtime paths can route cross-auth calls.
    */
   getFastModel(): string | undefined {
-    const authType =
-      this.contentGeneratorConfig?.authType ??
-      this.modelsConfig.getCurrentAuthType();
-    if (!authType) return undefined;
     const selector = this.resolveFastModelSelector();
     if (!selector) return undefined;
-    if (selector.authType && selector.authType !== authType) return undefined;
 
-    const available = this.getAllConfiguredModels([authType]);
-    return available.some((m) => m.id === selector.modelId)
-      ? selector.modelId
-      : undefined;
-  }
-
-  /**
-   * Returns the fast model for side-query paths. Unlike {@link getFastModel},
-   * this can return an authType-qualified selector because BaseLlmClient can
-   * route a single request through a provider different from the main session.
-   */
-  getFastModelForSideQuery(): string | undefined {
-    const selector = this.resolveFastModelSelector();
-    if (!selector) return undefined;
-
-    if (selector.authType) {
-      const available = this.getAllConfiguredModels([selector.authType]);
-      return available.some((m) => m.id === selector.modelId)
-        ? `${selector.authType}:${selector.modelId}`
-        : undefined;
+    const available = selector.authType
+      ? this.getAllConfiguredModels([selector.authType])
+      : this.getAllConfiguredModels();
+    if (!available.some((m) => m.id === selector.modelId)) {
+      return undefined;
     }
 
-    const available = this.getAllConfiguredModels();
-    return available.some((m) => m.id === selector.modelId)
-      ? selector.modelId
-      : undefined;
+    const rawSelector = resolveModelId(this.fastModel);
+    return rawSelector?.authType
+      ? `${rawSelector.authType}:${selector.modelId}`
+      : selector.modelId;
   }
 
   private resolveFastModelSelector() {
     if (!this.fastModel) return undefined;
     try {
-      return resolveModelId(this.fastModel);
+      return resolveModelId(this.fastModel, {
+        currentAuthType: this.getContentGeneratorConfig()?.authType,
+        getAvailableModels: (authTypes) =>
+          this.getAllConfiguredModels(authTypes),
+      });
     } catch {
       return undefined;
     }

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

@@ -559,7 +559,16 @@ describe('BaseLlmClient', () => {
         getEmbeddingModel: vi.fn().mockReturnValue('test-embedding-model'),
         getModel: vi.fn().mockReturnValue('main-model'),
         getFastModel: vi.fn().mockReturnValue(undefined),
-        getFastModelForSideQuery: vi.fn().mockReturnValue(undefined),
+        getAllConfiguredModels: vi.fn((authTypes?: AuthType[]) =>
+          authTypes?.includes(AuthType.QWEN_OAUTH)
+            ? []
+            : [
+                {
+                  id: fastModel,
+                  authType: AuthType.USE_ANTHROPIC,
+                },
+              ],
+        ),
         getModelsConfig: vi.fn().mockReturnValue({ getResolvedModel }),
       } as unknown as Mocked<Config>;
     });
@@ -575,6 +584,29 @@ describe('BaseLlmClient', () => {
       expect(mockCreateContentGenerator).not.toHaveBeenCalled();
     });
 
+    it('returns the active runtime generator when model matches the runtime view', async () => {
+      const runtimeContentGenerator = {
+        generateContent: vi.fn(),
+        embedContent: vi.fn(),
+      } as unknown as Mocked<ContentGenerator>;
+      crossProviderConfig.getContentGenerator = vi
+        .fn()
+        .mockReturnValue(runtimeContentGenerator);
+      vi.mocked(crossProviderConfig.getContentGeneratorConfig).mockReturnValue({
+        authType: AuthType.USE_OPENAI,
+        model: 'runtime-model',
+      });
+      vi.mocked(crossProviderConfig.getModel).mockReturnValue('runtime-model');
+      const c = new BaseLlmClient(mockContentGenerator, crossProviderConfig);
+
+      const resolved = await c.resolveForModel('runtime-model');
+
+      expect(resolved.contentGenerator).toBe(runtimeContentGenerator);
+      expect(resolved.retryAuthType).toBe(AuthType.USE_OPENAI);
+      expect(getResolvedModel).not.toHaveBeenCalled();
+      expect(mockCreateContentGenerator).not.toHaveBeenCalled();
+    });
+
     it('builds a per-model generator when model differs and is registered under another authType', async () => {
       // Main authType is QWEN_OAUTH; fast model only resolves under USE_ANTHROPIC.
       getResolvedModel.mockImplementation((authType: string, model: string) => {
@@ -646,6 +678,38 @@ describe('BaseLlmClient', () => {
       expect(mockCreateContentGenerator).not.toHaveBeenCalled();
     });
 
+    it('does not cache the unregistered-model fallback across runtime-view changes', async () => {
+      // Unregistered selector: createContentGeneratorForModel falls back to
+      // getCurrentContentGenerator(). The runtime view changes between calls
+      // — caching would pin the first call's generator under the selector
+      // key and return it on the second call after the view has unwound.
+      getResolvedModel.mockReturnValue(undefined);
+
+      const firstRuntimeGenerator = {
+        generateContent: vi.fn(),
+        embedContent: vi.fn(),
+      } as unknown as Mocked<ContentGenerator>;
+      const secondRuntimeGenerator = {
+        generateContent: vi.fn(),
+        embedContent: vi.fn(),
+      } as unknown as Mocked<ContentGenerator>;
+      const getContentGenerator = vi
+        .fn()
+        .mockReturnValueOnce(firstRuntimeGenerator)
+        .mockReturnValueOnce(secondRuntimeGenerator);
+      crossProviderConfig.getContentGenerator = getContentGenerator;
+
+      const c = new BaseLlmClient(mockContentGenerator, crossProviderConfig);
+
+      const first = await c.resolveForModel('unknown-model');
+      const second = await c.resolveForModel('unknown-model');
+
+      expect(first.contentGenerator).toBe(firstRuntimeGenerator);
+      expect(second.contentGenerator).toBe(secondRuntimeGenerator);
+      expect(getContentGenerator).toHaveBeenCalledTimes(2);
+      expect(mockCreateContentGenerator).not.toHaveBeenCalled();
+    });
+
     it('falls back to the main generator when createContentGenerator throws', async () => {
       getResolvedModel.mockReturnValue({
         authType: AuthType.USE_ANTHROPIC,
@@ -738,9 +802,7 @@ describe('BaseLlmClient', () => {
     });
 
     it('generateJson resolves fast selectors through the configured fast model', async () => {
-      crossProviderConfig.getFastModelForSideQuery.mockReturnValue(
-        'openai:shared-model',
-      );
+      crossProviderConfig.getFastModel.mockReturnValue('openai:shared-model');
       getResolvedModel.mockImplementation((authType: string, model: string) => {
         if (authType === AuthType.USE_OPENAI && model === 'shared-model') {
           return {