chat: fix performance slowdowns when closing/reloading the window (microsoft#287186)

- _onDidChangeToolsScheduler.isScheduled is checked to avoid thrashing
  setTimeout when disposing many tools
- WorkspaceExtensionsManagementService was listening to file change events
  using a debounce. Debounces have overhead because a new timer is
  scheduled on every single call. For large amount of file changes
  (during EH shutdown when schemas for tools are deregistered) this
  caused a notable slowdown. `throttle` should be functionally equivalent.
- avoid triggering input updates (w/ downstream editor effects) each
  time the input gets parsed, which happened every time tool is called
- big hammer -- don't bother deregistering MCP tools each time

Results:

- `216ms` to shut down EH before making these changes
- `87ms` in the first three bullets
- `54ms` after skipping MCP tool deregistering. (Basically all the
   overhead there was unregistering the JSON schema for tool inputs.)

Author: connor4312

src/vs/base/common/event.ts

@@ -345,6 +345,89 @@ export namespace Event {
 		}, delay, undefined, flushOnListenerRemove ?? true, undefined, disposable);
 	}
 
+	/**
+	 * Throttles an event, ensuring the event is fired at most once during the specified delay period.
+	 * Unlike debounce, throttle will fire immediately on the leading edge and/or after the delay on the trailing edge.
+	 *
+	 * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+	 * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+	 * returned event causes this utility to leak a listener on the original event.
+	 *
+	 * @param event The event source for the new event.
+	 * @param merge An accumulator function that merges events if multiple occur during the throttle period.
+	 * @param delay The number of milliseconds to throttle.
+	 * @param leading Whether to fire on the leading edge (immediately on first event).
+	 * @param trailing Whether to fire on the trailing edge (after delay with the last value).
+	 * @param leakWarningThreshold See {@link EmitterOptions.leakWarningThreshold}.
+	 * @param disposable A disposable store to register the throttle emitter to.
+	 */
+	export function throttle<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number | typeof MicrotaskDelay, leading?: boolean, trailing?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;
+	export function throttle<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number | typeof MicrotaskDelay, leading?: boolean, trailing?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;
+	export function throttle<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay: number | typeof MicrotaskDelay = 100, leading = true, trailing = true, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O> {
+		let subscription: IDisposable;
+		let output: O | undefined = undefined;
+		let handle: Timeout | undefined = undefined;
+		let numThrottledCalls = 0;
+
+		const options: EmitterOptions | undefined = {
+			leakWarningThreshold,
+			onWillAddFirstListener() {
+				subscription = event(cur => {
+					numThrottledCalls++;
+					output = merge(output, cur);
+
+					// If not currently throttling, fire immediately if leading is enabled
+					if (handle === undefined) {
+						if (leading) {
+							emitter.fire(output);
+							output = undefined;
+							numThrottledCalls = 0;
+						}
+
+						// Set up the throttle period
+						if (typeof delay === 'number') {
+							handle = setTimeout(() => {
+								// Fire on trailing edge if there were calls during throttle period
+								if (trailing && numThrottledCalls > 0) {
+									emitter.fire(output!);
+								}
+								output = undefined;
+								handle = undefined;
+								numThrottledCalls = 0;
+							}, delay);
+						} else {
+							// Use a special marker to indicate microtask is pending
+							handle = 0 as unknown as Timeout;
+							queueMicrotask(() => {
+								// Fire on trailing edge if there were calls during throttle period
+								if (trailing && numThrottledCalls > 0) {
+									emitter.fire(output!);
+								}
+								output = undefined;
+								handle = undefined;
+								numThrottledCalls = 0;
+							});
+						}
+					}
+					// If already throttling, just accumulate the value for trailing edge
+				});
+			},
+			onDidRemoveLastListener() {
+				subscription.dispose();
+			}
+		};
+
+		if (!disposable) {
+			_addLeakageTraceLogic(options);
+		}
+
+		const emitter = new Emitter<O>(options);
+
+		disposable?.add(emitter);
+
+		return emitter.event;
+	}
+
 	/**
 	 * Filters an event such that some condition is _not_ met more than once in a row, effectively ensuring duplicate
 	 * event objects from different sources do not fire the same event object.

src/vs/base/test/common/event.test.ts

@@ -1598,6 +1598,273 @@ suite('Event utils', () => {
 		});
 	});
 
+	suite('throttle', () => {
+		test('leading only', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				const throttled = Event.throttle(emitter.event, (l, e) => l ? l + 1 : 1, 10, /*leading=*/true, /*trailing=*/false);
+
+				const calls: number[] = [];
+				ds.add(throttled((e) => calls.push(e)));
+
+				// First event fires immediately
+				emitter.fire(1);
+				assert.deepStrictEqual(calls, [1]);
+
+				// Subsequent events during throttle period are ignored
+				emitter.fire(2);
+				emitter.fire(3);
+				assert.deepStrictEqual(calls, [1]);
+
+				// Wait for throttle period to end
+				await timeout(15);
+				assert.deepStrictEqual(calls, [1], 'no trailing edge fire with trailing=false');
+
+				// After throttle period, next event fires immediately
+				emitter.fire(4);
+				assert.deepStrictEqual(calls, [1, 1]);
+			});
+		});
+
+		test('trailing only', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				const throttled = Event.throttle(emitter.event, (l, e) => l ? l + 1 : 1, 10, /*leading=*/false, /*trailing=*/true);
+
+				const calls: number[] = [];
+				ds.add(throttled((e) => calls.push(e)));
+
+				// First event does not fire immediately
+				emitter.fire(1);
+				assert.deepStrictEqual(calls, []);
+
+				// Multiple events during throttle period
+				emitter.fire(2);
+				emitter.fire(3);
+				assert.deepStrictEqual(calls, []);
+
+				// Wait for throttle period - should fire with accumulated value
+				await timeout(15);
+				assert.deepStrictEqual(calls, [3]);
+
+				// New events start a new throttle period
+				emitter.fire(4);
+				emitter.fire(5);
+				assert.deepStrictEqual(calls, [3]);
+
+				await timeout(15);
+				assert.deepStrictEqual(calls, [3, 2]);
+			});
+		});
+
+		test('both leading and trailing', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				const throttled = Event.throttle(emitter.event, (l, e) => l ? l + 1 : 1, 10, /*leading=*/true, /*trailing=*/true);
+
+				const calls: number[] = [];
+				ds.add(throttled((e) => calls.push(e)));
+
+				// First event fires immediately (leading)
+				emitter.fire(1);
+				assert.deepStrictEqual(calls, [1]);
+
+				// Events during throttle period are accumulated
+				emitter.fire(2);
+				emitter.fire(3);
+				assert.deepStrictEqual(calls, [1]);
+
+				// Wait for throttle period - should fire trailing edge with accumulated value
+				await timeout(15);
+				assert.deepStrictEqual(calls, [1, 2]);
+			});
+		});
+
+		test('only leading edge if no subsequent events', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				const throttled = Event.throttle(emitter.event, (l, e) => l ? l + 1 : 1, 10, /*leading=*/true, /*trailing=*/true);
+
+				const calls: number[] = [];
+				ds.add(throttled((e) => calls.push(e)));
+
+				// Single event fires immediately (leading)
+				emitter.fire(1);
+				assert.deepStrictEqual(calls, [1]);
+
+				// No more events during throttle period
+				await timeout(15);
+				// Should not fire trailing edge since there were no more events
+				assert.deepStrictEqual(calls, [1]);
+			});
+		});
+
+		test('microtask delay', function (done: () => void) {
+			const emitter = ds.add(new Emitter<number>());
+			const throttled = Event.throttle(emitter.event, (l, e) => l ? l + 1 : 1, MicrotaskDelay);
+
+			const calls: number[] = [];
+			ds.add(throttled((e) => calls.push(e)));
+
+			// First event fires immediately (leading by default)
+			emitter.fire(1);
+			assert.deepStrictEqual(calls, [1]);
+
+			// Events during microtask
+			emitter.fire(2);
+			emitter.fire(3);
+			assert.deepStrictEqual(calls, [1]);
+
+			// Check after microtask
+			queueMicrotask(() => {
+				// Should have fired trailing edge
+				assert.deepStrictEqual(calls, [1, 2]);
+				done();
+			});
+		});
+
+		test('merge function accumulates values', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				const throttled = Event.throttle(
+					emitter.event,
+					(last, cur) => (last || 0) + cur,
+					10,
+					/*leading=*/true,
+					/*trailing=*/true
+				);
+
+				const calls: number[] = [];
+				ds.add(throttled((e) => calls.push(e)));
+
+				// First event fires immediately with value 1
+				emitter.fire(1);
+				assert.deepStrictEqual(calls, [1]);
+
+				// Accumulate more values: 2 + 3 = 5
+				emitter.fire(2);
+				emitter.fire(3);
+				assert.deepStrictEqual(calls, [1]);
+
+				await timeout(15);
+				// Trailing edge fires with accumulated sum
+				assert.deepStrictEqual(calls, [1, 5]);
+			});
+		});
+
+		test('rapid consecutive throttle periods', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				const throttled = Event.throttle(emitter.event, (l, e) => e, 10, /*leading=*/true, /*trailing=*/true);
+
+				const calls: number[] = [];
+				ds.add(throttled((e) => calls.push(e)));
+
+				// Period 1
+				emitter.fire(1);
+				emitter.fire(2);
+				assert.deepStrictEqual(calls, [1]);
+
+				await timeout(15);
+				assert.deepStrictEqual(calls, [1, 2]);
+
+				// Period 2
+				emitter.fire(3);
+				emitter.fire(4);
+				assert.deepStrictEqual(calls, [1, 2, 3]);
+
+				await timeout(15);
+				assert.deepStrictEqual(calls, [1, 2, 3, 4]);
+
+				// Period 3
+				emitter.fire(5);
+				assert.deepStrictEqual(calls, [1, 2, 3, 4, 5]);
+
+				await timeout(15);
+				// No trailing fire since only one event
+				assert.deepStrictEqual(calls, [1, 2, 3, 4, 5]);
+			});
+		});
+
+		test('default parameters', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				// Default: delay=100, leading=true, trailing=true
+				const throttled = Event.throttle(emitter.event, (l, e) => e);
+
+				const calls: number[] = [];
+				ds.add(throttled((e) => calls.push(e)));
+
+				emitter.fire(1);
+				assert.deepStrictEqual(calls, [1], 'should fire leading edge by default');
+
+				emitter.fire(2);
+				await timeout(110);
+				assert.deepStrictEqual(calls, [1, 2], 'should fire trailing edge by default');
+			});
+		});
+
+		test('disposal cleans up', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				const throttled = Event.throttle(emitter.event, (l, e) => e, 10);
+
+				const calls: number[] = [];
+				const listener = throttled((e) => calls.push(e));
+
+				emitter.fire(1);
+				emitter.fire(2);
+				assert.deepStrictEqual(calls, [1]);
+
+				listener.dispose();
+
+				// Events after disposal should not fire
+				await timeout(15);
+				emitter.fire(3);
+				assert.deepStrictEqual(calls, [1]);
+			});
+		});
+
+		test('no events during throttle with trailing=false', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				const throttled = Event.throttle(emitter.event, (l, e) => l ? l + 1 : 1, 10, /*leading=*/true, /*trailing=*/false);
+
+				const calls: number[] = [];
+				ds.add(throttled((e) => calls.push(e)));
+
+				emitter.fire(1);
+				assert.deepStrictEqual(calls, [1]);
+
+				// No more events
+				await timeout(15);
+				assert.deepStrictEqual(calls, [1]);
+
+				// Next event after throttle period
+				emitter.fire(2);
+				assert.deepStrictEqual(calls, [1, 1]);
+			});
+		});
+
+		test('neither leading nor trailing', async function () {
+			return runWithFakedTimers({}, async function () {
+				const emitter = ds.add(new Emitter<number>());
+				const throttled = Event.throttle(emitter.event, (l, e) => e, 10, /*leading=*/false, /*trailing=*/false);
+
+				const calls: number[] = [];
+				ds.add(throttled((e) => calls.push(e)));
+
+				emitter.fire(1);
+				emitter.fire(2);
+				emitter.fire(3);
+				assert.deepStrictEqual(calls, []);
+
+				await timeout(15);
+				assert.deepStrictEqual(calls, [], 'no events should fire with both leading and trailing false');
+			});
+		});
+	});
+
 	test('issue #230401', () => {
 		let count = 0;
 		const emitter = ds.add(new Emitter<void>());

src/vs/editor/common/core/ranges/offsetRange.ts

@@ -18,6 +18,10 @@ export class OffsetRange implements IOffsetRange {
 		return new OffsetRange(start, endExclusive);
 	}
 
+	public static equals(r1: IOffsetRange, r2: IOffsetRange): boolean {
+		return r1.start === r2.start && r1.endExclusive === r2.endExclusive;
+	}
+
 	public static addRange(range: OffsetRange, sortedRanges: OffsetRange[]): void {
 		let i = 0;
 		while (i < sortedRanges.length && sortedRanges[i].endExclusive < range.start) {

src/vs/workbench/contrib/chat/browser/tools/languageModelToolsService.ts

@@ -206,7 +206,9 @@ export class LanguageModelToolsService extends Disposable implements ILanguageMo
 
 		this._tools.set(toolData.id, { data: toolData });
 		this._ctxToolsCount.set(this._tools.size);
-		this._onDidChangeToolsScheduler.schedule();
+		if (!this._onDidChangeToolsScheduler.isScheduled()) {
+			this._onDidChangeToolsScheduler.schedule();
+		}
 
 		toolData.when?.keys().forEach(key => this._toolContextKeys.add(key));
 
@@ -223,7 +225,9 @@ export class LanguageModelToolsService extends Disposable implements ILanguageMo
 			this._tools.delete(toolData.id);
 			this._ctxToolsCount.set(this._tools.size);
 			this._refreshAllToolContextKeys();
-			this._onDidChangeToolsScheduler.schedule();
+			if (!this._onDidChangeToolsScheduler.isScheduled()) {
+				this._onDidChangeToolsScheduler.schedule();
+			}
 		});
 	}