@codingame/monaco-vscode-api 2.2.2 → 3.1.0

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

@@ -1,88 +1,172 @@
 import { coalesce } from '../../../base/common/arrays.js';
-import { raceCancellation, DeferredPromise } from '../../../base/common/async.js';
-import { CancellationToken } from '../../../base/common/cancellation.js';
+import { raceCancellation } from '../../../base/common/async.js';
 import { toErrorMessage } from '../../../base/common/errorMessage.js';
 import { Emitter } from '../../../base/common/event.js';
+import { Iterable } from '../../../base/common/iterator.js';
+import { DisposableMap, DisposableStore } from '../../../base/common/lifecycle.js';
 import { StopWatch } from '../../../base/common/stopwatch.js';
 import { assertType } from '../../../base/common/types.js';
 import { URI } from '../../../base/common/uri.js';
 import { localizeWithPath } from '../../../nls.js';
-import { Progress } from '../../../platform/progress/common/progress.js';
+import { ExtensionIdentifier } from '../../../platform/extensions/common/extensions.js';
 import { MainContext } from './extHost.protocol.js';
-import { ChatAgentRequest, ChatResponseProgress, ChatAgentCompletionItem, ChatFollowup, MarkdownString } from './extHostTypeConverters.js';
-import { ChatAgentResultFeedbackKind, ThemeIcon } from './extHostTypes.js';
+import { ChatAgentRequest, ChatAgentResult, ChatAgentResolvedVariable, ChatResponsePart, ChatFollowup, ChatAgentUserActionEvent, ChatAgentCompletionItem, MarkdownString, ChatResponseMarkdownPart, ChatResponseFilesPart, ChatResponseAnchorPart, ChatResponseCommandButtonPart, ChatResponseProgressPart, ChatResponseReferencePart, ChatResponseProgress } from './extHostTypeConverters.js';
+import { ChatRequestTurn, ChatResponseTurn, ChatResultFeedbackKind, ThemeIcon, ChatResponseMarkdownPart as ChatResponseMarkdownPart$1, ChatResponseFileTreePart, ChatResponseAnchorPart as ChatResponseAnchorPart$1, ChatResponseCommandButtonPart as ChatResponseCommandButtonPart$1, ChatResponseProgressPart as ChatResponseProgressPart$1, ChatResponseReferencePart as ChatResponseReferencePart$1 } from './extHostTypes.js';
 import { InteractiveSessionVoteDirection } from '../../contrib/chat/common/chatService.js';
 import { checkProposedApiEnabled, isProposedApiEnabled } from '../../services/extensions/common/extensions.js';
