@codingame/monaco-vscode-chat-service-override 37.1.0 → 37.3.0

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

@@ -0,0 +1,10 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatStatusItemService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatStatus/chatStatusItemService.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { ChatStatusItemDto, MainThreadChatStatusShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadChatStatus extends Disposable implements MainThreadChatStatusShape {
+    private readonly _chatStatusItemService;
+    constructor(_extHostContext: IExtHostContext, _chatStatusItemService: IChatStatusItemService);
+    $setEntry(id: string, entry: ChatStatusItemDto): void;
+    $disposeEntry(id: string): void;
+}

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

@@ -0,0 +1,28 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IChatStatusItemService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatStatus/chatStatusItemService.service';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { MainContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol';
+
+let MainThreadChatStatus = class MainThreadChatStatus extends Disposable {
+    constructor(_extHostContext, _chatStatusItemService) {
+        super();
+        this._chatStatusItemService = _chatStatusItemService;
+    }
+    $setEntry(id, entry) {
+        this._chatStatusItemService.setOrUpdateEntry({
+            id,
+            label: entry.title,
+            description: entry.description,
+            detail: entry.detail,
+            tooltip: entry.tooltip
+        });
+    }
+    $disposeEntry(id) {
+        this._chatStatusItemService.deleteEntry(id);
+    }
+};
+MainThreadChatStatus = __decorate([extHostNamedCustomer(MainContext.MainThreadChatStatus), ( __param(1, IChatStatusItemService))], MainThreadChatStatus);
+
+export { MainThreadChatStatus };

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

@@ -0,0 +1,27 @@
+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 { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.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 "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { Dto, SerializableObjectWithBuffers } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
+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 _productService;
+    private readonly _proxy;
+    private readonly _tools;
+    private readonly _runningToolCalls;
+    constructor(extHostContext: IExtHostContext, _languageModelToolsService: ILanguageModelToolsService, _logService: ILogService, _productService: IProductService);
+    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, hasHandleToolStream: boolean): void;
+    $registerToolWithDefinition(extensionId: ExtensionIdentifier, definition: IToolDefinitionDto, hasHandleToolStream: boolean): void;
+    $unregisterTool(name: string): void;
+}

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

@@ -0,0 +1,167 @@
+
+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, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { revive } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+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 { 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 { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { toToolSetKey } from '../../contrib/chat/common/tools/languageModelToolsContribution.js';
+import { toolResultHasBuffers, ToolDataSource, 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 '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+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, _logService, _productService) {
+        super();
+        this._languageModelToolsService = _languageModelToolsService;
+        this._logService = _logService;
+        this._productService = _productService;
+        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()))
+        );
+    }
+    getToolDtos() {
+        const fullReferenceNameMap = this._languageModelToolsService.getFullReferenceNameMap();
+        return Array.from(this._languageModelToolsService.getAllToolsIncludingDisabled()).map(tool => ({
+            id: tool.id,
+            displayName: tool.displayName,
+            toolReferenceName: tool.toolReferenceName,
+            legacyToolReferenceFullNames: tool.legacyToolReferenceFullNames,
+            fullReferenceName: fullReferenceNameMap.get(tool) ?? undefined,
+            tags: tool.tags,
+            userDescription: tool.userDescription,
+            modelDescription: tool.modelDescription,
+            inputSchema: tool.inputSchema,
+            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 out = {
+            content: result.content,
+            toolMetadata: result.toolMetadata,
+            toolResultError: result.toolResultError
+        };
+        return toolResultHasBuffers(result) ? ( new SerializableObjectWithBuffers(out)) : out;
+    }
+    $acceptToolProgress(callId, progress) {
+        this._runningToolCalls.get(callId)?.progress.report(progress);
+    }
+    $countTokensForInvocation(callId, input, token) {
+        const fn = this._runningToolCalls.get(callId);
+        if (!fn) {
+            throw ( new Error(`Tool invocation call ${callId} not found`));
+        }
+        return fn.countTokens(input, token);
+    }
+    $registerTool(id, hasHandleToolStream) {
+        const disposable = this._languageModelToolsService.registerToolImplementation(id, {
+            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);
+                }
+            },
+            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 isBuiltinTool = this._productService.defaultChatAgent?.chatExtensionId ? ExtensionIdentifier.equals(extensionId, this._productService.defaultChatAgent.chatExtensionId) : false;
+        const source = isBuiltinTool ? ToolDataSource.Internal : 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(2, ILogService)),
+    ( __param(3, IProductService))
+], MainThreadLanguageModelTools);
+
+export { MainThreadLanguageModelTools };

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

