@codingame/monaco-vscode-chat-service-override 9.0.2 → 10.0.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatCurrentLine.js

@@ -1,11 +1,10 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { DisposableStore, MutableDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { CursorChangeReason } from 'vscode/vscode/vs/editor/common/cursorEvents';
 import { localize, localize2 } from 'vscode/vscode/vs/nls';
 import { RawContextKey, ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { InlineChatController, State } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
 import { CTX_INLINE_CHAT_VISIBLE, CTX_INLINE_CHAT_HAS_AGENT } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
 import { EditorAction2 } from 'vscode/vscode/vs/editor/browser/editorExtensions';
 import { EditOperation } from 'vscode/vscode/vs/editor/common/core/editOperation';
@@ -15,7 +14,7 @@ import { AbstractInlineChatAction } from 'vscode/vscode/vs/workbench/contrib/inl
 import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
 
 const CTX_INLINE_CHAT_EXPANSION = ( (new RawContextKey('inlineChatExpansion', false, ( localize(
-    7200,
+    7267,
     "Whether the inline chat expansion is enabled when at the end of a just-typed line"
 )))));
 let InlineChatExansionContextKey = class InlineChatExansionContextKey {
@@ -47,7 +46,7 @@ let InlineChatExansionContextKey = class InlineChatExansionContextKey {
         const lastChangeEnds = [];
         store.add(editor.onDidChangeCursorPosition(e => {
             let enabled = false;
-            if (e.reason === CursorChangeReason.NotSet) {
+            if (e.reason === 0 ) {
                 const position = editor.getPosition();
                 const positionOffset = model.getOffsetAt(position);
                 const lineLength = model.getLineLength(position.lineNumber);
@@ -85,7 +84,7 @@ class InlineChatExpandLineAction extends EditorAction2 {
         super({
             id: 'inlineChat.startWithCurrentLine',
             category: AbstractInlineChatAction.category,
-            title: ( localize2(7201, "Start in Editor with Current Line")),
+            title: ( localize2(7268, "Start in Editor with Current Line")),
             f1: true,
             precondition: ( (ContextKeyExpr.and(
                  (CTX_INLINE_CHAT_VISIBLE.negate()),
@@ -121,7 +120,7 @@ class InlineChatExpandLineAction extends EditorAction2 {
         finally {
             d.dispose();
         }
-        if (lastState === State.CANCEL) {
+        if (lastState === "CANCEL" ) {
             model.pushEditOperations(null, undoEdits, () => null);
         }
     }

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl.js

@@ -4,10 +4,7 @@ import { DisposableStore, MutableDisposable, dispose, combinedDisposable } from
 import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
 import { localize } from 'vscode/vscode/vs/nls';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { SaveReason } from 'vscode/vscode/vs/workbench/common/editor';
 import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService.service';
-import { InlineChatConfigKeys } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
-import { GroupsOrder } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
 import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
@@ -86,10 +83,10 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         this._saveParticipant.value = combinedDisposable(d1, d2, queue);
     }
     async _participate(uri, reason, progress, token) {
-        if (reason !== SaveReason.EXPLICIT) {
+        if (reason !== 1 ) {
             return;
         }
-        if (!this._configService.getValue(InlineChatConfigKeys.AcceptedOrDiscardBeforeSave)) {
+        if (!this._configService.getValue("inlineChat.acceptedOrDiscardBeforeSave" )) {
             return;
         }
         const sessions = ( (new Map()));
@@ -103,9 +100,9 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
         }
         progress.report({
             message: sessions.size === 1
-                ? ( localize(3058, "Waiting for Inline Chat changes to be Accepted or Discarded..."))
+                ? ( localize(3128, "Waiting for Inline Chat changes to be Accepted or Discarded..."))
                 : ( localize(
-                3059,
+                3129,
                 "Waiting for Inline Chat changes in {0} editors to be Accepted or Discarded...",
                 sessions.size
             ))
@@ -122,7 +119,7 @@ let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
     }
     _getGroupsAndOrphans(sessions) {
         const groupByEditor = ( (new Map()));
-        for (const group of this._editorGroupService.getGroups(GroupsOrder.MOST_RECENTLY_ACTIVE)) {
+        for (const group of this._editorGroupService.getGroups(1 )) {
             const candidate = group.activeEditorPane?.getControl();
             if (isCodeEditor(candidate)) {
                 groupByEditor.set(candidate, group);

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

@@ -1,58 +0,0 @@
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
-
-class ChatContextAttachments extends Disposable {
-    static { this.ID = 'chatContextAttachments'; }
-    get id() {
-        return ChatContextAttachments.ID;
-    }
-    constructor(widget) {
-        super();
-        this.widget = widget;
-        this._attachedContext = ( new Set());
-        this._register(this.widget.onDidChangeContext((e) => {
-            if (e.removed) {
-                this._removeContext(e.removed);
-            }
-        }));
-        this._register(this.widget.onDidSubmitAgent(() => {
-            this._clearAttachedContext();
-        }));
-    }
-    getInputState() {
-        return [...( this._attachedContext.values())];
-    }
-    setInputState(s) {
-        if (!Array.isArray(s)) {
-            s = [];
-        }
-        this._attachedContext.clear();
-        for (const attachment of s) {
-            this._attachedContext.add(attachment);
-        }
-        this.widget.setContext(true, ...s);
-    }
-    getContext() {
-        return ( new Set(( [...( this._attachedContext.values())].map((v) => v.id))));
-    }
-    setContext(overwrite, ...attachments) {
-        if (overwrite) {
-            this._attachedContext.clear();
-        }
-        for (const attachment of attachments) {
-            this._attachedContext.add(attachment);
-        }
-        this.widget.setContext(overwrite, ...attachments);
-    }
-    _removeContext(attachments) {
-        if (attachments.length) {
-            attachments.forEach(this._attachedContext.delete, this._attachedContext);
-        }
-    }
-    _clearAttachedContext() {
-        this._attachedContext.clear();
-    }
-}
-ChatWidget.CONTRIBS.push(ChatContextAttachments);
-
-export { ChatContextAttachments };

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

@@ -1,412 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { getWordAtText } from 'vscode/vscode/vs/editor/common/core/wordHelper';
-import { CompletionItemKind } from 'vscode/vscode/vs/editor/common/languages';
-import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
-import { localize } from 'vscode/vscode/vs/nls';
-import { Action2, registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-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.service';
-import { ChatInputPart } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatInputPart';
-import { SelectAndInsertFileAction } from 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
-import { getFullyQualifiedId, ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
-import { IChatAgentService, IChatAgentNameService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
-import { ChatRequestAgentPart, ChatRequestAgentSubcommandPart, ChatRequestTextPart, chatSubcommandLeader, chatAgentLeader, chatVariableLeader, ChatRequestVariablePart, ChatRequestToolPart } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands.service';
-import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables.service';
-import { ILanguageModelToolsService } from 'vscode/vscode/vs/workbench/contrib/chat/common/languageModelToolsService.service';
-import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-
-var BuiltinDynamicCompletions_1, VariableCompletions_1;
-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) {
-                    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(widget.location);
-                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: CompletionItemKind.Text,
-                            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, 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;
-        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 = 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((agent, i) => {
-                        const { label: agentLabel, isDupe } = this.getAgentCompletionDetails(agent);
-                        return {
-                            label: isDupe ?
-                                { label: agentLabel, description: agent.description, detail: ` (${agent.publisherDisplayName})` } :
-                                agentLabel,
-                            insertText: `${agentLabel} `,
-                            detail: agent.description,
-                            range: ( (new Range(1, 1, 1, 1))),
-                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent: agent, widget }] },
-                            kind: CompletionItemKind.Text,
-                        };
-                    })))
-                };
-            }
-        }));
-        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 = 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: CompletionItemKind.Text,
-                        };
-                    })))
-                };
-            }
-        }));
-        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) {
-                    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 getFilterText = (agent, command) => {
-                    const dummyPrefix = agent.id === 'github.copilot.terminalPanel' ? `0000` : ``;
-                    return `${chatSubcommandLeader}${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,
-                        detail,
-                        filterText: `${chatSubcommandLeader}${agent.name}`,
-                        insertText: `${agentLabel} `,
-                        range: ( (new Range(1, 1, 1, 1))),
-                        kind: CompletionItemKind.Text,
-                        sortText: `${chatSubcommandLeader}${agent.name}`,
-                        command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
-                    };
-                })));
-                return {
-                    suggestions: justAgents.concat(agents.flatMap(agent => ( (agent.slashCommands.map((c, i) => {
-                        const { label: agentLabel, isDupe } = this.getAgentCompletionDetails(agent);
-                        const withSlash = `${chatSubcommandLeader}${c.name}`;
-                        const item = {
-                            label: { label: withSlash, description: agentLabel, detail: isDupe ? ` (${agent.publisherDisplayName})` : undefined },
-                            filterText: getFilterText(agent, c.name),
-                            commitCharacters: [' '],
-                            insertText: `${agentLabel} ${withSlash} `,
-                            detail: `(${agentLabel}) ${c.description ?? ''}`,
-                            range: ( (new Range(1, 1, 1, 1))),
-                            kind: CompletionItemKind.Text,
-                            sortText: `${chatSubcommandLeader}${agent.name}${c.name}`,
-                            command: { id: AssignSelectedAgentAction.ID, title: AssignSelectedAgentAction.ID, arguments: [{ agent, widget }] },
-                        };
-                        if (agent.isDefault) {
-                            item.label = withSlash;
-                            item.insertText = `${withSlash} `;
-                            item.detail = c.description;
-                        }
-                        return item;
-                    })))))
-                };
-            }
-        }));
-    }
-    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;
-        }
-        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) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, BuiltinDynamicCompletions_1.VariableNameDef, true);
-                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: ( localize(7161, "Pick a file")),
-                            range,
-                            kind: CompletionItemKind.Text,
-                            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, 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 && 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 };
-}
-let VariableCompletions = class VariableCompletions extends Disposable {
-    static { VariableCompletions_1 = this; }
-    static { this.VariableNameDef = ( (new RegExp(`${chatVariableLeader}\\w*`, 'g'))); }
-    constructor(languageFeaturesService, chatWidgetService, chatVariablesService, configService, toolsService) {
-        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 locations = ( (new Set()));
-                locations.add(ChatAgentLocation.Panel);
-                for (const value of ( (Object.values(ChatAgentLocation)))) {
-                    if (typeof value === 'string' && configService.getValue(`chat.experimental.variables.${value}`)) {
-                        locations.add(value);
-                    }
-                }
-                const widget = this.chatWidgetService.getWidgetByInputUri(model.uri);
-                if (!widget || !( (locations.has(widget.location)))) {
-                    return null;
-                }
-                const range = computeCompletionRanges(model, position, VariableCompletions_1.VariableNameDef, true);
-                if (!range) {
-                    return null;
-                }
-                const usedAgent = widget.parsedInput.parts.find(p => p instanceof ChatRequestAgentPart);
-                const slowSupported = usedAgent ? usedAgent.agent.metadata.supportsSlowVariables : true;
-                const usedVariables = widget.parsedInput.parts.filter((p) => p instanceof ChatRequestVariablePart);
-                const usedVariableNames = ( (new Set( (usedVariables.map(v => v.variableName)))));
-                const variableItems = ( (Array.from(this.chatVariablesService.getVariables(widget.location))
-                    .filter(v => !( (usedVariableNames.has(v.name))))
-                    .filter(v => !v.isSlow || slowSupported)
-                    .map((v) => {
-                    const withLeader = `${chatVariableLeader}${v.name}`;
-                    return {
-                        label: withLeader,
-                        range,
-                        insertText: withLeader + ' ',
-                        detail: v.description,
-                        kind: CompletionItemKind.Text,
-                        sortText: 'z'
-                    };
-                })));
-                const usedTools = widget.parsedInput.parts.filter((p) => p instanceof ChatRequestToolPart);
-                const usedToolNames = ( (new Set( (usedTools.map(v => v.toolName)))));
-                const toolItems = [];
-                if (!usedAgent || usedAgent.agent.supportsToolReferences) {
-                    toolItems.push(...( (Array.from(toolsService.getTools())
-                        .filter(t => t.canBeInvokedManually)
-                        .filter(t => !( (usedToolNames.has(t.name ?? ''))))
-                        .map((t) => {
-                        const withLeader = `${chatVariableLeader}${t.name}`;
-                        return {
-                            label: withLeader,
-                            range,
-                            insertText: withLeader + ' ',
-                            detail: t.userDescription,
-                            kind: CompletionItemKind.Text,
-                            sortText: 'z'
-                        };
-                    }))));
-                }
-                return {
-                    suggestions: [...variableItems, ...toolItems]
-                };
-            }
-        }));
-    }
-};
-VariableCompletions = VariableCompletions_1 = ( (__decorate([
-    ( (__param(0, ILanguageFeaturesService))),
-    ( (__param(1, IChatWidgetService))),
-    ( (__param(2, IChatVariablesService))),
-    ( (__param(3, IConfigurationService))),
-    ( (__param(4, ILanguageModelToolsService)))
-], VariableCompletions)));
-( (Registry.as(Extensions.Workbench))).registerWorkbenchContribution(VariableCompletions, LifecyclePhase.Eventually);