+class ChatAgentResponseStream {
+    constructor(_extension, _request, _proxy, _logService, _commandsConverter, _sessionDisposables) {
+        this._extension = _extension;
+        this._request = _request;
+        this._proxy = _proxy;
+        this._logService = _logService;
+        this._commandsConverter = _commandsConverter;
+        this._sessionDisposables = _sessionDisposables;
+        this._stopWatch = StopWatch.create(false);
+        this._isClosed = false;
+    }
+    close() {
+        this._isClosed = true;
+    }
+    get timings() {
+        return {
+            firstProgress: this._firstProgress,
+            totalElapsed: this._stopWatch.elapsed()
+        };
+    }
+    get apiObject() {
+        if (!this._apiObject) {
+            const that = this;
+            this._stopWatch.reset();
+            function throwIfDone(source) {
+                if (that._isClosed) {
+                    const err = ( new Error('Response stream has been closed'));
+                    Error.captureStackTrace(err, source);
+                    throw err;
+                }
+            }
+            const _report = (progress) => {
+                if (typeof this._firstProgress === 'undefined' && 'content' in progress) {
+                    this._firstProgress = this._stopWatch.elapsed();
+                }
+                this._proxy.$handleProgressChunk(this._request.requestId, progress);
+            };
+            this._apiObject = {
+                markdown(value) {
+                    throwIfDone(this.markdown);
+                    const part = new ChatResponseMarkdownPart$1(value);
+                    const dto = ChatResponseMarkdownPart.to(part);
+                    _report(dto);
+                    return this;
+                },
+                filetree(value, baseUri) {
+                    throwIfDone(this.filetree);
+                    const part = new ChatResponseFileTreePart(value, baseUri);
+                    const dto = ChatResponseFilesPart.to(part);
+                    _report(dto);
+                    return this;
+                },
+                anchor(value, title) {
+                    throwIfDone(this.anchor);
+                    const part = new ChatResponseAnchorPart$1(value, title);
+                    const dto = ChatResponseAnchorPart.to(part);
+                    _report(dto);
+                    return this;
+                },
+                button(value) {
+                    throwIfDone(this.anchor);
+                    const part = new ChatResponseCommandButtonPart$1(value);
+                    const dto = ChatResponseCommandButtonPart.to(part, that._commandsConverter, that._sessionDisposables);
+                    _report(dto);
+                    return this;
+                },
+                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;
+                },
+                report(progress) {
+                    throwIfDone(this.report);
+                    if ('placeholder' in progress && 'resolvedContent' in progress) {
+                        return;
+                    }
+                    const value = ChatResponseProgress.from(that._extension, progress);
+                    if (!value) {
+                        that._logService.error('Unknown progress type: ' + JSON.stringify(progress));
+                        return;
+                    }
+                    _report(value);
+                    return this;
+                }
+            };
+        }
+        return this._apiObject;
+    }
+}
 class ExtHostChatAgents2 {
     static { this._idPool = 0; }
-    constructor(mainContext, _extHostChatProvider, _logService) {
-        this._extHostChatProvider = _extHostChatProvider;
+    constructor(mainContext, _logService, commands) {
         this._logService = _logService;
+        this.commands = commands;
         this._agents = ( new Map());
-        this._previousResultMap = ( new Map());
-        this._resultsBySessionAndRequestId = ( new Map());
+        this._sessionDisposables = ( new DisposableMap());
         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, {});
+        this._proxy.$registerAgent(handle, extension.identifier, name, {});
         return agent.apiAgent;
     }
     async $invokeAgent(handle, request, context, token) {
-        this._previousResultMap.delete(request.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');
-            }
+        let sessionDisposables = this._sessionDisposables.get(request.sessionId);
+        if (!sessionDisposables) {
+            sessionDisposables = ( new DisposableStore());
+            this._sessionDisposables.set(request.sessionId, sessionDisposables);
         }
-        const commandExecution = ( new DeferredPromise());
-        token.onCancellationRequested(() => commandExecution.complete());
-        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;
+        const stream = ( new ChatAgentResponseStream(
+            agent.extension,
+            request,
+            this._proxy,
+            this._logService,
+            this.commands.converter,
+            sessionDisposables
+        ));
         try {
-            const convertedHistory = await this.prepareHistory(agent, request, context);
-            const task = agent.invoke(ChatAgentRequest.to(request, slashCommand), { history: convertedHistory }, ( 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) ;
-                else {
-                    this._proxy.$handleProgressChunk(request.requestId, convertedProgress);
-                }
-            })), token);
+            const convertedHistory = await this.prepareHistoryTurns(request.agentId, context);
+            const task = agent.invoke(ChatAgentRequest.to(request), { history: convertedHistory }, stream.apiObject, token);
             return await raceCancellation(Promise.resolve(task).then((result) => {
-                if (result) {
-                    this._previousResultMap.set(request.sessionId, result);
-                    let sessionResults = this._resultsBySessionAndRequestId.get(request.sessionId);
-                    if (!sessionResults) {
-                        sessionResults = ( new Map());
-                        this._resultsBySessionAndRequestId.set(request.sessionId, sessionResults);
+                if (result?.metadata) {
+                    try {
+                        JSON.stringify(result.metadata);
+                    }
+                    catch (err) {
+                        const msg = `result.metadata MUST be JSON.stringify-able. Got error: ${err.message}`;
+                        this._logService.error(`[${agent.extension.identifier.value}] [@${agent.id}] ${msg}`, agent.extension);
+                        return { errorDetails: { message: msg }, timings: stream.timings };
                     }
-                    sessionResults.set(request.requestId, result);
-                    const timings = { firstProgress: firstProgress, totalElapsed: stopWatch.elapsed() };
-                    return { errorDetails: result.errorDetails, timings };
-                }
-                else {
-                    this._previousResultMap.delete(request.sessionId);
                 }
-                return undefined;
+                return { errorDetails: result?.errorDetails, timings: stream.timings, metadata: result?.metadata };
             }), token);
         }
         catch (e) {
@@ -95,77 +179,87 @@ class ExtHostChatAgents2 {
             )), responseIsIncomplete: true } };
         }
         finally {
-            done = true;
-            commandExecution.complete();
+            stream.close();
         }
     }
