@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,617 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import { ICodeEditorService } from '../../../../../editor/browser/services/codeEditorService.js';
+import { Range } from '../../../../../editor/common/core/range.js';
+import { getWordAtText } from '../../../../../editor/common/core/wordHelper.js';
+import { ILanguageFeaturesService } from '../../../../../editor/common/services/languageFeatures.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { Action2, registerAction2 } from '../../../../../platform/actions/common/actions.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { Registry } from '../../../../../platform/registry/common/platform.js';
+import '../../../../../platform/theme/common/colorUtils.js';
+import '../../../../../platform/theme/common/colors/baseColors.js';
+import '../../../../../platform/theme/common/colors/chartsColors.js';
+import '../../../../../platform/theme/common/colors/editorColors.js';
+import { inputPlaceholderForeground } from '../../../../../platform/theme/common/colors/inputColors.js';
+import '../../../../../platform/theme/common/colors/listColors.js';
+import '../../../../../platform/theme/common/colors/menuColors.js';
+import '../../../../../platform/theme/common/colors/minimapColors.js';
+import '../../../../../platform/theme/common/colors/miscColors.js';
+import '../../../../../platform/theme/common/colors/quickpickColors.js';
+import '../../../../../platform/theme/common/colors/searchColors.js';
+import { IThemeService } from '../../../../../platform/theme/common/themeService.js';
+import { Extensions } from '../../../../common/contributions.js';
+import { SubmitAction } from '../actions/chatExecuteActions.js';
+import { IChatWidgetService } from '../chat.js';
+import { ChatInputPart } from '../chatInputPart.js';
+import { ChatWidget } from '../chatWidget.js';
+import { SelectAndInsertFileAction, dynamicVariableDecorationType } from './chatDynamicVariables.js';
+import { ChatAgentLocation, IChatAgentService } from '../../common/chatAgents.js';
+import { chatSlashCommandForeground, chatSlashCommandBackground } from '../../common/chatColors.js';
+import { chatVariableLeader, ChatRequestVariablePart, ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestSlashCommandPart, ChatRequestTextPart, chatSubcommandLeader, chatAgentLeader } from '../../common/chatParserTypes.js';
+import { ChatRequestParser } from '../../common/chatRequestParser.js';
+import { IChatSlashCommandService } from '../../common/chatSlashCommands.js';
+import { IChatVariablesService } from '../../common/chatVariables.js';
+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 subcommand ? `${agent.id}__${subcommand}` : agent.id;
+}
+let InputEditorDecorations = class InputEditorDecorations extends Disposable {
+    constructor(widget, codeEditorService, themeService, chatAgentService) {
+        super();
+        this.widget = widget;
+        this.codeEditorService = codeEditorService;
+        this.themeService = themeService;
+        this.chatAgentService = chatAgentService;
+        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.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, e.slashCommand?.name));
+        }));
+        this._register(this.chatAgentService.onDidChangeAgents(() => this.updateInputEditorDecorations()));
+        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 defaultAgent = this.chatAgentService.getDefaultAgent(this.widget.location);
+            const decoration = [
+                {
+                    range: {
+                        startLineNumber: 1,
+                        endLineNumber: 1,
+                        startColumn: 1,
+                        endColumn: 1000
+                    },
+                    renderOptions: {
+                        after: {
+                            contentText: viewModel.inputPlaceholder ?? defaultAgent?.description ?? '',
+                            color: this.getPlaceholderColor()
+                        }
+                    }
+                }
+            ];
+            this.widget.inputEditor.setDecorationsByType(decorationDescription, placeholderDecorationType, decoration);
+            return;
+        }
+        const parsedRequest = this.widget.parsedInput.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 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, undefined)));
+            const shouldRenderFollowupPlaceholder = isFollowupSlashCommand && agentPart.agent.metadata.followupPlaceholder;
+            if (agentPart.agent.description && exactlyOneSpaceAfterPart(agentPart)) {
+                placeholderDecoration = [{
+                        range: getRangeForPlaceholder(agentPart),
+                        renderOptions: {
+                            after: {
+                                contentText: shouldRenderFollowupPlaceholder ? agentPart.agent.metadata.followupPlaceholder : agentPart.agent.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, agentSubcommandPart.command.name)));
+            const shouldRenderFollowupPlaceholder = isFollowupSlashCommand && agentSubcommandPart.command.followupPlaceholder;
+            if (agentSubcommandPart?.command.description && exactlyOneSpaceAfterPart(agentSubcommandPart)) {
+                placeholderDecoration = [{
+                        range: getRangeForPlaceholder(agentSubcommandPart),
+                        renderOptions: {
+                            after: {
+                                contentText: shouldRenderFollowupPlaceholder ? agentSubcommandPart.command.followupPlaceholder : agentSubcommandPart.command.description,
+                                color: this.getPlaceholderColor(),
+                            }
+                        }
+                    }];
+            }
+        }
+        this.widget.inputEditor.setDecorationsByType(decorationDescription, placeholderDecorationType, placeholderDecoration ?? []);
+        const textDecorations = [];
+        if (agentPart) {
+            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, hoverMessage: ( new MarkdownString(agentSubcommandPart.command.description)) });
+            }
+        }
+        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, ICodeEditorService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IChatAgentService))
+], InputEditorDecorations));
+class InputEditorSlashCommandMode extends Disposable {
+    constructor(widget) {
+        super();
+        this.widget = widget;
+        this.id = 'InputEditorSlashCommandMode';
+        this._register(this.widget.onDidSubmitAgent(e => {
+            this.repopulateAgentCommand(e.agent, e.slashCommand);
+        }));
+    }
+    async repopulateAgentCommand(agent, slashCommand) {
+        let value;
+        if (slashCommand && slashCommand.isSticky) {
+            value = `${chatAgentLeader}${agent.name} ${chatSubcommandLeader}${slashCommand.name} `;
+        }
+        else if (agent.metadata.isSticky) {
+            value = `${chatAgentLeader}${agent.name} `;
+        }
+        if (value) {
+            this.widget.inputEditor.setValue(value);
+            this.widget.inputEditor.setPosition({ lineNumber: 1, column: value.length + 1 });
+        }
+    }
+}
+ChatWidget.CONTRIBS.push(InputEditorDecorations, InputEditorSlashCommandMode);
+let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
+    constructor(languageFeaturesService, chatWidgetService, chatSlashCommandService) {
+        super();
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        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 || widget.location !== ChatAgentLocation.Panel ) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, /\/\w*/g);
+                if (!range) {
+                    return null;
+                }
+                const parsedRequest = widget.parsedInput.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, IChatSlashCommandService))
+], SlashCommandCompletions));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(SlashCommandCompletions, 4 );
+let AgentCompletions = class AgentCompletions extends Disposable {
+    constructor(languageFeaturesService, chatWidgetService, chatAgentService) {
+        super();
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatAgentService = chatAgentService;
+        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 || widget.location !== ChatAgentLocation.Panel ) {
+                    return null;
+                }
+                const parsedRequest = widget.parsedInput.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.isDefault)
+                    .filter(a => a.locations.includes(widget.location));
+                return {
+                    suggestions: ( agents.map((a, i) => {
+                        const withAt = `@${a.name}`;
+                        const isDupe = !!agents.find(other => other.name === a.name && other.id !== a.id);
+                        return {
+                            label: isDupe ?
+                                { label: withAt, description: a.description, detail: ` (${a.id})` } :
+                                withAt,
+                            insertText: `${withAt} `,
+                            detail: a.description,
+                            range: ( new Range(1, 1, 1, 1)),
+                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent: a, widget }] },
+                            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 || widget.location !== ChatAgentLocation.Panel ) {
+                    return;
+                }
+                const range = computeCompletionRanges(model, position, /\/\w*/g);
+                if (!range) {
+                    return null;
+                }
+                const parsedRequest = widget.parsedInput.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];
+                return {
+                    suggestions: ( usedAgent.agent.slashCommands.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);
+                const viewModel = 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()
+                    .filter(a => a.locations.includes(widget.location));
+                const justAgents = ( agents
+                    .filter(a => !a.isDefault)
+                    .map(agent => {
+                    const isDupe = !!agents.find(other => other.name === agent.name && other.id !== agent.id);
+                    const detail = agent.description;
+                    const agentLabel = `${chatAgentLeader}${agent.name}`;
+                    return {
+                        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 => ( agent.slashCommands.map((c, i) => {
+                        const agentLabel = `${chatAgentLeader}${agent.name}`;
+                        const withSlash = `${chatSubcommandLeader}${c.name}`;
+                        return {
+                            label: { label: withSlash, description: agentLabel },
+                            filterText: `${chatSubcommandLeader}${agent.name}${c.name}`,
+                            commitCharacters: [' '],
+                            insertText: `${agentLabel} ${withSlash} `,
+                            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 }] },
+                        };
+                    }))))
+                };
+            }
+        }));
+    }
+};
+AgentCompletions = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IChatWidgetService)),
+    ( __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')); }
+    constructor(languageFeaturesService, chatWidgetService) {
+        super();
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: ChatInputPart.INPUT_SCHEME, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'chatDynamicCompletions',
+            triggerCharacters: [chatVariableLeader],
+            provideCompletionItems: async (model, position, _context, _token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.supportsFileReferences || widget.location !== ChatAgentLocation.Panel ) {
+                    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.startColumn + '#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))
+], 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) {
+        super();
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatVariablesService = chatVariablesService;
+        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 || widget.location !== ChatAgentLocation.Panel ) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, VariableCompletions_1.VariableNameDef);
+                if (!range) {
+                    return null;
+                }
+                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,
+                        range,
+                        insertText: withLeader + ' ',
+                        detail: v.description,
+                        kind: 18 ,
+                        sortText: 'z'
+                    };
+                }));
+                return {
+                    suggestions: variableItems
+                };
+            }
+        }));
+    }
+};
+VariableCompletions = VariableCompletions_1 = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IChatWidgetService)),
+    ( __param(2, IChatVariablesService))
+], 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;
+        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, 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);
+                    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();
+            previousSelectedAgent = this.widget.lastSelectedAgent;
+        }));
+    }
+};
+ChatTokenDeleter = ( __decorate([
+    ( __param(1, IInstantiationService))
+], ChatTokenDeleter));
+ChatWidget.CONTRIBS.push(ChatTokenDeleter);

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

@@ -26,4 +26,5 @@ var ChatCopyKind;
     ChatCopyKind[ChatCopyKind["Toolbar"] = 2] = "Toolbar";
 })(ChatCopyKind || (ChatCopyKind = {})));
 const IChatService = ( createDecorator('IChatService'));
-export { ChatCopyKind, IChatService, InteractiveSessionVoteDirection, isIDocumentContext, isIUsedContext };
+const KEYWORD_ACTIVIATION_SETTING_ID = 'accessibility.voice.keywordActivation';
+export { ChatCopyKind, IChatService, InteractiveSessionVoteDirection, KEYWORD_ACTIVIATION_SETTING_ID, isIDocumentContext, isIUsedContext };