@codingame/monaco-vscode-chat-service-override 1.85.1

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

@@ -0,0 +1,626 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { raceCancellation } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IProductService } from 'monaco-editor/esm/vs/platform/product/common/productService.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { inputPlaceholderForeground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { SubmitAction } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatExecuteActions';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+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 { chatVariableLeader, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, ChatRequestTextPart, ChatRequestVariablePart, 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';
+const placeholderDecorationType = 'chat-session-detail';
+const slashCommandTextDecorationType = 'chat-session-text';
+const variableTextDecorationType = 'chat-variable-text';
+function agentAndCommandToKey(agent, subcommand) {
+    return `${agent}__${subcommand}`;
+}
+let InputEditorDecorations = class InputEditorDecorations extends Disposable {
+    constructor(widget, instantiationService, codeEditorService, themeService, chatService) {
+        super();
+        this.widget = widget;
+        this.instantiationService = instantiationService;
+        this.codeEditorService = codeEditorService;
+        this.themeService = themeService;
+        this.chatService = chatService;
+        this.id = 'inputEditorDecorations';
+        this.previouslyUsedAgents = ( new Set());
+        this.viewModelDisposables = this._register(( new MutableDisposable()));
+        this.codeEditorService.registerDecorationType(decorationDescription, placeholderDecorationType, {});
+        this._register(this.themeService.onDidColorThemeChange(() => this.updateRegisteredDecorationTypes()));
+        this.updateRegisteredDecorationTypes();
+        this.updateInputEditorDecorations();
+        this._register(this.widget.inputEditor.onDidChangeModelContent(() => this.updateInputEditorDecorations()));
+        this._register(this.widget.onDidChangeViewModel(() => {
+            this.registerViewModelListeners();
+            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.registerViewModelListeners();
+    }
+    registerViewModelListeners() {
+        this.viewModelDisposables.value = this.widget.viewModel?.onDidChange(e => {
+            if (e?.kind === 'changePlaceholder' || e?.kind === 'initialize') {
+                this.updateInputEditorDecorations();
+            }
+        });
+    }
+    updateRegisteredDecorationTypes() {
+        this.codeEditorService.removeDecorationType(variableTextDecorationType);
+        this.codeEditorService.removeDecorationType(dynamicVariableDecorationType);
+        this.codeEditorService.removeDecorationType(slashCommandTextDecorationType);
+        const theme = this.themeService.getColorTheme();
+        this.codeEditorService.registerDecorationType(decorationDescription, slashCommandTextDecorationType, {
+            color: theme.getColor(chatSlashCommandForeground)?.toString(),
+            backgroundColor: theme.getColor(chatSlashCommandBackground)?.toString(),
+            borderRadius: '3px'
+        });
+        this.codeEditorService.registerDecorationType(decorationDescription, variableTextDecorationType, {
+            color: theme.getColor(chatSlashCommandForeground)?.toString(),
+            backgroundColor: theme.getColor(chatSlashCommandBackground)?.toString(),
+            borderRadius: '3px'
+        });
+        this.codeEditorService.registerDecorationType(decorationDescription, dynamicVariableDecorationType, {
+            color: theme.getColor(chatSlashCommandForeground)?.toString(),
+            backgroundColor: theme.getColor(chatSlashCommandBackground)?.toString(),
+            borderRadius: '3px'
+        });
+        this.updateInputEditorDecorations();
+    }
+    getPlaceholderColor() {
+        const theme = this.themeService.getColorTheme();
+        const transparentForeground = theme.getColor(inputPlaceholderForeground);
+        return transparentForeground?.toString();
+    }
+    async updateInputEditorDecorations() {
+        const inputValue = this.widget.inputEditor.getValue();
+        const viewModel = this.widget.viewModel;
+        if (!viewModel) {
+            return;
+        }
+        if (!inputValue) {
+            const viewModelPlaceholder = this.widget.viewModel?.inputPlaceholder;
+            const placeholder = viewModelPlaceholder ?? '';
+            const decoration = [
+                {
+                    range: {
+                        startLineNumber: 1,
+                        endLineNumber: 1,
+                        startColumn: 1,
+                        endColumn: 1000
+                    },
+                    renderOptions: {
+                        after: {
+                            contentText: placeholder,
+                            color: this.getPlaceholderColor()
+                        }
+                    }
+                }
+            ];
+            this.widget.inputEditor.setDecorationsByType(decorationDescription, placeholderDecorationType, decoration);
+            return;
+        }
+        const parsedRequest = (await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(viewModel.sessionId, inputValue)).parts;
+        let placeholderDecoration;
+        const agentPart = parsedRequest.find((p) => p instanceof ChatRequestAgentPart);
+        const agentSubcommandPart = parsedRequest.find((p) => p instanceof ChatRequestAgentSubcommandPart);
+        const slashCommandPart = parsedRequest.find((p) => p instanceof ChatRequestSlashCommandPart);
+        const exactlyOneSpaceAfterPart = (part) => {
+            const partIdx = parsedRequest.indexOf(part);
+            if (parsedRequest.length > partIdx + 2) {
+                return false;
+            }
+            const nextPart = parsedRequest[partIdx + 1];
+            return nextPart && nextPart instanceof ChatRequestTextPart && nextPart.text === ' ';
+        };
+        const onlyAgentAndWhitespace = agentPart && parsedRequest.every(p => p instanceof ChatRequestTextPart && !p.text.trim().length || p instanceof ChatRequestAgentPart);
+        if (onlyAgentAndWhitespace) {
+            if (agentPart.agent.metadata.description && exactlyOneSpaceAfterPart(agentPart)) {
+                placeholderDecoration = [{
+                        range: {
+                            startLineNumber: agentPart.editorRange.startLineNumber,
+                            endLineNumber: agentPart.editorRange.endLineNumber,
+                            startColumn: agentPart.editorRange.endColumn + 1,
+                            endColumn: 1000
+                        },
+                        renderOptions: {
+                            after: {
+                                contentText: agentPart.agent.metadata.description,
+                                color: this.getPlaceholderColor(),
+                            }
+                        }
+                    }];
+            }
+        }
+        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 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
+                        },
+                        renderOptions: {
+                            after: {
+                                contentText: shouldRenderFollowupPlaceholder ? agentSubcommandPart.command.followupPlaceholder : agentSubcommandPart.command.description,
+                                color: this.getPlaceholderColor(),
+                            }
+                        }
+                    }];
+            }
+        }
+        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) {
+            textDecorations.push({ range: agentPart.editorRange });
+            if (agentSubcommandPart) {
+                textDecorations.push({ range: agentSubcommandPart.editorRange });
+            }
+        }
+        if (slashCommandPart) {
+            textDecorations.push({ range: slashCommandPart.editorRange });
+        }
+        this.widget.inputEditor.setDecorationsByType(decorationDescription, slashCommandTextDecorationType, textDecorations);
+        const varDecorations = [];
+        const variableParts = parsedRequest.filter((p) => p instanceof ChatRequestVariablePart);
+        for (const variable of variableParts) {
+            varDecorations.push({ range: variable.editorRange });
+        }
+        this.widget.inputEditor.setDecorationsByType(decorationDescription, variableTextDecorationType, varDecorations);
+    }
+};
+InputEditorDecorations = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ICodeEditorService)),
+    ( __param(3, IThemeService)),
+    ( __param(4, IChatService))
+], InputEditorDecorations));
+let InputEditorSlashCommandMode = class InputEditorSlashCommandMode extends Disposable {
+    constructor(widget, chatService) {
+        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.repopulateAgentCommand(e.agent, e.slashCommand);
+        }));
+    }
+    async repopulateAgentCommand(agent, slashCommand) {
+        if (slashCommand.shouldRepopulate) {
+            const value = `${chatAgentLeader}${agent.id} ${chatSubcommandLeader}${slashCommand.name} `;
+            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) {
+        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',
+            triggerCharacters: ['/'],
+            provideCompletionItems: async (model, position, _context, _token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.viewModel) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, /\/\w*/g);
+                if (!range) {
+                    return null;
+                }
+                const parsedRequest = (await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue())).parts;
+                const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
+                if (usedAgent) {
+                    return;
+                }
+                const slashCommands = this.chatSlashCommandService.getCommands();
+                if (!slashCommands) {
+                    return null;
+                }
+                return {
+                    suggestions: ( slashCommands.map((c, i) => {
+                        const withSlash = `/${c.command}`;
+                        return {
+                            label: withSlash,
+                            insertText: c.executeImmediately ? '' : `${withSlash} `,
+                            detail: c.detail,
+                            range: ( new Range(1, 1, 1, 1)),
+                            sortText: c.sortText ?? 'a'.repeat(i + 1),
+                            kind: 18 ,
+                            command: c.executeImmediately ? { id: SubmitAction.ID, title: withSlash, arguments: [{ widget, inputValue: `${withSlash} ` }] } : undefined,
+                        };
+                    }))
+                };
+            }
+        }));
+    }
+};
+SlashCommandCompletions = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IChatWidgetService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IChatSlashCommandService))
+], SlashCommandCompletions));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(SlashCommandCompletions, 4 );
+let AgentCompletions = class AgentCompletions extends Disposable {
+    constructor(languageFeaturesService, chatWidgetService, chatAgentService, instantiationService) {
+        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: ['@'],
+            provideCompletionItems: async (model, position, _context, _token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.viewModel) {
+                    return null;
+                }
+                const parsedRequest = (await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue())).parts;
+                const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
+                if (usedAgent && !Range.containsPosition(usedAgent.editorRange, position)) {
+                    return;
+                }
+                const range = computeCompletionRanges(model, position, /@\w*/g);
+                if (!range) {
+                    return null;
+                }
+                const agents = this.chatAgentService.getAgents()
+                    .filter(a => !a.metadata.isDefault);
+                return {
+                    suggestions: ( agents.map((c, i) => {
+                        const withAt = `@${c.id}`;
+                        return {
+                            label: withAt,
+                            insertText: `${withAt} `,
+                            detail: c.metadata.description,
+                            range,
+                            kind: 18 ,
+                        };
+                    }))
+                };
+            }
+        }));
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'chatAgentSubcommand',
+            triggerCharacters: ['/'],
+            provideCompletionItems: async (model, position, _context, token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.viewModel) {
+                    return;
+                }
+                const range = computeCompletionRanges(model, position, /\/\w*/g);
+                if (!range) {
+                    return null;
+                }
+                const parsedRequest = (await this.instantiationService.createInstance(ChatRequestParser).parseChatRequest(widget.viewModel.sessionId, model.getValue())).parts;
+                const usedAgentIdx = parsedRequest.findIndex((p) => p instanceof ChatRequestAgentPart);
+                if (usedAgentIdx < 0) {
+                    return;
+                }
+                const usedSubcommand = parsedRequest.find(p => p instanceof ChatRequestAgentSubcommandPart);
+                if (usedSubcommand) {
+                    return;
+                }
+                for (const partAfterAgent of parsedRequest.slice(usedAgentIdx + 1)) {
+                    if (!(partAfterAgent instanceof ChatRequestTextPart) || !partAfterAgent.text.trim().match(/^(\/\w*)?$/)) {
+                        return;
+                    }
+                }
+                const usedAgent = parsedRequest[usedAgentIdx];
+                const commands = await usedAgent.agent.provideSlashCommands(token);
+                return {
+                    suggestions: ( commands.map((c, i) => {
+                        const withSlash = `/${c.name}`;
+                        return {
+                            label: withSlash,
+                            insertText: `${withSlash} `,
+                            detail: c.description,
+                            range,
+                            kind: 18 ,
+                        };
+                    }))
+                };
+            }
+        }));
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'chatAgentAndSubcommand',
+            triggerCharacters: ['/'],
+            provideCompletionItems: async (model, position, _context, token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget) {
+                    return;
+                }
+                const range = computeCompletionRanges(model, position, /\/\w*/g);
+                if (!range) {
+                    return null;
+                }
+                const agents = this.chatAgentService.getAgents();
+                const all = ( agents.map(agent => agent.provideSlashCommands(token)));
+                const commands = await raceCancellation(Promise.all(all), token);
+                if (!commands) {
+                    return;
+                }
+                const justAgents = ( agents
+                    .filter(a => !a.metadata.isDefault)
+                    .map(agent => {
+                    const agentLabel = `${chatAgentLeader}${agent.id}`;
+                    return {
+                        label: { label: agentLabel, description: agent.metadata.description },
+                        filterText: `${chatSubcommandLeader}${agent.id}`,
+                        insertText: `${agentLabel} `,
+                        range: ( new Range(1, 1, 1, 1)),
+                        kind: 18 ,
+                        sortText: `${chatSubcommandLeader}${agent.id}`,
+                    };
+                }));
+                return {
+                    suggestions: justAgents.concat(agents.flatMap((agent, i) => ( commands[i].map((c, i) => {
+                        const agentLabel = `${chatAgentLeader}${agent.id}`;
+                        const withSlash = `${chatSubcommandLeader}${c.name}`;
+                        return {
+                            label: { label: withSlash, description: agentLabel },
+                            filterText: `${chatSubcommandLeader}${agent.id}${c.name}`,
+                            insertText: `${agentLabel} ${withSlash} `,
+                            detail: `(${agentLabel}) ${c.description}`,
+                            range: ( new Range(1, 1, 1, 1)),
+                            kind: 18 ,
+                            sortText: `${chatSubcommandLeader}${agent.id}${c.name}`,
+                        };
+                    }))))
+                };
+            }
+        }));
+    }
+};
+AgentCompletions = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IChatWidgetService)),
+    ( __param(2, IChatAgentService)),
+    ( __param(3, IInstantiationService))
+], AgentCompletions));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AgentCompletions, 4 );
+let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposable {
+    static { BuiltinDynamicCompletions_1 = this; }
+    static { this.VariableNameDef = ( new RegExp(`${chatVariableLeader}\\w*`, 'g')); }
+    constructor(languageFeaturesService, chatWidgetService, configurationService, productService) {
+        super();
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        this.configurationService = configurationService;
+        this.productService = productService;
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'chatDynamicCompletions',
+            triggerCharacters: [chatVariableLeader],
+            provideCompletionItems: async (model, position, _context, _token) => {
+                const fileVariablesEnabled = this.configurationService.getValue('chat.experimental.fileVariables') ?? this.productService.quality !== 'stable';
+                if (!fileVariablesEnabled) {
+                    return;
+                }
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.supportsFileReferences) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, BuiltinDynamicCompletions_1.VariableNameDef);
+                if (!range) {
+                    return null;
+                }
+                const afterRange = ( new Range(
+                    position.lineNumber,
+                    range.replace.startColumn,
+                    position.lineNumber,
+                    range.replace.endColumn + 'file:'.length
+                ));
+                return {
+                    suggestions: [
+                        {
+                            label: `${chatVariableLeader}file`,
+                            insertText: `${chatVariableLeader}file:`,
+                            detail: ( localizeWithPath(
+                                'vs/workbench/contrib/chat/browser/contrib/chatInputEditorContrib',
+                                'pickFileLabel',
+                                "Pick a file"
+                            )),
+                            range,
+                            kind: 18 ,
+                            command: { id: SelectAndInsertFileAction.ID, title: SelectAndInsertFileAction.ID, arguments: [{ widget, range: afterRange }] },
+                            sortText: 'z'
+                        }
+                    ]
+                };
+            }
+        }));
+    }
+};
+BuiltinDynamicCompletions = BuiltinDynamicCompletions_1 = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IChatWidgetService)),
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IProductService))
+], BuiltinDynamicCompletions));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BuiltinDynamicCompletions, 4 );
+function computeCompletionRanges(model, position, reg) {
+    const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
+    if (!varWord && model.getWordUntilPosition(position).word) {
+        return;
+    }
+    let insert;
+    let replace;
+    if (!varWord) {
+        insert = replace = Range.fromPositions(position);
+    }
+    else {
+        insert = ( new Range(
+            position.lineNumber,
+            varWord.startColumn,
+            position.lineNumber,
+            position.column
+        ));
+        replace = ( new Range(
+            position.lineNumber,
+            varWord.startColumn,
+            position.lineNumber,
+            varWord.endColumn
+        ));
+    }
+    return { insert, replace, varWord };
+}
+let VariableCompletions = class VariableCompletions extends Disposable {
+    static { VariableCompletions_1 = this; }
+    static { this.VariableNameDef = ( new RegExp(`${chatVariableLeader}\\w*`, 'g')); }
+    constructor(languageFeaturesService, chatWidgetService, chatVariablesService, configurationService) {
+        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],
+            provideCompletionItems: async (model, position, _context, _token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, VariableCompletions_1.VariableNameDef);
+                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 withLeader = `${chatVariableLeader}${v.name}`;
+                    return {
+                        label: withLeader,
+                        range,
+                        insertText: withLeader + ' ',
+                        detail: v.description,
+                        kind: 18 ,
+                        sortText: 'z'
+                    };
+                }));
+                return {
+                    suggestions: [...variableItems, ...historyItems]
+                };
+            }
+        }));
+    }
+};
+VariableCompletions = VariableCompletions_1 = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IChatWidgetService)),
+    ( __param(2, IChatVariablesService)),
+    ( __param(3, IConfigurationService))
+], VariableCompletions));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(VariableCompletions, 4 );
+let ChatTokenDeleter = class ChatTokenDeleter extends Disposable {
+    constructor(widget, instantiationService) {
+        super();
+        this.widget = widget;
+        this.instantiationService = instantiationService;
+        this.id = 'chatTokenDeleter';
+        const parser = this.instantiationService.createInstance(ChatRequestParser);
+        const inputValue = this.widget.inputEditor.getValue();
+        let previousInputValue;
+        this.widget.inputEditor.onDidChangeModelContent(e => {
+            if (!previousInputValue) {
+                previousInputValue = inputValue;
+            }
+            const change = e.changes[0];
+            if (!change.text) {
+                parser.parseChatRequest(this.widget.viewModel.sessionId, previousInputValue).then(previousParsedValue => {
+                    const deletableTokens = previousParsedValue.parts.filter(p => p instanceof ChatRequestAgentPart || p instanceof ChatRequestAgentSubcommandPart || p instanceof ChatRequestSlashCommandPart);
+                    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: '',
+                                }]);
+                        }
+                    });
+                });
+            }
+            previousInputValue = this.widget.inputEditor.getValue();
+        });
+    }
+};
+ChatTokenDeleter = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ChatTokenDeleter));
+ChatWidget.CONTRIBS.push(ChatTokenDeleter);

