@codingame/monaco-vscode-api 2.2.2 → 3.1.0

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

@@ -1,47 +1,57 @@
 import { CancellationTokenSource } from '../../../base/common/cancellation.js';
 import { toDisposable } from '../../../base/common/lifecycle.js';
 import { MainContext } from './extHost.protocol.js';
-import { ChatMessage } from './extHostTypeConverters.js';
+import { LanguageModelMessage } from './extHostTypeConverters.js';
 import { Progress } from '../../../platform/progress/common/progress.js';
-import { ExtensionIdentifierMap } from '../../../platform/extensions/common/extensions.js';
+import { ExtensionIdentifierMap, ExtensionIdentifier, ExtensionIdentifierSet } from '../../../platform/extensions/common/extensions.js';
 import { AsyncIterableSource } from '../../../base/common/async.js';
-import { Emitter } from '../../../base/common/event.js';
-class ChatResponseStream {
+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 { toErrorMessage } from '../../../base/common/errorMessage.js';
+class LanguageModelResponseStream {
     constructor(option, stream) {
+        this.option = option;
         this.stream = ( new AsyncIterableSource());
         this.stream = stream ?? ( new AsyncIterableSource());
-        const that = this;
-        this.apiObj = {
-            option: option,
-            response: that.stream.asyncIterable
-        };
     }
 }
-class ChatRequest {
+class LanguageModelRequest {
     constructor(promise, cts) {
-        this._onDidStart = ( new Emitter());
+        this.cts = cts;
         this._responseStreams = ( new Map());
         this._defaultStream = ( new AsyncIterableSource());
         this._isDone = false;
         const that = this;
         this.apiObject = {
             result: promise,
-            response: that._defaultStream.asyncIterable,
-            onDidStartResponseStream: that._onDidStart.event,
-            cancel() { cts.cancel(); },
+            stream: that._defaultStream.asyncIterable,
         };
-        promise.finally(() => {
-            this._isDone = true;
-            if (this._responseStreams.size > 0) {
-                for (const [, value] of this._responseStreams) {
-                    value.stream.resolve();
-                }
+        promise.then(() => {
+            for (const stream of this._streams()) {
+                stream.resolve();
             }
-            else {
-                this._defaultStream.resolve();
+        }).catch(err => {
+            if (!(err instanceof Error)) {
+                err = ( new Error(toErrorMessage(err), { cause: err }));
+            }
+            for (const stream of this._streams()) {
+                stream.reject(err);
             }
+        }).finally(() => {
+            this._isDone = true;
         });
     }
+    *_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;
@@ -49,37 +59,56 @@ class ChatRequest {
         let res = this._responseStreams.get(fragment.index);
         if (!res) {
             if (this._responseStreams.size === 0) {
-                res = ( new ChatResponseStream(fragment.index, this._defaultStream));
+                res = ( new LanguageModelResponseStream(fragment.index, this._defaultStream));
             }
             else {
-                res = ( new ChatResponseStream(fragment.index));
+                res = ( new LanguageModelResponseStream(fragment.index));
             }
             this._responseStreams.set(fragment.index, res);
-            this._onDidStart.fire(res.apiObj);
         }
         res.stream.emitOne(fragment.part);
     }
 }
 class ExtHostChatProvider {
     static { this._idPool = 1; }
-    constructor(mainContext, _logService) {
+    constructor(mainContext, _logService, _extHostAuthentication) {
         this._logService = _logService;
-        this._providers = ( new Map());
+        this._extHostAuthentication = _extHostAuthentication;
+        this._onDidChangeModelAccess = ( new Emitter());
+        this._onDidChangeProviders = ( new Emitter());
+        this.onDidChangeProviders = this._onDidChangeProviders.event;
+        this._languageModels = ( new Map());
+        this._languageModelIds = ( new Set());
+        this._modelAccessList = ( new ExtensionIdentifierMap());
         this._pendingRequest = ( new Map());
-        this._chatAccessAllowList = ( new ExtensionIdentifierMap());
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatProvider));
     }
-    registerProvider(extension, identifier, provider, metadata) {
+    dispose() {
+        this._onDidChangeModelAccess.dispose();
+        this._onDidChangeProviders.dispose();
+    }
+    registerLanguageModel(extension, identifier, provider, metadata) {
         const handle = ExtHostChatProvider._idPool++;
-        this._providers.set(handle, { extension, provider });
-        this._proxy.$registerProvider(handle, identifier, { extension, model: metadata.name ?? '' });
+        this._languageModels.set(handle, { extension: extension.identifier, provider });
+        let auth;
+        if (metadata.auth) {
+            auth = {
+                providerLabel: extension.displayName || extension.name,
+                accountLabel: typeof metadata.auth === 'object' ? metadata.auth.label : undefined
+            };
+        }
+        this._proxy.$registerProvider(handle, identifier, {
+            extension: extension.identifier,
+            model: metadata.name ?? '',
+            auth
+        });
         return toDisposable(() => {
+            this._languageModels.delete(handle);
             this._proxy.$unregisterProvider(handle);
-            this._providers.delete(handle);
         });
     }
-    async $provideChatResponse(handle, requestId, messages, options, token) {
-        const data = this._providers.get(handle);
+    async $provideLanguageModelResponse(handle, requestId, from, messages, options, token) {
+        const data = this._languageModels.get(handle);
         if (!data) {
             return;
         }
@@ -90,19 +119,65 @@ class ExtHostChatProvider {
             }
             this._proxy.$handleProgressChunk(requestId, { index: fragment.index, part: fragment.part });
         }));
-        return data.provider.provideChatResponse(( messages.map(ChatMessage.to)), options, progress, token);
+        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 id of data.added) {
+                this._languageModelIds.add(id);
+                added.push(id);
+            }
+        }
+        if (data.removed) {
+            for (const id of data.removed) {
+                this._languageModelIds.delete(id);
+                removed.push(id);
+                for (const [key, value] of this._pendingRequest) {
+                    if (value.languageModelId === id) {
+                        value.res.cts.cancel();
+                        this._pendingRequest.delete(key);
+                    }
+                }
+            }
+        }
+        this._onDidChangeProviders.fire(( Object.freeze({
+            added: ( Object.freeze(added)),
+            removed: ( Object.freeze(removed))
+        })));
     }
-    allowListExtensionWhile(extension, promise) {
-        this._chatAccessAllowList.set(extension, promise);
-        promise.finally(() => this._chatAccessAllowList.delete(extension));
+    getLanguageModelIds() {
+        return Array.from(this._languageModelIds);
     }
-    async requestChatResponseProvider(from, identifier) {
-        if (!( this._chatAccessAllowList.has(from))) {
-            throw new Error('Extension is NOT allowed to make chat requests');
+    $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);
+            }
         }
-        const metadata = await this._proxy.$prepareChatAccess(identifier);
+    }
+    async requestLanguageModelAccess(extension, languageModelId, options) {
+        const from = extension.identifier;
+        const justification = options?.justification;
+        const metadata = await this._proxy.$prepareChatAccess(from, languageModelId, justification);
         if (!metadata) {
-            throw new Error(`ChatAccess '${identifier}' NOT found`);
+            throw new Error(`Language model '${languageModelId}' NOT found`);
+        }
+        if (this._isUsingAuth(from, metadata)) {
+            await this._getAuthAccess(extension, { identifier: metadata.extension, displayName: metadata.auth.providerLabel }, justification);
         }
         const that = this;
         return {
@@ -110,19 +185,28 @@ class ExtHostChatProvider {
                 return metadata.model;
             },
             get isRevoked() {
-                return !( that._chatAccessAllowList.has(from));
+                return (that._isUsingAuth(from, metadata) && !that._modelAccessList.get(from)?.has(metadata.extension)) || !( that._languageModelIds.has(languageModelId));
+            },
+            get onDidChangeAccess() {
+                const onDidRemoveLM = Event.filter(that._onDidChangeProviders.event, e => e.removed.includes(languageModelId));
+                const onDidChangeModelAccess = Event.filter(that._onDidChangeModelAccess.event, e => ExtensionIdentifier.equals(e.from, from) && ExtensionIdentifier.equals(e.to, metadata.extension));
+                return Event.signal(Event.any(onDidRemoveLM, onDidChangeModelAccess));
             },
-            makeRequest(messages, options, token) {
-                if (!( that._chatAccessAllowList.has(from))) {
+            makeChatRequest(messages, options, token) {
+                if (that._isUsingAuth(from, metadata) && !that._modelAccessList.get(from)?.has(metadata.extension)) {
                     throw new Error('Access to chat has been revoked');
                 }
+                if (!( that._languageModelIds.has(languageModelId))) {
+                    throw new Error('Language Model has been removed');
+                }
                 const cts = ( new CancellationTokenSource(token));
                 const requestId = (Math.random() * 1e6) | 0;
-                const requestPromise = that._proxy.$fetchResponse(from, identifier, requestId, ( messages.map(ChatMessage.from)), options ?? {}, cts.token);
-                const res = ( new ChatRequest(requestPromise, cts));
-                that._pendingRequest.set(requestId, { res });
+                const requestPromise = that._proxy.$fetchResponse(from, languageModelId, requestId, ( messages.map(LanguageModelMessage.from)), options ?? {}, cts.token);
+                const res = ( new LanguageModelRequest(requestPromise, cts));
+                that._pendingRequest.set(requestId, { languageModelId, res });
                 requestPromise.finally(() => {
                     that._pendingRequest.delete(requestId);
+                    cts.dispose();
                 });
                 return res.apiObject;
             },
@@ -134,5 +218,36 @@ class ExtHostChatProvider {
             data.res.handleFragment(chunk);
         }
     }
+    async _getAuthAccess(from, to, justification) {
+        const providerId = INTERNAL_AUTH_PROVIDER_PREFIX + to.identifier.value;
+        const session = await this._extHostAuthentication.getSession(from, providerId, [], { silent: true });
+        if (!session) {
+            try {
+                const detail = justification
+                    ? ( localizeWithPath(
+                    'vs/workbench/api/common/extHostChatProvider',
+                    'chatAccessWithJustification',
+                    "To allow access to the language models provided by {0}. Justification:\n\n{1}",
+                    to.displayName,
+                    justification
+                ))
+                    : ( localizeWithPath(
+                    'vs/workbench/api/common/extHostChatProvider',
+                    'chatAccess',
+                    "To allow access to the language models provided by {0}",
+                    to.displayName
+                ));
+                await this._extHostAuthentication.getSession(from, providerId, [], { forceNewSession: { detail } });
+            }
+            catch (err) {
+                throw new Error('Access to language models has not been granted');
+            }
+        }
+        this.$updateModelAccesslist([{ from: from.identifier, to: to.identifier, enabled: true }]);
+    }
+    _isUsingAuth(from, toMetadata) {
+        return !!toMetadata.auth
+            && !ExtensionIdentifier.equals(toMetadata.extension, from);
+    }
 }
 export { ExtHostChatProvider };

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

@@ -1,22 +1,34 @@
+import { onUnexpectedExternalError } from '../../../base/common/errors.js';
 import { toDisposable } from '../../../base/common/lifecycle.js';
 import { MainContext } from './extHost.protocol.js';
-import { onUnexpectedExternalError } from '../../../base/common/errors.js';
-import { ChatVariable } from './extHostTypeConverters.js';
+import { ChatVariable, ChatResponseProgressPart, ChatResponseReferencePart, ChatResponsePart } from './extHostTypeConverters.js';
+import { ChatResponseProgressPart as ChatResponseProgressPart$1, ChatResponseReferencePart as ChatResponseReferencePart$1 } from './extHostTypes.js';
+import { checkProposedApiEnabled } from '../../services/extensions/common/extensions.js';
 class ExtHostChatVariables {
     static { this._idPool = 0; }
     constructor(mainContext) {
         this._resolver = ( new Map());
         this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatVariables));
     }
-    async $resolveVariable(handle, messageText, token) {
+    async $resolveVariable(handle, requestId, messageText, token) {
         const item = this._resolver.get(handle);
         if (!item) {
             return undefined;
         }
         try {
-            const value = await item.resolver.resolve(item.data.name, { prompt: messageText }, token);
-            if (value) {
-                return ( value.map(ChatVariable.from));
+            if (item.resolver.resolve2) {
+                checkProposedApiEnabled(item.extension, 'chatParticipantAdditions');
+                const stream = ( new ChatVariableResolverResponseStream(requestId, this._proxy));
+                const value = await item.resolver.resolve2(item.data.name, { prompt: messageText }, stream.apiObject, token);
+                if (value) {
+                    return ( value.map(ChatVariable.from));
+                }
+            }
+            else {
+                const value = await item.resolver.resolve(item.data.name, { prompt: messageText }, token);
+                if (value) {
+                    return ( value.map(ChatVariable.from));
+                }
             }
         }
         catch (err) {
@@ -26,7 +38,7 @@ class ExtHostChatVariables {
     }
     registerVariableResolver(extension, name, description, resolver) {
         const handle = ExtHostChatVariables._idPool++;
-        this._resolver.set(handle, { extension: extension.identifier, data: { name, description }, resolver: resolver });
+        this._resolver.set(handle, { extension, data: { name, description }, resolver: resolver });
         this._proxy.$registerVariable(handle, { name, description });
         return toDisposable(() => {
             this._resolver.delete(handle);
@@ -34,4 +46,52 @@ class ExtHostChatVariables {
         });
     }
 }
+class ChatVariableResolverResponseStream {
+    constructor(_requestId, _proxy) {
+        this._requestId = _requestId;
+        this._proxy = _proxy;
+        this._isClosed = false;
+    }
+    close() {
+        this._isClosed = true;
+    }
+    get apiObject() {
+        if (!this._apiObject) {
+            const that = this;
+            function throwIfDone(source) {
+                if (that._isClosed) {
+                    const err = ( new Error('Response stream has been closed'));
+                    Error.captureStackTrace(err, source);
+                    throw err;
+                }
+            }
+            const _report = (progress) => {
+                this._proxy.$handleProgressChunk(this._requestId, progress);
+            };
+            this._apiObject = {
+                progress(value) {
+                    throwIfDone(this.progress);
+                    const part = new ChatResponseProgressPart$1(value);
+                    const dto = ChatResponseProgressPart.to(part);
+                    _report(dto);
+                    return this;
+                },
+                reference(value) {
+                    throwIfDone(this.reference);
+                    const part = new ChatResponseReferencePart$1(value);
+                    const dto = ChatResponseReferencePart.to(part);
+                    _report(dto);
+                    return this;
+                },
+                push(part) {
+                    throwIfDone(this.push);
+                    const dto = ChatResponsePart.to(part);
+                    _report(dto);
+                    return this;
+                }
+            };
+        }
+        return this._apiObject;
+    }
+}
 export { ExtHostChatVariables };

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

@@ -111,6 +111,13 @@ function createExtHostComments(mainContext, commands, documents) {
             }
             commentController.$createCommentThreadTemplate(uriComponents, range);
         }
+        async $setActiveComment(controllerHandle, commentInfo) {
+            const commentController = this._commentControllers.get(controllerHandle);
+            if (!commentController) {
+                return;
+            }
+            commentController.$setActiveComment(commentInfo ?? undefined);
+        }
         async $updateCommentThreadTemplate(commentControllerHandle, threadHandle, range) {
             const commentController = this._commentControllers.get(commentControllerHandle);
             if (!commentController) {
@@ -404,6 +411,14 @@ function createExtHostComments(mainContext, commands, documents) {
             this._options = options;
             proxy.$updateCommentControllerFeatures(this.handle, { options: this._options });
         }
+        get activeComment() {
+            checkProposedApiEnabled(this._extension, 'activeComment');
+            return this._activeComment;
+        }
+        get activeCommentThread() {
+            checkProposedApiEnabled(this._extension, 'activeComment');
+            return this._activeThread;
+        }
         constructor(_extension, _handle, _id, _label) {
             this._extension = _extension;
             this._handle = _handle;
@@ -421,6 +436,7 @@ function createExtHostComments(mainContext, commands, documents) {
                 set commentingRangeProvider(commentingRangeProvider) { that.commentingRangeProvider = commentingRangeProvider; },
                 get reactionHandler() { return that.reactionHandler; },
                 set reactionHandler(handler) { that.reactionHandler = handler; },
+                get activeCommentThread() { return that.activeCommentThread; },
                 createCommentThread(uri, range, comments) {
                     return that.createCommentThread(uri, range, comments).value;
                 },
@@ -450,6 +466,18 @@ function createExtHostComments(mainContext, commands, documents) {
             this._threads.set(commentThread.handle, commentThread);
             return commentThread;
         }
+        $setActiveComment(commentInfo) {
+            if (!commentInfo) {
+                this._activeComment = undefined;
+                this._activeThread = undefined;
+                return;
+            }
+            const thread = this._threads.get(commentInfo.commentThreadHandle);
+            if (thread) {
+                this._activeComment = commentInfo.uniqueIdInThread ? thread.getCommentByUniqueId(commentInfo.uniqueIdInThread) : undefined;
+                this._activeThread = thread;
+            }
+        }
         $createCommentThreadTemplate(uriComponents, range) {
             const commentThread = ( new ExtHostCommentThread(
                 this.id,