agent-host: stop redundant customization sync events (#317611)

* agent-host: stop redundant customization sync events

Refactors customization syncing to publish state changes as SessionActions
through the session state manager rather than via a per-call progress callback
that emitted full lists each tick. Also avoids redundant `activeClientChanged`
dispatches that were driving large loops of customization/file requests across
the connection.

- `setClientCustomizations` now takes the session URI and publishes
  `SessionCustomizationsChanged` once with the resolved list, followed by
  `SessionCustomizationUpdated` actions only when an individual customization's
  state actually changes.
- `agentSideEffects` no longer wires its own progress callback; it lets the
  agent publish actions and forwards action signals into the state manager even
  when no turn is active so session-level state (customizations, title, config)
  stays consistent.
- `agentHostSessionHandler` no longer claims the active-client role on session
  restore, and only re-dispatches `activeClientChanged` when the local view of
  `activeClient` actually differs from the session state. The pre-send hook
  ensures the active client is current before sending a message.
- `agentCustomizationItemProvider` reads session customizations from the
  shared session subscription instead of caching them locally and re-firing on
  every customization update.
- Adds tests covering the no-redundant-dispatch behavior and the new progress
  publishing flow.

Fixes #316538

(Commit message generated by Copilot)

* address Copilot review and fix provider tests

- copilotAgent: construct SessionCustomizationUpdated explicitly (omit clientId)

- mockAgent: always emit SessionCustomizationsChanged so clears propagate

- agentCustomizationItemProvider: restore session customizations cache and handle both Changed/Updated actions

- agentSideEffects.test: assert clear publishes one empty SessionCustomizationsChanged

* drop local session-customization cache, read from session subscription

Replaces the provider-local _sessionCustomizationsCache with a direct read from the central session subscription via getSubscriptionUnmanaged(StateComponents.Session). The session reducer already maintains 'customizations' from SessionCustomizationsChanged/Updated, so the local mirror only duplicated logic and would have missed state populated before the provider attached. Teaches MockAgentConnection to expose session subscriptions backed by fireAction so tests exercise the same code path.

* build

Author: connor4312

src/vs/platform/agentHost/common/agentPluginManager.ts

@@ -41,15 +41,15 @@ export interface IAgentPluginManager {
 	 * Syncs a set of client-provided customization refs to local storage.
 	 *
 	 * Each ref is copied to a local directory, respecting nonce-based
-	 * caching. The optional {@link progress} callback fires as individual
-	 * customizations complete or fail, allowing callers to publish
-	 * incremental status updates.
+	 * caching. The optional {@link progress} callback fires with the single
+	 * customization that completed or failed, allowing callers to publish
+	 * targeted incremental status updates.
 	 *
 	 * Concurrent calls for the same plugin URI are serialized so that
 	 * overlapping syncs do not clobber each other.
 	 *
 	 * @returns Final status for every customization, with `pluginDir`
 	 * defined when the sync was successful.
 	 */
-	syncCustomizations(clientId: string, customizations: CustomizationRef[], progress?: (status: SessionCustomization[]) => void): Promise<ISyncedCustomization[]>;
+	syncCustomizations(clientId: string, customizations: CustomizationRef[], progress?: (status: SessionCustomization) => void): Promise<ISyncedCustomization[]>;
 }

src/vs/platform/agentHost/common/agentService.ts

@@ -644,13 +644,13 @@ export interface IAgent {
 	onArchivedChanged?(session: URI, isArchived: boolean): Promise<void>;
 
 	/**
-	 * Receives client-provided customization refs and syncs them (e.g. copies
-	 * plugin files to local storage). Returns per-customization status with
-	 * local plugin directories.
+	 * Receives client-provided customization refs for a session and syncs them
+	 * (e.g. copies plugin files to local storage). The agent publishes
+	 * customization state actions as the sync progresses.
 	 *
 	 * The agent MAY defer a client restart until all active sessions are idle.
 	 */
-	setClientCustomizations(clientId: string, customizations: CustomizationRef[], progress?: (results: ISyncedCustomization[]) => void): Promise<ISyncedCustomization[]>;
+	setClientCustomizations(session: URI, clientId: string, customizations: CustomizationRef[]): Promise<ISyncedCustomization[]>;
 
 	/**
 	 * Receives client-provided tool definitions to make available in a

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

@@ -68,32 +68,24 @@ export class AgentPluginManager implements IAgentPluginManager {
 	async syncCustomizations(
 		clientId: string,
 		customizations: CustomizationRef[],
-		progress?: (status: SessionCustomization[]) => void,
+		progress?: (status: SessionCustomization) => void,
 	): Promise<ISyncedCustomization[]> {
 		await this._ensureCacheLoaded();
 
-		// Build initial loading status and fire it immediately via progress
-		const statuses: SessionCustomization[] = customizations.map(c => ({
-			customization: c,
-			enabled: true,
-			status: CustomizationStatus.Loading,
-		}));
-		progress?.([...statuses]);
-
 		// Sync each customization in parallel, serialized per URI
-		const results = await Promise.all(customizations.map((ref, i) =>
+		const results = await Promise.all(customizations.map(ref =>
 			this._sequencer.queue(ref.uri, async (): Promise<ISyncedCustomization> => {
 				try {
 					const pluginDir = await this._syncPlugin(clientId, ref);
-					statuses[i] = { customization: ref, enabled: true, status: CustomizationStatus.Loaded };
-					progress?.([...statuses]);
-					return { customization: statuses[i], pluginDir };
+					const customization = { customization: ref, enabled: true, status: CustomizationStatus.Loaded };
+					progress?.(customization);
+					return { customization, pluginDir };
 				} catch (err) {
 					const message = err instanceof Error ? err.message : String(err);
 					this._logService.error(`[AgentPluginManager] Failed to sync plugin ${ref.uri}: ${message}`);
-					statuses[i] = { customization: ref, enabled: true, status: CustomizationStatus.Error, statusMessage: message };
-					progress?.([...statuses]);
-					return { customization: statuses[i] };
+					const customization = { customization: ref, enabled: true, status: CustomizationStatus.Error, statusMessage: message };
+					progress?.(customization);
+					return { customization };
 				}
 			})
 		));

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

@@ -332,14 +332,16 @@ export class AgentSideEffects extends Disposable {
 			return;
 		}
 
-		// No active turn on the session. Most signals are silently dropped,
-		// but a `SessionTurnComplete` (idle) still needs to drive its
-		// post-turn side effects — flushing pending diff computation,
-		// recomputing diffs, and notifying the host. Tests routinely fire
-		// `idle` without first dispatching the matching `SessionTurnStarted`
-		// through the state manager.
-		if (signal.kind === 'action' && signal.action.type === ActionType.SessionTurnComplete) {
-			this._runTurnCompleteSideEffects(sessionKey, undefined);
+		// No active turn on the session. Non-action signals are silently
+		// dropped, but action signals can still target session-level state
+		// such as customizations, title, or configuration. A turnComplete
+		// action also drives post-turn side effects even when the matching
+		// turnStarted was not observed by this side-effects instance.
+		if (signal.kind === 'action') {
+			this._stateManager.dispatchServerAction(sessionKey, signal.action);
+			if (signal.action.type === ActionType.SessionTurnComplete) {
+				this._runTurnCompleteSideEffects(sessionKey, undefined);
+			}
 		}
 	}
 
@@ -798,15 +800,7 @@ export class AgentSideEffects extends Disposable {
 				agent.setClientTools(URI.parse(channel), clientId, action.activeClient?.tools ?? []);
 
 				const refs = action.activeClient?.customizations ?? [];
-				agent.setClientCustomizations(
-					clientId,
-					refs,
-					() => {
-						this._publishSessionCustomizationsSoon(agent, channel);
-					},
-				).then(() => {
-					this._publishSessionCustomizationsSoon(agent, channel);
-				}).catch(err => {
+				agent.setClientCustomizations(URI.parse(channel), clientId, refs).catch(err => {
 					this._logService.error('[AgentSideEffects] setClientCustomizations failed', err);
 				});
 				break;
@@ -971,4 +965,3 @@ export class AgentSideEffects extends Disposable {
 		super.dispose();
 	}
 }
-

src/vs/platform/agentHost/node/claude/claudeAgent.ts

@@ -1078,7 +1078,7 @@ export class ClaudeAgent extends Disposable implements IAgent {
 		// matching pending promise on the SDK session.
 	}
 
-	setClientCustomizations(_clientId: string, _customizations: CustomizationRef[], _progress?: (results: ISyncedCustomization[]) => void): Promise<ISyncedCustomization[]> {
+	setClientCustomizations(_session: URI, _clientId: string, _customizations: CustomizationRef[]): Promise<ISyncedCustomization[]> {
 		throw new Error('TODO: Phase 11');
 	}
 

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

@@ -30,6 +30,7 @@ import { SessionConfigKey } from '../../common/sessionConfigKeys.js';
 import { ISessionDataService, SESSION_DB_FILENAME } from '../../common/sessionDataService.js';
 import type { ResolveSessionConfigResult, SessionConfigCompletionsResult } from '../../common/state/protocol/commands.js';
 import { ProtectedResourceMetadata, type ConfigSchema, type ModelSelection, type SessionCustomization, type ToolDefinition } from '../../common/state/protocol/state.js';
+import { ActionType, type SessionAction } from '../../common/state/sessionActions.js';
 import { AHP_AUTH_REQUIRED, ProtocolError } from '../../common/state/sessionProtocol.js';
 import { CustomizationRef, CustomizationStatus, ResponsePartKind, SessionInputResponseKind, parseSubagentSessionUri, type MessageAttachment, type PendingMessage, type PolicyState, type ResponsePart, type SessionInputAnswer, type ToolCallResult, type Turn } from '../../common/state/sessionState.js';
 import { IAgentConfigurationService } from '../agentConfigurationService.js';
@@ -310,14 +311,18 @@ export class CopilotAgent extends Disposable implements IAgent {
 	}
 
 	async getSessionCustomizations(session: URI): Promise<readonly SessionCustomization[]> {
+		return this._plugins.getSessionCustomizations(await this._getSessionCustomizationDirectory(session));
+	}
+
+	private async _getSessionCustomizationDirectory(session: URI): Promise<URI | undefined> {
 		const sessionId = AgentSession.id(session);
 		const provisional = this._provisionalSessions.get(sessionId);
 		if (provisional) {
-			return this._plugins.getSessionCustomizations(provisional.workingDirectory);
+			return provisional.workingDirectory;
 		}
 		const entry = this._sessions.get(sessionId);
 		const metadata = entry ? undefined : await this._readSessionMetadata(session);
-		return this._plugins.getSessionCustomizations(entry?.customizationDirectory ?? metadata?.customizationDirectory ?? metadata?.workingDirectory);
+		return entry?.customizationDirectory ?? metadata?.customizationDirectory ?? metadata?.workingDirectory;
 	}
 
 	async authenticate(resource: string, token: string): Promise<boolean> {
@@ -760,7 +765,7 @@ export class CopilotAgent extends Disposable implements IAgent {
 			const ac = this._getOrCreateActiveClient(sessionUri);
 			ac.updateTools(config.activeClient.clientId, config.activeClient.tools);
 			if (config.activeClient.customizations !== undefined) {
-				await this._plugins.sync(config.activeClient.clientId, config.activeClient.customizations);
+				await this._plugins.sync(config.activeClient.clientId, config.activeClient.customizations, config.workingDirectory);
 			}
 		}
 
@@ -940,8 +945,11 @@ export class CopilotAgent extends Disposable implements IAgent {
 		return { items: branches.map(branch => ({ value: branch, label: branch })) };
 	}
 
-	async setClientCustomizations(clientId: string, customizations: CustomizationRef[], progress?: (results: ISyncedCustomization[]) => void): Promise<ISyncedCustomization[]> {
-		return this._plugins.sync(clientId, customizations, progress);
+	async setClientCustomizations(session: URI, clientId: string, customizations: CustomizationRef[]): Promise<ISyncedCustomization[]> {
+		const directory = await this._getSessionCustomizationDirectory(session);
+		return this._plugins.sync(clientId, customizations, directory, action => {
+			this._onDidSessionProgress.fire({ kind: 'action', session, action });
+		});
 	}
 
 	setClientTools(session: URI, clientId: string, tools: ToolDefinition[]): void {
@@ -1931,7 +1939,7 @@ class PluginController extends Disposable {
 		});
 	}
 
-	public sync(clientId: string, customizations: CustomizationRef[], progress?: (results: ISyncedCustomization[]) => void) {
+	public sync(clientId: string, customizations: CustomizationRef[], directory: URI | undefined, publish?: (action: SessionAction) => void) {
 		const revision = ++this._clientRevision;
 		this._clientCustomizations = customizations.map(customization => ({
 			customization: {
@@ -1941,7 +1949,29 @@ class PluginController extends Disposable {
 				status: CustomizationStatus.Loading,
 			},
 		}));
-		progress?.(this._clientCustomizations.map(item => ({ customization: this._applyEnablement(item.customization) })));
+		publish?.({
+			type: ActionType.SessionCustomizationsChanged,
+			customizations: [...this.getSessionCustomizations(directory)],
+		});
+		const published = new Map<string, SessionCustomization>();
+		for (const customization of this._clientCustomizations) {
+			const enabled = this._applyEnablement(customization.customization);
+			published.set(enabled.customization.uri, this._applyEnablement(customization.customization));
+		}
+		const publishUpdate = (item: IResolvedCustomization) => {
+			const customization = this._applyEnablement(item.customization);
+			if (equals(published.get(customization.customization.uri), customization)) {
+				return;
+			}
+			published.set(customization.customization.uri, { ...customization });
+			publish?.({
+				type: ActionType.SessionCustomizationUpdated,
+				customization: customization.customization,
+				enabled: customization.enabled,
+				status: customization.status,
+				statusMessage: customization.statusMessage,
+			});
+		};
 
 		const prev = this._clientSync;
 		const promise = this._clientSync = prev.catch(err => {
@@ -1952,18 +1982,15 @@ class PluginController extends Disposable {
 					return;
 				}
 
-				this._clientCustomizations = status.map(customization => ({
-					customization: {
-						...customization,
-						clientId,
-					},
-				}));
-				progress?.(this._clientCustomizations.map(item => ({ customization: this._applyEnablement(item.customization) })));
+				publishUpdate({ customization: { ...status, clientId } });
 			});
 
 			const resolved = await Promise.all(result.map(item => this._resolveSyncedCustomization(item, clientId)));
 			if (revision === this._clientRevision) {
 				this._clientCustomizations = resolved;
+				for (const item of resolved) {
+					publishUpdate(item);
+				}
 			}
 			return resolved;
 		});

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

@@ -88,18 +88,15 @@ suite('AgentPluginManager', () => {
 			assert.strictEqual(results[1].pluginDir, undefined);
 		});
 
-		test('fires progress callback with loading, then loaded', async () => {
+		test('fires progress callback with changed customization status', async () => {
 			await seedPluginDir('prog', { 'index.js': 'content' });
 
-			const progressCalls: SessionCustomization[][] = [];
-			await manager.syncCustomizations('test-client', [makeRef('prog', 'n1')], statuses => {
-				progressCalls.push(statuses);
+			const progressCalls: SessionCustomization[] = [];
+			await manager.syncCustomizations('test-client', [makeRef('prog', 'n1')], status => {
+				progressCalls.push(status);
 			});
 
-			// At least two calls: initial loading + final loaded
-			assert.ok(progressCalls.length >= 2, `expected at least 2 progress calls, got ${progressCalls.length}`);
-			assert.strictEqual(progressCalls[0][0].status, CustomizationStatus.Loading);
-			assert.strictEqual(progressCalls[progressCalls.length - 1][0].status, CustomizationStatus.Loaded);
+			assert.deepStrictEqual(progressCalls.map(call => call.status), [CustomizationStatus.Loaded]);
 		});
 
 		test('skips copy when nonce matches', async () => {

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

@@ -23,7 +23,7 @@ import { ISessionDataService } from '../../common/sessionDataService.js';
 import type { RootConfigChangedAction } from '../../common/state/protocol/actions.js';
 import { CustomizationStatus } from '../../common/state/protocol/state.js';
 import { ActionType, ActionEnvelope, SessionAction } from '../../common/state/sessionActions.js';
-import { buildSubagentSessionUri, MessageAttachmentKind, PendingMessageKind, ResponsePartKind, SessionStatus, ToolCallConfirmationReason, ToolCallStatus, ToolResultContentType } from '../../common/state/sessionState.js';
+import { buildSubagentSessionUri, MessageAttachmentKind, PendingMessageKind, ResponsePartKind, SessionStatus, ToolCallConfirmationReason, ToolCallStatus, ToolResultContentType, type SessionCustomization } from '../../common/state/sessionState.js';
 import { IProductService } from '../../../product/common/productService.js';
 import { ITelemetryService, TelemetryLevel } from '../../../telemetry/common/telemetry.js';
 import { NullTelemetryService } from '../../../telemetry/common/telemetryUtils.js';
@@ -864,7 +864,11 @@ suite('AgentSideEffects', () => {
 
 	suite('handleAction — session/activeClientChanged', () => {
 
-		test('calls setClientCustomizations and dispatches customizationsChanged', async () => {
+		setup(() => {
+			disposables.add(sideEffects.registerProgressListener(agent));
+		});
+
+		test('calls setClientCustomizations and dispatches customizationsChanged once', async () => {
 			setupSession();
 			agent.getSessionCustomizations = async () => [
 				{
@@ -908,7 +912,83 @@ suite('AgentSideEffects', () => {
 
 			const customizationActions = envelopes
 				.filter(e => e.action.type === ActionType.SessionCustomizationsChanged);
-			assert.ok(customizationActions.length >= 1, 'should dispatch at least one customizationsChanged');
+			assert.strictEqual(customizationActions.length, 1, 'should dispatch one full customizationsChanged replacement');
+			assert.strictEqual(
+				envelopes.filter(e => e.action.type === ActionType.SessionCustomizationUpdated).length,
+				0,
+				'should not dispatch customizationUpdated when progress matches the final state',
+			);
+		});
+
+		test('dispatches customizationUpdated for sync progress after initial replacement', async () => {
+			setupSession();
+			const customization = { uri: 'file:///plugin-a', displayName: 'Plugin A' };
+			let currentCustomizations: readonly SessionCustomization[] = [];
+			agent.getSessionCustomizations = async () => currentCustomizations;
+			agent.setClientCustomizations = async (session, clientId, customizations) => {
+				agent.setClientCustomizationsCalls.push({ clientId, customizations });
+				currentCustomizations = [{
+					customization,
+					enabled: true,
+					status: CustomizationStatus.Loading,
+				}];
+				agent.fireProgress({
+					kind: 'action',
+					session,
+					action: {
+						type: ActionType.SessionCustomizationsChanged,
+						customizations: [...currentCustomizations],
+					},
+				});
+				await new Promise(resolve => setTimeout(resolve, 0));
+				currentCustomizations = [{
+					customization,
+					enabled: true,
+					status: CustomizationStatus.Loaded,
+				}];
+				agent.fireProgress({
+					kind: 'action',
+					session,
+					action: {
+						type: ActionType.SessionCustomizationUpdated,
+						customization,
+						enabled: true,
+						status: CustomizationStatus.Loaded,
+					},
+				});
+				return currentCustomizations.map(customization => ({ customization }));
+			};
+
+			const envelopes: ActionEnvelope[] = [];
+			disposables.add(stateManager.onDidEmitEnvelope(e => envelopes.push(e)));
+
+			sideEffects.handleAction(sessionUri.toString(), {
+				type: ActionType.SessionActiveClientChanged,
+				activeClient: {
+					clientId: 'test-client',
+					tools: [],
+					customizations: [customization],
+				},
+			});
+			await new Promise(resolve => setTimeout(resolve, 50));
+
+			const customizationsChanged = envelopes.filter(e => e.action.type === ActionType.SessionCustomizationsChanged);
+			assert.strictEqual(customizationsChanged.length, 1);
+			const firstCustomizationsChanged = customizationsChanged[0].action;
+			assert.strictEqual(firstCustomizationsChanged.type, ActionType.SessionCustomizationsChanged);
+			assert.deepStrictEqual(firstCustomizationsChanged.customizations, [{
+				customization,
+				enabled: true,
+				status: CustomizationStatus.Loading,
+			}]);
+
+			const customizationUpdated = envelopes.filter(e => e.action.type === ActionType.SessionCustomizationUpdated);
+			assert.deepStrictEqual(customizationUpdated.map(e => e.action), [{
+				type: ActionType.SessionCustomizationUpdated,
+				customization,
+				enabled: true,
+				status: CustomizationStatus.Loaded,
+			}]);
 		});
 
 		test('clears client customizations when activeClient has no customizations', () => {
@@ -932,7 +1012,11 @@ suite('AgentSideEffects', () => {
 			}]);
 			const customizationActions = envelopes
 				.filter(e => e.action.type === ActionType.SessionCustomizationsChanged);
-			assert.strictEqual(customizationActions.length, 0);
+			assert.strictEqual(customizationActions.length, 1);
+			assert.deepStrictEqual(customizationActions[0].action, {
+				type: ActionType.SessionCustomizationsChanged,
+				customizations: [],
+			});
 		});
 
 		test('clears client customizations when activeClient is null', () => {