@@ -0,0 +1,46 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { SerializedError } from "@codingame/monaco-vscode-api/vscode/vs/base/common/errors";
+import { UriComponents } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+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 { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
+import { ILanguageModelIgnoredFilesService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/ignoredFiles.service";
+import { IChatMessage, IChatResponsePart, ILanguageModelChatSelector } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IAuthenticationAccessService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/browser/authenticationAccessService.service";
+import { IAuthenticationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service";
+import { IExtHostContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { SerializableObjectWithBuffers } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/proxyIdentifier";
+import { MainThreadLanguageModelsShape } from "@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHost.protocol";
+export declare class MainThreadLanguageModels implements MainThreadLanguageModelsShape {
+    private readonly _chatProviderService;
+    private readonly _logService;
+    private readonly _productService;
+    private readonly _authenticationService;
+    private readonly _authenticationAccessService;
+    private readonly _extensionService;
+    private readonly _ignoredFilesService;
+    private readonly _proxy;
+    private readonly _store;
+    private readonly _providerRegistrations;
+    private readonly _lmProviderChange;
+    private readonly _pendingProgress;
+    private readonly _pendingCancelCTS;
+    private readonly _ignoredFileProviderRegistrations;
+    constructor(extHostContext: IExtHostContext, _chatProviderService: ILanguageModelsService, _logService: ILogService, _productService: IProductService, _authenticationService: IAuthenticationService, _authenticationAccessService: IAuthenticationAccessService, _extensionService: IExtensionService, _ignoredFilesService: ILanguageModelIgnoredFilesService);
+    dispose(): void;
+    $registerLanguageModelProvider(vendor: string): void;
+    $onLMProviderChange(vendor: string): void;
+    $reportResponsePart(requestId: number, chunk: SerializableObjectWithBuffers<IChatResponsePart | IChatResponsePart[]>): Promise<void>;
+    $reportResponseDone(requestId: number, err: SerializedError | undefined): Promise<void>;
+    $unregisterProvider(vendor: string): void;
+    $cancelLanguageModelChatRequest(requestId: number): void;
+    $selectChatModels(selector: ILanguageModelChatSelector): Promise<string[]>;
+    $tryStartChatRequest(extension: ExtensionIdentifier, modelIdentifier: string, requestId: number, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: {}, token: CancellationToken): Promise<void>;
+    $countTokens(modelId: string, value: string | IChatMessage, token: CancellationToken): Promise<number>;
+    private _registerAuthenticationProvider;
+    $fileIsIgnored(uri: UriComponents, token: CancellationToken): Promise<boolean>;
+    $registerFileIgnoreProvider(handle: number): void;
+    $unregisterFileIgnoreProvider(handle: number): void;
+}

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

@@ -0,0 +1,358 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DeferredPromise, AsyncIterableSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
+import { CancellationError, transformErrorFromSerialization, transformErrorForSerialization } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { equalSets } from '@codingame/monaco-vscode-api/vscode/vs/base/common/collections';
+import { Disposable, DisposableStore, DisposableMap, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { resizeImage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatImageUtils';
+import { ILanguageModelIgnoredFilesService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/ignoredFiles.service';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { IAuthenticationAccessService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/browser/authenticationAccessService.service';
+import { INTERNAL_AUTH_PROVIDER_PREFIX } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication';
+import { IAuthenticationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/authentication/common/authentication.service';
+import { extHostNamedCustomer } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extHostCustomers';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+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';
+import { LanguageModelError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/api/common/extHostTypes';
+
+class RequestCancellationTokenSource extends Disposable {
+    constructor(parent, onCancellationRequested) {
+        super();
+        this._source = this._register(( new CancellationTokenSource(parent)));
+        if (onCancellationRequested) {
+            this._register(this._source.token.onCancellationRequested(onCancellationRequested));
+        }
+    }
+    get token() {
+        return this._source.token;
+    }
+    cancel() {
+        this._source.cancel();
+    }
+}
+let MainThreadLanguageModels = class MainThreadLanguageModels {
+    constructor(
+        extHostContext,
+        _chatProviderService,
+        _logService,
+        _productService,
+        _authenticationService,
+        _authenticationAccessService,
+        _extensionService,
+        _ignoredFilesService
+    ) {
+        this._chatProviderService = _chatProviderService;
+        this._logService = _logService;
+        this._productService = _productService;
+        this._authenticationService = _authenticationService;
+        this._authenticationAccessService = _authenticationAccessService;
+        this._extensionService = _extensionService;
+        this._ignoredFilesService = _ignoredFilesService;
+        this._store = ( new DisposableStore());
+        this._providerRegistrations = ( new DisposableMap());
+        this._lmProviderChange = ( new Emitter());
+        this._pendingProgress = ( new Map());
+        this._pendingCancelCTS = ( new DisposableMap());
+        this._ignoredFileProviderRegistrations = ( new DisposableMap());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostChatProvider));
+        let lastModelIds = ( new Set(this._chatProviderService.getLanguageModelIds()));
+        this._store.add(this._chatProviderService.onDidChangeLanguageModels(() => {
+            const currentModelIds = ( new Set(this._chatProviderService.getLanguageModelIds()));
+            if (equalSets(lastModelIds, currentModelIds)) {
+                return;
+            }
+            lastModelIds = currentModelIds;
+            this._proxy.$onChatModelsChange();
+        }));
+    }
+    dispose() {
+        this._lmProviderChange.dispose();
+        this._providerRegistrations.dispose();
+        this._pendingProgress.clear();
+        this._pendingCancelCTS.dispose();
+        this._ignoredFileProviderRegistrations.dispose();
+        this._store.dispose();
+    }
+    $registerLanguageModelProvider(vendor) {
+        const disposables = ( new DisposableStore());
+        try {
+            disposables.add(this._chatProviderService.registerLanguageModelProvider(vendor, {
+                onDidChange: Event.filter(this._lmProviderChange.event, e => e.vendor === vendor, disposables),
+                provideLanguageModelChatInfo: async (options, token) => {
+                    const modelsAndIdentifiers = await this._proxy.$provideLanguageModelChatInfo(vendor, options, token);
+                    const copilotExtensionId = this._productService.defaultChatAgent?.chatExtensionId;
+                    return modelsAndIdentifiers.map(m => {
+                        if (m.metadata.auth) {
+                            disposables.add(
+                                this._registerAuthenticationProvider(m.metadata.extension, m.metadata.auth)
+                            );
+                        }
+                        if (m.metadata.isBYOK !== undefined) {
+                            return m;
+                        }
+                        const isBuiltinCopilot = !!copilotExtensionId && ExtensionIdentifier.equals(m.metadata.extension, copilotExtensionId);
+                        return {
+                            ...m,
+                            metadata: {
+                                ...m.metadata,
+                                isBYOK: !isBuiltinCopilot
+                            }
+                        };
+                    });
+                },
+                sendChatRequest: async (modelId, messages, from, options, token) => {
+                    const requestId = (Math.random() * 1e6) | 0;
+                    const defer = ( new DeferredPromise());
+                    defer.p.catch(() => {});
+                    const stream = new AsyncIterableSource();
+                    try {
+                        this._pendingProgress.set(requestId, {
+                            defer,
+                            stream
+                        });
+                        const cts = ( new RequestCancellationTokenSource(token, () => {
+                            this._proxy.$cancelLanguageModelChatRequest(requestId);
+                        }));
+                        this._pendingCancelCTS.set(requestId, cts);
+                        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));
+                            })
+                        );
+                        if (token.isCancellationRequested) {
+                            this._pendingProgress.delete(requestId);
+                            this._pendingCancelCTS.deleteAndDispose(requestId);
+                            const err = ( new CancellationError());
+                            stream.reject(err);
+                            defer.error(err);
+                            return {
+                                result: defer.p,
+                                stream: stream.asyncIterable
+                            };
+                        }
+                        await this._proxy.$startChatRequest(modelId, requestId, from, ( new SerializableObjectWithBuffers(messages)), options, cts.token);
+                    } catch (err) {
+                        this._pendingProgress.delete(requestId);
+                        this._pendingCancelCTS.deleteAndDispose(requestId);
+                        throw err;
+                    }
+                    return {
+                        result: defer.p,
+                        stream: stream.asyncIterable
+                    };
+                },
+                provideTokenCount: (modelId, str, token) => {
+                    return this._proxy.$provideTokenLength(modelId, str, token);
+                }
+            }));
+            this._providerRegistrations.set(vendor, disposables);
+        } catch (err) {
+            disposables.dispose();
+            throw err;
+        }
+    }
+    $onLMProviderChange(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);
+        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);
+        if (data) {
+            this._pendingProgress.delete(requestId);
+            this._pendingCancelCTS.deleteAndDispose(requestId);
+            if (err) {
+                const error = LanguageModelError.tryDeserialize(err) ?? transformErrorFromSerialization(err);
+                data.stream.reject(error);
+                data.defer.error(error);
+            } else {
+                data.stream.resolve();
+                data.defer.complete(undefined);
+            }
+        }
+    }
+    $unregisterProvider(vendor) {
+        this._providerRegistrations.deleteAndDispose(vendor);
+    }
+    $cancelLanguageModelChatRequest(requestId) {
+        this._pendingCancelCTS.get(requestId)?.cancel();
+    }
+    $selectChatModels(selector) {
+        return this._chatProviderService.selectLanguageModels(selector);
+    }
+    async $tryStartChatRequest(extension, modelIdentifier, requestId, messages, options, token) {
+        this._logService.trace("[CHAT] request STARTED", extension.value, requestId);
+        const cts = ( new RequestCancellationTokenSource(token));
+        this._pendingCancelCTS.set(requestId, cts);
+        let response;
+        try {
+            response = await this._chatProviderService.sendChatRequest(modelIdentifier, extension, messages.value, options, cts.token);
+        } catch (err) {
+            this._logService.error("[CHAT] request FAILED", extension.value, requestId, err);
+            this._pendingCancelCTS.deleteAndDispose(requestId);
+            throw err;
+        }
+        const streaming = (async () => {
+            try {
+                for await (const part of response.stream) {
+                    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._proxy.$acceptResponseDone(requestId, transformErrorForSerialization(err));
+            }
+        })();
+        Promise.allSettled([response.result, streaming]).then(() => {
+            this._logService.debug("[CHAT] extension request DONE", extension.value, requestId);
+            this._pendingCancelCTS.deleteAndDispose(requestId);
+            this._proxy.$acceptResponseDone(requestId, undefined);
+        }, err => {
+            this._logService.error(
+                "[CHAT] extension request ERRORED",
+                toErrorMessage(err, true),
+                extension.value,
+                requestId
+            );
+            this._pendingCancelCTS.deleteAndDispose(requestId);
+            this._proxy.$acceptResponseDone(requestId, transformErrorForSerialization(err));
+        });
+    }
+    $countTokens(modelId, value, token) {
+        return this._chatProviderService.computeTokenLength(modelId, value, token);
+    }
+    _registerAuthenticationProvider(extension, auth) {
+        const authProviderId = INTERNAL_AUTH_PROVIDER_PREFIX + extension.value;
+        if (this._authenticationService.getProviderIds().includes(authProviderId)) {
+            return Disposable.None;
+        }
+        const accountLabel = auth.accountLabel ?? ( localize(4983, "Language Models"));
+        const disposables = ( new DisposableStore());
+        const provider = ( new LanguageModelAccessAuthProvider(authProviderId, auth.providerLabel, accountLabel));
+        this._authenticationService.registerAuthenticationProvider(authProviderId, provider);
+        disposables.add(toDisposable(() => {
+            this._authenticationService.unregisterAuthenticationProvider(authProviderId);
+            provider.dispose();
+        }));
+        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);
+            })
+        );
+        return disposables;
+    }
+    $fileIsIgnored(uri, token) {
+        return this._ignoredFilesService.fileIsIgnored(URI.revive(uri), token);
+    }
+    $registerFileIgnoreProvider(handle) {
+        this._ignoredFileProviderRegistrations.set(handle, this._ignoredFilesService.registerIgnoredFileProvider({
+            isFileIgnored: async (uri, token) => this._proxy.$isFileIgnored(handle, uri, token)
+        }));
+    }
+    $unregisterFileIgnoreProvider(handle) {
+        this._ignoredFileProviderRegistrations.deleteAndDispose(handle);
+    }
+};
+MainThreadLanguageModels = __decorate(
+    [extHostNamedCustomer(MainContext.MainThreadLanguageModels), ( __param(1, ILanguageModelsService)), ( __param(2, ILogService)), ( __param(3, IProductService)), ( __param(4, IAuthenticationService)), ( __param(5, IAuthenticationAccessService)), ( __param(6, IExtensionService)), ( __param(7, ILanguageModelIgnoredFilesService))],
+    MainThreadLanguageModels
+);
+class LanguageModelAccessAuthProvider {
+    constructor(id, label, _accountLabel) {
+        this.id = id;
+        this.label = label;
+        this._accountLabel = _accountLabel;
+        this.supportsMultipleAccounts = false;
+        this._onDidChangeSessions = ( new Emitter());
+        this.onDidChangeSessions = this._onDidChangeSessions.event;
+    }
+    async getSessions(scopes) {
+        if (scopes === undefined && !this._session) {
+            return [];
+        }
+        if (this._session) {
+            return [this._session];
+        }
+        return [await this.createSession(scopes || [])];
+    }
+    async createSession(scopes) {
+        this._session = this._createFakeSession(scopes);
+        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._session = undefined;
+        }
+        return Promise.resolve();
+    }
+    confirmation(extensionName, _recreatingSession) {
+        return localize(
+            4984,
+            "The extension '{0}' wants to access the language models provided by {1}.",
+            extensionName,
+            this.label
+        );
+    }
+    _createFakeSession(scopes) {
+        return {
+            id: "fake-session",
+            account: {
+                id: this.id,
+                label: this._accountLabel
+            },
+            accessToken: "fake-access-token",
+            scopes
+        };
+    }
+    dispose() {
+        this._onDidChangeSessions.dispose();
+    }
+}
+
+export { MainThreadLanguageModels };