@codingame/monaco-vscode-extensions-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/api/browser/mainThreadLanguageModelTools.d.ts

@@ -1,21 +1,25 @@
 import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ExtensionIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IToolInvocation, IToolProgressStep, IToolResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
 import { Dto, SerializableObjectWithBuffers } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
-import { IToolDataDto, MainThreadLanguageModelToolsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { IToolDataDto, IToolDefinitionDto, MainThreadLanguageModelToolsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 export declare class MainThreadLanguageModelTools extends Disposable implements MainThreadLanguageModelToolsShape {
     private readonly _languageModelToolsService;
+    private readonly _logService;
     private readonly _proxy;
     private readonly _tools;
     private readonly _runningToolCalls;
-    constructor(extHostContext: IExtHostContext, _languageModelToolsService: ILanguageModelToolsService);
+    constructor(extHostContext: IExtHostContext, _languageModelToolsService: ILanguageModelToolsService, _logService: ILogService);
     private getToolDtos;
     $getTools(): Promise<IToolDataDto[]>;
     $invokeTool(dto: Dto<IToolInvocation>, token?: CancellationToken): Promise<Dto<IToolResult> | SerializableObjectWithBuffers<Dto<IToolResult>>>;
     $acceptToolProgress(callId: string, progress: IToolProgressStep): void;
     $countTokensForInvocation(callId: string, input: string, token: CancellationToken): Promise<number>;
-    $registerTool(id: string): void;
+    $registerTool(id: string, hasHandleToolStream: boolean): void;
+    $registerToolWithDefinition(extensionId: ExtensionIdentifier, definition: IToolDefinitionDto, hasHandleToolStream: boolean): void;
     $unregisterTool(name: string): void;
 }

package/vscode/src/vs/workbench/api/browser/mainThreadLanguageModelTools.js

@@ -1,26 +1,32 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
-import { toolResultHasBuffers } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { isUriComponents, URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { toToolSetKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsContribution';
+import { toolResultHasBuffers, ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
 import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
 import { SerializableObjectWithBuffers } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
 import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
 
 let MainThreadLanguageModelTools = class MainThreadLanguageModelTools extends Disposable {
-    constructor(extHostContext, _languageModelToolsService) {
+    constructor(extHostContext, _languageModelToolsService, _logService) {
         super();
         this._languageModelToolsService = _languageModelToolsService;
+        this._logService = _logService;
         this._tools = this._register(( new DisposableMap()));
         this._runningToolCalls = ( new Map());
         this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostLanguageModelTools));
-        this._register(this._languageModelToolsService.onDidChangeTools(e => this._proxy.$onDidChangeTools(this.getToolDtos())));
+        this._register(
+            this._languageModelToolsService.onDidChangeTools(e => this._proxy.$onDidChangeTools(this.getToolDtos()))
+        );
     }
     getToolDtos() {
-        return ( Array.from(this._languageModelToolsService.getTools())
-            .map(tool => ({
+        return ( Array.from(this._languageModelToolsService.getAllToolsIncludingDisabled()).map(tool => ({
             id: tool.id,
             displayName: tool.displayName,
             toolReferenceName: tool.toolReferenceName,
@@ -29,14 +35,18 @@ let MainThreadLanguageModelTools = class MainThreadLanguageModelTools extends Di
             userDescription: tool.userDescription,
             modelDescription: tool.modelDescription,
             inputSchema: tool.inputSchema,
-            source: tool.source,
+            source: tool.source
         })));
     }
     async $getTools() {
         return this.getToolDtos();
     }
     async $invokeTool(dto, token) {
-        const result = await this._languageModelToolsService.invokeTool(revive(dto), (input, token) => this._proxy.$countTokensForInvocation(dto.callId, input, token), token ?? CancellationToken.None);
+        const result = await this._languageModelToolsService.invokeTool(
+            revive(dto),
+            (input, token) => this._proxy.$countTokensForInvocation(dto.callId, input, token),
+            token ?? CancellationToken.None
+        );
         const out = {
             content: result.content,
             toolMetadata: result.toolMetadata
@@ -53,30 +63,97 @@ let MainThreadLanguageModelTools = class MainThreadLanguageModelTools extends Di
         }
         return fn.countTokens(input, token);
     }
-    $registerTool(id) {
+    $registerTool(id, hasHandleToolStream) {
         const disposable = this._languageModelToolsService.registerToolImplementation(id, {
             invoke: async (dto, countTokens, progress, token) => {
                 try {
-                    this._runningToolCalls.set(dto.callId, { countTokens, progress });
+                    this._runningToolCalls.set(dto.callId, {
+                        countTokens,
+                        progress
+                    });
                     const resultSerialized = await this._proxy.$invokeTool(dto, token);
                     const resultDto = resultSerialized instanceof SerializableObjectWithBuffers ? resultSerialized.value : resultSerialized;
                     return revive(resultDto);
-                }
-                finally {
+                } finally {
                     this._runningToolCalls.delete(dto.callId);
                 }
             },
             prepareToolInvocation: (context, token) => this._proxy.$prepareToolInvocation(id, context, token),
+            handleToolStream: hasHandleToolStream ? (context, token) => this._proxy.$handleToolStream(id, context, token) : undefined
         });
         this._tools.set(id, disposable);
     }
+    $registerToolWithDefinition(extensionId, definition, hasHandleToolStream) {
+        let icon;
+        if (definition.icon) {
+            if (ThemeIcon.isThemeIcon(definition.icon)) {
+                icon = definition.icon;
+            } else if (typeof definition.icon === "object" && definition.icon !== null && isUriComponents(definition.icon)) {
+                icon = {
+                    dark: URI.revive(definition.icon)
+                };
+            } else {
+                const iconObj = definition.icon;
+                icon = {
+                    dark: URI.revive(iconObj.dark),
+                    light: iconObj.light ? URI.revive(iconObj.light) : undefined
+                };
+            }
+        }
+        const source = revive(definition.source);
+        const toolData = {
+            id: definition.id,
+            displayName: definition.displayName,
+            toolReferenceName: definition.toolReferenceName,
+            legacyToolReferenceFullNames: definition.legacyToolReferenceFullNames,
+            tags: definition.tags,
+            userDescription: definition.userDescription,
+            modelDescription: definition.modelDescription,
+            inputSchema: definition.inputSchema,
+            source,
+            icon,
+            models: definition.models,
+            canBeReferencedInPrompt: !!definition.userDescription && !definition.toolSet
+        };
+        const id = definition.id;
+        const store = ( new DisposableStore());
+        store.add(this._languageModelToolsService.registerTool(toolData, {
+            invoke: async (dto, countTokens, progress, token) => {
+                try {
+                    this._runningToolCalls.set(dto.callId, {
+                        countTokens,
+                        progress
+                    });
+                    const resultSerialized = await this._proxy.$invokeTool(dto, token);
+                    const resultDto = resultSerialized instanceof SerializableObjectWithBuffers ? resultSerialized.value : resultSerialized;
+                    return revive(resultDto);
+                } finally {
+                    this._runningToolCalls.delete(dto.callId);
+                }
+            },
+            handleToolStream: hasHandleToolStream ? (context, token) => this._proxy.$handleToolStream(id, context, token) : undefined,
+            prepareToolInvocation: (context, token) => this._proxy.$prepareToolInvocation(id, context, token)
+        }));
+        if (definition.toolSet) {
+            const ts = this._languageModelToolsService.getToolSet(toToolSetKey(extensionId, definition.toolSet)) || this._languageModelToolsService.getToolSet(definition.toolSet);
+            if (!ts || !(ts instanceof ToolSet)) {
+                this._logService.warn(
+                    `ToolSet ${definition.toolSet} not found for tool ${definition.id} from extension ${extensionId.value}`
+                );
+            } else {
+                store.add(ts.addTool(toolData));
+            }
+        }
+        this._tools.set(id, store);
+    }
     $unregisterTool(name) {
         this._tools.deleteAndDispose(name);
     }
 };
 MainThreadLanguageModelTools = __decorate([
     extHostNamedCustomer(MainContext.MainThreadLanguageModelTools),
-    ( __param(1, ILanguageModelToolsService))
+    ( __param(1, ILanguageModelToolsService)),
+    ( __param(2, ILogService))
 ], MainThreadLanguageModelTools);
 
 export { MainThreadLanguageModelTools };

package/vscode/src/vs/workbench/api/browser/mainThreadLanguageModels.js

@@ -22,7 +22,15 @@ import { ExtHostContext, MainContext } from '@codingame/monaco-vscode-api/vscode
 import { LanguageModelError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHostTypes';
 
 let MainThreadLanguageModels = class MainThreadLanguageModels {
-    constructor(extHostContext, _chatProviderService, _logService, _authenticationService, _authenticationAccessService, _extensionService, _ignoredFilesService) {
+    constructor(
+        extHostContext,
+        _chatProviderService,
+        _logService,
+        _authenticationService,
+        _authenticationAccessService,
+        _extensionService,
+        _ignoredFilesService
+    ) {
         this._chatProviderService = _chatProviderService;
         this._logService = _logService;
         this._authenticationService = _authenticationService;
@@ -51,7 +59,9 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
                     const modelsAndIdentifiers = await this._proxy.$provideLanguageModelChatInfo(vendor, options, token);
                     modelsAndIdentifiers.forEach(m => {
                         if (m.metadata.auth) {
-                            disposables.add(this._registerAuthenticationProvider(m.metadata.extension, m.metadata.auth));
+                            disposables.add(
+                                this._registerAuthenticationProvider(m.metadata.extension, m.metadata.auth)
+                            );
                         }
                     });
                     return modelsAndIdentifiers;
@@ -61,15 +71,15 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
                     const defer = ( new DeferredPromise());
                     const stream = ( new AsyncIterableSource());
                     try {
-                        this._pendingProgress.set(requestId, { defer, stream });
-                        await Promise.all(( messages.flatMap(msg => msg.content)
-                            .filter(part => part.type === 'image_url')
-                            .map(async (part) => {
+                        this._pendingProgress.set(requestId, {
+                            defer,
+                            stream
+                        });
+                        await Promise.all(( messages.flatMap(msg => msg.content).filter(part => part.type === "image_url").map(async part => {
                             part.value.data = VSBuffer.wrap(await resizeImage(part.value.data.buffer));
                         })));
                         await this._proxy.$startChatRequest(modelId, requestId, from, ( new SerializableObjectWithBuffers(messages)), options, token);
-                    }
-                    catch (err) {
+                    } catch (err) {
                         this._pendingProgress.delete(requestId);
                         throw err;
                     }
@@ -80,36 +90,36 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
                 },
                 provideTokenCount: (modelId, str, token) => {
                     return this._proxy.$provideTokenLength(modelId, str, token);
-                },
+                }
             }));
             this._providerRegistrations.set(vendor, disposables);
-        }
-        catch (err) {
+        } catch (err) {
             disposables.dispose();
             throw err;
         }
     }
     $onLMProviderChange(vendor) {
-        this._lmProviderChange.fire({ vendor });
+        this._lmProviderChange.fire({
+            vendor
+        });
     }
     async $reportResponsePart(requestId, chunk) {
         const data = this._pendingProgress.get(requestId);
-        this._logService.trace('[LM] report response PART', Boolean(data), requestId, chunk);
+        this._logService.trace("[LM] report response PART", Boolean(data), requestId, chunk);
         if (data) {
             data.stream.emitOne(chunk.value);
         }
     }
     async $reportResponseDone(requestId, err) {
         const data = this._pendingProgress.get(requestId);
-        this._logService.trace('[LM] report response DONE', Boolean(data), requestId, err);
+        this._logService.trace("[LM] report response DONE", Boolean(data), requestId, err);
         if (data) {
             this._pendingProgress.delete(requestId);
             if (err) {
                 const error = LanguageModelError.tryDeserialize(err) ?? transformErrorFromSerialization(err);
                 data.stream.reject(error);
                 data.defer.error(error);
-            }
-            else {
+            } else {
                 data.stream.resolve();
                 data.defer.complete(undefined);
             }
@@ -122,33 +132,41 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         return this._chatProviderService.selectLanguageModels(selector);
     }
     async $tryStartChatRequest(extension, modelIdentifier, requestId, messages, options, token) {
-        this._logService.trace('[CHAT] request STARTED', extension.value, requestId);
+        this._logService.trace("[CHAT] request STARTED", extension.value, requestId);
         let response;
         try {
             response = await this._chatProviderService.sendChatRequest(modelIdentifier, extension, messages.value, options, token);
-        }
-        catch (err) {
-            this._logService.error('[CHAT] request FAILED', extension.value, requestId, err);
+        } catch (err) {
+            this._logService.error("[CHAT] request FAILED", extension.value, requestId, err);
             throw err;
         }
         const streaming = (async () => {
             try {
                 for await (const part of response.stream) {
-                    this._logService.trace('[CHAT] request PART', extension.value, requestId, part);
+                    this._logService.trace("[CHAT] request PART", extension.value, requestId, part);
                     await this._proxy.$acceptResponsePart(requestId, ( new SerializableObjectWithBuffers(part)));
                 }
-                this._logService.trace('[CHAT] request DONE', extension.value, requestId);
-            }
-            catch (err) {
-                this._logService.error('[CHAT] extension request ERRORED in STREAM', toErrorMessage(err, true), extension.value, requestId);
+                this._logService.trace("[CHAT] request DONE", extension.value, requestId);
+            } catch (err) {
+                this._logService.error(
+                    "[CHAT] extension request ERRORED in STREAM",
+                    toErrorMessage(err, true),
+                    extension.value,
+                    requestId
+                );
                 this._proxy.$acceptResponseDone(requestId, transformErrorForSerialization(err));
             }
         })();
         Promise.allSettled([response.result, streaming]).then(() => {
-            this._logService.debug('[CHAT] extension request DONE', extension.value, requestId);
+            this._logService.debug("[CHAT] extension request DONE", extension.value, requestId);
             this._proxy.$acceptResponseDone(requestId, undefined);
         }, err => {
-            this._logService.error('[CHAT] extension request ERRORED', toErrorMessage(err, true), extension.value, requestId);
+            this._logService.error(
+                "[CHAT] extension request ERRORED",
+                toErrorMessage(err, true),
+                extension.value,
+                requestId
+            );
             this._proxy.$acceptResponseDone(requestId, transformErrorForSerialization(err));
         });
     }
@@ -160,27 +178,29 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         if (this._authenticationService.getProviderIds().includes(authProviderId)) {
             return Disposable.None;
         }
-        const accountLabel = auth.accountLabel ?? ( localize(2533, 'Language Models'));
+        const accountLabel = auth.accountLabel ?? ( localize(2536, "Language Models"));
         const disposables = ( new DisposableStore());
         this._authenticationService.registerAuthenticationProvider(authProviderId, ( new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel)));
         disposables.add(toDisposable(() => {
             this._authenticationService.unregisterAuthenticationProvider(authProviderId);
         }));
-        disposables.add(this._authenticationAccessService.onDidChangeExtensionSessionAccess(async (e) => {
-            const allowedExtensions = this._authenticationAccessService.readAllowedExtensions(authProviderId, accountLabel);
-            const accessList = [];
-            for (const allowedExtension of allowedExtensions) {
-                const from = await this._extensionService.getExtension(allowedExtension.id);
-                if (from) {
-                    accessList.push({
-                        from: from.identifier,
-                        to: extension,
-                        enabled: allowedExtension.allowed ?? true
-                    });
+        disposables.add(
+            this._authenticationAccessService.onDidChangeExtensionSessionAccess(async e => {
+                const allowedExtensions = this._authenticationAccessService.readAllowedExtensions(authProviderId, accountLabel);
+                const accessList = [];
+                for (const allowedExtension of allowedExtensions) {
+                    const from = await this._extensionService.getExtension(allowedExtension.id);
+                    if (from) {
+                        accessList.push({
+                            from: from.identifier,
+                            to: extension,
+                            enabled: allowedExtension.allowed ?? true
+                        });
+                    }
                 }
-            }
-            this._proxy.$updateModelAccesslist(accessList);
-        }));
+                this._proxy.$updateModelAccesslist(accessList);
+            })
+        );
         return disposables;
     }
     $fileIsIgnored(uri, token) {
@@ -195,15 +215,10 @@ let MainThreadLanguageModels = class MainThreadLanguageModels {
         this._ignoredFileProviderRegistrations.deleteAndDispose(handle);
     }
 };
-MainThreadLanguageModels = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadLanguageModels),
-    ( __param(1, ILanguageModelsService)),
-    ( __param(2, ILogService)),
-    ( __param(3, IAuthenticationService)),
-    ( __param(4, IAuthenticationAccessService)),
-    ( __param(5, IExtensionService)),
-    ( __param(6, ILanguageModelIgnoredFilesService))
-], MainThreadLanguageModels);
+MainThreadLanguageModels = __decorate(
+    [extHostNamedCustomer(MainContext.MainThreadLanguageModels), ( __param(1, ILanguageModelsService)), ( __param(2, ILogService)), ( __param(3, IAuthenticationService)), ( __param(4, IAuthenticationAccessService)), ( __param(5, IExtensionService)), ( __param(6, ILanguageModelIgnoredFilesService))],
+    MainThreadLanguageModels
+);
 class LanguageModelAccessAuthProvider {
     constructor(id, label, _accountLabel) {
         this.id = id;
@@ -224,19 +239,27 @@ class LanguageModelAccessAuthProvider {
     }
     async createSession(scopes) {
         this._session = this._createFakeSession(scopes);
-        this._onDidChangeSessions.fire({ added: [this._session], changed: [], removed: [] });
+        this._onDidChangeSessions.fire({
+            added: [this._session],
+            changed: [],
+            removed: []
+        });
         return this._session;
     }
     removeSession(sessionId) {
         if (this._session) {
-            this._onDidChangeSessions.fire({ added: [], changed: [], removed: [this._session] });
+            this._onDidChangeSessions.fire({
+                added: [],
+                changed: [],
+                removed: [this._session]
+            });
             this._session = undefined;
         }
         return Promise.resolve();
     }
     confirmation(extensionName, _recreatingSession) {
         return localize(
-            2534,
+            2537,
             "The extension '{0}' wants to access the language models provided by {1}.",
             extensionName,
             this.label
@@ -244,13 +267,13 @@ class LanguageModelAccessAuthProvider {
     }
     _createFakeSession(scopes) {
         return {
-            id: 'fake-session',
+            id: "fake-session",
             account: {
                 id: this.id,
-                label: this._accountLabel,
+                label: this._accountLabel
             },
-            accessToken: 'fake-access-token',
-            scopes,
+            accessToken: "fake-access-token",
+            scopes
         };
     }
 }

package/vscode/src/vs/workbench/api/browser/mainThreadLanguages.js

@@ -11,7 +11,13 @@ import { ILanguageStatusService } from '@codingame/monaco-vscode-api/vscode/vs/w
 import { Disposable, DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 
 let MainThreadLanguages = class MainThreadLanguages extends Disposable {
-    constructor(_extHostContext, _languageService, _modelService, _resolverService, _languageStatusService) {
+    constructor(
+        _extHostContext,
+        _languageService,
+        _modelService,
+        _resolverService,
+        _languageStatusService
+    ) {
         super();
         this._languageService = _languageService;
         this._modelService = _modelService;
@@ -32,8 +38,7 @@ let MainThreadLanguages = class MainThreadLanguages extends Disposable {
         const ref = await this._resolverService.createModelReference(uri);
         try {
             ref.object.textEditorModel.setLanguage(this._languageService.createById(languageId));
-        }
-        finally {
+        } finally {
             ref.dispose();
         }
     }
@@ -63,12 +68,6 @@ let MainThreadLanguages = class MainThreadLanguages extends Disposable {
         this._status.deleteAndDispose(handle);
     }
 };
-MainThreadLanguages = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadLanguages),
-    ( __param(1, ILanguageService)),
-    ( __param(2, IModelService)),
-    ( __param(3, ITextModelService)),
-    ( __param(4, ILanguageStatusService))
-], MainThreadLanguages);
+MainThreadLanguages = __decorate([extHostNamedCustomer(MainContext.MainThreadLanguages), ( __param(1, ILanguageService)), ( __param(2, IModelService)), ( __param(3, ITextModelService)), ( __param(4, ILanguageStatusService))], MainThreadLanguages);
 
 export { MainThreadLanguages };

package/vscode/src/vs/workbench/api/browser/mainThreadLocalization.js

@@ -17,8 +17,7 @@ let MainThreadLocalization = class MainThreadLocalization extends Disposable {
         try {
             const uri = await this.languagePackService.getBuiltInExtensionTranslationsUri(id, language);
             return uri;
-        }
-        catch (e) {
+        } catch (e) {
             return undefined;
         }
     }
@@ -27,10 +26,6 @@ let MainThreadLocalization = class MainThreadLocalization extends Disposable {
         return ( contents.value.toString());
     }
 };
-MainThreadLocalization = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadLocalization),
-    ( __param(1, IFileService)),
-    ( __param(2, ILanguagePackService))
-], MainThreadLocalization);
+MainThreadLocalization = __decorate([extHostNamedCustomer(MainContext.MainThreadLocalization), ( __param(1, IFileService)), ( __param(2, ILanguagePackService))], MainThreadLocalization);
 
 export { MainThreadLocalization };

package/vscode/src/vs/workbench/api/browser/mainThreadLogService.js

@@ -17,8 +17,7 @@ let MainThreadLoggerService = class MainThreadLoggerService {
         this.disposables.add(loggerService.onDidChangeLogLevel(arg => {
             if (isLogLevel(arg)) {
                 proxy.$setLogLevel(arg);
-            }
-            else {
+            } else {
                 proxy.$setLogLevel(arg[1], arg[0]);
             }
         }));
@@ -26,7 +25,7 @@ let MainThreadLoggerService = class MainThreadLoggerService {
     $log(file, messages) {
         const logger = this.loggerService.getLogger(URI.revive(file));
         if (!logger) {
-            throw ( new Error('Create the logger before logging'));
+            throw ( new Error("Create the logger before logging"));
         }
         for (const [level, message] of messages) {
             log(logger, level, message);
@@ -50,7 +49,7 @@ let MainThreadLoggerService = class MainThreadLoggerService {
     $flush(file) {
         const logger = this.loggerService.getLogger(URI.revive(file));
         if (!logger) {
-            throw ( new Error('Create the logger before flushing'));
+            throw ( new Error("Create the logger before flushing"));
         }
         logger.flush();
     }
@@ -58,11 +57,8 @@ let MainThreadLoggerService = class MainThreadLoggerService {
         this.disposables.dispose();
     }
 };
-MainThreadLoggerService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadLogger),
-    ( __param(1, ILoggerService))
-], MainThreadLoggerService);
-CommandsRegistry.registerCommand('_extensionTests.setLogLevel', function (accessor, level) {
+MainThreadLoggerService = __decorate([extHostNamedCustomer(MainContext.MainThreadLogger), ( __param(1, ILoggerService))], MainThreadLoggerService);
+CommandsRegistry.registerCommand("_extensionTests.setLogLevel", function(accessor, level) {
     const loggerService = accessor.get(ILoggerService);
     const environmentService = accessor.get(IEnvironmentService);
     if (environmentService.isExtensionDevelopment && !!environmentService.extensionTestsLocationURI) {
@@ -72,7 +68,7 @@ CommandsRegistry.registerCommand('_extensionTests.setLogLevel', function (access
         }
     }
 });
-CommandsRegistry.registerCommand('_extensionTests.getLogLevel', function (accessor) {
+CommandsRegistry.registerCommand("_extensionTests.getLogLevel", function(accessor) {
     const logService = accessor.get(ILogService);
     return LogLevelToString(logService.getLevel());
 });

package/vscode/src/vs/workbench/api/browser/mainThreadManagedSockets.js

@@ -26,18 +26,17 @@ let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable
             connect(connectTo, path, query, debugLabel) {
                 return ( new Promise((resolve, reject) => {
                     if (connectTo.id !== socketFactoryId) {
-                        return reject(( new Error('Invalid connectTo')));
+                        return reject(( new Error("Invalid connectTo")));
                     }
                     const factoryId = connectTo.id;
                     that._proxy.$openRemoteSocket(factoryId).then(socketId => {
                         const half = {
                             onClose: ( new Emitter()),
                             onData: ( new Emitter()),
-                            onEnd: ( new Emitter()),
+                            onEnd: ( new Emitter())
                         };
                         that._remoteSockets.set(socketId, half);
-                        MainThreadManagedSocket.connect(socketId, that._proxy, path, query, debugLabel, half)
-                            .then(socket => {
+                        MainThreadManagedSocket.connect(socketId, that._proxy, path, query, debugLabel, half).then(socket => {
                             socket.onDidDispose(() => that._remoteSockets.delete(socketId));
                             resolve(socket);
                         }, err => {
@@ -47,8 +46,11 @@ let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable
                     }).catch(reject);
                 }));
             }
-        });
-        this._registrations.set(socketFactoryId, this._remoteSocketFactoryService.register(RemoteConnectionType.Managed, socketFactory));
+        })();
+        this._registrations.set(
+            socketFactoryId,
+            this._remoteSocketFactoryService.register(RemoteConnectionType.Managed, socketFactory)
+        );
     }
     async $unregisterSocketFactory(socketFactoryId) {
         this._registrations.get(socketFactoryId)?.dispose();
@@ -68,10 +70,10 @@ let MainThreadManagedSockets = class MainThreadManagedSockets extends Disposable
         this._remoteSockets.get(socketId)?.onEnd.fire();
     }
 };
-MainThreadManagedSockets = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadManagedSockets),
-    ( __param(1, IRemoteSocketFactoryService))
-], MainThreadManagedSockets);
+MainThreadManagedSockets = __decorate(
+    [extHostNamedCustomer(MainContext.MainThreadManagedSockets), ( __param(1, IRemoteSocketFactoryService))],
+    MainThreadManagedSockets
+);
 class MainThreadManagedSocket extends ManagedSocket {
     static connect(socketId, proxy, path, query, debugLabel, half) {
         const socket = ( new MainThreadManagedSocket(socketId, proxy, debugLabel, half));

package/vscode/src/vs/workbench/api/browser/mainThreadMcp.d.ts

@@ -12,7 +12,7 @@ import { IAuthenticationService } from "@codingame/monaco-vscode-api/vscode/vs/w
 import { IDynamicAuthenticationProviderStorageService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/dynamicAuthenticationProviderStorage.service";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
 import { IExtHostContext } from "../../services/extensions/common/extHostCustomers.js";
-import { IMcpAuthenticationDetails, IMcpAuthenticationOptions, IMcpAuthSetupTelemetry, MainThreadMcpShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+import { IMcpAuthenticationDetails, IMcpAuthenticationOptions, IAuthMetadataSource, MainThreadMcpShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
 export declare class MainThreadMcp extends Disposable implements MainThreadMcpShape {
     private readonly _extHostContext;
     private readonly _mcpRegistry;
@@ -32,6 +32,7 @@ export declare class MainThreadMcp extends Disposable implements MainThreadMcpSh
     private readonly _proxy;
     private readonly _collectionDefinitions;
     constructor(_extHostContext: IExtHostContext, _mcpRegistry: IMcpRegistry, dialogService: IDialogService, _authenticationService: IAuthenticationService, authenticationMcpServersService: IAuthenticationMcpService, authenticationMCPServerAccessService: IAuthenticationMcpAccessService, authenticationMCPServerUsageService: IAuthenticationMcpUsageService, _dynamicAuthenticationProviderStorageService: IDynamicAuthenticationProviderStorageService, _extensionService: IExtensionService, _contextKeyService: IContextKeyService, _telemetryService: ITelemetryService);
+    private _publishServerDefinitions;
     $upsertMcpCollection(collection: McpCollectionDefinition.FromExtHost, serversDto: McpServerDefinition.Serialized[]): void;
     $deleteMcpCollection(collectionId: string): void;
     $onDidChangeState(id: number, update: McpConnectionState): void;
@@ -42,7 +43,7 @@ export declare class MainThreadMcp extends Disposable implements MainThreadMcpSh
     private _getSessionForProvider;
     private continueWithIncorrectAccountPrompt;
     private _onDidChangeAuthSessions;
-    $logMcpAuthSetup(data: IMcpAuthSetupTelemetry): void;
+    $logMcpAuthSetup(data: IAuthMetadataSource): void;
     private loginPrompt;
     dispose(): void;
 }