agentHost: add Claude and Codex session telemetry (#333274)

* agentHost: add Claude and Codex session telemetry

Generalize Agent Host subscription telemetry across providers while preserving Copilot-specific SDK resume dimensions. Add coverage for Claude, Codex, and future providers.\n\n(Written by Copilot)\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* agentHost: filter session telemetry by registered provider

Resolve subscription providers through the provider service so future registered providers are included while terminal and unknown resource schemes are excluded.\n\n(Written by Copilot)\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* agentHost: use canonical provider service interface

Keep the production dependency typed as IAgentHostProviderService and move partial service stubbing into test code.\n\n(Written by Copilot)\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* docs: require canonical injected service interfaces

Document that production service dependencies use their canonical interfaces and keep partial test conveniences in test code.\n\n(Written by Copilot)\n\nCo-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: roblourens

.github/instructions/source-code-organization.instructions.md

@@ -64,4 +64,6 @@ class MyComponent {
 }
 ```
 
+Decorated service parameters must use their canonical service interface. Do not invent local subset interfaces or `Pick<...>` aliases in production to simplify tests; keep partial stubs, adapters, and other test-only conveniences in test code.
+
 Services are provided via `registerSingleton(IMyService, MyServiceImpl, InstantiationType.Delayed)`.

src/vs/platform/agentHost/node/agentHostSessionOpenTelemetry.ts

@@ -9,13 +9,15 @@ import { StopWatch } from '../../../base/common/stopwatch.js';
 import { URI } from '../../../base/common/uri.js';
 import { createDecorator } from '../../instantiation/common/instantiation.js';
 import { ITelemetryService } from '../../telemetry/common/telemetry.js';
-import { AgentSession } from '../common/agent.js';
+import type { AgentProvider } from '../common/agent.js';
 import { isAhpChatChannel, isDefaultChatUri, parseRequiredSessionUriFromChatUri } from '../common/state/sessionState.js';
+import { IAgentHostProviderService } from './agentHostProviderService.js';
 
-export const AgentHostCopilotSessionSubscribeTimeoutMs = 60_000;
+export const AgentHostSessionSubscribeTimeoutMs = 60_000;
 
-export type AgentHostCopilotSessionSubscribeChannel = 'session' | 'defaultChat' | 'chat';
-export type AgentHostCopilotSessionSubscribeOutcome = 'success' | 'failure' | 'timeout';
+export type AgentHostSessionSubscribeProvider = AgentProvider;
+export type AgentHostSessionSubscribeChannel = 'session' | 'defaultChat' | 'chat';
+export type AgentHostSessionSubscribeOutcome = 'success' | 'failure' | 'timeout';
 export type AgentHostCopilotSdkResumeOutcome = 'success' | 'failure' | 'fallbackCreate' | 'incomplete' | 'notStarted';
 
 export interface IAgentHostSessionOpenTelemetryScope {
@@ -35,13 +37,14 @@ export interface IAgentHostSessionOpenTelemetry {
 
 export const IAgentHostSessionOpenTelemetry = createDecorator<IAgentHostSessionOpenTelemetry>('agentHostSessionOpenTelemetry');
 
-type AgentHostCopilotSessionSubscribeEvent = {
+type AgentHostSessionSubscribeEvent = {
+	provider: string;
 	channel: string;
 	outcome: string;
 	servedFromMemory: boolean | undefined;
 	joinedRestore: boolean | undefined;
-	sdkResumeOutcome: string;
-	sdkResumeAttemptCount: number;
+	sdkResumeOutcome: string | undefined;
+	sdkResumeAttemptCount: number | undefined;
 	timeToRestoreStartMs: number | undefined;
 	timeToSdkResumeStartMs: number | undefined;
 	sdkResumeDurationMs: number | undefined;
@@ -50,9 +53,10 @@ type AgentHostCopilotSessionSubscribeEvent = {
 	totalDurationMs: number;
 };
 
-type AgentHostCopilotSessionSubscribeClassification = {
+type AgentHostSessionSubscribeClassification = {
 	owner: 'roblourens';
-	comment: 'Measures Copilot Agent Host subscription latency from the subscribe request through session restoration and SDK resume to the returned snapshot.';
+	comment: 'Measures Agent Host subscription latency from the subscribe request through session restoration and provider-specific resume work to the returned snapshot.';
+	provider: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'Agent provider identifier.' };
 	channel: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'Bounded subscribed channel kind: session, defaultChat, or chat.' };
 	outcome: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; comment: 'Terminal subscription outcome: success, failure, or timeout.' };
 	servedFromMemory: { classification: 'SystemMetaData'; purpose: 'PerformanceAndHealth'; isMeasurement: true; comment: 'Whether the subscribed snapshot was already materialized when the request was received.' };
@@ -72,7 +76,7 @@ class AgentHostSessionOpenTelemetryAttempt extends Disposable {
 	readonly resources = this._register(new DisposableStore());
 	servedFromMemory: boolean | undefined;
 	joinedRestore: boolean | undefined;
-	sdkResumeOutcome: AgentHostCopilotSdkResumeOutcome = 'notStarted';
+	sdkResumeOutcome: AgentHostCopilotSdkResumeOutcome | undefined;
 	sdkResumeAttemptCount = 0;
 	timeToRestoreStartMs: number | undefined;
 	timeToSdkResumeStartMs: number | undefined;
@@ -84,9 +88,11 @@ class AgentHostSessionOpenTelemetryAttempt extends Disposable {
 	constructor(
 		readonly id: number,
 		readonly session: URI,
-		readonly channel: AgentHostCopilotSessionSubscribeChannel,
+		readonly provider: AgentHostSessionSubscribeProvider,
+		readonly channel: AgentHostSessionSubscribeChannel,
 	) {
 		super();
+		this.sdkResumeOutcome = provider === 'copilotcli' ? 'notStarted' : undefined;
 	}
 }
 
@@ -99,6 +105,7 @@ export class AgentHostSessionOpenTelemetry extends Disposable implements IAgentH
 
 	constructor(
 		@ITelemetryService private readonly _telemetryService: ITelemetryService,
+		@IAgentHostProviderService private readonly _providerService: IAgentHostProviderService,
 	) {
 		super();
 		this._register(toDisposable(() => {
@@ -170,15 +177,15 @@ export class AgentHostSessionOpenTelemetry extends Disposable implements IAgentH
 			return undefined;
 		}
 
-		const attempt = new AgentHostSessionOpenTelemetryAttempt(this._nextAttemptId++, info.session, info.channel);
+		const attempt = new AgentHostSessionOpenTelemetryAttempt(this._nextAttemptId++, info.session, info.provider, info.channel);
 		this._attempts.set(attempt.id, attempt);
 		let sessionAttempts = this._attemptsBySession.get(info.session.toString());
 		if (!sessionAttempts) {
 			sessionAttempts = new Set();
 			this._attemptsBySession.set(info.session.toString(), sessionAttempts);
 		}
 		sessionAttempts.add(attempt);
-		attempt.resources.add(disposableTimeout(() => this._finish(attempt, 'timeout', attempt.servedFromMemory), AgentHostCopilotSessionSubscribeTimeoutMs));
+		attempt.resources.add(disposableTimeout(() => this._finish(attempt, 'timeout', attempt.servedFromMemory), AgentHostSessionSubscribeTimeoutMs));
 		return attempt;
 	}
 
@@ -221,7 +228,7 @@ export class AgentHostSessionOpenTelemetry extends Disposable implements IAgentH
 		}
 	}
 
-	private _finish(attempt: AgentHostSessionOpenTelemetryAttempt, outcome: AgentHostCopilotSessionSubscribeOutcome, servedFromMemory: boolean | undefined): void {
+	private _finish(attempt: AgentHostSessionOpenTelemetryAttempt, outcome: AgentHostSessionSubscribeOutcome, servedFromMemory: boolean | undefined): void {
 		if (!this._attempts.delete(attempt.id)) {
 			return;
 		}
@@ -252,13 +259,14 @@ export class AgentHostSessionOpenTelemetry extends Disposable implements IAgentH
 		const totalDurationMs = Math.max(timeToRestoreCompleteMs ?? timeToSdkResumeCompleteMs ?? timeToRestoreStartMs ?? 0, elapsed);
 		attempt.dispose();
 
-		this._telemetryService.publicLog2<AgentHostCopilotSessionSubscribeEvent, AgentHostCopilotSessionSubscribeClassification>('agentHost.copilotSessionSubscribe', {
+		this._telemetryService.publicLog2<AgentHostSessionSubscribeEvent, AgentHostSessionSubscribeClassification>('agentHost.sessionSubscribe', {
+			provider: attempt.provider,
 			channel: attempt.channel,
 			outcome,
 			servedFromMemory,
 			joinedRestore: attempt.joinedRestore,
 			sdkResumeOutcome: attempt.sdkResumeOutcome,
-			sdkResumeAttemptCount: attempt.sdkResumeAttemptCount,
+			sdkResumeAttemptCount: attempt.provider === 'copilotcli' ? attempt.sdkResumeAttemptCount : undefined,
 			timeToRestoreStartMs,
 			timeToSdkResumeStartMs,
 			sdkResumeDurationMs: attempt.sdkResumeAttemptCount > 0 ? attempt.sdkResumeDurationMs : undefined,
@@ -280,16 +288,18 @@ export class AgentHostSessionOpenTelemetry extends Disposable implements IAgentH
 		return Math.max(0, Math.round(attempt.stopwatch.elapsed()));
 	}
 
-	private _classify(resource: URI): { readonly session: URI; readonly channel: AgentHostCopilotSessionSubscribeChannel } | undefined {
+	private _classify(resource: URI): { readonly session: URI; readonly provider: AgentHostSessionSubscribeProvider; readonly channel: AgentHostSessionSubscribeChannel } | undefined {
 		const resourceString = resource.toString();
 		const session = isAhpChatChannel(resourceString)
 			? URI.parse(parseRequiredSessionUriFromChatUri(resourceString))
 			: resource;
-		if (AgentSession.provider(session) !== 'copilotcli') {
+		const provider = this._providerService.getProviderForSession(session)?.id;
+		if (!provider) {
 			return undefined;
 		}
 		return {
 			session,
+			provider,
 			channel: !isAhpChatChannel(resourceString) ? 'session' : isDefaultChatUri(resource) ? 'defaultChat' : 'chat',
 		};
 	}

src/vs/platform/agentHost/test/node/agentHostSessionOpenTelemetry.test.ts

@@ -6,12 +6,16 @@
 import assert from 'assert';
 import { DeferredPromise, timeout } from '../../../../base/common/async.js';
 import { URI } from '../../../../base/common/uri.js';
+import { mock } from '../../../../base/test/common/mock.js';
 import { runWithFakedTimers } from '../../../../base/test/common/timeTravelScheduler.js';
 import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../base/test/common/utils.js';
+import { TestInstantiationService } from '../../../instantiation/test/common/instantiationServiceMock.js';
+import { ITelemetryService } from '../../../telemetry/common/telemetry.js';
 import { NullTelemetryServiceShape } from '../../../telemetry/common/telemetryUtils.js';
-import { AgentSession } from '../../common/agent.js';
+import { AgentSession, CLAUDE_AGENT_PROVIDER_ID, CODEX_AGENT_PROVIDER_ID, type IAgent } from '../../common/agent.js';
 import { buildDefaultChatUri } from '../../common/state/sessionState.js';
-import { AgentHostCopilotSessionSubscribeTimeoutMs, AgentHostSessionOpenTelemetry } from '../../node/agentHostSessionOpenTelemetry.js';
+import { IAgentHostProviderService } from '../../node/agentHostProviderService.js';
+import { AgentHostSessionOpenTelemetry, AgentHostSessionSubscribeTimeoutMs } from '../../node/agentHostSessionOpenTelemetry.js';
 
 function isTelemetryData(data: unknown): data is Record<string, unknown> {
 	return typeof data === 'object' && data !== null;
@@ -31,11 +35,28 @@ suite('AgentHostSessionOpenTelemetry', () => {
 	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
 	const session = AgentSession.uri('copilotcli', 'session');
 	const defaultChat = URI.parse(buildDefaultChatUri(session));
+	const createService = (telemetryService: TestTelemetryService, providers: readonly string[] = ['copilotcli']) => {
+		const instantiationService = disposables.add(new TestInstantiationService());
+		instantiationService.stub(ITelemetryService, telemetryService);
+		instantiationService.stub(IAgentHostProviderService, {
+			getProviderForSession: session => {
+				const provider = AgentSession.provider(session);
+				if (!provider || !providers.includes(provider)) {
+					return undefined;
+				}
+				const providerId = provider;
+				return new class extends mock<IAgent>() {
+					override readonly id = providerId;
+				};
+			},
+		});
+		return disposables.add(instantiationService.createInstance(AgentHostSessionOpenTelemetry));
+	};
 
 	test('emits ordered subscribe, restore, and SDK resume milestones', async () => {
 		await runWithFakedTimers({ useFakeTimers: true, startTime: 1_000 }, async () => {
 			const telemetryService = new TestTelemetryService();
-			const service = disposables.add(new AgentHostSessionOpenTelemetry(telemetryService));
+			const service = createService(telemetryService);
 			await service.withSubscription(defaultChat, async telemetry => {
 				telemetry.setServedFromMemory(false);
 				await timeout(5);
@@ -48,8 +69,9 @@ suite('AgentHostSessionOpenTelemetry', () => {
 			});
 
 			assert.deepStrictEqual(telemetryService.events, [{
-				name: 'agentHost.copilotSessionSubscribe',
+				name: 'agentHost.sessionSubscribe',
 				data: {
+					provider: 'copilotcli',
 					channel: 'defaultChat',
 					outcome: 'success',
 					servedFromMemory: false,
@@ -70,10 +92,11 @@ suite('AgentHostSessionOpenTelemetry', () => {
 	test('records warm subscriptions without restore or SDK resume milestones', async () => {
 		await runWithFakedTimers({ useFakeTimers: true }, async () => {
 			const telemetryService = new TestTelemetryService();
-			const service = disposables.add(new AgentHostSessionOpenTelemetry(telemetryService));
+			const service = createService(telemetryService);
 			await service.withSubscription(session, async telemetry => telemetry.setServedFromMemory(true));
 
 			assert.deepStrictEqual(telemetryService.events.map(event => event.data), [{
+				provider: 'copilotcli',
 				channel: 'session',
 				outcome: 'success',
 				servedFromMemory: true,
@@ -93,7 +116,7 @@ suite('AgentHostSessionOpenTelemetry', () => {
 	test('accumulates retries and reports fallback creation without duplicate emission', async () => {
 		await runWithFakedTimers({ useFakeTimers: true }, async () => {
 			const telemetryService = new TestTelemetryService();
-			const service = disposables.add(new AgentHostSessionOpenTelemetry(telemetryService));
+			const service = createService(telemetryService);
 			await service.withSubscription(session, async telemetry => {
 				telemetry.setServedFromMemory(false);
 				telemetry.restoreStarted(true);
@@ -127,7 +150,7 @@ suite('AgentHostSessionOpenTelemetry', () => {
 	test('does not attribute an in-flight SDK resume to a late subscriber', async () => {
 		await runWithFakedTimers({ useFakeTimers: true }, async () => {
 			const telemetryService = new TestTelemetryService();
-			const service = disposables.add(new AgentHostSessionOpenTelemetry(telemetryService));
+			const service = createService(telemetryService);
 			const first = service.withSubscription(session, async telemetry => {
 				telemetry.setServedFromMemory(false);
 				await service.withSdkResume(session, () => timeout(20));
@@ -153,7 +176,7 @@ suite('AgentHostSessionOpenTelemetry', () => {
 
 	test('emits one failure outcome and rethrows the subscription error', async () => {
 		const telemetryService = new TestTelemetryService();
-		const service = disposables.add(new AgentHostSessionOpenTelemetry(telemetryService));
+		const service = createService(telemetryService);
 		const expectedError = new Error('Restore failed');
 
 		await assert.rejects(service.withSubscription(defaultChat, async telemetry => {
@@ -173,11 +196,46 @@ suite('AgentHostSessionOpenTelemetry', () => {
 		}]);
 	});
 
-	test('emits a bounded timeout and ignores non-Copilot subscriptions', async () => {
+	test('emits subscription telemetry for current and future providers', async () => {
+		const telemetryService = new TestTelemetryService();
+		const providers = [CLAUDE_AGENT_PROVIDER_ID, CODEX_AGENT_PROVIDER_ID, 'future'];
+		const service = createService(telemetryService, providers);
+		for (const provider of [CLAUDE_AGENT_PROVIDER_ID, CODEX_AGENT_PROVIDER_ID, 'future']) {
+			await service.withSubscription(AgentSession.uri(provider, 'session'), async telemetry => {
+				telemetry.setServedFromMemory(false);
+				telemetry.restoreStarted(false);
+				telemetry.restoreCompleted();
+			});
+		}
+		const terminalResult = await service.withSubscription(URI.parse('agenthost-terminal:/terminal'), async () => 'terminal');
+		const unknownResult = await service.withSubscription(AgentSession.uri('unknown', 'session'), async () => 'unknown');
+
+		assert.deepStrictEqual({
+			terminalResult,
+			unknownResult,
+			events: telemetryService.events.map(event => ({
+				name: event.name,
+				provider: event.data.provider,
+				channel: event.data.channel,
+				outcome: event.data.outcome,
+				sdkResumeOutcome: event.data.sdkResumeOutcome,
+				sdkResumeAttemptCount: event.data.sdkResumeAttemptCount,
+			})),
+		}, {
+			terminalResult: 'terminal',
+			unknownResult: 'unknown',
+			events: [
+				{ name: 'agentHost.sessionSubscribe', provider: 'claude', channel: 'session', outcome: 'success', sdkResumeOutcome: undefined, sdkResumeAttemptCount: undefined },
+				{ name: 'agentHost.sessionSubscribe', provider: 'codex', channel: 'session', outcome: 'success', sdkResumeOutcome: undefined, sdkResumeAttemptCount: undefined },
+				{ name: 'agentHost.sessionSubscribe', provider: 'future', channel: 'session', outcome: 'success', sdkResumeOutcome: undefined, sdkResumeAttemptCount: undefined },
+			],
+		});
+	});
+
+	test('emits a bounded timeout', async () => {
 		await runWithFakedTimers({ useFakeTimers: true }, async () => {
 			const telemetryService = new TestTelemetryService();
-			const service = disposables.add(new AgentHostSessionOpenTelemetry(telemetryService));
-			assert.strictEqual(await service.withSubscription(AgentSession.uri('claude', 'session'), async () => 'not measured'), 'not measured');
+			const service = createService(telemetryService);
 			const resume = new DeferredPromise<void>();
 			const subscription = service.withSubscription(session, async telemetry => {
 				telemetry.setServedFromMemory(false);
@@ -187,11 +245,12 @@ suite('AgentHostSessionOpenTelemetry', () => {
 			});
 
 			await timeout(10_000);
-			await timeout(AgentHostCopilotSessionSubscribeTimeoutMs - 10_000);
+			await timeout(AgentHostSessionSubscribeTimeoutMs - 10_000);
 
 			assert.deepStrictEqual(telemetryService.events, [{
-				name: 'agentHost.copilotSessionSubscribe',
+				name: 'agentHost.sessionSubscribe',
 				data: {
+					provider: 'copilotcli',
 					channel: 'session',
 					outcome: 'timeout',
 					servedFromMemory: false,
@@ -203,7 +262,7 @@ suite('AgentHostSessionOpenTelemetry', () => {
 					sdkResumeDurationMs: 50_000,
 					timeToSdkResumeCompleteMs: undefined,
 					timeToRestoreCompleteMs: undefined,
-					totalDurationMs: AgentHostCopilotSessionSubscribeTimeoutMs,
+					totalDurationMs: AgentHostSessionSubscribeTimeoutMs,
 				},
 			}]);
 			resume.complete();

src/vs/platform/agentHost/test/node/copilotAgent.test.ts

@@ -34,7 +34,7 @@ import type { IByokLmBridgeConnection, IByokLmModelInfo } from '../../common/age
 import { ITelemetryService } from '../../../telemetry/common/telemetry.js';
 import { NullTelemetryService, NullTelemetryServiceShape } from '../../../telemetry/common/telemetryUtils.js';
 import { AgentHostTelemetryService } from '../../node/agentHostTelemetryService.js';
-import { AgentHostSessionOpenTelemetry, IAgentHostSessionOpenTelemetry } from '../../node/agentHostSessionOpenTelemetry.js';
+import { IAgentHostSessionOpenTelemetry } from '../../node/agentHostSessionOpenTelemetry.js';
 import { CopilotCliConfigKey, CopilotCliVSCodeAssignmentContextKey } from '../../common/copilotCliConfig.js';
 import { AgentHostConfigKey } from '../../common/agentHostCustomizationConfig.js';
 import { AgentHostAutoApprovePolicyRestrictedConfigKey, AgentHostByokModelsEnabledConfigKey, AgentHostGitHubMcpServerEnabledConfigKey, AgentHostCopilotMultiRootEnabledConfigKey, AgentHostMigrateLegacyCopilotCliEnabledConfigKey, AgentHostProxyConfigKey, AgentHostSystemProxyEnabledConfigKey } from '../../common/agentHostSchema.js';
@@ -917,7 +917,17 @@ function createTestAgentContext(disposables: Pick<DisposableStore, 'add'>, optio
 	const copilotApiService = options?.copilotApiService ?? new TestCopilotApiService();
 	services.set(ICopilotApiService, copilotApiService);
 	services.set(ITelemetryService, telemetryService);
-	services.set(IAgentHostSessionOpenTelemetry, disposables.add(new AgentHostSessionOpenTelemetry(telemetryService)));
+	services.set(IAgentHostSessionOpenTelemetry, {
+		_serviceBrand: undefined,
+		withSubscription: async (_resource, operation) => operation({
+			servedFromMemory: undefined,
+			setServedFromMemory: () => { },
+			restoreStarted: () => { },
+			restoreCompleted: () => { },
+		}),
+		withSdkResume: async (_session, operation) => operation(),
+		sdkResumeFallbackCreated: () => { },
+	});
 	if (options?.environmentServiceRegistration !== 'none') {
 		const environmentService = {
 			_serviceBrand: undefined,