@codingame/monaco-vscode-chat-service-override 3.2.2 → 4.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/contrib/chatInputEditorContrib.js

@@ -1,14 +1,25 @@
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { raceCancellation } from 'vscode/vscode/vs/base/common/async';
+import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
 import { Disposable, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
 import { getWordAtText } from 'vscode/vscode/vs/editor/common/core/wordHelper';
 import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { Action2, registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { inputPlaceholderForeground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
+import 'vscode/vscode/vs/platform/theme/common/colorUtils';
+import 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/editorColors';
+import { inputPlaceholderForeground } from 'vscode/vscode/vs/platform/theme/common/colors/inputColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/listColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/menuColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/minimapColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/miscColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/quickpickColors';
+import 'vscode/vscode/vs/platform/theme/common/colors/searchColors';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
 import { SubmitAction } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatExecuteActions';
@@ -16,9 +27,8 @@ import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/brow
 import { ChatInputPart } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatInputPart';
 import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
 import { SelectAndInsertFileAction, dynamicVariableDecorationType } from 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
-import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { chatSlashCommandForeground, chatSlashCommandBackground } from '../../common/chatColors.js';
-import { getHistoryEntriesFromModel } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatAgentLocation, IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { chatSlashCommandForeground, chatSlashCommandBackground } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatColors';
 import { chatVariableLeader, ChatRequestVariablePart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, ChatRequestTextPart, chatAgentLeader, chatSubcommandLeader } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
 import { ChatRequestParser } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
 import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands';
@@ -30,7 +40,7 @@ const placeholderDecorationType = 'chat-session-detail';
 const slashCommandTextDecorationType = 'chat-session-text';
 const variableTextDecorationType = 'chat-variable-text';
 function agentAndCommandToKey(agent, subcommand) {
-    return subcommand ? `${agent}__${subcommand}` : agent;
+    return subcommand ? `${agent.id}__${subcommand}` : agent.id;
 }
 let InputEditorDecorations = class InputEditorDecorations extends Disposable {
     constructor(widget, codeEditorService, themeService, chatAgentService) {
@@ -47,13 +57,14 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
         this.updateRegisteredDecorationTypes();
         this.updateInputEditorDecorations();
         this._register(this.widget.inputEditor.onDidChangeModelContent(() => this.updateInputEditorDecorations()));
+        this._register(this.widget.onDidChangeParsedInput(() => this.updateInputEditorDecorations()));
         this._register(this.widget.onDidChangeViewModel(() => {
             this.registerViewModelListeners();
             this.previouslyUsedAgents.clear();
             this.updateInputEditorDecorations();
         }));
         this._register(this.widget.onDidSubmitAgent((e) => {
-            this.previouslyUsedAgents.add(agentAndCommandToKey(e.agent.id, e.slashCommand?.name));
+            this.previouslyUsedAgents.add(agentAndCommandToKey(e.agent, e.slashCommand?.name));
         }));
         this._register(this.chatAgentService.onDidChangeAgents(() => this.updateInputEditorDecorations()));
         this.registerViewModelListeners();
@@ -99,8 +110,7 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
             return;
         }
         if (!inputValue) {
-            const viewModelPlaceholder = this.widget.viewModel?.inputPlaceholder;
-            const placeholder = viewModelPlaceholder ?? '';
+            const defaultAgent = this.chatAgentService.getDefaultAgent(this.widget.location);
             const decoration = [
                 {
                     range: {
@@ -111,7 +121,7 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
                     },
                     renderOptions: {
                         after: {
-                            contentText: placeholder,
+                            contentText: viewModel.inputPlaceholder ?? defaultAgent?.description ?? '',
                             color: this.getPlaceholderColor()
                         }
                     }
@@ -141,14 +151,14 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
         });
         const onlyAgentAndWhitespace = agentPart && parsedRequest.every(p => p instanceof ChatRequestTextPart && !p.text.trim().length || p instanceof ChatRequestAgentPart);
         if (onlyAgentAndWhitespace) {
-            const isFollowupSlashCommand = ( this.previouslyUsedAgents.has(agentAndCommandToKey(agentPart.agent.id, undefined)));
+            const isFollowupSlashCommand = ( this.previouslyUsedAgents.has(agentAndCommandToKey(agentPart.agent, undefined)));
             const shouldRenderFollowupPlaceholder = isFollowupSlashCommand && agentPart.agent.metadata.followupPlaceholder;
-            if (agentPart.agent.metadata.description && exactlyOneSpaceAfterPart(agentPart)) {
+            if (agentPart.agent.description && exactlyOneSpaceAfterPart(agentPart)) {
                 placeholderDecoration = [{
                         range: getRangeForPlaceholder(agentPart),
                         renderOptions: {
                             after: {
-                                contentText: shouldRenderFollowupPlaceholder ? agentPart.agent.metadata.followupPlaceholder : agentPart.agent.metadata.description,
+                                contentText: shouldRenderFollowupPlaceholder ? agentPart.agent.metadata.followupPlaceholder : agentPart.agent.description,
                                 color: this.getPlaceholderColor(),
                             }
                         }
@@ -157,7 +167,7 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
         }
         const onlyAgentCommandAndWhitespace = agentPart && agentSubcommandPart && parsedRequest.every(p => p instanceof ChatRequestTextPart && !p.text.trim().length || p instanceof ChatRequestAgentPart || p instanceof ChatRequestAgentSubcommandPart);
         if (onlyAgentCommandAndWhitespace) {
-            const isFollowupSlashCommand = ( this.previouslyUsedAgents.has(agentAndCommandToKey(agentPart.agent.id, agentSubcommandPart.command.name)));
+            const isFollowupSlashCommand = ( this.previouslyUsedAgents.has(agentAndCommandToKey(agentPart.agent, agentSubcommandPart.command.name)));
             const shouldRenderFollowupPlaceholder = isFollowupSlashCommand && agentSubcommandPart.command.followupPlaceholder;
             if (agentSubcommandPart?.command.description && exactlyOneSpaceAfterPart(agentSubcommandPart)) {
                 placeholderDecoration = [{
@@ -174,9 +184,12 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
         this.widget.inputEditor.setDecorationsByType(decorationDescription, placeholderDecorationType, placeholderDecoration ?? []);
         const textDecorations = [];
         if (agentPart) {
-            textDecorations.push({ range: agentPart.editorRange });
+            const isDupe = !!this.chatAgentService.getAgents().find(other => other.name === agentPart.agent.name && other.id !== agentPart.agent.id);
+            const id = isDupe ? `(${agentPart.agent.id}) ` : '';
+            const agentHover = `${id}${agentPart.agent.description}`;
+            textDecorations.push({ range: agentPart.editorRange, hoverMessage: ( new MarkdownString(agentHover)) });
             if (agentSubcommandPart) {
-                textDecorations.push({ range: agentSubcommandPart.editorRange });
+                textDecorations.push({ range: agentSubcommandPart.editorRange, hoverMessage: ( new MarkdownString(agentSubcommandPart.command.description)) });
             }
         }
         if (slashCommandPart) {
@@ -208,10 +221,10 @@ class InputEditorSlashCommandMode extends Disposable {
     async repopulateAgentCommand(agent, slashCommand) {
         let value;
         if (slashCommand && slashCommand.isSticky) {
-            value = `${chatAgentLeader}${agent.id} ${chatSubcommandLeader}${slashCommand.name} `;
+            value = `${chatAgentLeader}${agent.name} ${chatSubcommandLeader}${slashCommand.name} `;
         }
         else if (agent.metadata.isSticky) {
-            value = `${chatAgentLeader}${agent.id} `;
+            value = `${chatAgentLeader}${agent.name} `;
         }
         if (value) {
             this.widget.inputEditor.setValue(value);
@@ -231,7 +244,7 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
             triggerCharacters: ['/'],
             provideCompletionItems: async (model, position, _context, _token) => {
                 const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
+                if (!widget || !widget.viewModel || widget.location !== ChatAgentLocation.Panel ) {
                     return null;
                 }
                 const range = computeCompletionRanges(model, position, /\/\w*/g);
@@ -282,7 +295,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
             triggerCharacters: ['@'],
             provideCompletionItems: async (model, position, _context, _token) => {
                 const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
+                if (!widget || !widget.viewModel || widget.location !== ChatAgentLocation.Panel ) {
                     return null;
                 }
                 const parsedRequest = widget.parsedInput.parts;
@@ -295,15 +308,20 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                     return null;
                 }
                 const agents = this.chatAgentService.getAgents()
-                    .filter(a => !a.metadata.isDefault);
+                    .filter(a => !a.isDefault)
+                    .filter(a => a.locations.includes(widget.location));
                 return {
-                    suggestions: ( agents.map((c, i) => {
-                        const withAt = `@${c.id}`;
+                    suggestions: ( agents.map((a, i) => {
+                        const withAt = `@${a.name}`;
+                        const isDupe = !!agents.find(other => other.name === a.name && other.id !== a.id);
                         return {
-                            label: withAt,
+                            label: isDupe ?
+                                { label: withAt, description: a.description, detail: ` (${a.id})` } :
+                                withAt,
                             insertText: `${withAt} `,
-                            detail: c.metadata.description,
+                            detail: a.description,
                             range: ( new Range(1, 1, 1, 1)),
+                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent: a, widget }] },
                             kind: 18 ,
                         };
                     }))
@@ -315,7 +333,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
             triggerCharacters: ['/'],
             provideCompletionItems: async (model, position, _context, token) => {
                 const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.viewModel) {
+                if (!widget || !widget.viewModel || widget.location !== ChatAgentLocation.Panel ) {
                     return;
                 }
                 const range = computeCompletionRanges(model, position, /\/\w*/g);
@@ -337,9 +355,8 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                     }
                 }
                 const usedAgent = parsedRequest[usedAgentIdx];
-                const commands = await usedAgent.agent.provideSlashCommands(widget.viewModel.model, getHistoryEntriesFromModel(widget.viewModel.model), token);
                 return {
-                    suggestions: ( commands.map((c, i) => {
+                    suggestions: ( usedAgent.agent.slashCommands.map((c, i) => {
                         const withSlash = `/${c.name}`;
                         return {
                             label: withSlash,
@@ -358,47 +375,48 @@ let AgentCompletions = class AgentCompletions extends Disposable {
             provideCompletionItems: async (model, position, _context, token) => {
                 const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
                 const viewModel = widget?.viewModel;
-                if (!widget || !viewModel) {
+                if (!widget || !viewModel || widget.location !== ChatAgentLocation.Panel ) {
                     return;
                 }
                 const range = computeCompletionRanges(model, position, /\/\w*/g);
                 if (!range) {
                     return null;
                 }
-                const agents = this.chatAgentService.getAgents();
-                const all = ( agents.map(
-                    agent => agent.provideSlashCommands(viewModel.model, getHistoryEntriesFromModel(viewModel.model), token)
-                ));
-                const commands = await raceCancellation(Promise.all(all), token);
-                if (!commands) {
-                    return;
-                }
+                const agents = this.chatAgentService.getAgents()
+                    .filter(a => a.locations.includes(widget.location));
                 const justAgents = ( agents
-                    .filter(a => !a.metadata.isDefault)
+                    .filter(a => !a.isDefault)
                     .map(agent => {
-                    const agentLabel = `${chatAgentLeader}${agent.id}`;
+                    const isDupe = !!agents.find(other => other.name === agent.name && other.id !== agent.id);
+                    const detail = agent.description;
+                    const agentLabel = `${chatAgentLeader}${agent.name}`;
                     return {
-                        label: { label: agentLabel, description: agent.metadata.description },
-                        filterText: `${chatSubcommandLeader}${agent.id}`,
+                        label: isDupe ?
+                            { label: agentLabel, description: agent.description, detail: ` (${agent.id})` } :
+                            agentLabel,
+                        detail,
+                        filterText: `${chatSubcommandLeader}${agent.name}`,
                         insertText: `${agentLabel} `,
                         range: ( new Range(1, 1, 1, 1)),
                         kind: 18 ,
                         sortText: `${chatSubcommandLeader}${agent.id}`,
+                        command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
                     };
                 }));
                 return {
-                    suggestions: justAgents.concat(agents.flatMap((agent, i) => ( commands[i].map((c, i) => {
-                        const agentLabel = `${chatAgentLeader}${agent.id}`;
+                    suggestions: justAgents.concat(agents.flatMap(agent => ( agent.slashCommands.map((c, i) => {
+                        const agentLabel = `${chatAgentLeader}${agent.name}`;
                         const withSlash = `${chatSubcommandLeader}${c.name}`;
                         return {
                             label: { label: withSlash, description: agentLabel },
-                            filterText: `${chatSubcommandLeader}${agent.id}${c.name}`,
+                            filterText: `${chatSubcommandLeader}${agent.name}${c.name}`,
                             commitCharacters: [' '],
                             insertText: `${agentLabel} ${withSlash} `,
-                            detail: `(${agentLabel}) ${c.description}`,
+                            detail: `(${agentLabel}) ${c.description ?? ''}`,
                             range: ( new Range(1, 1, 1, 1)),
                             kind: 18 ,
                             sortText: `${chatSubcommandLeader}${agent.id}${c.name}`,
+                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
                         };
                     }))))
                 };
@@ -412,6 +430,23 @@ AgentCompletions = ( __decorate([
     ( __param(2, IChatAgentService))
 ], AgentCompletions));
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AgentCompletions, 4 );
+class AssignSelectedAgentAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.assignSelectedAgent'; }
+    constructor() {
+        super({
+            id: AssignSelectedAgentAction.ID,
+            title: ''
+        });
+    }
+    async run(accessor, ...args) {
+        const arg = args[0];
+        if (!arg || !arg.widget || !arg.agent) {
+            return;
+        }
+        arg.widget.lastSelectedAgent = arg.agent;
+    }
+}
+registerAction2(AssignSelectedAgentAction);
 let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposable {
     static { BuiltinDynamicCompletions_1 = this; }
     static { this.VariableNameDef = ( new RegExp(`${chatVariableLeader}\\w*`, 'g')); }
@@ -424,7 +459,7 @@ let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposab
             triggerCharacters: [chatVariableLeader],
             provideCompletionItems: async (model, position, _context, _token) => {
                 const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !widget.supportsFileReferences) {
+                if (!widget || !widget.supportsFileReferences || widget.location !== ChatAgentLocation.Panel ) {
                     return null;
                 }
                 const range = computeCompletionRanges(model, position, BuiltinDynamicCompletions_1.VariableNameDef);
@@ -502,7 +537,7 @@ let VariableCompletions = class VariableCompletions extends Disposable {
             triggerCharacters: [chatVariableLeader],
             provideCompletionItems: async (model, position, _context, _token) => {
                 const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget) {
+                if (!widget || widget.location !== ChatAgentLocation.Panel ) {
                     return null;
                 }
                 const range = computeCompletionRanges(model, position, VariableCompletions_1.VariableNameDef);
@@ -545,13 +580,15 @@ let ChatTokenDeleter = class ChatTokenDeleter extends Disposable {
         const parser = this.instantiationService.createInstance(ChatRequestParser);
         const inputValue = this.widget.inputEditor.getValue();
         let previousInputValue;
-        this.widget.inputEditor.onDidChangeModelContent(e => {
+        let previousSelectedAgent;
+        this._register(this.widget.inputEditor.onDidChangeModelContent(e => {
             if (!previousInputValue) {
                 previousInputValue = inputValue;
+                previousSelectedAgent = this.widget.lastSelectedAgent;
             }
             const change = e.changes[0];
             if (!change.text && this.widget.viewModel) {
-                const previousParsedValue = parser.parseChatRequest(this.widget.viewModel.sessionId, previousInputValue);
+                const previousParsedValue = parser.parseChatRequest(this.widget.viewModel.sessionId, previousInputValue, ChatAgentLocation.Panel, { selectedAgent: previousSelectedAgent });
                 const deletableTokens = previousParsedValue.parts.filter(p => p instanceof ChatRequestAgentPart || p instanceof ChatRequestAgentSubcommandPart || p instanceof ChatRequestSlashCommandPart || p instanceof ChatRequestVariablePart);
                 deletableTokens.forEach(token => {
                     const deletedRangeOfToken = Range.intersectRanges(token.editorRange, change.range);
@@ -571,7 +608,8 @@ let ChatTokenDeleter = class ChatTokenDeleter extends Disposable {
                 });
             }
             previousInputValue = this.widget.inputEditor.getValue();
-        });
+            previousSelectedAgent = this.widget.lastSelectedAgent;
+        }));
     }
 };
 ChatTokenDeleter = ( __decorate([

package/vscode/src/vs/workbench/contrib/chat/common/chatServiceImpl.js

@@ -1,7 +1,8 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { Action } from 'vscode/vscode/vs/base/common/actions';
 import { CancellationToken, CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { ErrorNoTelemetry } from 'vscode/vscode/vs/base/common/errors';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
 import { Disposable, DisposableMap, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
@@ -18,7 +19,7 @@ import { Progress } from 'vscode/vscode/vs/platform/progress/common/progress';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { ChatAgentLocation, IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
 import { CONTEXT_PROVIDER_EXISTS } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
 import { ChatModel, ChatWelcomeMessageModel, ChatModelInitState, getHistoryEntriesFromModel, updateRanges } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
 import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, getPromptText } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
@@ -82,11 +83,6 @@ let ChatService = class ChatService extends Disposable {
             this._transferredSessionData = { sessionId: transferredChat.sessionId, inputValue: transferredData.inputValue };
         }
         this._register(storageService.onWillSaveState(() => this.saveState()));
-        this._register(Event.debounce(this.chatAgentService.onDidChangeAgents, () => { }, 500)(() => {
-            for (const model of ( this._sessionModels.values())) {
-                this.warmSlashCommandCache(model);
-            }
-        }));
     }
     saveState() {
         let allSessions = Array.from(( this._sessionModels.values()))
@@ -227,19 +223,14 @@ let ChatService = class ChatService extends Disposable {
         this.trace('reinitializeModel', `Start reinit`);
         this.initializeSession(model, CancellationToken.None);
     }
-    warmSlashCommandCache(model, agent) {
-        const agents = agent ? [agent] : this.chatAgentService.getAgents();
-        agents.forEach(agent => agent.provideSlashCommands(model, [], CancellationToken.None));
-    }
     async initializeSession(model, token) {
         try {
             this.trace('initializeSession', `Initialize session ${model.sessionId}`);
-            this.warmSlashCommandCache(model);
             model.startInitialize();
             await this.extensionService.activateByEvent(`onInteractiveSession:${model.providerId}`);
             const provider = this._providers.get(model.providerId);
             if (!provider) {
-                throw new Error(`Unknown provider: ${model.providerId}`);
+                throw new ErrorNoTelemetry(`Unknown provider: ${model.providerId}`);
             }
             let session;
             try {
@@ -252,7 +243,7 @@ let ChatService = class ChatService extends Disposable {
                 throw new Error('Provider returned no session');
             }
             this.trace('startSession', `Provider returned session`);
-            const defaultAgent = this.chatAgentService.getDefaultAgent();
+            const defaultAgent = this.chatAgentService.getDefaultAgent(ChatAgentLocation.Panel);
             if (!defaultAgent) {
                 this.notificationService.notify({
                     severity: Severity.Error,
@@ -273,10 +264,10 @@ let ChatService = class ChatService extends Disposable {
                         ]
                     }
                 });
-                throw new Error('No default agent');
+                throw new ErrorNoTelemetry('No default agent');
             }
             const welcomeMessage = model.welcomeMessage ? undefined : (await defaultAgent.provideWelcomeMessage?.(token)) ?? undefined;
-            const welcomeModel = welcomeMessage && ( new ChatWelcomeMessageModel(model, ( welcomeMessage.map(item => typeof item === 'string' ? ( new MarkdownString(item)) : item)), (await defaultAgent.provideSampleQuestions?.(token)) ?? []));
+            const welcomeModel = welcomeMessage && this.instantiationService.createInstance(ChatWelcomeMessageModel, ( welcomeMessage.map(item => typeof item === 'string' ? ( new MarkdownString(item)) : item)), (await defaultAgent.provideSampleQuestions?.(token)) ?? []);
             model.initialize(session, welcomeModel);
         }
         catch (err) {
@@ -310,7 +301,7 @@ let ChatService = class ChatService extends Disposable {
     loadSessionFromContent(data) {
         return this._startSession(data.providerId, data, CancellationToken.None);
     }
-    async sendRequest(sessionId, request) {
+    async sendRequest(sessionId, request, implicitVariablesEnabled, location = ChatAgentLocation.Panel, parserContext) {
         this.trace('sendRequest', `sessionId: ${sessionId}, message: ${request.substring(0, 20)}${request.length > 20 ? '[...]' : ''}}`);
         if (!request.trim()) {
             this.trace('sendRequest', 'Rejected empty message');
@@ -329,11 +320,12 @@ let ChatService = class ChatService extends Disposable {
             this.trace('sendRequest', `Session ${sessionId} already has a pending request`);
             return;
         }
-        const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, request);
-        const agent = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart)?.agent ?? this.chatAgentService.getDefaultAgent();
+        const defaultAgent = this.chatAgentService.getDefaultAgent(location);
+        const parsedRequest = this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(sessionId, request, location, parserContext);
+        const agent = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart)?.agent ?? defaultAgent;
         const agentSlashCommandPart = parsedRequest.parts.find((r) => r instanceof ChatRequestAgentSubcommandPart);
         return {
-            responseCompletePromise: this._sendRequestAsync(model, sessionId, provider, parsedRequest),
+            responseCompletePromise: this._sendRequestAsync(model, sessionId, provider, parsedRequest, implicitVariablesEnabled ?? false, defaultAgent, location),
             agent,
             slashCommand: agentSlashCommandPart?.command,
         };
@@ -344,7 +336,7 @@ let ChatService = class ChatService extends Disposable {
         this._sessionFollowupCancelTokens.set(sessionId, newTokenSource);
         return newTokenSource.token;
     }
-    async _sendRequestAsync(model, sessionId, provider, parsedRequest) {
+    async _sendRequestAsync(model, sessionId, provider, parsedRequest, implicitVariablesEnabled, defaultAgent, location) {
         const followupsCancelToken = this.refreshFollowupsCancellationToken(sessionId);
         let request;
         const agentPart = 'kind' in parsedRequest ? undefined : parsedRequest.parts.find((r) => r instanceof ChatRequestAgentPart);
@@ -386,26 +378,37 @@ let ChatService = class ChatService extends Disposable {
             try {
                 let rawResult;
                 let agentOrCommandFollowups = undefined;
-                const defaultAgent = this.chatAgentService.getDefaultAgent();
                 if (agentPart || (defaultAgent && !commandPart)) {
                     const agent = (agentPart?.agent ?? defaultAgent);
+                    await this.extensionService.activateByEvent(`onChatParticipant:${agent.id}`);
                     const history = getHistoryEntriesFromModel(model);
                     const initVariableData = { variables: [] };
                     request = model.addRequest(parsedRequest, initVariableData, agent, agentSlashCommandPart?.command);
                     const variableData = await this.chatVariablesService.resolveVariables(parsedRequest, model, progressCallback, token);
                     request.variableData = variableData;
                     const promptTextResult = getPromptText(request.message);
+                    const updatedVariableData = updateRanges(variableData, promptTextResult.diff);
+                    if (implicitVariablesEnabled) {
+                        const implicitVariables = agent.defaultImplicitVariables;
+                        if (implicitVariables) {
+                            const resolvedImplicitVariables = await Promise.all(( implicitVariables.map(
+                                async (v) => ({ name: v, values: await this.chatVariablesService.resolveVariable(v, parsedRequest.text, model, progressCallback, token) })
+                            )));
+                            updatedVariableData.variables.push(...resolvedImplicitVariables);
+                        }
+                    }
                     const requestProps = {
                         sessionId,
                         requestId: request.id,
                         agentId: agent.id,
                         message: promptTextResult.message,
                         command: agentSlashCommandPart?.command.name,
-                        variables: updateRanges(variableData, promptTextResult.diff)
+                        variables: updatedVariableData,
+                        location
                     };
                     const agentResult = await this.chatAgentService.invokeAgent(agent.id, requestProps, progressCallback, history, token);
                     rawResult = agentResult;
-                    agentOrCommandFollowups = this.chatAgentService.getFollowups(agent.id, requestProps, agentResult, followupsCancelToken);
+                    agentOrCommandFollowups = this.chatAgentService.getFollowups(agent.id, requestProps, agentResult, history, followupsCancelToken);
                 }
                 else if (commandPart && this.chatSlashCommandService.hasCommand(commandPart.slashCommand.command)) {
                     request = model.addRequest(parsedRequest, { variables: [] });
@@ -486,10 +489,6 @@ let ChatService = class ChatService extends Disposable {
         }
         model.removeRequest(requestId);
     }
-    async sendRequestToProvider(sessionId, message) {
-        this.trace('sendRequestToProvider', `sessionId: ${sessionId}`);
-        return await this.sendRequest(sessionId, message.message);
-    }
     getProviders() {
         return Array.from(( this._providers.keys()));
     }

package/vscode/src/vs/workbench/contrib/chat/common/voiceChat.js

@@ -0,0 +1,141 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { rtrim } from 'vscode/vscode/vs/base/common/strings';
+import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { chatAgentLeader, chatSubcommandLeader } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { SpeechToTextStatus, ISpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
+
+var VoiceChatService_1;
+var PhraseTextType;
+( (function(PhraseTextType) {
+    PhraseTextType[PhraseTextType["AGENT"] = 1] = "AGENT";
+    PhraseTextType[PhraseTextType["COMMAND"] = 2] = "COMMAND";
+    PhraseTextType[PhraseTextType["AGENT_AND_COMMAND"] = 3] = "AGENT_AND_COMMAND";
+})(PhraseTextType || (PhraseTextType = {})));
+let VoiceChatService = class VoiceChatService extends Disposable {
+    static { VoiceChatService_1 = this; }
+    static { this.AGENT_PREFIX = chatAgentLeader; }
+    static { this.COMMAND_PREFIX = chatSubcommandLeader; }
+    static { this.PHRASES_LOWER = {
+        [VoiceChatService_1.AGENT_PREFIX]: 'at',
+        [VoiceChatService_1.COMMAND_PREFIX]: 'slash'
+    }; }
+    static { this.PHRASES_UPPER = {
+        [VoiceChatService_1.AGENT_PREFIX]: 'At',
+        [VoiceChatService_1.COMMAND_PREFIX]: 'Slash'
+    }; }
+    static { this.CHAT_AGENT_ALIAS = ( new Map([['vscode', 'code']])); }
+    constructor(speechService, chatAgentService) {
+        super();
+        this.speechService = speechService;
+        this.chatAgentService = chatAgentService;
+    }
+    createPhrases(model) {
+        const phrases = ( new Map());
+        for (const agent of this.chatAgentService.getActivatedAgents()) {
+            const agentPhrase = `${VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.AGENT_PREFIX]} ${VoiceChatService_1.CHAT_AGENT_ALIAS.get(agent.id) ?? agent.id}`.toLowerCase();
+            phrases.set(agentPhrase, { agent: agent.id });
+            for (const slashCommand of agent.slashCommands) {
+                const slashCommandPhrase = `${VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.COMMAND_PREFIX]} ${slashCommand.name}`.toLowerCase();
+                phrases.set(slashCommandPhrase, { agent: agent.id, command: slashCommand.name });
+                const agentSlashCommandPhrase = `${agentPhrase} ${slashCommandPhrase}`.toLowerCase();
+                phrases.set(agentSlashCommandPhrase, { agent: agent.id, command: slashCommand.name });
+            }
+        }
+        return phrases;
+    }
+    toText(value, type) {
+        switch (type) {
+            case PhraseTextType.AGENT:
+                return `${VoiceChatService_1.AGENT_PREFIX}${value.agent}`;
+            case PhraseTextType.COMMAND:
+                return `${VoiceChatService_1.COMMAND_PREFIX}${value.command}`;
+            case PhraseTextType.AGENT_AND_COMMAND:
+                return `${VoiceChatService_1.AGENT_PREFIX}${value.agent} ${VoiceChatService_1.COMMAND_PREFIX}${value.command}`;
+        }
+    }
+    async createVoiceChatSession(token, options) {
+        const disposables = ( new DisposableStore());
+        disposables.add(token.onCancellationRequested(() => disposables.dispose()));
+        let detectedAgent = false;
+        let detectedSlashCommand = false;
+        const emitter = disposables.add(( new Emitter()));
+        const session = await this.speechService.createSpeechToTextSession(token, 'chat');
+        const phrases = this.createPhrases(options.model);
+        disposables.add(session.onDidChange(e => {
+            switch (e.status) {
+                case SpeechToTextStatus.Recognizing:
+                case SpeechToTextStatus.Recognized:
+                    if (e.text) {
+                        const startsWithAgent = e.text.startsWith(VoiceChatService_1.PHRASES_UPPER[VoiceChatService_1.AGENT_PREFIX]) || e.text.startsWith(VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.AGENT_PREFIX]);
+                        const startsWithSlashCommand = e.text.startsWith(VoiceChatService_1.PHRASES_UPPER[VoiceChatService_1.COMMAND_PREFIX]) || e.text.startsWith(VoiceChatService_1.PHRASES_LOWER[VoiceChatService_1.COMMAND_PREFIX]);
+                        if (startsWithAgent || startsWithSlashCommand) {
+                            const originalWords = e.text.split(' ');
+                            let transformedWords;
+                            let waitingForInput = false;
+                            if (options.usesAgents && startsWithAgent && !detectedAgent && !detectedSlashCommand && originalWords.length >= 4) {
+                                const phrase = phrases.get(( originalWords.slice(0, 4).map(word => this.normalizeWord(word))).join(' '));
+                                if (phrase) {
+                                    transformedWords = [this.toText(phrase, PhraseTextType.AGENT_AND_COMMAND), ...originalWords.slice(4)];
+                                    waitingForInput = originalWords.length === 4;
+                                    if (e.status === SpeechToTextStatus.Recognized) {
+                                        detectedAgent = true;
+                                        detectedSlashCommand = true;
+                                    }
+                                }
+                            }
+                            if (options.usesAgents && startsWithAgent && !detectedAgent && !transformedWords && originalWords.length >= 2) {
+                                const phrase = phrases.get(( originalWords.slice(0, 2).map(word => this.normalizeWord(word))).join(' '));
+                                if (phrase) {
+                                    transformedWords = [this.toText(phrase, PhraseTextType.AGENT), ...originalWords.slice(2)];
+                                    waitingForInput = originalWords.length === 2;
+                                    if (e.status === SpeechToTextStatus.Recognized) {
+                                        detectedAgent = true;
+                                    }
+                                }
+                            }
+                            if (startsWithSlashCommand && !detectedSlashCommand && !transformedWords && originalWords.length >= 2) {
+                                const phrase = phrases.get(( originalWords.slice(0, 2).map(word => this.normalizeWord(word))).join(' '));
+                                if (phrase) {
+                                    transformedWords = [this.toText(phrase, options.usesAgents && !detectedAgent ?
+                                            PhraseTextType.AGENT_AND_COMMAND :
+                                            PhraseTextType.COMMAND
+                                        ), ...originalWords.slice(2)];
+                                    waitingForInput = originalWords.length === 2;
+                                    if (e.status === SpeechToTextStatus.Recognized) {
+                                        detectedSlashCommand = true;
+                                    }
+                                }
+                            }
+                            emitter.fire({
+                                status: e.status,
+                                text: (transformedWords ?? originalWords).join(' '),
+                                waitingForInput
+                            });
+                            break;
+                        }
+                    }
+                default:
+                    emitter.fire(e);
+                    break;
+            }
+        }));
+        return {
+            onDidChange: emitter.event
+        };
+    }
+    normalizeWord(word) {
+        word = rtrim(word, '.');
+        word = rtrim(word, ',');
+        word = rtrim(word, '?');
+        return word.toLowerCase();
+    }
+};
+VoiceChatService = VoiceChatService_1 = ( __decorate([
+    ( __param(0, ISpeechService)),
+    ( __param(1, IChatAgentService))
+], VoiceChatService));
+
+export { VoiceChatService };