Agent Mode pauses when VS Code loses focus (fix microsoft#252384) (microsoft#254827)

* Agent Mode pauses when VS Code loses focus (fix microsoft#252384)

* add logging

* refactor - rename throttling parameter to allowed

* refactor - extend `IChatModel` with `IDisposable`

Author: bpasero

src/vs/platform/native/common/native.ts

@@ -130,6 +130,8 @@ export interface ICommonNativeHostService {
 
 	saveWindowSplash(splash: IPartsSplash): Promise<void>;
 
+	setBackgroundThrottling(allowed: boolean): Promise<void>;
+
 	/**
 	 * Make the window focused.
 	 * @param options specify the specific window to focus and the focus mode.

src/vs/platform/native/electron-main/nativeHostMainService.ts

@@ -371,6 +371,14 @@ export class NativeHostMainService extends Disposable implements INativeHostMain
 		this.themeMainService.saveWindowSplash(windowId, window?.openedWorkspace, splash);
 	}
 
+	async setBackgroundThrottling(windowId: number | undefined, allowed: boolean): Promise<void> {
+		const window = this.codeWindowById(windowId);
+
+		this.logService.trace(`Setting background throttling for window ${windowId} to '${allowed}'`);
+
+		window?.win?.webContents?.setBackgroundThrottling(allowed);
+	}
+
 	//#endregion
 
 

src/vs/workbench/contrib/chat/common/chatModel.ts

@@ -901,7 +901,7 @@ export interface IChatRequestDisablement {
 	afterUndoStop?: string;
 }
 
-export interface IChatModel {
+export interface IChatModel extends IDisposable {
 	readonly onDidDispose: Event<void>;
 	readonly onDidChange: Event<IChatChangeEvent>;
 	readonly sessionId: string;

src/vs/workbench/contrib/chat/common/chatService.ts

@@ -574,6 +574,8 @@ export interface IChatService {
 	activateDefaultAgent(location: ChatAgentLocation): Promise<void>;
 
 	readonly edits2Enabled: boolean;
+
+	readonly requestInProgressObs: IObservable<boolean>;
 }
 
 export const KEYWORD_ACTIVIATION_SETTING_ID = 'accessibility.voice.keywordActivation';

src/vs/workbench/contrib/chat/common/chatServiceImpl.ts

@@ -13,6 +13,7 @@ import { MarkdownString } from '../../../../base/common/htmlContent.js';
 import { Iterable } from '../../../../base/common/iterator.js';
 import { Disposable, DisposableMap, IDisposable } from '../../../../base/common/lifecycle.js';
 import { revive } from '../../../../base/common/marshalling.js';
+import { derived, IObservable, ObservableMap } from '../../../../base/common/observable.js';
 import { StopWatch } from '../../../../base/common/stopwatch.js';
 import { URI } from '../../../../base/common/uri.js';
 import { isLocation } from '../../../../editor/common/languages.js';
@@ -109,7 +110,7 @@ class CancellableRequest implements IDisposable {
 export class ChatService extends Disposable implements IChatService {
 	declare _serviceBrand: undefined;
 
-	private readonly _sessionModels = this._register(new DisposableMap<string, ChatModel>());
+	private readonly _sessionModels = new ObservableMap<string, ChatModel>();
 	private readonly _pendingRequests = this._register(new DisposableMap<string, CancellableRequest>());
 	private _persistedSessions: ISerializableChatsData;
 
@@ -134,6 +135,8 @@ export class ChatService extends Disposable implements IChatService {
 	private readonly _chatServiceTelemetry: ChatServiceTelemetry;
 	private readonly _chatSessionStore: ChatSessionStore;
 
+	readonly requestInProgressObs: IObservable<boolean>;
+
 	@memoize
 	private get useFileStorage(): boolean {
 		return this.configurationService.getValue(ChatConfiguration.UseFileStorage);
@@ -196,6 +199,11 @@ export class ChatService extends Disposable implements IChatService {
 		}
 
 		this._register(storageService.onWillSaveState(() => this.saveState()));
+
+		this.requestInProgressObs = derived(reader => {
+			const models = this._sessionModels.observable.read(reader).values();
+			return Array.from(models).some(model => model.requestInProgressObs.read(reader));
+		});
 	}
 
 	isEnabled(location: ChatAgentLocation): boolean {
@@ -1125,7 +1133,8 @@ export class ChatService extends Disposable implements IChatService {
 			}
 		}
 
-		this._sessionModels.deleteAndDispose(sessionId);
+		this._sessionModels.delete(sessionId);
+		model.dispose();
 		this._pendingRequests.get(sessionId)?.cancel();
 		this._pendingRequests.deleteAndDispose(sessionId);
 		this._onDidDisposeSession.fire({ sessionId, reason: 'cleared' });

src/vs/workbench/contrib/chat/electron-browser/chat.contribution.ts

@@ -27,6 +27,9 @@ import { IWorkbenchLayoutService } from '../../../services/layout/browser/layout
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
 import { ChatContextKeys } from '../common/chatContextKeys.js';
 import { ViewContainerLocation } from '../../../common/views.js';
+import { INativeHostService } from '../../../../platform/native/common/native.js';
+import { IChatService } from '../common/chatService.js';
+import { autorun } from '../../../../base/common/observable.js';
 
 class NativeBuiltinToolsContribution extends Disposable implements IWorkbenchContribution {
 
@@ -106,6 +109,27 @@ class ChatCommandLineHandler extends Disposable {
 	}
 }
 
+class ChatSuspendThrottlingHandler extends Disposable {
+
+	static readonly ID = 'workbench.contrib.chatSuspendThrottlingHandler';
+
+	constructor(
+		@INativeHostService nativeHostService: INativeHostService,
+		@IChatService chatService: IChatService
+	) {
+		super();
+
+		this._register(autorun(reader => {
+			const running = chatService.requestInProgressObs.read(reader);
+
+			// When a chat request is in progress, we must ensure that background
+			// throttling is not applied so that the chat session can continue
+			// even when the window is not in focus.
+			nativeHostService.setBackgroundThrottling(!running);
+		}));
+	}
+}
+
 registerAction2(StartVoiceChatAction);
 registerAction2(InstallSpeechProviderForVoiceChatAction);
 
@@ -126,3 +150,4 @@ registerChatDeveloperActions();
 registerWorkbenchContribution2(KeywordActivationContribution.ID, KeywordActivationContribution, WorkbenchPhase.AfterRestored);
 registerWorkbenchContribution2(NativeBuiltinToolsContribution.ID, NativeBuiltinToolsContribution, WorkbenchPhase.AfterRestored);
 registerWorkbenchContribution2(ChatCommandLineHandler.ID, ChatCommandLineHandler, WorkbenchPhase.BlockRestore);
+registerWorkbenchContribution2(ChatSuspendThrottlingHandler.ID, ChatSuspendThrottlingHandler, WorkbenchPhase.AfterRestored);

src/vs/workbench/contrib/chat/test/common/chatService.test.ts

@@ -287,6 +287,7 @@ suite('ChatService', () => {
 		assert(chatModel2);
 
 		await assertSnapshot(toSnapshotExportData(chatModel2));
+		chatModel2.dispose();
 	});
 
 	test('can deserialize with response', async () => {
@@ -315,6 +316,7 @@ suite('ChatService', () => {
 		assert(chatModel2);
 
 		await assertSnapshot(toSnapshotExportData(chatModel2));
+		chatModel2.dispose();
 	});
 });
 

src/vs/workbench/contrib/chat/test/common/mockChatService.ts

@@ -5,13 +5,15 @@
 
 import { CancellationToken } from '../../../../../base/common/cancellation.js';
 import { Event } from '../../../../../base/common/event.js';
+import { observableValue } from '../../../../../base/common/observable.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { ChatModel, IChatModel, IChatRequestModel, IChatRequestVariableData, ISerializableChatData } from '../../common/chatModel.js';
 import { IParsedChatRequest } from '../../common/chatParserTypes.js';
 import { IChatCompleteResponse, IChatDetail, IChatProviderInfo, IChatSendRequestData, IChatSendRequestOptions, IChatService, IChatTransferredSessionData, IChatUserActionEvent } from '../../common/chatService.js';
 import { ChatAgentLocation } from '../../common/constants.js';
 
 export class MockChatService implements IChatService {
+	requestInProgressObs = observableValue('name', false);
 	edits2Enabled: boolean = false;
 	_serviceBrand: undefined;
 	transferredSessionData: IChatTransferredSessionData | undefined;

src/vs/workbench/test/electron-browser/workbenchTestServices.ts

@@ -104,11 +104,12 @@ export class TestNativeHostService implements INativeHostService {
 	async isWindowAlwaysOnTop(options?: INativeHostOptions): Promise<boolean> { return false; }
 	async toggleWindowAlwaysOnTop(options?: INativeHostOptions): Promise<void> { }
 	async setWindowAlwaysOnTop(alwaysOnTop: boolean, options?: INativeHostOptions): Promise<void> { }
-	getCursorScreenPoint(): Promise<{ readonly point: IPoint; readonly display: IRectangle }> { throw new Error('Method not implemented.'); }
+	async getCursorScreenPoint(): Promise<{ readonly point: IPoint; readonly display: IRectangle }> { throw new Error('Method not implemented.'); }
 	async positionWindow(position: IRectangle, options?: INativeHostOptions): Promise<void> { }
 	async updateWindowControls(options: { height?: number; backgroundColor?: string; foregroundColor?: string }): Promise<void> { }
 	async setMinimumSize(width: number | undefined, height: number | undefined): Promise<void> { }
 	async saveWindowSplash(value: IPartsSplash): Promise<void> { }
+	async setBackgroundThrottling(throttling: boolean): Promise<void> { }
 	async focusWindow(options?: INativeHostOptions): Promise<void> { }
 	async showMessageBox(options: Electron.MessageBoxOptions): Promise<Electron.MessageBoxReturnValue> { throw new Error('Method not implemented.'); }
 	async showSaveDialog(options: Electron.SaveDialogOptions): Promise<Electron.SaveDialogReturnValue> { throw new Error('Method not implemented.'); }