@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,1069 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { coalesce } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { isPatternInWord } from '@codingame/monaco-vscode-api/vscode/vs/base/common/filters';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { isCodeEditor, getCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { getWordAtText } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/wordHelper';
+import { CompletionItemKind, SymbolKinds } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { IOutlineModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/contrib/documentSymbols/browser/outlineModel.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { FileKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { EditorsOrder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/history/common/history.service';
+import { LifecyclePhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle';
+import { ISearchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service';
+import { McpPromptArgumentPick } from '../../../mcp/browser/mcpPromptArgumentPick.js';
+import { McpResourceURI } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { IMcpService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service';
+import { searchFilesAndFolders } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/search/browser/searchChatContext';
+import { getFullyQualifiedId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { IChatAgentService, IChatAgentNameService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { getAttachableImageExtension } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { ChatRequestAgentPart, chatSubcommandLeader, chatAgentLeader, ChatRequestAgentSubcommandPart, ChatRequestSlashPromptPart, ChatRequestTextPart, chatVariableLeader, ChatRequestToolPart, ChatRequestToolSetPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service';
+import { ChatAgentLocation, ChatModeKind, isSupportedChatFileScheme } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelToolsService';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { ChatSubmitAction } from '../actions/chatExecuteActions.js';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { resizeImage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/imageUtils';
+import { ChatDynamicVariableModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
+
+var BuiltinDynamicCompletions_1, ToolCompletions_1;
+let SlashCommandCompletions = class SlashCommandCompletions extends Disposable {
+    constructor(languageFeaturesService, chatWidgetService, chatSlashCommandService, promptsService, mcpService) {
+        super();
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatSlashCommandService = chatSlashCommandService;
+        this.promptsService = promptsService;
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'globalSlashCommands',
+            triggerCharacters: [chatSubcommandLeader],
+            provideCompletionItems: async (model, position, _context, _token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.viewModel) {
+                    return null;
+                }
+                if (widget.lockedAgentId) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, /\/\w*/g);
+                if (!range) {
+                    return null;
+                }
+                if (!isEmptyUpToCompletionWord(model, range)) {
+                    return;
+                }
+                const parsedRequest = widget.parsedInput.parts;
+                const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
+                if (usedAgent) {
+                    return;
+                }
+                const slashCommands = this.chatSlashCommandService.getCommands(widget.location, widget.input.currentModeKind);
+                if (!slashCommands) {
+                    return null;
+                }
+                return {
+                    suggestions: ( slashCommands.map((c, i) => {
+                        const withSlash = `/${c.command}`;
+                        return {
+                            label: withSlash,
+                            insertText: c.executeImmediately ? '' : `${withSlash} `,
+                            documentation: c.detail,
+                            range,
+                            sortText: c.sortText ?? 'a'.repeat(i + 1),
+                            kind: CompletionItemKind.Text,
+                            command: c.executeImmediately ? { id: ChatSubmitAction.ID, title: withSlash, arguments: [{ widget, inputValue: `${withSlash} ` }] } : undefined,
+                        };
+                    }))
+                };
+            }
+        }));
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'globalSlashCommandsAt',
+            triggerCharacters: [chatAgentLeader],
+            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;
+                }
+                if (!isEmptyUpToCompletionWord(model, range)) {
+                    return;
+                }
+                const slashCommands = this.chatSlashCommandService.getCommands(widget.location, widget.input.currentModeKind);
+                if (!slashCommands) {
+                    return null;
+                }
+                if (widget.lockedAgentId) {
+                    return null;
+                }
+                return {
+                    suggestions: ( slashCommands.map((c, i) => {
+                        const withSlash = `${chatSubcommandLeader}${c.command}`;
+                        return {
+                            label: withSlash,
+                            insertText: c.executeImmediately ? '' : `${withSlash} `,
+                            documentation: c.detail,
+                            range,
+                            filterText: `${chatAgentLeader}${c.command}`,
+                            sortText: c.sortText ?? 'z'.repeat(i + 1),
+                            kind: CompletionItemKind.Text,
+                            command: c.executeImmediately ? { id: ChatSubmitAction.ID, title: withSlash, arguments: [{ widget, inputValue: `${withSlash} ` }] } : undefined,
+                        };
+                    }))
+                };
+            }
+        }));
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'promptSlashCommands',
+            triggerCharacters: [chatSubcommandLeader],
+            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;
+                }
+                if (!isEmptyUpToCompletionWord(model, range)) {
+                    return;
+                }
+                const parsedRequest = widget.parsedInput.parts;
+                const usedAgent = parsedRequest.find(p => p instanceof ChatRequestAgentPart);
+                if (usedAgent) {
+                    return;
+                }
+                const promptCommands = await this.promptsService.getPromptSlashCommands(token);
+                if (promptCommands.length === 0) {
+                    return null;
+                }
+                if (widget.lockedAgentId) {
+                    return null;
+                }
+                return {
+                    suggestions: ( promptCommands.map((c, i) => {
+                        const label = `/${c.name}`;
+                        const description = c.description;
+                        return {
+                            label: { label, description },
+                            insertText: `${label} `,
+                            documentation: c.description,
+                            range,
+                            sortText: 'a'.repeat(i + 1),
+                            kind: CompletionItemKind.Text,
+                        };
+                    }))
+                };
+            }
+        }));
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'mcpPromptSlashCommands',
+            triggerCharacters: [chatSubcommandLeader],
+            provideCompletionItems: async (model, position, _context, _token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget || !widget.viewModel) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, /\/[a-z0-9_.-]*/g);
+                if (!range) {
+                    return null;
+                }
+                if (!isEmptyUpToCompletionWord(model, range)) {
+                    return;
+                }
+                if (widget.lockedAgentId) {
+                    return null;
+                }
+                return {
+                    suggestions: mcpService.servers.get().flatMap(server => ( server.prompts.get().map((prompt) => {
+                        const label = `/mcp.${prompt.id}`;
+                        return {
+                            label: { label, description: prompt.description },
+                            command: {
+                                id: StartParameterizedPromptAction.ID,
+                                title: prompt.name,
+                                arguments: [model, server, prompt, `${label} `],
+                            },
+                            insertText: `${label} `,
+                            range,
+                            kind: CompletionItemKind.Text,
+                        };
+                    })))
+                };
+            }
+        }));
+    }
+};
+SlashCommandCompletions = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IChatWidgetService)),
+    ( __param(2, IChatSlashCommandService)),
+    ( __param(3, IPromptsService)),
+    ( __param(4, IMcpService))
+], SlashCommandCompletions));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(SlashCommandCompletions, LifecyclePhase.Eventually);
+let AgentCompletions = class AgentCompletions extends Disposable {
+    constructor(languageFeaturesService, chatWidgetService, chatAgentService, chatAgentNameService) {
+        super();
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatAgentService = chatAgentService;
+        this.chatAgentNameService = chatAgentNameService;
+        const subCommandProvider = {
+            _debugDisplayName: 'chatAgentSubcommand',
+            triggerCharacters: [chatSubcommandLeader],
+            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;
+                }
+                const usedAgent = this.getCurrentAgentForWidget(widget);
+                if (!usedAgent || usedAgent.command) {
+                    return;
+                }
+                return {
+                    suggestions: ( usedAgent.agent.slashCommands.map((c, i) => {
+                        const withSlash = `/${c.name}`;
+                        return {
+                            label: withSlash,
+                            insertText: `${withSlash} `,
+                            documentation: c.description,
+                            range,
+                            kind: CompletionItemKind.Text,
+                        };
+                    }))
+                };
+            }
+        };
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, subCommandProvider));
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'chatAgentAndSubcommand',
+            triggerCharacters: [chatAgentLeader],
+            provideCompletionItems: async (model, position, _context, token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                const viewModel = widget?.viewModel;
+                if (!widget || !viewModel) {
+                    return;
+                }
+                if (widget.lockedAgentId) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, /(@|\/)\w*/g);
+                if (!range) {
+                    return null;
+                }
+                if (!isEmptyUpToCompletionWord(model, range)) {
+                    return;
+                }
+                const agents = this.chatAgentService.getAgents()
+                    .filter(a => a.locations.includes(widget.location));
+                const getFilterText = (agent, command) => {
+                    const dummyPrefix = agent.id === 'github.copilot.terminalPanel' ? `0000` : ``;
+                    return `${chatAgentLeader}${dummyPrefix}${agent.name}.${command}`;
+                };
+                const justAgents = ( agents
+                    .filter(a => !a.isDefault)
+                    .map(agent => {
+                    const { label: agentLabel, isDupe } = this.getAgentCompletionDetails(agent);
+                    const detail = agent.description;
+                    return {
+                        label: isDupe ?
+                            { label: agentLabel, description: agent.description, detail: ` (${agent.publisherDisplayName})` } :
+                            agentLabel,
+                        documentation: detail,
+                        filterText: `${chatAgentLeader}${agent.name}`,
+                        insertText: `${agentLabel} `,
+                        range,
+                        kind: CompletionItemKind.Text,
+                        sortText: `${chatAgentLeader}${agent.name}`,
+                        command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
+                    };
+                }));
+                return {
+                    suggestions: justAgents.concat(coalesce(agents.flatMap(agent => ( agent.slashCommands.map((c, i) => {
+                        if (agent.isDefault && this.chatAgentService.getDefaultAgent(widget.location, widget.input.currentModeKind)?.id !== agent.id) {
+                            return;
+                        }
+                        const { label: agentLabel, isDupe } = this.getAgentCompletionDetails(agent);
+                        const label = `${agentLabel} ${chatSubcommandLeader}${c.name}`;
+                        const item = {
+                            label: isDupe ?
+                                { label, description: c.description, detail: isDupe ? ` (${agent.publisherDisplayName})` : undefined } :
+                                label,
+                            documentation: c.description,
+                            filterText: getFilterText(agent, c.name),
+                            commitCharacters: [' '],
+                            insertText: label + ' ',
+                            range,
+                            kind: CompletionItemKind.Text,
+                            sortText: `x${chatAgentLeader}${agent.name}${c.name}`,
+                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
+                        };
+                        if (agent.isDefault) {
+                            const label = `${chatSubcommandLeader}${c.name}`;
+                            item.label = label;
+                            item.insertText = `${label} `;
+                            item.documentation = c.description;
+                        }
+                        return item;
+                    })))))
+                };
+            }
+        }));
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'chatAgentAndSubcommand',
+            triggerCharacters: [chatSubcommandLeader],
+            provideCompletionItems: async (model, position, _context, token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                const viewModel = widget?.viewModel;
+                if (!widget || !viewModel) {
+                    return;
+                }
+                if (widget.lockedAgentId) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, /(@|\/)\w*/g);
+                if (!range) {
+                    return null;
+                }
+                if (!isEmptyUpToCompletionWord(model, range)) {
+                    return;
+                }
+                const agents = this.chatAgentService.getAgents()
+                    .filter(a => a.locations.includes(widget.location) && a.modes.includes(widget.input.currentModeKind));
+                return {
+                    suggestions: coalesce(agents.flatMap(agent => ( agent.slashCommands.map((c, i) => {
+                        if (agent.isDefault && this.chatAgentService.getDefaultAgent(widget.location, widget.input.currentModeKind)?.id !== agent.id) {
+                            return;
+                        }
+                        const { label: agentLabel, isDupe } = this.getAgentCompletionDetails(agent);
+                        const withSlash = `${chatSubcommandLeader}${c.name}`;
+                        const extraSortText = agent.id === 'github.copilot.terminalPanel' ? `z` : ``;
+                        const sortText = `${chatSubcommandLeader}${extraSortText}${agent.name}${c.name}`;
+                        const item = {
+                            label: { label: withSlash, description: agentLabel, detail: isDupe ? ` (${agent.publisherDisplayName})` : undefined },
+                            commitCharacters: [' '],
+                            insertText: `${agentLabel} ${withSlash} `,
+                            documentation: `(${agentLabel}) ${c.description ?? ''}`,
+                            range,
+                            kind: CompletionItemKind.Text,
+                            sortText,
+                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
+                        };
+                        if (agent.isDefault) {
+                            const label = `${chatSubcommandLeader}${c.name}`;
+                            item.label = label;
+                            item.insertText = `${label} `;
+                            item.documentation = c.description;
+                        }
+                        return item;
+                    }))))
+                };
+            }
+        }));
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'installChatExtensions',
+            triggerCharacters: [chatAgentLeader],
+            provideCompletionItems: async (model, position, _context, token) => {
+                if (!model.getLineContent(1).startsWith(chatAgentLeader)) {
+                    return;
+                }
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (widget?.location !== ChatAgentLocation.Chat || widget.input.currentModeKind !== ChatModeKind.Ask) {
+                    return;
+                }
+                if (widget.lockedAgentId) {
+                    return null;
+                }
+                const range = computeCompletionRanges(model, position, /(@|\/)\w*/g);
+                if (!range) {
+                    return;
+                }
+                if (!isEmptyUpToCompletionWord(model, range)) {
+                    return;
+                }
+                const label = ( localize(5687, "Install Chat Extensions..."));
+                const item = {
+                    label,
+                    insertText: '',
+                    range,
+                    kind: CompletionItemKind.Text,
+                    command: { id: 'workbench.extensions.search', title: '', arguments: ['@tag:chat-participant'] },
+                    filterText: chatAgentLeader + label,
+                    sortText: 'zzz'
+                };
+                return {
+                    suggestions: [item]
+                };
+            }
+        }));
+    }
+    getCurrentAgentForWidget(widget) {
+        if (widget.lockedAgentId) {
+            const usedAgent = this.chatAgentService.getAgent(widget.lockedAgentId);
+            return usedAgent && { agent: usedAgent };
+        }
+        const parsedRequest = widget.parsedInput.parts;
+        const usedAgentIdx = parsedRequest.findIndex((p) => p instanceof ChatRequestAgentPart);
+        if (usedAgentIdx < 0) {
+            return;
+        }
+        const usedAgent = parsedRequest[usedAgentIdx];
+        const usedOtherCommand = parsedRequest.find(p => p instanceof ChatRequestAgentSubcommandPart || p instanceof ChatRequestSlashPromptPart);
+        if (usedOtherCommand) {
+            return {
+                agent: usedAgent.agent,
+                command: usedOtherCommand instanceof ChatRequestAgentSubcommandPart ? usedOtherCommand.command.name : undefined
+            };
+        }
+        for (const partAfterAgent of parsedRequest.slice(usedAgentIdx + 1)) {
+            if (!(partAfterAgent instanceof ChatRequestTextPart) || !partAfterAgent.text.trim().match(/^(\/\w*)?$/)) {
+                return;
+            }
+        }
+        return { agent: usedAgent.agent };
+    }
+    getAgentCompletionDetails(agent) {
+        const isAllowed = this.chatAgentNameService.getAgentNameRestriction(agent);
+        const agentLabel = `${chatAgentLeader}${isAllowed ? agent.name : getFullyQualifiedId(agent)}`;
+        const isDupe = isAllowed && this.chatAgentService.agentHasDupeName(agent.id);
+        return { label: agentLabel, isDupe };
+    }
+};
+AgentCompletions = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IChatWidgetService)),
+    ( __param(2, IChatAgentService)),
+    ( __param(3, IChatAgentNameService))
+], AgentCompletions));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(AgentCompletions, LifecyclePhase.Eventually);
+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;
+        }
+        if (!arg.agent.modes.includes(arg.widget.input.currentModeKind)) {
+            arg.widget.input.setChatMode(arg.agent.modes[0]);
+        }
+        arg.widget.lastSelectedAgent = arg.agent;
+    }
+}
+registerAction2(AssignSelectedAgentAction);
+class StartParameterizedPromptAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.startParameterizedPrompt'; }
+    constructor() {
+        super({
+            id: StartParameterizedPromptAction.ID,
+            title: ''
+        });
+    }
+    async run(accessor, model, server, prompt, textToReplace) {
+        if (!model || !prompt) {
+            return;
+        }
+        const instantiationService = accessor.get(IInstantiationService);
+        const notificationService = accessor.get(INotificationService);
+        const widgetService = accessor.get(IChatWidgetService);
+        const fileService = accessor.get(IFileService);
+        const chatWidget = await widgetService.revealWidget(true);
+        if (!chatWidget) {
+            return;
+        }
+        const lastPosition = model.getFullModelRange().collapseToEnd();
+        const getPromptIndex = () => model.findMatches(textToReplace, true, false, true, null, false)[0];
+        const replaceTextWith = (value) => model.applyEdits([{
+                range: getPromptIndex()?.range || lastPosition,
+                text: value,
+            }]);
+        const store = ( new DisposableStore());
+        const cts = store.add(( new CancellationTokenSource()));
+        store.add(chatWidget.input.startGenerating());
+        store.add(model.onDidChangeContent(() => {
+            if (getPromptIndex()) {
+                cts.cancel();
+            }
+        }));
+        model.changeDecorations(accessor => {
+            const id = accessor.addDecoration(lastPosition, {
+                description: 'mcp-prompt-spinner',
+                showIfCollapsed: true,
+                after: {
+                    content: ' ',
+                    inlineClassNameAffectsLetterSpacing: true,
+                    inlineClassName: ThemeIcon.asClassName(ThemeIcon.modify(Codicon.loading, 'spin')) + ' chat-prompt-spinner',
+                }
+            });
+            store.add(toDisposable(() => {
+                model.changeDecorations(a => a.removeDecoration(id));
+            }));
+        });
+        const pick = store.add(instantiationService.createInstance(McpPromptArgumentPick, prompt));
+        try {
+            await server.start();
+            const args = await pick.createArgs();
+            if (!args) {
+                replaceTextWith('');
+                return;
+            }
+            let messages;
+            try {
+                messages = await prompt.resolve(args, cts.token);
+            }
+            catch (e) {
+                if (!cts.token.isCancellationRequested) {
+                    notificationService.error(( localize(5688, "Error resolving prompt: {0}", String(e))));
+                }
+                replaceTextWith('');
+                return;
+            }
+            const toAttach = [];
+            const attachBlob = async (mimeType, contents, uriStr, isText = false) => {
+                let validURI;
+                if (uriStr) {
+                    for (const uri of [( URI.parse(uriStr)), McpResourceURI.fromServer(server.definition, uriStr)]) {
+                        try {
+                            validURI ||= (await fileService.exists(uri)) ? uri : undefined;
+                        }
+                        catch {
+                        }
+                    }
+                }
+                if (isText) {
+                    if (validURI) {
+                        toAttach.push({
+                            id: generateUuid(),
+                            kind: 'file',
+                            value: validURI,
+                            name: basename(validURI),
+                        });
+                    }
+                    else {
+                        toAttach.push({
+                            id: generateUuid(),
+                            kind: 'generic',
+                            value: contents,
+                            name: ( localize(5689, 'Prompt Resource')),
+                        });
+                    }
+                }
+                else if (mimeType && getAttachableImageExtension(mimeType)) {
+                    const resized = await resizeImage(contents)
+                        .catch(() => decodeBase64(contents).buffer);
+                    chatWidget.attachmentModel.addContext({
+                        id: generateUuid(),
+                        name: ( localize(5690, 'Prompt Image')),
+                        fullName: ( localize(5690, 'Prompt Image')),
+                        value: resized,
+                        kind: 'image',
+                        references: validURI && [{ reference: validURI, kind: 'reference' }],
+                    });
+                }
+                else if (validURI) {
+                    toAttach.push({
+                        id: generateUuid(),
+                        kind: 'file',
+                        value: validURI,
+                        name: basename(validURI),
+                    });
+                }
+                else {
+                }
+            };
+            const hasMultipleRoles = ( messages.some(m => m.role !== messages[0].role));
+            let input = '';
+            for (const message of messages) {
+                switch (message.content.type) {
+                    case 'text':
+                        if (input) {
+                            input += '\n\n';
+                        }
+                        if (hasMultipleRoles) {
+                            input += `--${message.role.toUpperCase()}\n`;
+                        }
+                        input += message.content.text;
+                        break;
+                    case 'resource':
+                        if ('text' in message.content.resource) {
+                            await attachBlob(message.content.resource.mimeType, message.content.resource.text, message.content.resource.uri, true);
+                        }
+                        else {
+                            await attachBlob(message.content.resource.mimeType, message.content.resource.blob, message.content.resource.uri);
+                        }
+                        break;
+                    case 'image':
+                    case 'audio':
+                        await attachBlob(message.content.mimeType, message.content.data);
+                        break;
+                }
+            }
+            if (toAttach.length) {
+                chatWidget.attachmentModel.addContext(...toAttach);
+            }
+            replaceTextWith(input);
+        }
+        finally {
+            store.dispose();
+        }
+    }
+}
+registerAction2(StartParameterizedPromptAction);
+class ReferenceArgument {
+    constructor(widget, variable) {
+        this.widget = widget;
+        this.variable = variable;
+    }
+}
+let BuiltinDynamicCompletions = class BuiltinDynamicCompletions extends Disposable {
+    static { BuiltinDynamicCompletions_1 = this; }
+    static { this.addReferenceCommand = '_addReferenceCmd'; }
+    static { this.VariableNameDef = ( new RegExp(`${chatVariableLeader}[\\w:-]*`, 'g')); }
+    constructor(historyService, workspaceContextService, searchService, labelService, languageFeaturesService, chatWidgetService, _chatEditingService, outlineService, editorService, configurationService, codeEditorService, chatAgentService, instantiationService) {
+        super();
+        this.historyService = historyService;
+        this.workspaceContextService = workspaceContextService;
+        this.searchService = searchService;
+        this.labelService = labelService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        this._chatEditingService = _chatEditingService;
+        this.outlineService = outlineService;
+        this.editorService = editorService;
+        this.configurationService = configurationService;
+        this.codeEditorService = codeEditorService;
+        this.chatAgentService = chatAgentService;
+        this.instantiationService = instantiationService;
+        const fileWordPattern = ( new RegExp(`${chatVariableLeader}[^\\s]*`, 'g'));
+        this.registerVariableCompletions('fileAndFolder', async ({ widget, range }, token) => {
+            if (!widget.supportsFileReferences) {
+                return;
+            }
+            const result = { suggestions: [] };
+            if (widget.lockedAgentId) {
+                const agent = this.chatAgentService.getAgent(widget.lockedAgentId);
+                if (agent && !agent.capabilities?.supportsFileAttachments) {
+                    return result;
+                }
+            }
+            await this.addFileAndFolderEntries(widget, result, range, token);
+            return result;
+        }, fileWordPattern);
+        this.registerVariableCompletions('selection', ({ widget, range }, token) => {
+            if (!widget.supportsFileReferences) {
+                return;
+            }
+            if (widget.location === ChatAgentLocation.EditorInline) {
+                return;
+            }
+            const active = this.findActiveCodeEditor();
+            if (!isCodeEditor(active)) {
+                return;
+            }
+            const currentResource = active.getModel()?.uri;
+            const currentSelection = active.getSelection();
+            if (!currentSelection || !currentResource || currentSelection.isEmpty()) {
+                return;
+            }
+            const basename = this.labelService.getUriBasenameLabel(currentResource);
+            const text = `${chatVariableLeader}file:${basename}:${currentSelection.startLineNumber}-${currentSelection.endLineNumber}`;
+            const fullRangeText = `:${currentSelection.startLineNumber}:${currentSelection.startColumn}-${currentSelection.endLineNumber}:${currentSelection.endColumn}`;
+            const description = this.labelService.getUriLabel(currentResource, { relative: true }) + fullRangeText;
+            const result = { suggestions: [] };
+            result.suggestions.push({
+                label: { label: `${chatVariableLeader}selection`, description },
+                filterText: `${chatVariableLeader}selection`,
+                insertText: range.varWord?.endColumn === range.replace.endColumn ? `${text} ` : text,
+                range,
+                kind: CompletionItemKind.Text,
+                sortText: 'z',
+                command: {
+                    id: BuiltinDynamicCompletions_1.addReferenceCommand, title: '', arguments: [( new ReferenceArgument(widget, {
+                            id: 'vscode.selection',
+                            isFile: true,
+                            range: { startLineNumber: range.replace.startLineNumber, startColumn: range.replace.startColumn, endLineNumber: range.replace.endLineNumber, endColumn: range.replace.startColumn + text.length },
+                            data: { range: currentSelection, uri: currentResource }
+                        }))]
+                }
+            });
+            return result;
+        });
+        this.registerVariableCompletions('symbol', ({ widget, range, position, model }, token) => {
+            if (!widget.supportsFileReferences) {
+                return null;
+            }
+            const result = { suggestions: [] };
+            const range2 = computeCompletionRanges(model, position, ( new RegExp(`${chatVariableLeader}[^\\s]*`, 'g')), true);
+            if (range2) {
+                this.addSymbolEntries(widget, result, range2, token);
+            }
+            return result;
+        });
+        this._register(CommandsRegistry.registerCommand(BuiltinDynamicCompletions_1.addReferenceCommand, (_services, arg) => {
+            assertType(arg instanceof ReferenceArgument);
+            return this.cmdAddReference(arg);
+        }));
+    }
+    findActiveCodeEditor() {
+        const codeEditor = this.codeEditorService.getActiveCodeEditor();
+        if (codeEditor) {
+            const model = codeEditor.getModel();
+            if (model?.uri.scheme === Schemas.vscodeNotebookCell) {
+                return undefined;
+            }
+            if (model) {
+                return codeEditor;
+            }
+        }
+        for (const codeOrDiffEditor of this.editorService.getVisibleTextEditorControls(EditorsOrder.MOST_RECENTLY_ACTIVE)) {
+            const codeEditor = getCodeEditor(codeOrDiffEditor);
+            if (!codeEditor) {
+                continue;
+            }
+            const model = codeEditor.getModel();
+            if (model) {
+                return codeEditor;
+            }
+        }
+        return undefined;
+    }
+    registerVariableCompletions(debugName, provider, wordPattern = BuiltinDynamicCompletions_1.VariableNameDef) {
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
+            _debugDisplayName: `chatVarCompletions-${debugName}`,
+            triggerCharacters: [chatVariableLeader],
+            provideCompletionItems: async (model, position, context, token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget) {
+                    return;
+                }
+                const range = computeCompletionRanges(model, position, wordPattern, true);
+                if (range) {
+                    return provider({ model, position, widget, range, context }, token);
+                }
+                return;
+            }
+        }));
+    }
+    async addFileAndFolderEntries(widget, result, info, token) {
+        const makeCompletionItem = (resource, kind, description, boostPriority) => {
+            const basename = this.labelService.getUriBasenameLabel(resource);
+            const text = `${chatVariableLeader}file:${basename}`;
+            const uriLabel = this.labelService.getUriLabel(resource, { relative: true });
+            const labelDescription = description
+                ? ( localize(5691, '{0} ({1})', uriLabel, description))
+                : uriLabel;
+            const sortText = boostPriority ? ' ' : '!';
+            return {
+                label: { label: basename, description: labelDescription },
+                filterText: `${chatVariableLeader}${basename}`,
+                insertText: info.varWord?.endColumn === info.replace.endColumn ? `${text} ` : text,
+                range: info,
+                kind: kind === FileKind.FILE ? CompletionItemKind.File : CompletionItemKind.Folder,
+                sortText,
+                command: {
+                    id: BuiltinDynamicCompletions_1.addReferenceCommand, title: '', arguments: [( new ReferenceArgument(widget, {
+                            id: ( resource.toString()),
+                            isFile: kind === FileKind.FILE,
+                            isDirectory: kind === FileKind.FOLDER,
+                            range: { startLineNumber: info.replace.startLineNumber, startColumn: info.replace.startColumn, endLineNumber: info.replace.endLineNumber, endColumn: info.replace.startColumn + text.length },
+                            data: resource
+                        }))]
+                }
+            };
+        };
+        let pattern;
+        if (info.varWord?.word && info.varWord.word.startsWith(chatVariableLeader)) {
+            pattern = info.varWord.word.toLowerCase().slice(1);
+        }
+        const seen = ( new ResourceSet());
+        const len = result.suggestions.length;
+        for (const [i, item] of this.historyService.getHistory().entries()) {
+            if (!item.resource || ( seen.has(item.resource)) || !this.instantiationService.invokeFunction(accessor => isSupportedChatFileScheme(accessor, item.resource.scheme))) {
+                continue;
+            }
+            if (pattern) {
+                const basename = this.labelService.getUriBasenameLabel(item.resource).toLowerCase();
+                if (!isPatternInWord(pattern, 0, pattern.length, basename, 0, basename.length)) {
+                    continue;
+                }
+            }
+            seen.add(item.resource);
+            const newLen = result.suggestions.push(makeCompletionItem(item.resource, FileKind.FILE, i === 0 ? ( localize(5692, 'Active file')) : undefined, i === 0));
+            if (newLen - len >= 5) {
+                break;
+            }
+        }
+        if (widget.input.currentModeKind !== ChatModeKind.Ask && widget.viewModel && widget.viewModel.model.editingSession) {
+            const relatedFiles = (await raceTimeout(this._chatEditingService.getRelatedFiles(widget.viewModel.sessionResource, widget.getInput(), widget.attachmentModel.fileAttachments, token), 200)) ?? [];
+            for (const relatedFileGroup of relatedFiles) {
+                for (const relatedFile of relatedFileGroup.files) {
+                    if (!( seen.has(relatedFile.uri))) {
+                        seen.add(relatedFile.uri);
+                        result.suggestions.push(makeCompletionItem(relatedFile.uri, FileKind.FILE, relatedFile.description));
+                    }
+                }
+            }
+        }
+        if (pattern) {
+            const cacheKey = this.updateCacheKey();
+            const workspaces = ( this.workspaceContextService.getWorkspace().folders.map(folder => folder.uri));
+            for (const workspace of workspaces) {
+                const { folders, files } = await searchFilesAndFolders(workspace, pattern, true, token, cacheKey.key, this.configurationService, this.searchService);
+                for (const file of files) {
+                    if (!( seen.has(file))) {
+                        result.suggestions.push(makeCompletionItem(file, FileKind.FILE));
+                        seen.add(file);
+                    }
+                }
+                for (const folder of folders) {
+                    if (!( seen.has(folder))) {
+                        result.suggestions.push(makeCompletionItem(folder, FileKind.FOLDER));
+                        seen.add(folder);
+                    }
+                }
+            }
+        }
+        result.incomplete = true;
+    }
+    addSymbolEntries(widget, result, info, token) {
+        const makeSymbolCompletionItem = (symbolItem, pattern) => {
+            const text = `${chatVariableLeader}sym:${symbolItem.name}`;
+            const resource = symbolItem.location.uri;
+            const uriLabel = this.labelService.getUriLabel(resource, { relative: true });
+            const sortText = pattern ? '{'  : '|' ;
+            return {
+                label: { label: symbolItem.name, description: uriLabel },
+                filterText: `${chatVariableLeader}${symbolItem.name}`,
+                insertText: info.varWord?.endColumn === info.replace.endColumn ? `${text} ` : text,
+                range: info,
+                kind: SymbolKinds.toCompletionKind(symbolItem.kind),
+                sortText,
+                command: {
+                    id: BuiltinDynamicCompletions_1.addReferenceCommand, title: '', arguments: [( new ReferenceArgument(widget, {
+                            id: `vscode.symbol/${JSON.stringify(symbolItem.location)}`,
+                            fullName: symbolItem.name,
+                            range: { startLineNumber: info.replace.startLineNumber, startColumn: info.replace.startColumn, endLineNumber: info.replace.endLineNumber, endColumn: info.replace.startColumn + text.length },
+                            data: symbolItem.location,
+                            icon: SymbolKinds.toIcon(symbolItem.kind)
+                        }))]
+                }
+            };
+        };
+        let pattern;
+        if (info.varWord?.word && info.varWord.word.startsWith(chatVariableLeader)) {
+            pattern = info.varWord.word.toLowerCase().slice(1);
+        }
+        const symbolsToAdd = [];
+        for (const outlineModel of this.outlineService.getCachedModels()) {
+            const symbols = outlineModel.asListOfDocumentSymbols();
+            for (const symbol of symbols) {
+                symbolsToAdd.push({ symbol, uri: outlineModel.uri });
+            }
+        }
+        for (const symbol of symbolsToAdd) {
+            result.suggestions.push(makeSymbolCompletionItem({ ...symbol.symbol, location: { uri: symbol.uri, range: symbol.symbol.range } }, pattern ?? ''));
+        }
+        result.incomplete = !!pattern;
+    }
+    updateCacheKey() {
+        if (this.cacheKey && Date.now() - this.cacheKey.time > 60000) {
+            this.searchService.clearCache(this.cacheKey.key);
+            this.cacheKey = undefined;
+        }
+        if (!this.cacheKey) {
+            this.cacheKey = {
+                key: generateUuid(),
+                time: Date.now()
+            };
+        }
+        this.cacheKey.time = Date.now();
+        return this.cacheKey;
+    }
+    cmdAddReference(arg) {
+        arg.widget.getContrib(ChatDynamicVariableModel.ID)?.addReference(arg.variable);
+    }
+};
+BuiltinDynamicCompletions = BuiltinDynamicCompletions_1 = ( __decorate([
+    ( __param(0, IHistoryService)),
+    ( __param(1, IWorkspaceContextService)),
+    ( __param(2, ISearchService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, ILanguageFeaturesService)),
+    ( __param(5, IChatWidgetService)),
+    ( __param(6, IChatEditingService)),
+    ( __param(7, IOutlineModelService)),
+    ( __param(8, IEditorService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, ICodeEditorService)),
+    ( __param(11, IChatAgentService)),
+    ( __param(12, IInstantiationService))
+], BuiltinDynamicCompletions));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BuiltinDynamicCompletions, LifecyclePhase.Eventually);
+function computeCompletionRanges(model, position, reg, onlyOnWordStart = false) {
+    const varWord = getWordAtText(position.column, reg, model.getLineContent(position.lineNumber), 0);
+    if (!varWord && model.getWordUntilPosition(position).word) {
+        return;
+    }
+    if (!varWord && position.column > 1) {
+        const textBefore = model.getValueInRange(( new Range(
+            position.lineNumber,
+            position.column - 1,
+            position.lineNumber,
+            position.column
+        )));
+        if (textBefore !== ' ') {
+            return;
+        }
+    }
+    if (varWord && onlyOnWordStart) {
+        const wordBefore = model.getWordUntilPosition({ lineNumber: position.lineNumber, column: varWord.startColumn });
+        if (wordBefore.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 };
+}
+function isEmptyUpToCompletionWord(model, rangeResult) {
+    const startToCompletionWordStart = ( new Range(1, 1, rangeResult.replace.startLineNumber, rangeResult.replace.startColumn));
+    return !!model.getValueInRange(startToCompletionWordStart).match(/^\s*$/);
+}
+let ToolCompletions = class ToolCompletions extends Disposable {
+    static { ToolCompletions_1 = this; }
+    static { this.VariableNameDef = ( new RegExp(`(?<=^|\\s)${chatVariableLeader}\\w*`, 'g')); }
+    constructor(languageFeaturesService, chatWidgetService, chatAgentService) {
+        super();
+        this.languageFeaturesService = languageFeaturesService;
+        this.chatWidgetService = chatWidgetService;
+        this.chatAgentService = chatAgentService;
+        this._register(this.languageFeaturesService.completionProvider.register({ scheme: Schemas.vscodeChatInput, hasAccessToAllModels: true }, {
+            _debugDisplayName: 'chatVariables',
+            triggerCharacters: [chatVariableLeader],
+            provideCompletionItems: async (model, position, _context, _token) => {
+                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
+                if (!widget) {
+                    return null;
+                }
+                if (widget.lockedAgentId) {
+                    const agent = this.chatAgentService.getAgent(widget.lockedAgentId);
+                    if (agent && !agent.capabilities?.supportsToolAttachments) {
+                        return null;
+                    }
+                }
+                const range = computeCompletionRanges(model, position, ToolCompletions_1.VariableNameDef, true);
+                if (!range) {
+                    return null;
+                }
+                const usedNames = ( new Set());
+                for (const part of widget.parsedInput.parts) {
+                    if (part instanceof ChatRequestToolPart) {
+                        usedNames.add(part.toolName);
+                    }
+                    else if (part instanceof ChatRequestToolSetPart) {
+                        usedNames.add(part.name);
+                    }
+                }
+                const suggestions = [];
+                const iter = widget.input.selectedToolsModel.entriesMap.get();
+                for (const [item, enabled] of iter) {
+                    if (!enabled) {
+                        continue;
+                    }
+                    let detail;
+                    let name;
+                    if (item instanceof ToolSet) {
+                        detail = item.description;
+                        name = item.referenceName;
+                    }
+                    else {
+                        const source = item.source;
+                        detail = ( localize(5693, "{0}: {1}", source.label, item.displayName));
+                        name = item.toolReferenceName ?? item.displayName;
+                    }
+                    if (( usedNames.has(name))) {
+                        continue;
+                    }
+                    const withLeader = `${chatVariableLeader}${name}`;
+                    suggestions.push({
+                        label: withLeader,
+                        range,
+                        detail,
+                        insertText: withLeader + ' ',
+                        kind: CompletionItemKind.Tool,
+                        sortText: 'z',
+                    });
+                }
+                return { suggestions };
+            }
+        }));
+    }
+};
+ToolCompletions = ToolCompletions_1 = ( __decorate([
+    ( __param(0, ILanguageFeaturesService)),
+    ( __param(1, IChatWidgetService)),
+    ( __param(2, IChatAgentService))
+], ToolCompletions));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ToolCompletions, LifecyclePhase.Eventually);
+
+export { computeCompletionRanges };