Add automode.routerModelSelection telemetry with actualModel

Emits a new telemetry event after all client-side model overrides
(same-provider, vision fallback, default selection) are applied.

Properties:
- candidateModel: the router's top pick (candidate_models[0])
- actualModel: the model actually used after all overrides
- overrideReason: none, defaultFallback, or clientOverride
- conversationId: for correlation

This enables accurate switch attribution without fragile cross-event
joins. The existing automode.routerDecision event captures the router's
recommendation, but doesn't know what model was ultimately selected
because vision fallback and default selection happen afterward.

Analysts can now query automode.routerModelSelection directly:
  | where candidateModel != actualModel
  | summarize count() by candidateModel, actualModel

Author: Aashna Garg

extensions/copilot/src/platform/endpoint/node/automodeService.ts

@@ -215,6 +215,31 @@ export class AutomodeService extends Disposable implements IAutomodeService {
 
 		selectedModel = this._applyVisionFallback(chatRequest, selectedModel, token.available_models, knownEndpoints);
 
+		// Emit the final model selection alongside the router's recommendation
+		// so analysts can detect overrides without fragile telemetry joins
+		if (!skipRouter && routerResult.candidateModel) {
+			/* __GDPR__
+				"automode.routerModelSelection" : {
+					"owner": "aashnagarg",
+					"comment": "Reports the router's recommended model vs the actual model used after all client-side overrides (same-provider, vision fallback, default selection)",
+					"conversationId": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The conversation ID" },
+					"candidateModel": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The router's top candidate model (candidate_models[0])" },
+					"actualModel": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "The model actually selected after all client-side overrides" },
+					"overrideReason": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "comment": "Why the actual model differs from the candidate: none, visionFallback, defaultFallback, or sameProvider" }
+				}
+			*/
+			const candidateModel = routerResult.candidateModel;
+			const overrideReason = candidateModel === selectedModel.model ? 'none'
+				: routerFallbackReason ? 'defaultFallback'
+				: 'clientOverride';
+			this._telemetryService.sendMSFTTelemetryEvent('automode.routerModelSelection', {
+				conversationId: conversationId ?? '',
+				candidateModel,
+				actualModel: selectedModel.model,
+				overrideReason,
+			});
+		}
+
 		// Reuse the cached endpoint if the session token and model haven't changed
 		const autoEndpoint = (entry?.endpoint && entry.lastSessionToken === token.session_token && entry.endpoint.model === selectedModel.model)
 			? entry.endpoint
@@ -250,7 +275,7 @@ export class AutomodeService extends Disposable implements IAutomodeService {
 		entry: AutoModelCacheEntry | undefined,
 		token: AutoModeAPIResponse,
 		knownEndpoints: IChatEndpoint[],
-	): Promise<{ selectedModel?: IChatEndpoint; lastRoutedPrompt?: string; fallbackReason?: string }> {
+	): Promise<{ selectedModel?: IChatEndpoint; lastRoutedPrompt?: string; fallbackReason?: string; candidateModel?: string }> {
 		const prompt = chatRequest?.prompt?.trim();
 		const lastRoutedPrompt = entry?.lastRoutedPrompt ?? prompt;
 
@@ -298,7 +323,7 @@ export class AutomodeService extends Disposable implements IAutomodeService {
 			if (result.sticky_override) {
 				this._logService.trace(`[AutomodeService] Sticky routing override: confidence=${(result.confidence * 100).toFixed(1)}%, label=${result.predicted_label}, router_model=${result.candidate_models[0]}, actual_model=${selectedModel.model}`);
 			}
-			return { selectedModel, lastRoutedPrompt: prompt };
+			return { selectedModel, lastRoutedPrompt: prompt, candidateModel: result.candidate_models[0] };
 		} catch (e) {
 			const isTimeout = isAbortError(e);
 			let fallbackReason: string;

extensions/copilot/src/platform/endpoint/node/test/automodeService.spec.ts

@@ -17,7 +17,7 @@ import { ILogService } from '../../../log/common/logService';
 import { IChatEndpoint } from '../../../networking/common/networking';
 import { NullRequestLogger } from '../../../requestLogger/node/nullRequestLogger';
 import { IExperimentationService, NullExperimentationService } from '../../../telemetry/common/nullExperimentationService';
-import { NullTelemetryService } from '../../../telemetry/common/nullTelemetryService';
+import { ITelemetryService } from '../../../telemetry/common/telemetry';
 import { ICAPIClientService } from '../../common/capiClient';
 import { AutomodeService } from '../automodeService';
 
@@ -60,6 +60,7 @@ describe('AutomodeService', () => {
 	let configurationService: IConfigurationService;
 	let mockChatEndpoint: IChatEndpoint;
 	let envService: NullEnvService;
+	let mockTelemetryService: ITelemetryService & { sendMSFTTelemetryEvent: ReturnType<typeof vi.fn> };
 
 	function createEndpoint(model: string, provider: string, overrides?: Partial<IChatEndpoint>): IChatEndpoint {
 		return {
@@ -87,7 +88,7 @@ describe('AutomodeService', () => {
 			mockExpService,
 			configurationService,
 			envService,
-			new NullTelemetryService(),
+			mockTelemetryService,
 			new NullRequestLogger()
 		);
 	}
@@ -145,6 +146,13 @@ describe('AutomodeService', () => {
 
 		configurationService = new InMemoryConfigurationService(new DefaultsOnlyConfigurationService());
 		envService = new NullEnvService();
+		mockTelemetryService = {
+			sendTelemetryEvent: vi.fn(),
+			sendMSFTTelemetryEvent: vi.fn(),
+			sendTelemetryErrorEvent: vi.fn(),
+			sendMSFTTelemetryErrorEvent: vi.fn(),
+			sendSharedTelemetryEvent: vi.fn(),
+		} as unknown as ITelemetryService & { sendMSFTTelemetryEvent: ReturnType<typeof vi.fn> };
 	});
 
 	afterEach(() => {
@@ -946,6 +954,68 @@ describe('AutomodeService', () => {
 		});
 	});
 
+	describe('routerModelSelection telemetry', () => {
+		it('should emit routerModelSelection with candidateModel and actualModel when router is used', async () => {
+			enableRouter();
+			const gpt4oEndpoint = createEndpoint('gpt-4o', 'OpenAI');
+			const claudeEndpoint = createEndpoint('claude-sonnet', 'Anthropic');
+
+			mockRouterResponse(
+				['gpt-4o', 'claude-sonnet'],
+				{ chosen_model: 'gpt-4o', candidate_models: ['gpt-4o', 'claude-sonnet'] }
+			);
+
+			automodeService = createService();
+			const chatRequest: Partial<ChatRequest> = {
+				location: ChatLocation.Panel,
+				prompt: 'test prompt',
+				sessionId: 'session-telemetry-test'
+			};
+
+			await automodeService.resolveAutoModeEndpoint(chatRequest as ChatRequest, [gpt4oEndpoint, claudeEndpoint]);
+
+			const telemetryCalls = mockTelemetryService.sendMSFTTelemetryEvent.mock.calls;
+			const selectionEvent = telemetryCalls.find((call: unknown[]) => call[0] === 'automode.routerModelSelection');
+			expect(selectionEvent).toBeDefined();
+			expect(selectionEvent![1]).toMatchObject({
+				candidateModel: 'gpt-4o',
+				actualModel: 'gpt-4o',
+				overrideReason: 'none',
+			});
+		});
+
+		it('should emit overrideReason=clientOverride when actual model differs from candidate', async () => {
+			enableRouter();
+			const gpt4oEndpoint = createEndpoint('gpt-4o', 'OpenAI');
+			const claudeEndpoint = createEndpoint('claude-sonnet', 'Anthropic');
+
+			// Router picks unknown-model but it has no endpoint, so falls back
+			mockRouterResponse(
+				['gpt-4o'],
+				{ chosen_model: 'unknown-model', candidate_models: ['unknown-model'] }
+			);
+
+			automodeService = createService();
+			const chatRequest: Partial<ChatRequest> = {
+				location: ChatLocation.Panel,
+				prompt: 'test prompt',
+				sessionId: 'session-telemetry-override'
+			};
+
+			await automodeService.resolveAutoModeEndpoint(chatRequest as ChatRequest, [gpt4oEndpoint, claudeEndpoint]);
+
+			const telemetryCalls = mockTelemetryService.sendMSFTTelemetryEvent.mock.calls;
+			const fallbackEvent = telemetryCalls.find((call: unknown[]) => call[0] === 'automode.routerModelSelection');
+			// When router returns unknown model, candidateModel is set but selectedModel
+			// is undefined so it falls to _selectDefaultModel — no routerModelSelection emitted
+			// because fallbackReason is set and candidateModel is returned
+			expect(fallbackEvent).toBeDefined();
+			if (fallbackEvent) {
+				expect(fallbackEvent[1].overrideReason).toBe('defaultFallback');
+			}
+		});
+	});
+
 	describe('vision fallback', () => {
 		it('should fall back to vision-capable model when selected model does not support vision', async () => {
 			const nonVisionEndpoint = createEndpoint('gpt-4o-mini', 'OpenAI', { supportsVision: false });