@codingame/monaco-vscode-api 19.1.4 → 20.0.0

package/vscode/src/vs/workbench/api/common/extHostLanguageModelTools.js

@@ -11,11 +11,33 @@ import { InternalFetchWebPageToolId } from '../../contrib/chat/common/tools/tool
 import { isProposedApiEnabled, checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
 import { MainContext } from './extHost.protocol.js';
-import { LanguageModelToolResult2, MarkdownString } from './extHostTypeConverters.js';
+import { LanguageModelToolSource, LanguageModelToolResult2, MarkdownString } from './extHostTypeConverters.js';
 import { SearchExtensionsToolId } from '../../contrib/extensions/common/searchExtensionsTool.js';
+import { Lazy } from '../../../base/common/lazy.js';
 
 class Tool {
     constructor(data) {
+        this._apiObject = ( new Lazy(() => {
+            const that = this;
+            return ( Object.freeze({
+                get name() { return that._data.id; },
+                get description() { return that._data.modelDescription; },
+                get inputSchema() { return that._data.inputSchema; },
+                get tags() { return that._data.tags ?? []; },
+                get source() { return undefined; }
+            }));
+        }));
+        this._apiObjectWithChatParticipantAdditions = ( new Lazy(() => {
+            const that = this;
+            const source = LanguageModelToolSource.to(that._data.source);
+            return ( Object.freeze({
+                get name() { return that._data.id; },
+                get description() { return that._data.modelDescription; },
+                get inputSchema() { return that._data.inputSchema; },
+                get tags() { return that._data.tags ?? []; },
+                get source() { return source; }
+            }));
+        }));
         this._data = data;
     }
     update(newData) {
@@ -25,16 +47,10 @@ class Tool {
         return this._data;
     }
     get apiObject() {
-        if (!this._apiObject) {
-            const that = this;
-            this._apiObject = ( Object.freeze({
-                get name() { return that._data.id; },
-                get description() { return that._data.modelDescription; },
-                get inputSchema() { return that._data.inputSchema; },
-                get tags() { return that._data.tags ?? []; },
-            }));
-        }
-        return this._apiObject;
+        return this._apiObject.value;
+    }
+    get apiObjectWithChatParticipantAdditions() {
+        return this._apiObjectWithChatParticipantAdditions.value;
     }
 }
 class ExtHostLanguageModelTools {
@@ -102,8 +118,11 @@ class ExtHostLanguageModelTools {
         }
     }
     getTools(extension) {
+        const hasParticipantAdditions = isProposedApiEnabled(extension, 'chatParticipantPrivate');
         return ( Array.from(( this._allTools.values()))
-            .map(tool => tool.apiObject))
+            .map(
+            tool => hasParticipantAdditions ? tool.apiObjectWithChatParticipantAdditions : tool.apiObject
+        ))
             .filter(tool => {
             switch (tool.name) {
                 case InternalEditToolId:
@@ -129,9 +148,6 @@ class ExtHostLanguageModelTools {
             options.chatRequestId = dto.chatRequestId;
             options.chatInteractionId = dto.chatInteractionId;
             options.chatSessionId = dto.context?.sessionId;
-            if (dto.toolSpecificData?.kind === 'terminal') {
-                options.terminalCommand = dto.toolSpecificData.command;
-            }
         }
         if (isProposedApiEnabled(item.extension, 'chatParticipantAdditions') && dto.modelId) {
             options.model = await this.getModel(dto.modelId, item.extension);
@@ -184,25 +200,7 @@ class ExtHostLanguageModelTools {
             chatSessionId: context.chatSessionId,
             chatInteractionId: context.chatInteractionId
         };
-        if (isProposedApiEnabled(item.extension, 'chatParticipantPrivate') && item.tool.prepareInvocation2) {
-            const result = await item.tool.prepareInvocation2(options, token);
-            if (!result) {
-                return undefined;
-            }
-            return {
-                confirmationMessages: result.confirmationMessages ? {
-                    title: typeof result.confirmationMessages.title === 'string' ? result.confirmationMessages.title : MarkdownString.from(result.confirmationMessages.title),
-                    message: typeof result.confirmationMessages.message === 'string' ? result.confirmationMessages.message : MarkdownString.from(result.confirmationMessages.message),
-                } : undefined,
-                toolSpecificData: {
-                    kind: 'terminal',
-                    language: result.language,
-                    command: result.command,
-                },
-                presentation: result.presentation
-            };
-        }
-        else if (item.tool.prepareInvocation) {
+        if (item.tool.prepareInvocation) {
             const result = await item.tool.prepareInvocation(options, token);
             if (!result) {
                 return undefined;

package/vscode/src/vs/workbench/api/common/extHostLanguageModels.d.ts

@@ -6,7 +6,7 @@ import { IDisposable } from "../../../base/common/lifecycle.js";
 import { UriComponents } from "../../../base/common/uri.js";
 import { ExtensionIdentifier, IExtensionDescription } from "../../../platform/extensions/common/extensions.js";
 import { ILogService } from "../../../platform/log/common/log.service.js";
-import { IChatMessage, IChatResponseFragment, ILanguageModelChatMetadata } from "../../contrib/chat/common/languageModels.js";
+import { IChatMessage, IChatResponseFragment, ILanguageModelChatMetadataAndIdentifier } from "../../contrib/chat/common/languageModels.js";
 import { ExtHostLanguageModelsShape } from "./extHost.protocol.js";
 import { IExtHostAuthentication } from "./extHostAuthentication.js";
 import { IExtHostRpcService } from "./extHostRpcService.js";
@@ -23,25 +23,22 @@ export declare class ExtHostLanguageModels implements ExtHostLanguageModelsShape
     private readonly _onDidChangeModelAccess;
     private readonly _onDidChangeProviders;
     readonly onDidChangeProviders: Event<void>;
-    private readonly _languageModels;
-    private readonly _allLanguageModelData;
+    private readonly _languageModelProviders;
+    private readonly _localModels;
     private readonly _modelAccessList;
     private readonly _pendingRequest;
     private readonly _ignoredFileProviders;
     constructor(extHostRpc: IExtHostRpcService, _logService: ILogService, _extHostAuthentication: IExtHostAuthentication);
     dispose(): void;
-    registerLanguageModel(extension: IExtensionDescription, identifier: string, provider: vscode.ChatResponseProvider, metadata: vscode.ChatResponseProviderMetadata): IDisposable;
-    $startChatRequest(handle: number, requestId: number, from: ExtensionIdentifier, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: vscode.LanguageModelChatRequestOptions, token: CancellationToken): Promise<void>;
-    $provideTokenLength(handle: number, value: string, token: CancellationToken): Promise<number>;
-    $acceptChatModelMetadata(data: {
-        added?: {
-            identifier: string;
-            metadata: ILanguageModelChatMetadata;
-        }[] | undefined;
-        removed?: string[] | undefined;
-    }): void;
-    getDefaultLanguageModel(extension: IExtensionDescription): Promise<vscode.LanguageModelChat | undefined>;
-    getLanguageModelByIdentifier(extension: IExtensionDescription, identifier: string): Promise<vscode.LanguageModelChat | undefined>;
+    registerLanguageModelProvider(extension: IExtensionDescription, vendor: string, provider: vscode.LanguageModelChatProvider2): IDisposable;
+    private _clearModelCache;
+    $prepareLanguageModelProvider(vendor: string, options: {
+        silent: boolean;
+    }, token: CancellationToken): Promise<ILanguageModelChatMetadataAndIdentifier[]>;
+    $startChatRequest(modelId: string, requestId: number, from: ExtensionIdentifier, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: vscode.LanguageModelChatRequestOptions, token: CancellationToken): Promise<void>;
+    $provideTokenLength(modelId: string, value: string, token: CancellationToken): Promise<number>;
+    getDefaultLanguageModel(extension: IExtensionDescription, forceResolveModels?: boolean): Promise<vscode.LanguageModelChat | undefined>;
+    getLanguageModelByIdentifier(extension: IExtensionDescription, modelId: string): Promise<vscode.LanguageModelChat | undefined>;
     selectLanguageModels(extension: IExtensionDescription, selector: vscode.LanguageModelChatSelector): Promise<vscode.LanguageModelChat[]>;
     private _sendChatRequest;
     private _convertMessages;

package/vscode/src/vs/workbench/api/common/extHostLanguageModels.js

@@ -2,7 +2,7 @@
 import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
 import { AsyncIterableSource, AsyncIterableObject, RunOnceScheduler } from '../../../base/common/async.js';
 import { CancellationToken } from '../../../base/common/cancellation.js';
-import { transformErrorForSerialization, CancellationError, transformErrorFromSerialization } from '../../../base/common/errors.js';
+import { transformErrorForSerialization, transformErrorFromSerialization } from '../../../base/common/errors.js';
 import { Emitter, Event } from '../../../base/common/event.js';
 import { Iterable } from '../../../base/common/iterator.js';
 import { toDisposable } from '../../../base/common/lifecycle.js';
@@ -21,6 +21,7 @@ import { LanguageModelChatMessage2 } from './extHostTypeConverters.js';
 import { LanguageModelTextPart, LanguageModelToolCallPart, LanguageModelDataPart, LanguageModelError, LanguageModelChatMessageRole } from './extHostTypes.js';
 import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
 import { VSBuffer } from '../../../base/common/buffer.js';
+import { DEFAULT_MODEL_PICKER_CATEGORY } from '../../contrib/chat/common/modelPicker/modelPickerWidget.js';
 
 var ExtHostLanguageModels_1;
 const IExtHostLanguageModels = ( createDecorator('IExtHostLanguageModels'));
@@ -71,7 +72,7 @@ class LanguageModelResponse {
         for (const fragment of Iterable.wrap(fragments)) {
             let out;
             if (fragment.part.type === 'text') {
-                out = new LanguageModelTextPart(fragment.part.value);
+                out = new LanguageModelTextPart(fragment.part.value, fragment.part.audience);
             }
             else if (fragment.part.type === 'data') {
                 out = new LanguageModelTextPart('');
@@ -123,8 +124,8 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         this._onDidChangeModelAccess = ( new Emitter());
         this._onDidChangeProviders = ( new Emitter());
         this.onDidChangeProviders = this._onDidChangeProviders.event;
-        this._languageModels = ( new Map());
-        this._allLanguageModelData = ( new Map());
+        this._languageModelProviders = ( new Map());
+        this._localModels = ( new Map());
         this._modelAccessList = ( new ExtensionIdentifierMap());
         this._pendingRequest = ( new Map());
         this._ignoredFileProviders = ( new Map());
@@ -135,47 +136,85 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         this._onDidChangeModelAccess.dispose();
         this._onDidChangeProviders.dispose();
     }
-    registerLanguageModel(extension, identifier, provider, metadata) {
-        const handle = ExtHostLanguageModels_1._idPool++;
-        this._languageModels.set(handle, { extension: extension.identifier, provider, languageModelId: identifier });
-        let auth;
-        if (metadata.auth) {
-            auth = {
-                providerLabel: extension.displayName || extension.name,
-                accountLabel: typeof metadata.auth === 'object' ? metadata.auth.label : undefined
-            };
+    registerLanguageModelProvider(extension, vendor, provider) {
+        this._languageModelProviders.set(vendor, { extension: extension.identifier, extensionName: extension.displayName || extension.name, provider });
+        this._proxy.$registerLanguageModelProvider(vendor);
+        let providerChangeEventDisposable;
+        if (provider.onDidChange) {
+            providerChangeEventDisposable = provider.onDidChange(() => {
+                this._proxy.$onLMProviderChange(vendor);
+            });
         }
-        this._proxy.$registerLanguageModelProvider(handle, `${ExtensionIdentifier.toKey(extension.identifier)}/${identifier}`, {
-            extension: extension.identifier,
-            id: identifier,
-            vendor: metadata.vendor ?? ExtensionIdentifier.toKey(extension.identifier),
-            name: metadata.name ?? '',
-            family: metadata.family ?? '',
-            cost: metadata.cost,
-            description: metadata.description,
-            version: metadata.version,
-            maxInputTokens: metadata.maxInputTokens,
-            maxOutputTokens: metadata.maxOutputTokens,
-            auth,
-            targetExtensions: metadata.extensions,
-            isDefault: metadata.isDefault,
-            isUserSelectable: metadata.isUserSelectable,
-            modelPickerCategory: metadata.category,
-            capabilities: metadata.capabilities,
-        });
-        const responseReceivedListener = provider.onDidReceiveLanguageModelResponse2?.(({ extensionId, participant, tokenCount }) => {
-            this._proxy.$whenLanguageModelChatRequestMade(identifier, ( new ExtensionIdentifier(extensionId)), participant, tokenCount);
-        });
         return toDisposable(() => {
-            this._languageModels.delete(handle);
-            this._proxy.$unregisterProvider(handle);
-            responseReceivedListener?.dispose();
+            this._languageModelProviders.delete(vendor);
+            this._clearModelCache(vendor);
+            providerChangeEventDisposable?.dispose();
+            this._proxy.$unregisterProvider(vendor);
         });
     }
-    async $startChatRequest(handle, requestId, from, messages, options, token) {
-        const data = this._languageModels.get(handle);
+    _clearModelCache(vendor) {
+        this._localModels.forEach((value, key) => {
+            if (value.metadata.vendor === vendor) {
+                this._localModels.delete(key);
+            }
+        });
+    }
+    async $prepareLanguageModelProvider(vendor, options, token) {
+        const data = this._languageModelProviders.get(vendor);
+        if (!data) {
+            return [];
+        }
+        this._clearModelCache(vendor);
+        const modelInformation = (await data.provider.prepareLanguageModelChat(options, token)) ?? [];
+        const modelMetadataAndIdentifier = ( modelInformation.map(m => {
+            let auth;
+            if (m.auth) {
+                auth = {
+                    providerLabel: data.extensionName,
+                    accountLabel: typeof m.auth === 'object' ? m.auth.label : undefined
+                };
+            }
+            return {
+                metadata: {
+                    extension: data.extension,
+                    id: m.id,
+                    vendor,
+                    name: m.name ?? '',
+                    family: m.family ?? '',
+                    cost: m.cost,
+                    description: m.description,
+                    version: m.version,
+                    maxInputTokens: m.maxInputTokens,
+                    maxOutputTokens: m.maxOutputTokens,
+                    auth,
+                    isDefault: m.isDefault,
+                    isUserSelectable: m.isUserSelectable,
+                    modelPickerCategory: m.category ?? DEFAULT_MODEL_PICKER_CATEGORY,
+                    capabilities: m.capabilities ? {
+                        vision: m.capabilities.vision,
+                        toolCalling: !!m.capabilities.toolCalling,
+                        agentMode: !!m.capabilities.toolCalling
+                    } : undefined,
+                },
+                identifier: `${vendor}/${m.id}`,
+            };
+        }));
+        for (let i = 0; i < modelMetadataAndIdentifier.length; i++) {
+            this._localModels.set(modelMetadataAndIdentifier[i].identifier, {
+                metadata: modelMetadataAndIdentifier[i].metadata,
+                info: modelInformation[i]
+            });
+        }
+        return modelMetadataAndIdentifier;
+    }
+    async $startChatRequest(modelId, requestId, from, messages, options, token) {
+        const knownModel = this._localModels.get(modelId);
+        if (!knownModel) {
+            throw ( new Error('Model not found'));
+        }
+        const data = this._languageModelProviders.get(knownModel.metadata.vendor);
         if (!data) {
-            throw ( new Error('Provider not found'));
+            throw ( new Error(`Language model provider for '${knownModel.metadata.id}' not found.`));
         }
         const queue = [];
         const sendNow = () => {
@@ -205,10 +244,10 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                 part = { type: 'tool_use', name: fragment.part.name, parameters: fragment.part.input, toolCallId: fragment.part.callId };
             }
             else if (fragment.part instanceof LanguageModelTextPart) {
-                part = { type: 'text', value: fragment.part.value };
+                part = { type: 'text', value: fragment.part.value, audience: fragment.part.audience };
             }
             else if (fragment.part instanceof LanguageModelDataPart) {
-                part = { type: 'data', value: { mimeType: fragment.part.mimeType, data: VSBuffer.wrap(fragment.part.data) } };
+                part = { type: 'data', value: { mimeType: fragment.part.mimeType, data: VSBuffer.wrap(fragment.part.data) }, audience: fragment.part.audience };
             }
             if (!part) {
                 this._logService.warn(`[CHAT](${data.extension.value}) UNKNOWN part ${JSON.stringify(fragment)}`);
@@ -218,7 +257,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         }));
         let value;
         try {
-            value = data.provider.provideLanguageModelResponse(( messages.value.map(LanguageModelChatMessage2.to)), options, ExtensionIdentifier.toKey(from), progress, token);
+            value = data.provider.provideLanguageModelChatResponse(knownModel.info, ( messages.value.map(LanguageModelChatMessage2.to)), { ...options, modelOptions: options.modelOptions ?? {}, extensionId: ExtensionIdentifier.toKey(from) }, progress, token);
         }
         catch (err) {
             throw err;
@@ -231,76 +270,68 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             this._proxy.$reportResponseDone(requestId, transformErrorForSerialization(err));
         });
     }
-    $provideTokenLength(handle, value, token) {
-        const data = this._languageModels.get(handle);
+    $provideTokenLength(modelId, value, token) {
+        const knownModel = this._localModels.get(modelId);
+        if (!knownModel) {
+            return Promise.resolve(0);
+        }
+        const data = this._languageModelProviders.get(knownModel.metadata.vendor);
         if (!data) {
             return Promise.resolve(0);
         }
-        return Promise.resolve(data.provider.provideTokenCount(value, token));
+        return Promise.resolve(data.provider.provideTokenCount(knownModel.info, value, token));
     }
-    $acceptChatModelMetadata(data) {
-        if (data.added) {
-            for (const { identifier, metadata } of data.added) {
-                this._allLanguageModelData.set(identifier, { metadata, apiObjects: ( new ExtensionIdentifierMap()) });
-            }
-        }
-        if (data.removed) {
-            for (const id of data.removed) {
-                this._allLanguageModelData.delete(id);
-                for (const [key, value] of this._pendingRequest) {
-                    if (value.languageModelId === id) {
-                        value.res.reject(( new CancellationError()));
-                        this._pendingRequest.delete(key);
-                    }
-                }
+    async getDefaultLanguageModel(extension, forceResolveModels) {
+        let defaultModelId;
+        if (forceResolveModels) {
+            await this.selectLanguageModels(extension, {});
+        }
+        for (const [modelIdentifier, modelData] of this._localModels) {
+            if (modelData.metadata.isDefault) {
+                defaultModelId = modelIdentifier;
+                break;
             }
         }
-        data.added?.forEach(added => this._fakeAuthPopulate(added.metadata));
-        this._onDidChangeProviders.fire(undefined);
-    }
-    async getDefaultLanguageModel(extension) {
-        const defaultModelId = Iterable.find(this._allLanguageModelData.entries(), ([, value]) => !!value.metadata.isDefault)?.[0];
         if (!defaultModelId) {
-            return;
+            return this.getDefaultLanguageModel(extension, true);
         }
         return this.getLanguageModelByIdentifier(extension, defaultModelId);
     }
-    async getLanguageModelByIdentifier(extension, identifier) {
-        const data = this._allLanguageModelData.get(identifier);
-        if (!data) {
+    async getLanguageModelByIdentifier(extension, modelId) {
+        const model = this._localModels.get(modelId);
+        if (!model) {
             return;
         }
-        if (this._isUsingAuth(extension.identifier, data.metadata)) {
-            await this._fakeAuthPopulate(data.metadata);
+        if (this._isUsingAuth(extension.identifier, model.metadata)) {
+            await this._fakeAuthPopulate(model.metadata);
         }
-        let apiObject = data.apiObjects.get(extension.identifier);
+        let apiObject;
         if (!apiObject) {
             const that = this;
             apiObject = {
-                id: data.metadata.id,
-                vendor: data.metadata.vendor,
-                family: data.metadata.family,
-                version: data.metadata.version,
-                name: data.metadata.name,
+                id: model.info.id,
+                vendor: model.metadata.vendor,
+                family: model.info.family,
+                version: model.info.version,
+                name: model.info.name,
                 capabilities: {
-                    supportsImageToText: data.metadata.capabilities?.vision ?? false,
-                    supportsToolCalling: data.metadata.capabilities?.toolCalling ?? false,
+                    supportsImageToText: model.metadata.capabilities?.vision ?? false,
+                    supportsToolCalling: !!model.metadata.capabilities?.toolCalling,
                 },
-                maxInputTokens: data.metadata.maxInputTokens,
+                maxInputTokens: model.metadata.maxInputTokens,
                 countTokens(text, token) {
-                    if (!( that._allLanguageModelData.has(identifier))) {
-                        throw LanguageModelError.NotFound(identifier);
+                    if (!( that._localModels.has(modelId))) {
+                        throw LanguageModelError.NotFound(modelId);
                     }
-                    return that._computeTokenLength(identifier, text, token ?? CancellationToken.None);
+                    return that._computeTokenLength(modelId, text, token ?? CancellationToken.None);
                 },
                 sendRequest(messages, options, token) {
-                    if (!( that._allLanguageModelData.has(identifier))) {
-                        throw LanguageModelError.NotFound(identifier);
+                    if (!( that._localModels.has(modelId))) {
+                        throw LanguageModelError.NotFound(modelId);
                     }
-                    return that._sendChatRequest(extension, identifier, messages, options ?? {}, token ?? CancellationToken.None);
+                    return that._sendChatRequest(extension, modelId, messages, options ?? {}, token ?? CancellationToken.None);
                 }
             };
-            data.apiObjects.set(extension.identifier, apiObject);
         }
         return apiObject;
     }
@@ -318,8 +349,8 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
     async _sendChatRequest(extension, languageModelId, messages, options, token) {
         const internalMessages = this._convertMessages(extension, messages);
         const from = extension.identifier;
-        const metadata = this._allLanguageModelData.get(languageModelId)?.metadata;
-        if (!metadata || !( this._allLanguageModelData.has(languageModelId))) {
+        const metadata = this._localModels.get(languageModelId)?.metadata;
+        if (!metadata || !( this._localModels.has(languageModelId))) {
             throw LanguageModelError.NotFound(`Language model '${languageModelId}' is unknown.`);
         }
         if (this._isUsingAuth(from, metadata)) {
@@ -381,7 +412,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
         }
         try {
             const detail = justification
-                ? ( localize(2600, "Justification: {1}", to.displayName, justification))
+                ? ( localize(2627, "Justification: {1}", to.displayName, justification))
                 : undefined;
             await this._extHostAuthentication.getSession(from, providerId, [], { forceNewSession: { detail } });
             this.$updateModelAccesslist([{ from: from.identifier, to: to.identifier, enabled: true }]);
@@ -409,16 +440,12 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
             }
         }
     }
-    async _computeTokenLength(languageModelId, value, token) {
-        const data = this._allLanguageModelData.get(languageModelId);
+    async _computeTokenLength(modelId, value, token) {
+        const data = this._localModels.get(modelId);
         if (!data) {
-            throw LanguageModelError.NotFound(`Language model '${languageModelId}' is unknown.`);
-        }
-        const local = Iterable.find(( this._languageModels.values()), candidate => candidate.languageModelId === languageModelId);
-        if (local) {
-            return local.provider.provideTokenCount(value, token);
+            throw LanguageModelError.NotFound(`Language model '${modelId}' is unknown.`);
         }
-        return this._proxy.$countTokens(languageModelId, (typeof value === 'string' ? value : LanguageModelChatMessage2.from(value)), token);
+        return this._languageModelProviders.get(data.metadata.vendor)?.provider.provideTokenCount(data.info, value, token) ?? 0;
     }
     $updateModelAccesslist(data) {
         const updated = ( new Array());
@@ -441,7 +468,6 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
     }
     createLanguageModelAccessInformation(from) {
         this._languageAccessInformationExtensions.add(from);
-        const that = this;
         const _onDidChangeAccess = Event.signal(Event.filter(this._onDidChangeModelAccess.event, e => ExtensionIdentifier.equals(e.from, from.identifier)));
         const _onDidAddRemove = Event.signal(this._onDidChangeProviders.event);
         return {
@@ -449,26 +475,7 @@ let ExtHostLanguageModels = class ExtHostLanguageModels {
                 return Event.any(_onDidChangeAccess, _onDidAddRemove);
             },
             canSendRequest(chat) {
-                let metadata;
-                out: for (const [_, value] of that._allLanguageModelData) {
-                    for (const candidate of ( value.apiObjects.values())) {
-                        if (candidate === chat) {
-                            metadata = value.metadata;
-                            break out;
-                        }
-                    }
-                }
-                if (!metadata) {
-                    return undefined;
-                }
-                if (!that._isUsingAuth(from.identifier, metadata)) {
-                    return true;
-                }
-                const list = that._modelAccessList.get(from.identifier);
-                if (!list) {
-                    return undefined;
-                }
-                return ( list.has(metadata.extension));
+                return true;
             }
         };
     }

package/vscode/src/vs/workbench/api/common/extHostLogService.js

@@ -8,7 +8,7 @@ import { IExtHostInitDataService } from './extHostInitDataService.js';
 let ExtHostLogService = class ExtHostLogService extends LogService {
     constructor(isWorker, loggerService, initData) {
         const id = initData.remote.isRemote ? 'remoteexthost' : isWorker ? 'workerexthost' : 'exthost';
-        const name = initData.remote.isRemote ? ( localize(2601, "Extension Host (Remote)")) : isWorker ? ( localize(2602, "Extension Host (Worker)")) : ( localize(2603, "Extension Host"));
+        const name = initData.remote.isRemote ? ( localize(2628, "Extension Host (Remote)")) : isWorker ? ( localize(2629, "Extension Host (Worker)")) : ( localize(2630, "Extension Host"));
         super(loggerService.createLogger(id, { name }));
     }
 };