@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.0

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

@@ -1,11 +1,8 @@
-import { raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
 import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
 import { MainContext } from './extHost.protocol.js';
-import { ChatReplyFollowup, ChatFollowup, CompletionItemKind, ChatVariable, MarkdownString, Range } from './extHostTypeConverters.js';
+import { ChatReplyFollowup, MarkdownString } from './extHostTypeConverters.js';
 class ChatProviderWrapper {
     static { this._pool = 0; }
     constructor(extension, provider) {
@@ -16,8 +13,7 @@ class ChatProviderWrapper {
 }
 class ExtHostChat {
     static { this._nextId = 0; }
-    constructor(mainContext, logService) {
-        this.logService = logService;
+    constructor(mainContext) {
         this._chatProvider = ( new Map());
         this._chatSessions = ( new Map());
         this._onDidPerformUserAction = ( new Emitter());
@@ -40,18 +36,15 @@ class ExtHostChat {
         }
         this._proxy.$transferChatSession(sessionId, newWorkspace);
     }
-    addChatRequest(context) {
-        this._proxy.$addRequest(context);
-    }
     sendInteractiveRequestToProvider(providerId, message) {
         this._proxy.$sendRequestToProvider(providerId, message);
     }
-    async $prepareChat(handle, initialState, token) {
+    async $prepareChat(handle, token) {
         const entry = this._chatProvider.get(handle);
         if (!entry) {
             return undefined;
         }
-        const session = await entry.provider.prepareSession(initialState, token);
+        const session = await entry.provider.prepareSession(token);
         if (!session) {
             return undefined;
         }
@@ -66,26 +59,6 @@ class ExtHostChat {
             inputPlaceholder: session.inputPlaceholder,
         };
     }
-    async $resolveRequest(handle, sessionId, context, token) {
-        const entry = this._chatProvider.get(handle);
-        if (!entry) {
-            return undefined;
-        }
-        const realSession = this._chatSessions.get(sessionId);
-        if (!realSession) {
-            return undefined;
-        }
-        if (!entry.provider.resolveRequest) {
-            return undefined;
-        }
-        const request = await entry.provider.resolveRequest(realSession, context, token);
-        if (request) {
-            return {
-                message: typeof request.message === 'string' ? request.message : ChatReplyFollowup.from(request.message),
-            };
-        }
-        return undefined;
-    }
     async $provideWelcomeMessage(handle, token) {
         const entry = this._chatProvider.get(handle);
         if (!entry) {
@@ -102,150 +75,27 @@ class ExtHostChat {
             if (typeof item === 'string') {
                 return item;
             }
-            else {
+            else if (Array.isArray(item)) {
                 return ( item.map(f => ChatReplyFollowup.from(f)));
             }
-        }));
-    }
-    async $provideFollowups(handle, sessionId, token) {
-        const entry = this._chatProvider.get(handle);
-        if (!entry) {
-            return undefined;
-        }
-        const realSession = this._chatSessions.get(sessionId);
-        if (!realSession) {
-            return;
-        }
-        if (!entry.provider.provideFollowups) {
-            return undefined;
-        }
-        const rawFollowups = await entry.provider.provideFollowups(realSession, token);
-        return rawFollowups?.map(f => ChatFollowup.from(f));
-    }
-    $removeRequest(handle, sessionId, requestId) {
-        const entry = this._chatProvider.get(handle);
-        if (!entry) {
-            return;
-        }
-        const realSession = this._chatSessions.get(sessionId);
-        if (!realSession) {
-            return;
-        }
-        if (!entry.provider.removeRequest) {
-            return;
-        }
-        entry.provider.removeRequest(realSession, requestId);
-    }
-    async $provideReply(handle, sessionId, request, token) {
-        const entry = this._chatProvider.get(handle);
-        if (!entry) {
-            return undefined;
-        }
-        const realSession = this._chatSessions.get(sessionId);
-        if (!realSession) {
-            return;
-        }
-        const requestObj = {
-            session: realSession,
-            message: typeof request.message === 'string' ? request.message : ChatReplyFollowup.to(request.message),
-            variables: {}
-        };
-        if (request.variables) {
-            for (const key of ( Object.keys(request.variables))) {
-                requestObj.variables[key] = ( request.variables[key].map(ChatVariable.to));
-            }
-        }
-        const stopWatch = StopWatch.create(false);
-        let firstProgress;
-        const progressObj = {
-            report: (progress) => {
-                if (token.isCancellationRequested) {
-                    return;
-                }
-                if (typeof firstProgress === 'undefined') {
-                    firstProgress = stopWatch.elapsed();
-                }
-                if ('responseId' in progress) {
-                    this._proxy.$acceptResponseProgress(handle, sessionId, { requestId: progress.responseId });
-                }
-                else if ('placeholder' in progress && 'resolvedContent' in progress) {
-                    const resolvedContent = Promise.all([this._proxy.$acceptResponseProgress(handle, sessionId, { placeholder: progress.placeholder }), progress.resolvedContent]);
-                    raceCancellation(resolvedContent, token).then((res) => {
-                        if (!res) {
-                            return;
-                        }
-                        const [progressHandle, progressContent] = res;
-                        this._proxy.$acceptResponseProgress(handle, sessionId, progressContent, progressHandle ?? undefined);
-                    });
-                }
-                else if ('content' in progress) {
-                    this._proxy.$acceptResponseProgress(handle, sessionId, {
-                        content: typeof progress.content === 'string' ? progress.content : MarkdownString.from(progress.content)
-                    });
-                }
-                else if ('documents' in progress) {
-                    this._proxy.$acceptResponseProgress(handle, sessionId, {
-                        documents: ( progress.documents.map(d => ({
-                            uri: d.uri,
-                            version: d.version,
-                            ranges: ( d.ranges.map(r => Range.from(r)))
-                        })))
-                    });
-                }
-                else {
-                    this._proxy.$acceptResponseProgress(handle, sessionId, progress);
-                }
-            }
-        };
-        let result;
-        try {
-            result = await entry.provider.provideResponseWithProgress(requestObj, progressObj, token);
-            if (!result) {
-                result = { errorDetails: { message: ( localizeWithPath(
-                    'vs/workbench/api/common/extHostChat',
-                    'emptyResponse',
-                    "Provider returned null response"
-                )) } };
-            }
-        }
-        catch (err) {
-            result = { errorDetails: { message: ( localizeWithPath(
-                'vs/workbench/api/common/extHostChat',
-                'errorResponse',
-                "Error from provider: {0}",
-                err.message
-            )), responseIsIncomplete: true } };
-            this.logService.error(err);
-        }
-        try {
-            if (realSession.saveState && ( this._chatSessions.has(sessionId))) {
-                const newState = realSession.saveState();
-                this._proxy.$acceptChatState(sessionId, newState);
+            else {
+                return MarkdownString.from(item);
             }
-        }
-        catch (err) {
-            this.logService.warn(err);
-        }
-        const timings = { firstProgress: firstProgress ?? 0, totalElapsed: stopWatch.elapsed() };
-        return { errorDetails: result.errorDetails, timings };
+        }));
     }
-    async $provideSlashCommands(handle, sessionId, token) {
+    async $provideSampleQuestions(handle, token) {
         const entry = this._chatProvider.get(handle);
         if (!entry) {
             return undefined;
         }
-        const realSession = this._chatSessions.get(sessionId);
-        if (!realSession) {
+        if (!entry.provider.provideSampleQuestions) {
             return undefined;
         }
-        if (!entry.provider.provideSlashCommands) {
+        const rawFollowups = await entry.provider.provideSampleQuestions(token);
+        if (!rawFollowups) {
             return undefined;
         }
-        const slashCommands = await entry.provider.provideSlashCommands(realSession, token);
-        return slashCommands?.map(c => ({
-            ...c,
-            kind: CompletionItemKind.from(c.kind)
-        }));
+        return rawFollowups?.map(f => ChatReplyFollowup.from(f));
     }
     $releaseSession(sessionId) {
         this._chatSessions.delete(sessionId);

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

@@ -0,0 +1,412 @@
+import { raceCancellation, DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { MainContext } from './extHost.protocol.js';
+import { ChatVariable, ChatMessage, ChatResponseProgress, ChatAgentCompletionItem, ChatFollowup, MarkdownString } from './extHostTypeConverters.js';
+import { ChatAgentResultFeedbackKind, ThemeIcon } from './extHostTypes.js';
+import { InteractiveSessionVoteDirection } from '../../contrib/chat/common/chatService.js';
+import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+class ExtHostChatAgents2 {
+    static { this._idPool = 0; }
+    constructor(mainContext, _extHostChatProvider, _logService) {
+        this._extHostChatProvider = _extHostChatProvider;
+        this._logService = _logService;
+        this._agents = ( new Map());
+        this._previousResultMap = ( new Map());
+        this._resultsBySessionAndRequestId = ( new Map());
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadChatAgents2));
+    }
+    createChatAgent(extension, name, handler) {
+        const handle = ExtHostChatAgents2._idPool++;
+        const agent = ( new ExtHostChatAgent(extension, name, this._proxy, handle, handler));
+        this._agents.set(handle, agent);
+        this._proxy.$registerAgent(handle, name, {});
+        return agent.apiAgent;
+    }
+    async $invokeAgent(handle, sessionId, requestId, request, context, token) {
+        this._previousResultMap.delete(sessionId);
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            throw new Error(`[CHAT](${handle}) CANNOT invoke agent because the agent is not registered`);
+        }
+        let done = false;
+        function throwIfDone() {
+            if (done) {
+                throw new Error('Only valid while executing the command');
+            }
+        }
+        const commandExecution = ( new DeferredPromise());
+        token.onCancellationRequested(() => commandExecution.complete());
+        setTimeout(() => commandExecution.complete(), 10 * 1000);
+        this._extHostChatProvider.allowListExtensionWhile(agent.extension.identifier, commandExecution.p);
+        const slashCommand = request.command
+            ? await agent.validateSlashCommand(request.command)
+            : undefined;
+        const stopWatch = StopWatch.create(false);
+        let firstProgress;
+        try {
+            const task = agent.invoke({
+                prompt: request.message,
+                variables: ChatVariable.objectTo(request.variables),
+                slashCommand
+            }, { history: ( context.history.map(ChatMessage.to)) }, ( new Progress(progress => {
+                throwIfDone();
+                if (typeof firstProgress === 'undefined' && 'content' in progress) {
+                    firstProgress = stopWatch.elapsed();
+                }
+                const convertedProgress = ChatResponseProgress.from(agent.extension, progress);
+                if (!convertedProgress) {
+                    this._logService.error('Unknown progress type: ' + JSON.stringify(progress));
+                    return;
+                }
+                if ('placeholder' in progress && 'resolvedContent' in progress) {
+                    const resolvedContent = Promise.all([this._proxy.$handleProgressChunk(requestId, convertedProgress), progress.resolvedContent]);
+                    raceCancellation(resolvedContent, token).then(res => {
+                        if (!res) {
+                            return;
+                        }
+                        const [progressHandle, progressContent] = res;
+                        const convertedContent = ChatResponseProgress.from(agent.extension, progressContent);
+                        if (!convertedContent) {
+                            this._logService.error('Unknown progress type: ' + JSON.stringify(progressContent));
+                            return;
+                        }
+                        this._proxy.$handleProgressChunk(requestId, convertedContent, progressHandle ?? undefined);
+                    });
+                }
+                else {
+                    this._proxy.$handleProgressChunk(requestId, convertedProgress);
+                }
+            })), token);
+            return await raceCancellation(Promise.resolve(task).then((result) => {
+                if (result) {
+                    this._previousResultMap.set(sessionId, result);
+                    let sessionResults = this._resultsBySessionAndRequestId.get(sessionId);
+                    if (!sessionResults) {
+                        sessionResults = ( new Map());
+                        this._resultsBySessionAndRequestId.set(sessionId, sessionResults);
+                    }
+                    sessionResults.set(requestId, result);
+                    const timings = { firstProgress: firstProgress, totalElapsed: stopWatch.elapsed() };
+                    return { errorDetails: result.errorDetails, timings };
+                }
+                else {
+                    this._previousResultMap.delete(sessionId);
+                }
+                return undefined;
+            }), token);
+        }
+        catch (e) {
+            this._logService.error(e, agent.extension);
+            return { errorDetails: { message: ( localizeWithPath(
+                'vs/workbench/api/common/extHostChatAgents2',
+                'errorResponse',
+                "Error from provider: {0}",
+                toErrorMessage(e)
+            )), responseIsIncomplete: true } };
+        }
+        finally {
+            done = true;
+            commandExecution.complete();
+        }
+    }
+    $releaseSession(sessionId) {
+        this._previousResultMap.delete(sessionId);
+        this._resultsBySessionAndRequestId.delete(sessionId);
+    }
+    async $provideSlashCommands(handle, token) {
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            return [];
+        }
+        return agent.provideSlashCommand(token);
+    }
+    $provideFollowups(handle, sessionId, token) {
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            return Promise.resolve([]);
+        }
+        const result = this._previousResultMap.get(sessionId);
+        if (!result) {
+            return Promise.resolve([]);
+        }
+        return agent.provideFollowups(result, token);
+    }
+    $acceptFeedback(handle, sessionId, requestId, vote, reportIssue) {
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            return;
+        }
+        const result = this._resultsBySessionAndRequestId.get(sessionId)?.get(requestId);
+        if (!result) {
+            return;
+        }
+        let kind;
+        switch (vote) {
+            case InteractiveSessionVoteDirection.Down:
+                kind = ChatAgentResultFeedbackKind.Unhelpful;
+                break;
+            case InteractiveSessionVoteDirection.Up:
+                kind = ChatAgentResultFeedbackKind.Helpful;
+                break;
+        }
+        agent.acceptFeedback(reportIssue ? ( Object.freeze({ result, kind, reportIssue })) : ( Object.freeze({ result, kind })));
+    }
+    $acceptAction(handle, sessionId, requestId, action) {
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            return;
+        }
+        const result = this._resultsBySessionAndRequestId.get(sessionId)?.get(requestId);
+        if (!result) {
+            return;
+        }
+        if (action.action.kind === 'vote') {
+            return;
+        }
+        agent.acceptAction(( Object.freeze({ action: action.action, result })));
+    }
+    async $invokeCompletionProvider(handle, query, token) {
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            return [];
+        }
+        const items = await agent.invokeCompletionProvider(query, token);
+        return ( items.map(ChatAgentCompletionItem.from));
+    }
+}
+class ExtHostChatAgent {
+    constructor(extension, _id, _proxy, _handle, _callback) {
+        this.extension = extension;
+        this._id = _id;
+        this._proxy = _proxy;
+        this._handle = _handle;
+        this._callback = _callback;
+        this._onDidReceiveFeedback = ( new Emitter());
+        this._onDidPerformAction = ( new Emitter());
+    }
+    acceptFeedback(feedback) {
+        this._onDidReceiveFeedback.fire(feedback);
+    }
+    acceptAction(event) {
+        this._onDidPerformAction.fire(event);
+    }
+    async invokeCompletionProvider(query, token) {
+        if (!this._agentVariableProvider) {
+            return [];
+        }
+        return (await this._agentVariableProvider.provider.provideCompletionItems(query, token)) ?? [];
+    }
+    async validateSlashCommand(command) {
+        if (!this._lastSlashCommands) {
+            await this.provideSlashCommand(CancellationToken.None);
+            assertType(this._lastSlashCommands);
+        }
+        const result = this._lastSlashCommands.find(candidate => candidate.name === command);
+        if (!result) {
+            throw new Error(`Unknown slashCommand: ${command}`);
+        }
+        return result;
+    }
+    async provideSlashCommand(token) {
+        if (!this._slashCommandProvider) {
+            return [];
+        }
+        const result = await this._slashCommandProvider.provideSlashCommands(token);
+        if (!result) {
+            return [];
+        }
+        this._lastSlashCommands = result;
+        return ( result
+            .map(c => ({
+            name: c.name,
+            description: c.description,
+            followupPlaceholder: c.followupPlaceholder,
+            shouldRepopulate: c.shouldRepopulate,
+            sampleRequest: c.sampleRequest
+        })));
+    }
+    async provideFollowups(result, token) {
+        if (!this._followupProvider) {
+            return [];
+        }
+        const followups = await this._followupProvider.provideFollowups(result, token);
+        if (!followups) {
+            return [];
+        }
+        return ( followups.map(f => ChatFollowup.from(f)));
+    }
+    get apiAgent() {
+        let disposed = false;
+        let updateScheduled = false;
+        const updateMetadataSoon = () => {
+            if (disposed) {
+                return;
+            }
+            if (updateScheduled) {
+                return;
+            }
+            updateScheduled = true;
+            queueMicrotask(() => {
+                this._proxy.$updateAgent(this._handle, {
+                    description: this._description ?? '',
+                    fullName: this._fullName,
+                    icon: !this._iconPath ? undefined :
+                        this._iconPath instanceof URI ? this._iconPath :
+                            'light' in this._iconPath ? this._iconPath.light :
+                                undefined,
+                    iconDark: !this._iconPath ? undefined :
+                        'dark' in this._iconPath ? this._iconPath.dark :
+                            undefined,
+                    themeIcon: this._iconPath instanceof ThemeIcon ? this._iconPath : undefined,
+                    hasSlashCommands: this._slashCommandProvider !== undefined,
+                    hasFollowups: this._followupProvider !== undefined,
+                    isDefault: this._isDefault,
+                    isSecondary: this._isSecondary,
+                    helpTextPrefix: (!this._helpTextPrefix || typeof this._helpTextPrefix === 'string') ? this._helpTextPrefix : MarkdownString.from(this._helpTextPrefix),
+                    helpTextPostfix: (!this._helpTextPostfix || typeof this._helpTextPostfix === 'string') ? this._helpTextPostfix : MarkdownString.from(this._helpTextPostfix),
+                    sampleRequest: this._sampleRequest,
+                    supportIssueReporting: this._supportIssueReporting
+                });
+                updateScheduled = false;
+            });
+        };
+        const that = this;
+        return {
+            get name() {
+                return that._id;
+            },
+            get description() {
+                return that._description ?? '';
+            },
+            set description(v) {
+                that._description = v;
+                updateMetadataSoon();
+            },
+            get fullName() {
+                return that._fullName ?? that.extension.displayName ?? that.extension.name;
+            },
+            set fullName(v) {
+                that._fullName = v;
+                updateMetadataSoon();
+            },
+            get iconPath() {
+                return that._iconPath;
+            },
+            set iconPath(v) {
+                that._iconPath = v;
+                updateMetadataSoon();
+            },
+            get slashCommandProvider() {
+                return that._slashCommandProvider;
+            },
+            set slashCommandProvider(v) {
+                that._slashCommandProvider = v;
+                updateMetadataSoon();
+            },
+            get followupProvider() {
+                return that._followupProvider;
+            },
+            set followupProvider(v) {
+                that._followupProvider = v;
+                updateMetadataSoon();
+            },
+            get isDefault() {
+                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                return that._isDefault;
+            },
+            set isDefault(v) {
+                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                that._isDefault = v;
+                updateMetadataSoon();
+            },
+            get helpTextPrefix() {
+                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                return that._helpTextPrefix;
+            },
+            set helpTextPrefix(v) {
+                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                if (!that._isDefault) {
+                    throw new Error('helpTextPrefix is only available on the default chat agent');
+                }
+                that._helpTextPrefix = v;
+                updateMetadataSoon();
+            },
+            get helpTextPostfix() {
+                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                return that._helpTextPostfix;
+            },
+            set helpTextPostfix(v) {
+                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                if (!that._isDefault) {
+                    throw new Error('helpTextPostfix is only available on the default chat agent');
+                }
+                that._helpTextPostfix = v;
+                updateMetadataSoon();
+            },
+            get isSecondary() {
+                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                return that._isSecondary;
+            },
+            set isSecondary(v) {
+                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                that._isSecondary = v;
+                updateMetadataSoon();
+            },
+            get sampleRequest() {
+                return that._sampleRequest;
+            },
+            set sampleRequest(v) {
+                that._sampleRequest = v;
+                updateMetadataSoon();
+            },
+            get supportIssueReporting() {
+                checkProposedApiEnabled(that.extension, 'chatAgents2Additions');
+                return that._supportIssueReporting;
+            },
+            set supportIssueReporting(v) {
+                checkProposedApiEnabled(that.extension, 'chatAgents2Additions');
+                that._supportIssueReporting = v;
+                updateMetadataSoon();
+            },
+            get onDidReceiveFeedback() {
+                return that._onDidReceiveFeedback.event;
+            },
+            set agentVariableProvider(v) {
+                that._agentVariableProvider = v;
+                if (v) {
+                    if (!v.triggerCharacters.length) {
+                        throw new Error('triggerCharacters are required');
+                    }
+                    that._proxy.$registerAgentCompletionsProvider(that._handle, v.triggerCharacters);
+                }
+                else {
+                    that._proxy.$unregisterAgentCompletionsProvider(that._handle);
+                }
+            },
+            get agentVariableProvider() {
+                return that._agentVariableProvider;
+            },
+            onDidPerformAction: !isProposedApiEnabled(this.extension, 'chatAgents2Additions')
+                ? undefined
+                : this._onDidPerformAction.event,
+            dispose() {
+                disposed = true;
+                that._slashCommandProvider = undefined;
+                that._followupProvider = undefined;
+                that._onDidReceiveFeedback.dispose();
+                that._proxy.$unregisterAgent(that._handle);
+            },
+        };
+    }
+    invoke(request, context, progress, token) {
+        return this._callback(request, context, progress, token);
+    }
+}
+export { ExtHostChatAgents2 };