@codingame/monaco-vscode-api 3.2.3 → 4.1.0

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

@@ -1,4 +1,4 @@
-import { isFalsyOrEmpty, coalesce, isNonEmptyArray } from '../../../base/common/arrays.js';
+import { isNonEmptyArray, coalesce, isFalsyOrEmpty, asArray } from '../../../base/common/arrays.js';
 import { raceCancellationError } from '../../../base/common/async.js';
 import { CancellationToken } from '../../../base/common/cancellation.js';
 import { isCancellationError, NotImplementedError } from '../../../base/common/errors.js';
@@ -15,8 +15,8 @@ import { InlineEditTriggerKind, InlineCompletionTriggerKind } from '../../../edi
 import { encodeSemanticTokensDto } from '../../../editor/common/services/semanticTokensDto.js';
 import { localizeWithPath } from '../../../nls.js';
 import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
-import { DocumentSelector, DocumentSymbol as DocumentSymbol$1, SymbolKind, SymbolTag, Range, Position, Hover, EvaluatableExpression, InlineValueContext, InlineValue, DocumentHighlight, MultiDocumentHighlight, location, Selection as Selection$1, CodeActionTriggerKind, Diagnostic, WorkspaceEdit, DataTransfer, TextEdit, WorkspaceSymbol, CompletionContext, CompletionItemKind, CompletionItemTag, MarkdownString, SignatureHelp, InlayHintKind, DocumentLink, Color, ColorPresentation, FoldingRange, SelectionRange, CallHierarchyItem, TypeHierarchyItem, DefinitionLink } from './extHostTypeConverters.js';
-import { Disposable, SyntaxTokenType, DocumentSymbol, Range as Range$2, CodeActionKind, InternalDataTransferItem, SemanticTokens, SemanticTokensEdits, SemanticTokensEdit, SnippetString, InlineEditTriggerKind as InlineEditTriggerKind$1, Location, CompletionList, InlineCompletionTriggerKind as InlineCompletionTriggerKind$1 } from './extHostTypes.js';
+import { Selection as Selection$1, Range, CodeActionTriggerKind, Diagnostic, WorkspaceEdit, DocumentSelector, DocumentSymbol as DocumentSymbol$1, SymbolKind, SymbolTag, Position, Hover, EvaluatableExpression, InlineValueContext, InlineValue, DocumentHighlight, MultiDocumentHighlight, location, DataTransfer, TextEdit, WorkspaceSymbol, CompletionContext, CompletionItemKind, CompletionItemTag, MarkdownString, SignatureHelp, InlayHintKind, DocumentLink, Color, ColorPresentation, FoldingRange, SelectionRange, CallHierarchyItem, TypeHierarchyItem, DefinitionLink, PartialAcceptInfo } from './extHostTypeConverters.js';
+import { CodeActionKind, Disposable, SyntaxTokenType, DocumentSymbol, Range as Range$2, InternalDataTransferItem, DocumentPasteEditKind, SemanticTokens, SemanticTokensEdits, SemanticTokensEdit, SnippetString, InlineEditTriggerKind as InlineEditTriggerKind$1, Location, CompletionList, InlineCompletionTriggerKind as InlineCompletionTriggerKind$1 } from './extHostTypes.js';
 import { isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 import { Cache } from './cache.js';
 import { MainContext } from './extHost.protocol.js';
@@ -432,15 +432,13 @@ class CodeActionAdapter {
     }
 }
 class DocumentPasteEditProvider {
-    static toInternalProviderId(extId, editId) {
-        return extId + '.' + editId;
-    }
     constructor(_proxy, _documents, _provider, _handle, _extension) {
         this._proxy = _proxy;
         this._documents = _documents;
         this._provider = _provider;
         this._handle = _handle;
         this._extension = _extension;
+        this._cache = ( new Cache('DocumentPasteEdit'));
     }
     async prepareDocumentPaste(resource, ranges, dataTransferDto, token) {
         if (!this._provider.prepareDocumentPaste) {
@@ -458,33 +456,49 @@ class DocumentPasteEditProvider {
         const entries = Array.from(dataTransfer).filter(([, value]) => !(value instanceof InternalDataTransferItem));
         return DataTransfer.from(entries);
     }
-    async providePasteEdits(requestId, resource, ranges, dataTransferDto, token) {
+    async providePasteEdits(requestId, resource, ranges, dataTransferDto, context, token) {
         if (!this._provider.provideDocumentPasteEdits) {
-            return;
+            return [];
         }
         const doc = this._documents.getDocument(resource);
         const vscodeRanges = ( ranges.map(range => Range.to(range)));
         const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, async (id) => {
             return (await this._proxy.$resolvePasteFileData(this._handle, requestId, id)).buffer;
         });
-        const edit = await this._provider.provideDocumentPasteEdits(doc, vscodeRanges, dataTransfer, token);
-        if (!edit) {
-            return;
+        const edits = await this._provider.provideDocumentPasteEdits(doc, vscodeRanges, dataTransfer, {
+            only: context.only ? ( new DocumentPasteEditKind(context.only)) : undefined,
+            triggerKind: context.triggerKind,
+        }, token);
+        if (!edits || token.isCancellationRequested) {
+            return [];
         }
-        return {
-            label: edit.label ?? ( localizeWithPath(
+        const cacheId = this._cache.add(edits);
+        return ( edits.map((edit, i) => ({
+            _cacheId: [cacheId, i],
+            title: edit.title ?? ( localizeWithPath(
                 'vs/workbench/api/common/extHostLanguageFeatures',
                 'defaultPasteLabel',
                 "Paste using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),
-            detail: this._extension.displayName || this._extension.name,
-            yieldTo: edit.yieldTo?.map(yTo => {
-                return 'mimeType' in yTo ? yTo : { providerId: DocumentPasteEditProvider.toInternalProviderId(yTo.extensionId, yTo.providerId) };
-            }),
+            kind: edit.kind,
+            yieldTo: edit.yieldTo?.map(x => x.value),
             insertText: typeof edit.insertText === 'string' ? edit.insertText : { snippet: edit.insertText.value },
             additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined) : undefined,
-        };
+        })));
+    }
+    async resolvePasteEdit(id, token) {
+        const [sessionId, itemId] = id;
+        const item = this._cache.get(sessionId, itemId);
+        if (!item || !this._provider.resolveDocumentPasteEdit) {
+            return {};
+        }
+        const resolvedItem = (await this._provider.resolveDocumentPasteEdit(item, token)) ?? item;
+        const additionalEdit = resolvedItem.additionalEdit ? WorkspaceEdit.from(resolvedItem.additionalEdit, undefined) : undefined;
+        return { additionalEdit };
+    }
+    releasePasteEdits(id) {
+        this._cache.delete(id);
     }
 }
 class DocumentFormattingAdapter {
@@ -991,7 +1005,7 @@ class InlineCompletionAdapterBase {
     }
     disposeCompletions(pid) { }
     handleDidShowCompletionItem(pid, idx, updatedInsertText) { }
-    handlePartialAccept(pid, idx, acceptedCharacters) { }
+    handlePartialAccept(pid, idx, acceptedCharacters, info) { }
 }
 class InlineCompletionAdapter extends InlineCompletionAdapterBase {
     constructor(_extension, _documents, _provider, _commands) {
@@ -1082,11 +1096,12 @@ class InlineCompletionAdapter extends InlineCompletionAdapterBase {
             }
         }
     }
-    handlePartialAccept(pid, idx, acceptedCharacters) {
+    handlePartialAccept(pid, idx, acceptedCharacters, info) {
         const completionItem = this._references.get(pid)?.items[idx];
         if (completionItem) {
             if (this._provider.handleDidPartiallyAcceptCompletionItem && this._isAdditionsProposedApiEnabled) {
                 this._provider.handleDidPartiallyAcceptCompletionItem(completionItem, acceptedCharacters);
+                this._provider.handleDidPartiallyAcceptCompletionItem(completionItem, PartialAcceptInfo.to(info));
             }
         }
     }
@@ -1343,7 +1358,7 @@ class LinkProviderAdapter {
         }
     }
     static _validateLink(link) {
-        if (link.target && link.target.path.length > 50000) {
+        if (link.target && link.target.path.length > 50_000) {
             console.warn('DROPPING link because it is too long');
             return false;
         }
@@ -1582,9 +1597,6 @@ class TypeHierarchyAdapter {
     }
 }
 class DocumentOnDropEditAdapter {
-    static toInternalProviderId(extId, editId) {
-        return extId + '.' + editId;
-    }
     constructor(_proxy, _documents, _provider, _handle, _extension) {
         this._proxy = _proxy;
         this._documents = _documents;
@@ -1598,23 +1610,22 @@ class DocumentOnDropEditAdapter {
         const dataTransfer = DataTransfer.toDataTransfer(dataTransferDto, async (id) => {
             return (await this._proxy.$resolveDocumentOnDropFileData(this._handle, requestId, id)).buffer;
         });
-        const edit = await this._provider.provideDocumentDropEdits(doc, pos, dataTransfer, token);
-        if (!edit) {
+        const edits = await this._provider.provideDocumentDropEdits(doc, pos, dataTransfer, token);
+        if (!edits) {
             return undefined;
         }
-        return {
-            label: edit.label ?? ( localizeWithPath(
+        return ( asArray(edits).map((edit) => ({
+            title: edit.title ?? ( localizeWithPath(
                 'vs/workbench/api/common/extHostLanguageFeatures',
                 'defaultDropLabel',
                 "Drop using '{0}' extension",
                 this._extension.displayName || this._extension.name
             )),
-            yieldTo: edit.yieldTo?.map(yTo => {
-                return 'mimeType' in yTo ? yTo : { providerId: DocumentOnDropEditAdapter.toInternalProviderId(yTo.extensionId, yTo.providerId) };
-            }),
+            kind: edit.kind?.value,
+            yieldTo: edit.yieldTo?.map(x => x.value),
             insertText: typeof edit.insertText === 'string' ? edit.insertText : { snippet: edit.insertText.value },
             additionalEdit: edit.additionalEdit ? WorkspaceEdit.from(edit.additionalEdit, undefined) : undefined,
-        };
+        })));
     }
 }
 class MappedEditsAdapter {
@@ -1995,9 +2006,9 @@ class ExtHostLanguageFeatures {
             adapter.handleDidShowCompletionItem(pid, idx, updatedInsertText);
         }, undefined, undefined);
     }
-    $handleInlineCompletionPartialAccept(handle, pid, idx, acceptedCharacters) {
+    $handleInlineCompletionPartialAccept(handle, pid, idx, acceptedCharacters, info) {
         this._withAdapter(handle, InlineCompletionAdapterBase, async (adapter) => {
-            adapter.handlePartialAccept(pid, idx, acceptedCharacters);
+            adapter.handlePartialAccept(pid, idx, acceptedCharacters, info);
         }, undefined, undefined);
     }
     $freeInlineCompletionsList(handle, pid) {
@@ -2140,8 +2151,7 @@ class ExtHostLanguageFeatures {
     registerDocumentOnDropEditProvider(extension, selector, provider, metadata) {
         const handle = this._nextHandle();
         this._adapter.set(handle, ( new AdapterData(( new DocumentOnDropEditAdapter(this._proxy, this._documents, provider, handle, extension)), extension)));
-        const id = isProposedApiEnabled(extension, 'dropMetadata') && metadata ? DocumentOnDropEditAdapter.toInternalProviderId(extension.identifier.value, metadata.id) : undefined;
-        this._proxy.$registerDocumentOnDropEditProvider(handle, this._transformDocumentSelector(selector, extension), id, isProposedApiEnabled(extension, 'dropMetadata') ? metadata : undefined);
+        this._proxy.$registerDocumentOnDropEditProvider(handle, this._transformDocumentSelector(selector, extension), isProposedApiEnabled(extension, 'dropMetadata') ? metadata : undefined);
         return this._createDisposable(handle);
     }
     $provideDocumentOnDropEdits(handle, requestId, resource, position, dataTransferDto, token) {
@@ -2158,10 +2168,11 @@ class ExtHostLanguageFeatures {
     registerDocumentPasteEditProvider(extension, selector, provider, metadata) {
         const handle = this._nextHandle();
         this._adapter.set(handle, ( new AdapterData(( new DocumentPasteEditProvider(this._proxy, this._documents, provider, handle, extension)), extension)));
-        const internalId = DocumentPasteEditProvider.toInternalProviderId(extension.identifier.value, metadata.id);
-        this._proxy.$registerPasteEditProvider(handle, this._transformDocumentSelector(selector, extension), internalId, {
+        this._proxy.$registerPasteEditProvider(handle, this._transformDocumentSelector(selector, extension), {
             supportsCopy: !!provider.prepareDocumentPaste,
             supportsPaste: !!provider.provideDocumentPasteEdits,
+            supportsResolve: !!provider.resolveDocumentPasteEdit,
+            providedPasteEditKinds: metadata.providedPasteEditKinds?.map(x => x.value),
             copyMimeTypes: metadata.copyMimeTypes,
             pasteMimeTypes: metadata.pasteMimeTypes,
         });
@@ -2170,8 +2181,14 @@ class ExtHostLanguageFeatures {
     $prepareDocumentPaste(handle, resource, ranges, dataTransfer, token) {
         return this._withAdapter(handle, DocumentPasteEditProvider, adapter => adapter.prepareDocumentPaste(URI.revive(resource), ranges, dataTransfer, token), undefined, token);
     }
-    $providePasteEdits(handle, requestId, resource, ranges, dataTransferDto, token) {
-        return this._withAdapter(handle, DocumentPasteEditProvider, adapter => adapter.providePasteEdits(requestId, URI.revive(resource), ranges, dataTransferDto, token), undefined, token);
+    $providePasteEdits(handle, requestId, resource, ranges, dataTransferDto, context, token) {
+        return this._withAdapter(handle, DocumentPasteEditProvider, adapter => adapter.providePasteEdits(requestId, URI.revive(resource), ranges, dataTransferDto, context, token), undefined, token);
+    }
+    $resolvePasteEdit(handle, id, token) {
+        return this._withAdapter(handle, DocumentPasteEditProvider, adapter => adapter.resolvePasteEdit(id, token), {}, undefined);
+    }
+    $releasePasteEdits(handle, cacheId) {
+        this._withAdapter(handle, DocumentPasteEditProvider, adapter => Promise.resolve(adapter.releasePasteEdits(cacheId)), undefined, undefined);
     }
     static _serializeRegExp(regExp) {
         return {

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

@@ -0,0 +1,305 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { toDisposable } from '../../../base/common/lifecycle.js';
+import { MainContext } from './extHost.protocol.js';
+import { LanguageModelMessage } from './extHostTypeConverters.js';
+import { LanguageModelError } from './extHostTypes.js';
+import { Progress } from '../../../platform/progress/common/progress.js';
+import { ExtensionIdentifierMap, ExtensionIdentifier, ExtensionIdentifierSet } from '../../../platform/extensions/common/extensions.js';
+import { Barrier, AsyncIterableSource } from '../../../base/common/async.js';
+import { Emitter, Event } from '../../../base/common/event.js';
+import { localizeWithPath } from '../../../nls.js';
+import { INTERNAL_AUTH_PROVIDER_PREFIX } from '../../services/authentication/common/authentication.js';
+import { CancellationError } from '../../../base/common/errors.js';
+import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { IExtHostAuthentication } from './extHostAuthentication.js';
+import { ILogService } from '../../../platform/log/common/log.js';
+var ExtHostLanguageModels_1;
+const IExtHostLanguageModels = ( createDecorator('IExtHostLanguageModels'));
+class LanguageModelResponseStream {
+    constructor(option, stream) {
+        this.option = option;
+        this.stream = ( new AsyncIterableSource());
+        this.stream = stream ?? ( new AsyncIterableSource());
+    }
+}
+class LanguageModelResponse {
+    constructor() {
+        this._responseStreams = ( new Map());
+        this._defaultStream = ( new AsyncIterableSource());
+        this._isDone = false;
+        this._isStreaming = false;
+        const that = this;
+        this.apiObject = {
+            stream: that._defaultStream.asyncIterable,
+        };
+    }
+    *_streams() {
+        if (this._responseStreams.size > 0) {
+            for (const [, value] of this._responseStreams) {
+                yield value.stream;
+            }
+        }
+        else {
+            yield this._defaultStream;
+        }
+    }
+    handleFragment(fragment) {
+        if (this._isDone) {
+            return;
+        }
+        this._isStreaming = true;
+        let res = this._responseStreams.get(fragment.index);
+        if (!res) {
+            if (this._responseStreams.size === 0) {
+                res = ( new LanguageModelResponseStream(fragment.index, this._defaultStream));
+            }
+            else {
+                res = ( new LanguageModelResponseStream(fragment.index));
+            }
+            this._responseStreams.set(fragment.index, res);
+        }
+        res.stream.emitOne(fragment.part);
+    }
+    get isStreaming() {
+        return this._isStreaming;
+    }
+    reject(err) {
+        this._isDone = true;
+        for (const stream of this._streams()) {
+            stream.reject(err);
+        }
+    }
+    resolve() {
+        this._isDone = true;
+        for (const stream of this._streams()) {
+            stream.resolve();
+        }
+    }
+}
+let ExtHostLanguageModels = class ExtHostLanguageModels {
+    static { ExtHostLanguageModels_1 = this; }
+    static { this._idPool = 1; }
+    constructor(extHostRpc, _logService, _extHostAuthentication) {
+        this._logService = _logService;
+        this._extHostAuthentication = _extHostAuthentication;
+        this._onDidChangeModelAccess = ( new Emitter());
+        this._onDidChangeProviders = ( new Emitter());
+        this.onDidChangeProviders = this._onDidChangeProviders.event;
+        this._languageModels = ( new Map());
+        this._allLanguageModelData = ( new Map());
+        this._modelAccessList = ( new ExtensionIdentifierMap());
+        this._pendingRequest = ( new Map());
+        this._languageAccessInformationExtensions = ( new Set());
+        this._proxy = ( extHostRpc.getProxy(MainContext.MainThreadLanguageModels));
+    }
+    dispose() {
+        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
+            };
+        }
+        this._proxy.$registerLanguageModelProvider(handle, identifier, {
+            extension: extension.identifier,
+            identifier: identifier,
+            model: metadata.name ?? '',
+            auth
+        });
+        return toDisposable(() => {
+            this._languageModels.delete(handle);
+            this._proxy.$unregisterProvider(handle);
+        });
+    }
+    async $provideLanguageModelResponse(handle, requestId, from, messages, options, token) {
+        const data = this._languageModels.get(handle);
+        if (!data) {
+            return;
+        }
+        const progress = ( new Progress(async (fragment) => {
+            if (token.isCancellationRequested) {
+                this._logService.warn(`[CHAT](${data.extension.value}) CANNOT send progress because the REQUEST IS CANCELLED`);
+                return;
+            }
+            this._proxy.$handleProgressChunk(requestId, { index: fragment.index, part: fragment.part });
+        }));
+        return data.provider.provideLanguageModelResponse2(( messages.map(LanguageModelMessage.to)), options, ExtensionIdentifier.toKey(from), progress, token);
+    }
+    $updateLanguageModels(data) {
+        const added = [];
+        const removed = [];
+        if (data.added) {
+            for (const metadata of data.added) {
+                this._allLanguageModelData.set(metadata.identifier, metadata);
+                added.push(metadata.model);
+            }
+        }
+        if (data.removed) {
+            for (const id of data.removed) {
+                this._allLanguageModelData.delete(id);
+                removed.push(id);
+                for (const [key, value] of this._pendingRequest) {
+                    if (value.languageModelId === id) {
+                        value.res.reject(( new CancellationError()));
+                        this._pendingRequest.delete(key);
+                    }
+                }
+            }
+        }
+        this._onDidChangeProviders.fire(( Object.freeze({
+            added: ( Object.freeze(added)),
+            removed: ( Object.freeze(removed))
+        })));
+        data.added?.forEach(this._fakeAuthPopulate, this);
+    }
+    getLanguageModelIds() {
+        return Array.from(( this._allLanguageModelData.keys()));
+    }
+    $updateModelAccesslist(data) {
+        const updated = ( new Array());
+        for (const { from, to, enabled } of data) {
+            const set = this._modelAccessList.get(from) ?? ( new ExtensionIdentifierSet());
+            const oldValue = ( set.has(to));
+            if (oldValue !== enabled) {
+                if (enabled) {
+                    set.add(to);
+                }
+                else {
+                    set.delete(to);
+                }
+                this._modelAccessList.set(from, set);
+                const newItem = { from, to };
+                updated.push(newItem);
+                this._onDidChangeModelAccess.fire(newItem);
+            }
+        }
+    }
+    async sendChatRequest(extension, languageModelId, messages, options, token) {
+        const from = extension.identifier;
+        const metadata = await this._proxy.$prepareChatAccess(from, languageModelId, options.justification);
+        if (!metadata || !( this._allLanguageModelData.has(languageModelId))) {
+            throw LanguageModelError.NotFound(`Language model '${languageModelId}' is unknown.`);
+        }
+        if (this._isUsingAuth(from, metadata)) {
+            const success = await this._getAuthAccess(extension, { identifier: metadata.extension, displayName: metadata.auth.providerLabel }, options.justification, options.silent);
+            if (!success || !this._modelAccessList.get(from)?.has(metadata.extension)) {
+                throw LanguageModelError.NoPermissions(`Language model '${languageModelId}' cannot be used by '${from.value}'.`);
+            }
+        }
+        const requestId = (Math.random() * 1e6) | 0;
+        const requestPromise = this._proxy.$fetchResponse(from, languageModelId, requestId, ( messages.map(LanguageModelMessage.from)), options.modelOptions ?? {}, token);
+        const barrier = ( new Barrier());
+        const res = ( new LanguageModelResponse());
+        this._pendingRequest.set(requestId, { languageModelId, res });
+        let error;
+        requestPromise.catch(err => {
+            if (barrier.isOpen()) {
+                res.reject(err);
+            }
+            else {
+                error = err;
+            }
+        }).finally(() => {
+            this._pendingRequest.delete(requestId);
+            res.resolve();
+            barrier.open();
+        });
+        await barrier.wait();
+        if (error) {
+            throw new LanguageModelError(`Language model '${languageModelId}' errored, check cause for more details`, 'Unknown', error);
+        }
+        return res.apiObject;
+    }
+    async $handleResponseFragment(requestId, chunk) {
+        const data = this._pendingRequest.get(requestId);
+        if (data) {
+            data.res.handleFragment(chunk);
+        }
+    }
+    async _getAuthAccess(from, to, justification, silent) {
+        const providerId = INTERNAL_AUTH_PROVIDER_PREFIX + to.identifier.value;
+        const session = await this._extHostAuthentication.getSession(from, providerId, [], { silent: true });
+        if (session) {
+            this.$updateModelAccesslist([{ from: from.identifier, to: to.identifier, enabled: true }]);
+            return true;
+        }
+        if (silent) {
+            return false;
+        }
+        try {
+            const detail = justification
+                ? ( localizeWithPath(
+                'vs/workbench/api/common/extHostLanguageModels',
+                'chatAccessWithJustification',
+                "To allow access to the language models provided by {0}. Justification:\n\n{1}",
+                to.displayName,
+                justification
+            ))
+                : ( localizeWithPath(
+                'vs/workbench/api/common/extHostLanguageModels',
+                'chatAccess',
+                "To allow access to the language models provided by {0}",
+                to.displayName
+            ));
+            await this._extHostAuthentication.getSession(from, providerId, [], { forceNewSession: { detail } });
+            this.$updateModelAccesslist([{ from: from.identifier, to: to.identifier, enabled: true }]);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    _isUsingAuth(from, toMetadata) {
+        return !!toMetadata.auth
+            && !ExtensionIdentifier.equals(toMetadata.extension, from);
+    }
+    async _fakeAuthPopulate(metadata) {
+        for (const from of this._languageAccessInformationExtensions) {
+            try {
+                await this._getAuthAccess(from, { identifier: metadata.extension, displayName: '' }, undefined, true);
+            }
+            catch (err) {
+                this._logService.error('Fake Auth request failed');
+                this._logService.error(err);
+            }
+        }
+    }
+    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 {
+            get onDidChange() {
+                return Event.any(_onDidChangeAccess, _onDidAddRemove);
+            },
+            canSendRequest(languageModelId) {
+                const data = that._allLanguageModelData.get(languageModelId);
+                if (!data) {
+                    return undefined;
+                }
+                if (!that._isUsingAuth(from.identifier, data)) {
+                    return true;
+                }
+                const list = that._modelAccessList.get(from.identifier);
+                if (!list) {
+                    return undefined;
+                }
+                return ( list.has(data.extension));
+            }
+        };
+    }
+};
+ExtHostLanguageModels = ExtHostLanguageModels_1 = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IExtHostAuthentication))
+], ExtHostLanguageModels));
+export { ExtHostLanguageModels, IExtHostLanguageModels };

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

@@ -1,7 +1,7 @@
 import { MainContext } from './extHost.protocol.js';
 import { Position, Range as Range$1, TokenType, DocumentSelector } from './extHostTypeConverters.js';
 import { StandardTokenType, Range, LanguageStatusSeverity } from './extHostTypes.js';
-import Severity from '../../../base/common/severity.js';
+import Severity$1 from '../../../base/common/severity.js';
 import { disposableTimeout } from '../../../base/common/async.js';
 import { DisposableStore } from '../../../base/common/lifecycle.js';
 import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
@@ -88,7 +88,7 @@ class ExtHostLanguages {
                     selector: DocumentSelector.from(data.selector, this._uriTransformer),
                     label: data.text,
                     detail: data.detail ?? '',
-                    severity: data.severity === LanguageStatusSeverity.Error ? Severity.Error : data.severity === LanguageStatusSeverity.Warning ? Severity.Warning : Severity.Info,
+                    severity: data.severity === LanguageStatusSeverity.Error ? Severity$1.Error : data.severity === LanguageStatusSeverity.Warning ? Severity$1.Warning : Severity$1.Info,
                     command: data.command && this._commands.toInternal(data.command, commandDisposables),
                     accessibilityInfo: data.accessibilityInformation,
                     busy: data.busy

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

@@ -2,7 +2,7 @@ import { Schemas } from '../../../base/common/network.js';
 import { URI } from '../../../base/common/uri.js';
 import { NotebookCellOutput, NotebookCellExecutionSummary, NotebookCellKind, NotebookCellOutputItem } from './extHostTypeConverters.js';
 import { NotebookRange } from './extHostTypes.js';
-import { isTextStreamMime, compressOutputItemStreams, NotebookCellsChangeType } from '../../contrib/notebook/common/notebookCommon.js';
+import { NotebookCellsChangeType, isTextStreamMime, compressOutputItemStreams } from '../../contrib/notebook/common/notebookCommon.js';
 class RawContentChangeEvent {
     constructor(start, deletedCount, deletedItems, items) {
         this.start = start;

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

@@ -68,10 +68,15 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
             ( new ApiCommandResult('A promise that resolves to an array of variables', (value, apiArgs) => {
                 return ( value.map(variable => {
                     return {
-                        name: variable.name,
-                        value: variable.value,
-                        type: variable.type,
-                        editable: false
+                        variable: {
+                            name: variable.name,
+                            value: variable.value,
+                            expression: variable.expression,
+                            type: variable.type,
+                            language: variable.language
+                        },
+                        hasNamedChildren: variable.hasNamedChildren,
+                        indexedChildrenCount: variable.indexedChildrenCount
                     };
                 }));
             }))
@@ -389,6 +394,9 @@ let ExtHostNotebookKernels = class ExtHostNotebookKernels {
                 name: result.variable.name,
                 value: result.variable.value,
                 type: result.variable.type,
+                interfaces: result.variable.interfaces,
+                language: result.variable.language,
+                expression: result.variable.expression,
                 hasNamedChildren: result.hasNamedChildren,
                 indexedChildrenCount: result.indexedChildrenCount,
                 extensionId: obj.extensionId.value,
@@ -577,16 +585,28 @@ class NotebookCellExecutionTask extends Disposable {
                     runStartTime: startTime
                 });
             },
-            end(success, endTime) {
+            end(success, endTime, executionError) {
                 if (that._state === NotebookCellExecutionTaskState.Resolved) {
                     throw new Error('Cannot call resolve twice');
                 }
                 that._state = NotebookCellExecutionTaskState.Resolved;
                 that._onDidChangeState.fire();
                 that._collector.flush();
+                const error = executionError ? {
+                    message: executionError.message,
+                    stack: executionError.stack,
+                    location: executionError?.location ? {
+                        startLineNumber: executionError.location.start.line,
+                        startColumn: executionError.location.start.character,
+                        endLineNumber: executionError.location.end.line,
+                        endColumn: executionError.location.end.character
+                    } : undefined,
+                    uri: executionError.uri
+                } : undefined;
                 that._proxy.$completeExecution(that._handle, ( new SerializableObjectWithBuffers({
                     runEndTime: endTime,
-                    lastRunSuccess: success
+                    lastRunSuccess: success,
+                    error
                 })));
             },
             clearOutput(cell) {