package/vscode/src/vs/workbench/contrib/chat/browser/media/chatEditor.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".show-file-icons .chat-editor-label.file-icon:before,.vs .show-file-icons .chat-editor-label.file-icon:before{content:\"\\EAC7\";font-family:codicon;font-size:16px}";
+n(css,{});
+
+export { css, css as default };

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

@@ -0,0 +1,31 @@
+import { Color, RGBA } from 'monaco-editor/esm/vs/base/common/color.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerColor, contrastBorder, badgeBackground, badgeForeground, foreground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+
+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.'
+)));
+const chatSlashCommandBackground = registerColor('chat.slashCommandBackground', { dark: '#34414B', light: '#D2ECFF', hcDark: Color.white, hcLight: badgeBackground }, ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatColors',
+ 'chat.slashCommandBackground',
+ 'The background color of a chat slash command.'
+)));
+const chatSlashCommandForeground = registerColor('chat.slashCommandForeground', { dark: '#40A6FF', light: '#306CA2', hcDark: Color.black, hcLight: badgeForeground }, ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatColors',
+ 'chat.slashCommandForeground',
+ 'The foreground color of a chat slash command.'
+)));
+registerColor('chat.avatarBackground', { dark: '#1f1f1f', light: '#f2f2f2', hcDark: Color.black, hcLight: Color.white, }, ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatColors',
+ 'chat.avatarBackground',
+ 'The background color of a chat avatar.'
+)));
+registerColor('chat.avatarForeground', { dark: foreground, light: foreground, hcDark: foreground, hcLight: foreground, }, ( localizeWithPath(
+ 'vs/workbench/contrib/chat/common/chatColors',
+ 'chat.avatarForeground',
+ 'The foreground color of a chat avatar.'
+)));
+
+export { chatSlashCommandBackground, chatSlashCommandForeground };