-    async prepareHistory(agent, request, context) {
-        return coalesce(await Promise.all(( context.history
-            .map(async (h) => {
-            const result = request.agentId === h.request.agentId && this._resultsBySessionAndRequestId.get(request.sessionId)?.get(h.request.requestId)
-                || h.result;
-            return {
-                request: ChatAgentRequest.to(h.request, undefined),
-                response: coalesce(( h.response.map(r => ChatResponseProgress.toProgressContent(r)))),
-                result
-            };
-        }))));
+    async prepareHistoryTurns(agentId, context) {
+        const res = [];
+        for (const h of context.history) {
+            const ehResult = ChatAgentResult.to(h.result);
+            const result = agentId === h.request.agentId ?
+                ehResult :
+                { ...ehResult, metadata: undefined };
+            res.push(new ChatRequestTurn(h.request.message, h.request.command, ( h.request.variables.variables.map(ChatAgentResolvedVariable.to)), { extensionId: '', name: h.request.agentId }));
+            const parts = coalesce(( h.response.map(r => ChatResponsePart.fromContent(r, this.commands.converter))));
+            res.push(new ChatResponseTurn(parts, result, { extensionId: '', name: h.request.agentId }, h.request.command));
+        }
+        return res;
     }
     $releaseSession(sessionId) {
-        this._previousResultMap.delete(sessionId);
-        this._resultsBySessionAndRequestId.delete(sessionId);
+        this._sessionDisposables.deleteAndDispose(sessionId);
     }
-    async $provideSlashCommands(handle, token) {
+    async $provideSlashCommands(handle, context, token) {
         const agent = this._agents.get(handle);
         if (!agent) {
             return [];
         }
-        return agent.provideSlashCommand(token);
+        const convertedHistory = await this.prepareHistoryTurns(agent.id, context);
+        try {
+            return await agent.provideSlashCommands({ history: convertedHistory }, token);
+        }
+        catch (err) {
+            const msg = toErrorMessage(err);
+            this._logService.error(`[${agent.extension.identifier.value}] [@${agent.id}] Error while providing slash commands: ${msg}`);
+            return [];
+        }
     }
-    $provideFollowups(handle, sessionId, token) {
+    async $provideFollowups(request, handle, result, 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);
+        const ehResult = ChatAgentResult.to(result);
+        return ( (await agent.provideFollowups(ehResult, token))
+            .filter(f => {
+            const isValid = !f.participant || ( Iterable.some(( this._agents.values()), a => a.id === f.participant && ExtensionIdentifier.equals(a.extension.identifier, agent.extension.identifier)));
+            if (!isValid) {
+                this._logService.warn(`[@${agent.id}] ChatFollowup refers to an invalid participant: ${f.participant}`);
+            }
+            return isValid;
+        })
+            .map(f => ChatFollowup.from(f, request)));
     }
-    $acceptFeedback(handle, sessionId, requestId, vote, reportIssue) {
+    $acceptFeedback(handle, result, vote, reportIssue) {
         const agent = this._agents.get(handle);
         if (!agent) {
             return;
         }
-        const result = this._resultsBySessionAndRequestId.get(sessionId)?.get(requestId);
-        if (!result) {
-            return;
-        }
+        const ehResult = ChatAgentResult.to(result);
         let kind;
         switch (vote) {
             case InteractiveSessionVoteDirection.Down:
-                kind = ChatAgentResultFeedbackKind.Unhelpful;
+                kind = ChatResultFeedbackKind.Unhelpful;
                 break;
             case InteractiveSessionVoteDirection.Up:
-                kind = ChatAgentResultFeedbackKind.Helpful;
+                kind = ChatResultFeedbackKind.Helpful;
                 break;
         }
-        agent.acceptFeedback(reportIssue ? ( Object.freeze({ result, kind, reportIssue })) : ( Object.freeze({ result, kind })));
+        agent.acceptFeedback(reportIssue ?
+            ( Object.freeze({ result: ehResult, kind, reportIssue })) :
+            ( Object.freeze({ result: ehResult, kind })));
     }
-    $acceptAction(handle, sessionId, requestId, action) {
+    $acceptAction(handle, result, event) {
         const agent = this._agents.get(handle);
         if (!agent) {
             return;
         }
-        const result = this._resultsBySessionAndRequestId.get(sessionId)?.get(requestId);
-        if (!result) {
+        if (event.action.kind === 'vote') {
             return;
         }
-        if (action.action.kind === 'vote') {
-            return;
+        const ehAction = ChatAgentUserActionEvent.to(result, event, this.commands.converter);
+        if (ehAction) {
+            agent.acceptAction(( Object.freeze(ehAction)));
         }
-        agent.acceptAction(( Object.freeze({ action: action.action, result })));
     }
     async $invokeCompletionProvider(handle, query, token) {
         const agent = this._agents.get(handle);
@@ -175,14 +269,29 @@ class ExtHostChatAgents2 {
         const items = await agent.invokeCompletionProvider(query, token);
         return ( items.map(ChatAgentCompletionItem.from));
     }
+    async $provideWelcomeMessage(handle, token) {
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            return;
+        }
+        return await agent.provideWelcomeMessage(token);
+    }
+    async $provideSampleQuestions(handle, token) {
+        const agent = this._agents.get(handle);
+        if (!agent) {
+            return;
+        }
+        return ( (await agent.provideSampleQuestions(token))
+            .map(f => ChatFollowup.from(f, undefined)));
+    }
 }
 class ExtHostChatAgent {
-    constructor(extension, id, _proxy, _handle, _callback) {
+    constructor(extension, id, _proxy, _handle, _requestHandler) {
         this.extension = extension;
         this.id = id;
         this._proxy = _proxy;
         this._handle = _handle;
-        this._callback = _callback;
+        this._requestHandler = _requestHandler;
         this._onDidReceiveFeedback = ( new Emitter());
         this._onDidPerformAction = ( new Emitter());
     }
@@ -198,34 +307,27 @@ class ExtHostChatAgent {
         }
         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) {
+    async provideSlashCommands(context, token) {
+        if (!this._commandProvider) {
             return [];
         }
-        const result = await this._slashCommandProvider.provideSubCommands(token);
+        const result = await this._commandProvider.provideCommands(context, 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
-        })));
+            .map(c => {
+            if ('isSticky2' in c) {
+                checkProposedApiEnabled(this.extension, 'chatParticipantAdditions');
+            }
+            return {
+                name: c.name,
+                description: c.description ?? '',
+                followupPlaceholder: c.isSticky2?.placeholder,
+                isSticky: c.isSticky2?.isSticky ?? c.isSticky,
+                sampleRequest: c.sampleRequest
+            };
+        }));
     }
     async provideFollowups(result, token) {
         if (!this._followupProvider) {
@@ -235,7 +337,36 @@ class ExtHostChatAgent {
         if (!followups) {
             return [];
         }
-        return ( followups.map(f => ChatFollowup.from(f)));
+        return followups
+            .filter(f => !(f && 'commandId' in f))
+            .filter(f => !(f && 'message' in f));
+    }
+    async provideWelcomeMessage(token) {
+        if (!this._welcomeMessageProvider) {
+            return [];
+        }
+        const content = await this._welcomeMessageProvider.provideWelcomeMessage(token);
+        if (!content) {
+            return [];
+        }
+        return ( content.map(item => {
+            if (typeof item === 'string') {
+                return item;
+            }
+            else {
+                return MarkdownString.from(item);
+            }
+        }));
+    }
+    async provideSampleQuestions(token) {
+        if (!this._welcomeMessageProvider || !this._welcomeMessageProvider.provideSampleQuestions) {
+            return [];
+        }
+        const content = await this._welcomeMessageProvider.provideSampleQuestions(token);
+        if (!content) {
+            return [];
+        }
+        return content;
     }
     get apiAgent() {
         let disposed = false;
@@ -260,14 +391,16 @@ class ExtHostChatAgent {
                         'dark' in this._iconPath ? this._iconPath.dark :
                             undefined,
                     themeIcon: this._iconPath instanceof ThemeIcon ? this._iconPath : undefined,
-                    hasSlashCommands: this._slashCommandProvider !== undefined,
+                    hasSlashCommands: this._commandProvider !== undefined,
                     hasFollowups: this._followupProvider !== undefined,
                     isDefault: this._isDefault,
                     isSecondary: this._isSecondary,
                     helpTextPrefix: (!this._helpTextPrefix || typeof this._helpTextPrefix === 'string') ? this._helpTextPrefix : MarkdownString.from(this._helpTextPrefix),
+                    helpTextVariablesPrefix: (!this._helpTextVariablesPrefix || typeof this._helpTextVariablesPrefix === 'string') ? this._helpTextVariablesPrefix : MarkdownString.from(this._helpTextVariablesPrefix),
                     helpTextPostfix: (!this._helpTextPostfix || typeof this._helpTextPostfix === 'string') ? this._helpTextPostfix : MarkdownString.from(this._helpTextPostfix),
                     sampleRequest: this._sampleRequest,
-                    supportIssueReporting: this._supportIssueReporting
+                    supportIssueReporting: this._supportIssueReporting,
+                    isSticky: this._isSticky,
                 });
                 updateScheduled = false;
             });
@@ -285,9 +418,11 @@ class ExtHostChatAgent {
                 updateMetadataSoon();
             },
             get fullName() {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 return that._fullName ?? that.extension.displayName ?? that.extension.name;
             },
             set fullName(v) {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 that._fullName = v;
                 updateMetadataSoon();
             },
@@ -298,11 +433,18 @@ class ExtHostChatAgent {
                 that._iconPath = v;
                 updateMetadataSoon();
             },
-            get subCommandProvider() {
-                return that._slashCommandProvider;
+            get requestHandler() {
+                return that._requestHandler;
+            },
+            set requestHandler(v) {
+                assertType(typeof v === 'function', 'Invalid request handler');
+                that._requestHandler = v;
             },
-            set subCommandProvider(v) {
-                that._slashCommandProvider = v;
+            get commandProvider() {
+                return that._commandProvider;
+            },
+            set commandProvider(v) {
+                that._commandProvider = v;
                 updateMetadataSoon();
             },
             get followupProvider() {
@@ -313,32 +455,44 @@ class ExtHostChatAgent {
                 updateMetadataSoon();
             },
             get isDefault() {
-                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 return that._isDefault;
             },
             set isDefault(v) {
-                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 that._isDefault = v;
                 updateMetadataSoon();
             },
             get helpTextPrefix() {
-                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 return that._helpTextPrefix;
             },
             set helpTextPrefix(v) {
-                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 if (!that._isDefault) {
                     throw new Error('helpTextPrefix is only available on the default chat agent');
                 }
                 that._helpTextPrefix = v;
                 updateMetadataSoon();
             },
+            get helpTextVariablesPrefix() {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
+                return that._helpTextVariablesPrefix;
+            },
+            set helpTextVariablesPrefix(v) {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
+                if (!that._isDefault) {
+                    throw new Error('helpTextVariablesPrefix is only available on the default chat agent');
+                }
+                that._helpTextVariablesPrefix = v;
+                updateMetadataSoon();
+            },
             get helpTextPostfix() {
-                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 return that._helpTextPostfix;
             },
             set helpTextPostfix(v) {
-                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 if (!that._isDefault) {
                     throw new Error('helpTextPostfix is only available on the default chat agent');
                 }
@@ -346,11 +500,11 @@ class ExtHostChatAgent {
                 updateMetadataSoon();
             },
             get isSecondary() {
-                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 return that._isSecondary;
             },
             set isSecondary(v) {
-                checkProposedApiEnabled(that.extension, 'defaultChatAgent');
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
                 that._isSecondary = v;
                 updateMetadataSoon();
             },
@@ -362,18 +516,19 @@ class ExtHostChatAgent {
                 updateMetadataSoon();
             },
             get supportIssueReporting() {
-                checkProposedApiEnabled(that.extension, 'chatAgents2Additions');
+                checkProposedApiEnabled(that.extension, 'chatParticipantAdditions');
                 return that._supportIssueReporting;
             },
             set supportIssueReporting(v) {
-                checkProposedApiEnabled(that.extension, 'chatAgents2Additions');
+                checkProposedApiEnabled(that.extension, 'chatParticipantAdditions');
                 that._supportIssueReporting = v;
                 updateMetadataSoon();
             },
             get onDidReceiveFeedback() {
                 return that._onDidReceiveFeedback.event;
             },
-            set agentVariableProvider(v) {
+            set participantVariableProvider(v) {
+                checkProposedApiEnabled(that.extension, 'chatParticipantAdditions');
                 that._agentVariableProvider = v;
                 if (v) {
                     if (!v.triggerCharacters.length) {
@@ -385,23 +540,40 @@ class ExtHostChatAgent {
                     that._proxy.$unregisterAgentCompletionsProvider(that._handle);
                 }
             },
-            get agentVariableProvider() {
+            get participantVariableProvider() {
+                checkProposedApiEnabled(that.extension, 'chatParticipantAdditions');
                 return that._agentVariableProvider;
             },
-            onDidPerformAction: !isProposedApiEnabled(this.extension, 'chatAgents2Additions')
+            set welcomeMessageProvider(v) {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
+                that._welcomeMessageProvider = v;
+                updateMetadataSoon();
+            },
+            get welcomeMessageProvider() {
+                checkProposedApiEnabled(that.extension, 'defaultChatParticipant');
+                return that._welcomeMessageProvider;
+            },
+            onDidPerformAction: !isProposedApiEnabled(this.extension, 'chatParticipantAdditions')
                 ? undefined
                 : this._onDidPerformAction.event,
+            get isSticky() {
+                return that._isSticky;
+            },
+            set isSticky(v) {
+                that._isSticky = v;
+                updateMetadataSoon();
+            },
             dispose() {
                 disposed = true;
-                that._slashCommandProvider = undefined;
+                that._commandProvider = undefined;
                 that._followupProvider = undefined;
                 that._onDidReceiveFeedback.dispose();
                 that._proxy.$unregisterAgent(that._handle);
             },
         };
     }
-    invoke(request, context, progress, token) {
-        return this._callback(request, context, progress, token);
+    invoke(request, context, response, token) {
+        return this._requestHandler(request, context, response, token);
     }
 }
 export { ExtHostChatAgents2 };