@codingame/monaco-vscode-chat-service-override 2.2.2 → 3.0.0

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

@@ -6,7 +6,6 @@ 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 { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 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';
@@ -19,12 +18,11 @@ import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat
 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 { chatVariableLeader, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, ChatRequestTextPart, ChatRequestVariablePart, chatAgentLeader, chatSubcommandLeader } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { getHistoryEntriesFromModel } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
+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 { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
 import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands';
 import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables';
-import { isResponseVM } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatViewModel';
 
 var BuiltinDynamicCompletions_1, VariableCompletions_1;
 const decorationDescription = 'chat';
@@ -32,16 +30,14 @@ const placeholderDecorationType = 'chat-session-detail';
 const slashCommandTextDecorationType = 'chat-session-text';
 const variableTextDecorationType = 'chat-variable-text';
 function agentAndCommandToKey(agent, subcommand) {
-    return `${agent}__${subcommand}`;
+    return subcommand ? `${agent}__${subcommand}` : agent;
 }
 let InputEditorDecorations = class InputEditorDecorations extends Disposable {
-    constructor(widget, instantiationService, codeEditorService, themeService, chatService, chatAgentService) {
+    constructor(widget, codeEditorService, themeService, chatAgentService) {
         super();
         this.widget = widget;
-        this.instantiationService = instantiationService;
         this.codeEditorService = codeEditorService;
         this.themeService = themeService;
-        this.chatService = chatService;
         this.chatAgentService = chatAgentService;
         this.id = 'inputEditorDecorations';
         this.previouslyUsedAgents = ( new Set());
@@ -56,10 +52,8 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
             this.previouslyUsedAgents.clear();
             this.updateInputEditorDecorations();
         }));
-        this._register(this.chatService.onDidSubmitAgent((e) => {
-            if (e.sessionId === this.widget.viewModel?.sessionId) {
-                this.previouslyUsedAgents.add(agentAndCommandToKey(e.agent.id, e.slashCommand.name));
-            }
+        this._register(this.widget.onDidSubmitAgent((e) => {
+            this.previouslyUsedAgents.add(agentAndCommandToKey(e.agent.id, e.slashCommand?.name));
         }));
         this._register(this.chatAgentService.onDidChangeAgents(() => this.updateInputEditorDecorations()));
         this.registerViewModelListeners();
@@ -126,7 +120,7 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
             this.widget.inputEditor.setDecorationsByType(decorationDescription, placeholderDecorationType, decoration);
             return;
         }
-        const parsedRequest = (await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(viewModel.sessionId, inputValue)).parts;
+        const parsedRequest = this.widget.parsedInput.parts;
         let placeholderDecoration;
         const agentPart = parsedRequest.find((p) => p instanceof ChatRequestAgentPart);
         const agentSubcommandPart = parsedRequest.find((p) => p instanceof ChatRequestAgentSubcommandPart);
@@ -139,19 +133,22 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
             const nextPart = parsedRequest[partIdx + 1];
             return nextPart && nextPart instanceof ChatRequestTextPart && nextPart.text === ' ';
         };
+        const getRangeForPlaceholder = (part) => ({
+            startLineNumber: part.editorRange.startLineNumber,
+            endLineNumber: part.editorRange.endLineNumber,
+            startColumn: part.editorRange.endColumn + 1,
+            endColumn: 1000
+        });
         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 shouldRenderFollowupPlaceholder = isFollowupSlashCommand && agentPart.agent.metadata.followupPlaceholder;
             if (agentPart.agent.metadata.description && exactlyOneSpaceAfterPart(agentPart)) {
                 placeholderDecoration = [{
-                        range: {
-                            startLineNumber: agentPart.editorRange.startLineNumber,
-                            endLineNumber: agentPart.editorRange.endLineNumber,
-                            startColumn: agentPart.editorRange.endColumn + 1,
-                            endColumn: 1000
-                        },
+                        range: getRangeForPlaceholder(agentPart),
                         renderOptions: {
                             after: {
-                                contentText: agentPart.agent.metadata.description,
+                                contentText: shouldRenderFollowupPlaceholder ? agentPart.agent.metadata.followupPlaceholder : agentPart.agent.metadata.description,
                                 color: this.getPlaceholderColor(),
                             }
                         }
@@ -164,12 +161,7 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
             const shouldRenderFollowupPlaceholder = isFollowupSlashCommand && agentSubcommandPart.command.followupPlaceholder;
             if (agentSubcommandPart?.command.description && exactlyOneSpaceAfterPart(agentSubcommandPart)) {
                 placeholderDecoration = [{
-                        range: {
-                            startLineNumber: agentSubcommandPart.editorRange.startLineNumber,
-                            endLineNumber: agentSubcommandPart.editorRange.endLineNumber,
-                            startColumn: agentSubcommandPart.editorRange.endColumn + 1,
-                            endColumn: 1000
-                        },
+                        range: getRangeForPlaceholder(agentSubcommandPart),
                         renderOptions: {
                             after: {
                                 contentText: shouldRenderFollowupPlaceholder ? agentSubcommandPart.command.followupPlaceholder : agentSubcommandPart.command.description,
@@ -179,25 +171,6 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
                     }];
             }
         }
-        const onlySlashCommandAndWhitespace = slashCommandPart && parsedRequest.every(p => p instanceof ChatRequestTextPart && !p.text.trim().length || p instanceof ChatRequestSlashCommandPart);
-        if (onlySlashCommandAndWhitespace) {
-            if (slashCommandPart.slashCommand.detail && exactlyOneSpaceAfterPart(slashCommandPart)) {
-                placeholderDecoration = [{
-                        range: {
-                            startLineNumber: slashCommandPart.editorRange.startLineNumber,
-                            endLineNumber: slashCommandPart.editorRange.endLineNumber,
-                            startColumn: slashCommandPart.editorRange.endColumn + 1,
-                            endColumn: 1000
-                        },
-                        renderOptions: {
-                            after: {
-                                contentText: slashCommandPart.slashCommand.detail,
-                                color: this.getPlaceholderColor(),
-                            }
-                        }
-                    }];
-            }
-        }
         this.widget.inputEditor.setDecorationsByType(decorationDescription, placeholderDecorationType, placeholderDecoration ?? []);
         const textDecorations = [];
         if (agentPart) {
@@ -219,43 +192,39 @@ let InputEditorDecorations = class InputEditorDecorations extends Disposable {
     }
 };
 InputEditorDecorations = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, ICodeEditorService)),
-    ( __param(3, IThemeService)),
-    ( __param(4, IChatService)),
-    ( __param(5, IChatAgentService))
+    ( __param(1, ICodeEditorService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IChatAgentService))
 ], InputEditorDecorations));
-let InputEditorSlashCommandMode = class InputEditorSlashCommandMode extends Disposable {
-    constructor(widget, chatService) {
+class InputEditorSlashCommandMode extends Disposable {
+    constructor(widget) {
         super();
         this.widget = widget;
-        this.chatService = chatService;
         this.id = 'InputEditorSlashCommandMode';
-        this._register(this.chatService.onDidSubmitAgent(e => {
-            if (this.widget.viewModel?.sessionId !== e.sessionId) {
-                return;
-            }
+        this._register(this.widget.onDidSubmitAgent(e => {
             this.repopulateAgentCommand(e.agent, e.slashCommand);
         }));
     }
     async repopulateAgentCommand(agent, slashCommand) {
-        if (slashCommand.shouldRepopulate) {
-            const value = `${chatAgentLeader}${agent.id} ${chatSubcommandLeader}${slashCommand.name} `;
+        let value;
+        if (slashCommand && slashCommand.isSticky) {
+            value = `${chatAgentLeader}${agent.id} ${chatSubcommandLeader}${slashCommand.name} `;
+        }
+        else if (agent.metadata.isSticky) {
+            value = `${chatAgentLeader}${agent.id} `;
+        }
+        if (value) {
             this.widget.inputEditor.setValue(value);
             this.widget.inputEditor.setPosition({ lineNumber: 1, column: value.length + 1 });
         }
     }
-};
-InputEditorSlashCommandMode = ( __decorate([
-    ( __param(1, IChatService))
-], InputEditorSlashCommandMode));
+}
 ChatWidget.CONTRIBS.push(InputEditorDecorations, InputEditorSlashCommandMode);
 let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
-    constructor(languageFeaturesService, chatWidgetService, instantiationService, chatSlashCommandService) {
+    constructor(languageFeaturesService, chatWidgetService, chatSlashCommandService) {
         super();
         this.languageFeaturesService = languageFeaturesService;
         this.chatWidgetService = chatWidgetService;
-        this.instantiationService = instantiationService;
         this.chatSlashCommandService = chatSlashCommandService;
         this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
             _debugDisplayName: 'globalSlashCommands',
@@ -269,7 +238,7 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
                 if (!range) {
                     return null;
                 }
-                const parsedRequest = (await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue())).parts;
+                const parsedRequest = widget.parsedInput.parts;
                 const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
                 if (usedAgent) {
                     return;
@@ -299,17 +268,15 @@ let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
 SlashCommandCompletions = ( __decorate([
     ( __param(0, ILanguageFeaturesService)),
     ( __param(1, IChatWidgetService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IChatSlashCommandService))
+    ( __param(2, IChatSlashCommandService))
 ], SlashCommandCompletions));
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(SlashCommandCompletions, 4 );
 let AgentCompletions = class AgentCompletions extends Disposable {
-    constructor(languageFeaturesService, chatWidgetService, chatAgentService, instantiationService) {
+    constructor(languageFeaturesService, chatWidgetService, chatAgentService) {
         super();
         this.languageFeaturesService = languageFeaturesService;
         this.chatWidgetService = chatWidgetService;
         this.chatAgentService = chatAgentService;
-        this.instantiationService = instantiationService;
         this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
             _debugDisplayName: 'chatAgent',
             triggerCharacters: ['@'],
@@ -318,7 +285,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                 if (!widget || !widget.viewModel) {
                     return null;
                 }
-                const parsedRequest = (await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue())).parts;
+                const parsedRequest = widget.parsedInput.parts;
                 const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
                 if (usedAgent && !Range.containsPosition(usedAgent.editorRange, position)) {
                     return;
@@ -336,7 +303,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                             label: withAt,
                             insertText: `${withAt} `,
                             detail: c.metadata.description,
-                            range,
+                            range: ( new Range(1, 1, 1, 1)),
                             kind: 18 ,
                         };
                     }))
@@ -355,7 +322,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                 if (!range) {
                     return null;
                 }
-                const parsedRequest = (await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue())).parts;
+                const parsedRequest = widget.parsedInput.parts;
                 const usedAgentIdx = parsedRequest.findIndex((p) => p instanceof ChatRequestAgentPart);
                 if (usedAgentIdx < 0) {
                     return;
@@ -370,7 +337,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                     }
                 }
                 const usedAgent = parsedRequest[usedAgentIdx];
-                const commands = await usedAgent.agent.provideSlashCommands(token);
+                const commands = await usedAgent.agent.provideSlashCommands(widget.viewModel.model, getHistoryEntriesFromModel(widget.viewModel.model), token);
                 return {
                     suggestions: ( commands.map((c, i) => {
                         const withSlash = `/${c.name}`;
@@ -390,7 +357,8 @@ let AgentCompletions = class AgentCompletions extends Disposable {
             triggerCharacters: ['/'],
             provideCompletionItems: async (model, position, _context, token) => {
                 const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget) {
+                const viewModel = widget?.viewModel;
+                if (!widget || !viewModel) {
                     return;
                 }
                 const range = computeCompletionRanges(model, position, /\/\w*/g);
@@ -398,7 +366,9 @@ let AgentCompletions = class AgentCompletions extends Disposable {
                     return null;
                 }
                 const agents = this.chatAgentService.getAgents();
-                const all = ( agents.map(agent => agent.provideSlashCommands(token)));
+                const all = ( agents.map(
+                    agent => agent.provideSlashCommands(viewModel.model, getHistoryEntriesFromModel(viewModel.model), token)
+                ));
                 const commands = await raceCancellation(Promise.all(all), token);
                 if (!commands) {
                     return;
@@ -439,8 +409,7 @@ let AgentCompletions = class AgentCompletions extends Disposable {
 AgentCompletions = ( __decorate([
     ( __param(0, ILanguageFeaturesService)),
     ( __param(1, IChatWidgetService)),
-    ( __param(2, IChatAgentService)),
-    ( __param(3, IInstantiationService))
+    ( __param(2, IChatAgentService))
 ], AgentCompletions));
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AgentCompletions, 4 );
 let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposable {
@@ -523,12 +492,11 @@ function computeCompletionRanges(model, position, reg) {
 let VariableCompletions = class VariableCompletions extends Disposable {
     static { VariableCompletions_1 = this; }
     static { this.VariableNameDef = ( new RegExp(`${chatVariableLeader}\\w*`, 'g')); }
-    constructor(languageFeaturesService, chatWidgetService, chatVariablesService, configurationService) {
+    constructor(languageFeaturesService, chatWidgetService, chatVariablesService) {
         super();
         this.languageFeaturesService = languageFeaturesService;
         this.chatWidgetService = chatWidgetService;
         this.chatVariablesService = chatVariablesService;
-        this.configurationService = configurationService;
         this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
             _debugDisplayName: 'chatVariables',
             triggerCharacters: [chatVariableLeader],
@@ -541,17 +509,10 @@ let VariableCompletions = class VariableCompletions extends Disposable {
                 if (!range) {
                     return null;
                 }
-                const history = widget.viewModel.getItems()
-                    .filter(isResponseVM);
-                const historyVariablesEnabled = this.configurationService.getValue('chat.experimental.historyVariables');
-                const historyItems = historyVariablesEnabled ? ( history.map((h, i) => ({
-                    label: `${chatVariableLeader}response:${i + 1}`,
-                    detail: h.response.asString(),
-                    insertText: `${chatVariableLeader}response:${String(i + 1).padStart(String(history.length).length, '0')} `,
-                    kind: 18 ,
-                    range,
-                }))) : [];
-                const variableItems = ( Array.from(this.chatVariablesService.getVariables()).map(v => {
+                const usedVariables = widget.parsedInput.parts.filter((p) => p instanceof ChatRequestVariablePart);
+                const variableItems = ( Array.from(this.chatVariablesService.getVariables())
+                    .filter(v => !( usedVariables.some(usedVar => usedVar.variableName === v.name)))
+                    .map(v => {
                     const withLeader = `${chatVariableLeader}${v.name}`;
                     return {
                         label: withLeader,
@@ -563,7 +524,7 @@ let VariableCompletions = class VariableCompletions extends Disposable {
                     };
                 }));
                 return {
-                    suggestions: [...variableItems, ...historyItems]
+                    suggestions: variableItems
                 };
             }
         }));
@@ -572,8 +533,7 @@ let VariableCompletions = class VariableCompletions extends Disposable {
 VariableCompletions = VariableCompletions_1 = ( __decorate([
     ( __param(0, ILanguageFeaturesService)),
     ( __param(1, IChatWidgetService)),
-    ( __param(2, IChatVariablesService)),
-    ( __param(3, IConfigurationService))
+    ( __param(2, IChatVariablesService))
 ], VariableCompletions));
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(VariableCompletions, 4 );
 let ChatTokenDeleter = class ChatTokenDeleter extends Disposable {
@@ -591,24 +551,23 @@ let ChatTokenDeleter = class ChatTokenDeleter extends Disposable {
             }
             const change = e.changes[0];
             if (!change.text && this.widget.viewModel) {
-                parser.parseChatRequest(this.widget.viewModel.sessionId, previousInputValue).then(previousParsedValue => {
-                    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);
-                        if ((deletedRangeOfToken && !deletedRangeOfToken.isEmpty()) && Range.compareRangesUsingStarts(token.editorRange, change.range) < 0) {
-                            const length = deletedRangeOfToken.endColumn - deletedRangeOfToken.startColumn;
-                            const rangeToDelete = ( new Range(
-                                token.editorRange.startLineNumber,
-                                token.editorRange.startColumn,
-                                token.editorRange.endLineNumber,
-                                token.editorRange.endColumn - length
-                            ));
-                            this.widget.inputEditor.executeEdits(this.id, [{
-                                    range: rangeToDelete,
-                                    text: '',
-                                }]);
-                        }
-                    });
+                const previousParsedValue = parser.parseChatRequest(this.widget.viewModel.sessionId, previousInputValue);
+                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);
+                    if (deletedRangeOfToken && Range.compareRangesUsingStarts(token.editorRange, change.range) < 0) {
+                        const length = deletedRangeOfToken.endColumn - deletedRangeOfToken.startColumn;
+                        const rangeToDelete = ( new Range(
+                            token.editorRange.startLineNumber,
+                            token.editorRange.startColumn,
+                            token.editorRange.endLineNumber,
+                            token.editorRange.endColumn - length
+                        ));
+                        this.widget.inputEditor.executeEdits(this.id, [{
+                                range: rangeToDelete,
+                                text: '',
+                            }]);
+                    }
                 });
             }
             previousInputValue = this.widget.inputEditor.getValue();

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

@@ -1,12 +1,17 @@
 import { Color, RGBA } from 'vscode/vscode/vs/base/common/color';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { registerColor, contrastBorder, badgeBackground, badgeForeground, foreground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
+import { registerColor, contrastBorder, transparent, editorBackground, editorWidgetBackground, badgeBackground, badgeForeground, foreground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
 
 registerColor('chat.requestBorder', { dark: ( new Color(( new RGBA(255, 255, 255, 0.10)))), light: ( new Color(( new RGBA(0, 0, 0, 0.10)))), hcDark: contrastBorder, hcLight: contrastBorder, }, ( localizeWithPath(
  'vs/workbench/contrib/chat/common/chatColors',
  'chat.requestBorder',
  'The border color of a chat request.'
 )));
+registerColor('chat.requestBackground', { dark: ( transparent(editorBackground, 0.62)), light: ( transparent(editorBackground, 0.62)), hcDark: editorWidgetBackground, hcLight: null }, ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatColors',
+ 'chat.requestBackground',
+ 'The background color of a chat request.'
+)));
 const chatSlashCommandBackground = registerColor('chat.slashCommandBackground', { dark: '#34414B', light: '#D2ECFF', hcDark: Color.white, hcLight: badgeBackground }, ( localizeWithPath(
  'vs/workbench/contrib/chat/common/chatColors',
  'chat.slashCommandBackground',