fixes microsoft#213716 (microsoft#213828)

* fixes microsoft#213716

* fix tests

Author: jrieken

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

@@ -7,7 +7,7 @@ import { CancellationToken } from 'vs/base/common/cancellation';
 import { Emitter, Event } from 'vs/base/common/event';
 import { Iterable } from 'vs/base/common/iterator';
 import { IJSONSchema } from 'vs/base/common/jsonSchema';
-import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { DisposableStore, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { isFalsyOrWhitespace } from 'vs/base/common/strings';
 import { localize } from 'vs/nls';
 import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
@@ -133,18 +133,20 @@ export class LanguageModelsService implements ILanguageModelsService {
 
 	readonly _serviceBrand: undefined;
 
+	private readonly _store = new DisposableStore();
+
 	private readonly _providers = new Map<string, ILanguageModelChat>();
 	private readonly _vendors = new Set<string>();
 
-	private readonly _onDidChangeProviders = new Emitter<ILanguageModelsChangeEvent>();
+	private readonly _onDidChangeProviders = this._store.add(new Emitter<ILanguageModelsChangeEvent>());
 	readonly onDidChangeLanguageModels: Event<ILanguageModelsChangeEvent> = this._onDidChangeProviders.event;
 
 	constructor(
 		@IExtensionService private readonly _extensionService: IExtensionService,
 		@ILogService private readonly _logService: ILogService,
 	) {
 
-		languageModelExtensionPoint.setHandler((extensions) => {
+		this._store.add(languageModelExtensionPoint.setHandler((extensions) => {
 
 			this._vendors.clear();
 
@@ -182,11 +184,11 @@ export class LanguageModelsService implements ILanguageModelsService {
 			if (removed.length > 0) {
 				this._onDidChangeProviders.fire({ removed });
 			}
-		});
+		}));
 	}
 
 	dispose() {
-		this._onDidChangeProviders.dispose();
+		this._store.dispose();
 		this._providers.clear();
 	}
 
@@ -213,22 +215,12 @@ export class LanguageModelsService implements ILanguageModelsService {
 
 		for (const [identifier, model] of this._providers) {
 
-			if (selector.vendor !== undefined && model.metadata.vendor === selector.vendor
-				|| selector.family !== undefined && model.metadata.family === selector.family
-				|| selector.version !== undefined && model.metadata.version === selector.version
-				|| selector.identifier !== undefined && model.metadata.id === selector.identifier
-				|| selector.extension !== undefined && model.metadata.targetExtensions?.some(candidate => ExtensionIdentifier.equals(candidate, selector.extension))
-			) {
-				// true selection
-				result.push(identifier);
-
-			} else if (!selector || (
-				selector.vendor === undefined
-				&& selector.family === undefined
-				&& selector.version === undefined
-				&& selector.identifier === undefined)
+			if ((selector.vendor === undefined || model.metadata.vendor === selector.vendor)
+				&& (selector.family === undefined || model.metadata.family === selector.family)
+				&& (selector.version === undefined || model.metadata.version === selector.version)
+				&& (selector.identifier === undefined || model.metadata.id === selector.identifier)
+				&& (!model.metadata.targetExtensions || model.metadata.targetExtensions.some(candidate => ExtensionIdentifier.equals(candidate, selector.extension)))
 			) {
-				// no selection
 				result.push(identifier);
 			}
 		}

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

@@ -0,0 +1,107 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { mock } from 'vs/base/test/common/mock';
+import { ensureNoDisposablesAreLeakedInTestSuite } from 'vs/base/test/common/utils';
+import { NullLogService } from 'vs/platform/log/common/log';
+import { languageModelExtensionPoint, LanguageModelsService } from 'vs/workbench/contrib/chat/common/languageModels';
+import { IExtensionService, nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
+import { ExtensionsRegistry } from 'vs/workbench/services/extensions/common/extensionsRegistry';
+
+suite('LanguageModels', function () {
+
+	let languageModels: LanguageModelsService;
+
+	const store = new DisposableStore();
+	const activationEvents = new Set<string>();
+
+	setup(function () {
+
+		languageModels = new LanguageModelsService(
+			new class extends mock<IExtensionService>() {
+				override activateByEvent(name: string) {
+					activationEvents.add(name);
+					return Promise.resolve();
+				}
+			},
+			new NullLogService()
+		);
+
+		const ext = ExtensionsRegistry.getExtensionPoints().find(e => e.name === languageModelExtensionPoint.name)!;
+
+		ext.acceptUsers([{
+			description: { ...nullExtensionDescription, enabledApiProposals: ['chatProvider'] },
+			value: { vendor: 'test-vendor' },
+			collector: null!
+		}]);
+
+
+		store.add(languageModels.registerLanguageModelChat('1', {
+			metadata: {
+				extension: nullExtensionDescription.identifier,
+				name: 'Pretty Name',
+				vendor: 'test-vendor',
+				family: 'test-family',
+				version: 'test-version',
+				id: 'test-id',
+				maxInputTokens: 100,
+				maxOutputTokens: 100,
+			},
+			provideChatResponse: async () => {
+				throw new Error();
+			},
+			provideTokenCount: async () => {
+				throw new Error();
+			}
+		}));
+
+		store.add(languageModels.registerLanguageModelChat('12', {
+			metadata: {
+				extension: nullExtensionDescription.identifier,
+				name: 'Pretty Name',
+				vendor: 'test-vendor',
+				family: 'test2-family',
+				version: 'test2-version',
+				id: 'test-id',
+				maxInputTokens: 100,
+				maxOutputTokens: 100,
+			},
+			provideChatResponse: async () => {
+				throw new Error();
+			},
+			provideTokenCount: async () => {
+				throw new Error();
+			}
+		}));
+	});
+
+	teardown(function () {
+		languageModels.dispose();
+		activationEvents.clear();
+		store.clear();
+	});
+
+	ensureNoDisposablesAreLeakedInTestSuite();
+
+	test('empty selector returns all', async function () {
+
+		const result1 = await languageModels.selectLanguageModels({});
+		assert.deepStrictEqual(result1.length, 2);
+		assert.deepStrictEqual(result1[0], '1');
+		assert.deepStrictEqual(result1[1], '12');
+	});
+
+	test('no warning that a matching model was not found #213716', async function () {
+		const result1 = await languageModels.selectLanguageModels({ vendor: 'test-vendor' });
+		assert.deepStrictEqual(result1.length, 2);
+
+		const result2 = await languageModels.selectLanguageModels({ vendor: 'test-vendor', family: 'FAKE' });
+		assert.deepStrictEqual(result2.length, 0);
+	});
+
+
+});

src/vs/workbench/services/extensions/common/extensionsRegistry.ts

@@ -16,6 +16,7 @@ import { ExtensionKind } from 'vs/platform/environment/common/environment';
 import { allApiProposals } from 'vs/workbench/services/extensions/common/extensionsApiProposals';
 import { productSchemaId } from 'vs/platform/product/common/productService';
 import { ImplicitActivationEvents, IActivationEventsGenerator } from 'vs/platform/extensionManagement/common/implicitActivationEvents';
+import { IDisposable } from 'vs/base/common/lifecycle';
 
 const schemaRegistry = Registry.as<IJSONContributionRegistry>(Extensions.JSONContribution);
 
@@ -67,7 +68,7 @@ export type IExtensionPointHandler<T> = (extensions: readonly IExtensionPointUse
 
 export interface IExtensionPoint<T> {
 	readonly name: string;
-	setHandler(handler: IExtensionPointHandler<T>): void;
+	setHandler(handler: IExtensionPointHandler<T>): IDisposable;
 	readonly defaultExtensionKind: ExtensionKind[] | undefined;
 }
 
@@ -121,12 +122,18 @@ export class ExtensionPoint<T> implements IExtensionPoint<T> {
 		this._delta = null;
 	}
 
-	setHandler(handler: IExtensionPointHandler<T>): void {
+	setHandler(handler: IExtensionPointHandler<T>): IDisposable {
 		if (this._handler !== null) {
 			throw new Error('Handler already set!');
 		}
 		this._handler = handler;
 		this._handle();
+
+		return {
+			dispose: () => {
+				this._handler = null;
+			}
+		};
 	}
 
 	acceptUsers(users: IExtensionPointUser<T>[]): void {