@codingame/monaco-vscode-xterm-addons-common 25.1.2 → 26.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-xterm-addons-common",
-  "version": "25.1.2",
+  "version": "26.0.1",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - common package depending on xterm addons",
   "keywords": [],
@@ -15,15 +15,15 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "25.1.2",
-    "@xterm/addon-clipboard": "0.3.0-beta.97",
-    "@xterm/addon-image": "0.10.0-beta.97",
-    "@xterm/addon-ligatures": "0.11.0-beta.97",
-    "@xterm/addon-progress": "0.3.0-beta.97",
-    "@xterm/addon-search": "0.17.0-beta.97",
-    "@xterm/addon-serialize": "0.15.0-beta.97",
-    "@xterm/addon-unicode11": "0.10.0-beta.97",
-    "@xterm/addon-webgl": "0.20.0-beta.104"
+    "@codingame/monaco-vscode-api": "26.0.1",
+    "@xterm/addon-clipboard": "0.3.0-beta.147",
+    "@xterm/addon-image": "0.10.0-beta.147",
+    "@xterm/addon-ligatures": "0.11.0-beta.147",
+    "@xterm/addon-progress": "0.3.0-beta.147",
+    "@xterm/addon-search": "0.17.0-beta.147",
+    "@xterm/addon-serialize": "0.15.0-beta.147",
+    "@xterm/addon-unicode11": "0.10.0-beta.147",
+    "@xterm/addon-webgl": "0.20.0-beta.146"
   },
   "exports": {
     ".": {

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatContext.js

@@ -1,10 +1,8 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { isElectron } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
-import { dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { IClipboardService } from '@codingame/monaco-vscode-api/vscode/vs/platform/clipboard/common/clipboardService.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
@@ -17,9 +15,8 @@ import { UntitledTextEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/
 import { FileEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/editors/fileEditorInput';
 import { NotebookEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
 import { IChatContextPickService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatContextPickService.service';
-import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService.service';
-import { toToolSetVariableEntry, toToolVariableEntry, OmittedState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
-import { ToolSet, ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { toToolSetVariableEntry, toToolVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
+import { isToolSet, ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { isImage } from '../widget/input/editor/chatPasteProviders.js';
 import { convertBufferToScreenshotVariable } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/attachments/chatScreenshotContext';
 import { ChatInstructionsPickerPick } from '../promptSyntax/attachInstructionsAction.js';
@@ -28,25 +25,33 @@ import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platf
 import { imageToHash } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatImageUtils';
 
 let ChatContextContributions = class ChatContextContributions extends Disposable {
-    static { this.ID = 'chat.contextContributions'; }
+    static {
+        this.ID = "chat.contextContributions";
+    }
     constructor(instantiationService, contextPickService) {
         super();
-        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(ToolsContextPickerPick)));
-        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(ChatInstructionsPickerPick)));
-        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(OpenEditorContextValuePick)));
-        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(RelatedFilesContextPickerPick)));
-        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(ClipboardImageContextValuePick)));
-        this._store.add(contextPickService.registerChatContextItem(instantiationService.createInstance(ScreenshotContextValuePick)));
+        this._store.add(
+            contextPickService.registerChatContextItem(instantiationService.createInstance(ToolsContextPickerPick))
+        );
+        this._store.add(
+            contextPickService.registerChatContextItem(instantiationService.createInstance(ChatInstructionsPickerPick))
+        );
+        this._store.add(
+            contextPickService.registerChatContextItem(instantiationService.createInstance(OpenEditorContextValuePick))
+        );
+        this._store.add(
+            contextPickService.registerChatContextItem(instantiationService.createInstance(ClipboardImageContextValuePick))
+        );
+        this._store.add(
+            contextPickService.registerChatContextItem(instantiationService.createInstance(ScreenshotContextValuePick))
+        );
     }
 };
-ChatContextContributions = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IChatContextPickService))
-], ChatContextContributions));
+ChatContextContributions = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IChatContextPickService))], ChatContextContributions));
 class ToolsContextPickerPick {
     constructor() {
-        this.type = 'pickerPick';
-        this.label = ( localize(4707, 'Tools...'));
+        this.type = "pickerPick";
+        this.label = ( localize(4719, "Tools..."));
         this.icon = Codicon.tools;
         this.ordinal = -500;
     }
@@ -57,15 +62,14 @@ class ToolsContextPickerPick {
         const items = [];
         for (const [entry, enabled] of widget.input.selectedToolsModel.entriesMap.get()) {
             if (enabled) {
-                if (entry instanceof ToolSet) {
+                if (isToolSet(entry)) {
                     items.push({
                         toolInfo: ToolDataSource.classify(entry.source),
                         label: entry.referenceName,
                         description: entry.description,
                         asAttachment: () => toToolSetVariableEntry(entry)
                     });
-                }
-                else {
+                } else {
                     items.push({
                         toolInfo: ToolDataSource.classify(entry.source),
                         label: entry.toolReferenceName ?? entry.displayName,
@@ -89,13 +93,16 @@ class ToolsContextPickerPick {
         const picks = [];
         for (const item of items) {
             if (lastGroupLabel !== item.toolInfo.label) {
-                picks.push({ type: 'separator', label: item.toolInfo.label });
+                picks.push({
+                    type: "separator",
+                    label: item.toolInfo.label
+                });
                 lastGroupLabel = item.toolInfo.label;
             }
             picks.push(item);
         }
         return {
-            placeholder: ( localize(4708, 'Select a tool')),
+            placeholder: ( localize(4720, "Select a tool")),
             picks: Promise.resolve(picks)
         };
     }
@@ -104,13 +111,15 @@ let OpenEditorContextValuePick = class OpenEditorContextValuePick {
     constructor(_editorService, _labelService) {
         this._editorService = _editorService;
         this._labelService = _labelService;
-        this.type = 'valuePick';
-        this.label = ( localize(4709, 'Open Editors'));
+        this.type = "valuePick";
+        this.label = ( localize(4721, "Open Editors"));
         this.icon = Codicon.file;
         this.ordinal = 800;
     }
     isEnabled() {
-        return this._editorService.editors.filter(e => e instanceof FileEditorInput || e instanceof DiffEditorInput || e instanceof UntitledTextEditorInput).length > 0;
+        return this._editorService.editors.filter(
+            e => e instanceof FileEditorInput || e instanceof DiffEditorInput || e instanceof UntitledTextEditorInput
+        ).length > 0;
     }
     async asAttachment() {
         const result = [];
@@ -118,92 +127,35 @@ let OpenEditorContextValuePick = class OpenEditorContextValuePick {
             if (!(editor instanceof FileEditorInput || editor instanceof DiffEditorInput || editor instanceof UntitledTextEditorInput || editor instanceof NotebookEditorInput)) {
                 continue;
             }
-            const uri = EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY });
+            const uri = EditorResourceAccessor.getOriginalUri(editor, {
+                supportSideBySide: SideBySideEditor.PRIMARY
+            });
             if (!uri) {
                 continue;
             }
             result.push({
-                kind: 'file',
+                kind: "file",
                 id: ( uri.toString()),
                 value: uri,
-                name: this._labelService.getUriBasenameLabel(uri),
+                name: this._labelService.getUriBasenameLabel(uri)
             });
         }
         return result;
     }
 };
-OpenEditorContextValuePick = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, ILabelService))
-], OpenEditorContextValuePick));
-let RelatedFilesContextPickerPick = class RelatedFilesContextPickerPick {
-    constructor(_chatEditingService, _labelService) {
-        this._chatEditingService = _chatEditingService;
-        this._labelService = _labelService;
-        this.type = 'pickerPick';
-        this.label = ( localize(4710, 'Related Files'));
-        this.icon = Codicon.sparkle;
-        this.ordinal = 300;
-    }
-    isEnabled(widget) {
-        return this._chatEditingService.hasRelatedFilesProviders() && (Boolean(widget.getInput()) || widget.attachmentModel.fileAttachments.length > 0);
-    }
-    asPicker(widget) {
-        const picks = (async () => {
-            const chatSessionResource = widget.viewModel?.sessionResource;
-            if (!chatSessionResource) {
-                return [];
-            }
-            const relatedFiles = await this._chatEditingService.getRelatedFiles(chatSessionResource, widget.getInput(), widget.attachmentModel.fileAttachments, CancellationToken.None);
-            if (!relatedFiles) {
-                return [];
-            }
-            const attachments = widget.attachmentModel.getAttachmentIDs();
-            return this._chatEditingService.getRelatedFiles(chatSessionResource, widget.getInput(), widget.attachmentModel.fileAttachments, CancellationToken.None)
-                .then((files) => (files ?? []).reduce((acc, cur) => {
-                acc.push({ type: 'separator', label: cur.group });
-                for (const file of cur.files) {
-                    const label = this._labelService.getUriBasenameLabel(file.uri);
-                    acc.push({
-                        label: label,
-                        description: this._labelService.getUriLabel(dirname(file.uri), { relative: true }),
-                        disabled: ( attachments.has(( file.uri.toString()))),
-                        asAttachment: () => {
-                            return {
-                                kind: 'file',
-                                id: ( file.uri.toString()),
-                                value: file.uri,
-                                name: label,
-                                omittedState: OmittedState.NotOmitted
-                            };
-                        }
-                    });
-                }
-                return acc;
-            }, []));
-        })();
-        return {
-            placeholder: ( localize(4711, 'Add related files to your working set')),
-            picks,
-        };
-    }
-};
-RelatedFilesContextPickerPick = ( __decorate([
-    ( __param(0, IChatEditingService)),
-    ( __param(1, ILabelService))
-], RelatedFilesContextPickerPick));
+OpenEditorContextValuePick = ( __decorate([( __param(0, IEditorService)), ( __param(1, ILabelService))], OpenEditorContextValuePick));
 let ClipboardImageContextValuePick = class ClipboardImageContextValuePick {
     constructor(_clipboardService) {
         this._clipboardService = _clipboardService;
-        this.type = 'valuePick';
-        this.label = ( localize(4712, 'Image from Clipboard'));
+        this.type = "valuePick";
+        this.label = ( localize(4722, "Image from Clipboard"));
         this.icon = Codicon.fileMedia;
     }
     async isEnabled(widget) {
         if (!widget.attachmentCapabilities.supportsImageAttachments) {
             return false;
         }
-        if (!widget.input.selectedLanguageModel?.metadata.capabilities?.vision) {
+        if (!widget.input.selectedLanguageModel.get()?.metadata.capabilities?.vision) {
             return false;
         }
         const imageData = await this._clipboardService.readImage();
@@ -213,23 +165,21 @@ let ClipboardImageContextValuePick = class ClipboardImageContextValuePick {
         const fileBuffer = await this._clipboardService.readImage();
         return {
             id: await imageToHash(fileBuffer),
-            name: ( localize(4713, 'Pasted Image')),
-            fullName: ( localize(4713, 'Pasted Image')),
+            name: ( localize(4723, "Pasted Image")),
+            fullName: ( localize(4723, "Pasted Image")),
             value: fileBuffer,
-            kind: 'image',
+            kind: "image"
         };
     }
 };
-ClipboardImageContextValuePick = ( __decorate([
-    ( __param(0, IClipboardService))
-], ClipboardImageContextValuePick));
+ClipboardImageContextValuePick = ( __decorate([( __param(0, IClipboardService))], ClipboardImageContextValuePick));
 let TerminalContext = class TerminalContext {
     constructor(_resource, _terminalService) {
         this._resource = _resource;
         this._terminalService = _terminalService;
-        this.type = 'valuePick';
+        this.type = "valuePick";
         this.icon = Codicon.terminal;
-        this.label = ( localize(4714, 'Terminal'));
+        this.label = ( localize(4724, "Terminal"));
     }
     isEnabled(widget) {
         const terminal = this._terminalService.getInstanceFromResource(this._resource);
@@ -241,12 +191,12 @@ let TerminalContext = class TerminalContext {
             return;
         }
         const params = ( new URLSearchParams(this._resource.query));
-        const command = terminal.capabilities.get(TerminalCapability.CommandDetection)?.commands.find(cmd => cmd.id === params.get('command'));
+        const command = terminal.capabilities.get(TerminalCapability.CommandDetection)?.commands.find(cmd => cmd.id === params.get("command"));
         if (!command) {
             return;
         }
         const attachment = {
-            kind: 'terminalCommand',
+            kind: "terminalCommand",
             id: `terminalCommand:${Date.now()}}`,
             value: this.asValue(command),
             name: command.command,
@@ -282,34 +232,28 @@ let TerminalContext = class TerminalContext {
         if (output) {
             value += `\nOutput:\n${output}`;
         }
-        if (typeof command.exitCode === 'number') {
+        if (typeof command.exitCode === "number") {
             value += `\nExit Code: ${command.exitCode}`;
         }
         return value;
     }
 };
-TerminalContext = ( __decorate([
-    ( __param(1, ITerminalService))
-], TerminalContext));
+TerminalContext = ( __decorate([( __param(1, ITerminalService))], TerminalContext));
 let ScreenshotContextValuePick = class ScreenshotContextValuePick {
     constructor(_hostService) {
         this._hostService = _hostService;
-        this.type = 'valuePick';
+        this.type = "valuePick";
         this.icon = Codicon.deviceCamera;
-        this.label = (isElectron
-            ? ( localize(4715, 'Screenshot Window'))
-            : ( localize(4716, 'Screenshot')));
+        this.label = (isElectron ? ( localize(4725, "Screenshot Window")) : ( localize(4726, "Screenshot")));
     }
     async isEnabled(widget) {
-        return !!widget.attachmentCapabilities.supportsImageAttachments && !!widget.input.selectedLanguageModel?.metadata.capabilities?.vision;
+        return !!widget.attachmentCapabilities.supportsImageAttachments && !!widget.input.selectedLanguageModel.get()?.metadata.capabilities?.vision;
     }
     async asAttachment() {
         const blob = await this._hostService.getScreenshot();
         return blob && convertBufferToScreenshotVariable(blob);
     }
 };
-ScreenshotContextValuePick = ( __decorate([
-    ( __param(0, IHostService))
-], ScreenshotContextValuePick));
+ScreenshotContextValuePick = ( __decorate([( __param(0, IHostService))], ScreenshotContextValuePick));
 
 export { ChatContextContributions, TerminalContext };

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables.d.ts

@@ -0,0 +1,42 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IRange } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range";
+import { Command } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { ServicesAccessor } 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 { IChatRequestVariableValue, IDynamicVariable } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariables";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidgetContrib } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatWidget";
+export declare const dynamicVariableDecorationType = "chat-dynamic-variable";
+export declare class ChatDynamicVariableModel extends Disposable implements IChatWidgetContrib {
+    private readonly widget;
+    private readonly labelService;
+    static readonly ID = "chatDynamicVariableModel";
+    private _variables;
+    get variables(): ReadonlyArray<IDynamicVariable>;
+    get id(): string;
+    private decorationData;
+    constructor(widget: IChatWidget, labelService: ILabelService);
+    getInputState(contrib: Record<string, unknown>): void;
+    setInputState(contrib: Readonly<Record<string, unknown>>): void;
+    addReference(ref: IDynamicVariable): void;
+    private updateDecorations;
+    private getHoverForReference;
+    /**
+     * Dispose all existing variables.
+     */
+    private disposeVariables;
+    dispose(): void;
+}
+export interface IAddDynamicVariableContext {
+    id: string;
+    widget: IChatWidget;
+    range: IRange;
+    variableData: IChatRequestVariableValue;
+    command?: Command;
+}
+export declare class AddDynamicVariableAction extends Action2 {
+    static readonly ID = "workbench.action.chat.addDynamicVariable";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/attachments/chatDynamicVariables.js

@@ -0,0 +1,209 @@
+
+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 { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, dispose, isDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { isLocation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { addDynamicVariableActionId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/editor/chatDynamicVariablesConstant';
+
+var ChatDynamicVariableModel_1;
+const dynamicVariableDecorationType = "chat-dynamic-variable";
+let ChatDynamicVariableModel = class ChatDynamicVariableModel extends Disposable {
+    static {
+        ChatDynamicVariableModel_1 = this;
+    }
+    static {
+        this.ID = "chatDynamicVariableModel";
+    }
+    get variables() {
+        return [...this._variables];
+    }
+    get id() {
+        return ChatDynamicVariableModel_1.ID;
+    }
+    constructor(widget, labelService) {
+        super();
+        this.widget = widget;
+        this.labelService = labelService;
+        this._variables = [];
+        this.decorationData = [];
+        this._register(widget.inputEditor.onDidChangeModelContent(e => {
+            const removed = [];
+            let didChange = false;
+            this._variables = coalesce(( this._variables.map((ref, idx) => {
+                const model = widget.inputEditor.getModel();
+                if (!model) {
+                    removed.push(ref);
+                    return null;
+                }
+                const data = this.decorationData[idx];
+                const newRange = model.getDecorationRange(data.id);
+                if (!newRange) {
+                    removed.push(ref);
+                    return null;
+                }
+                const newText = model.getValueInRange(newRange);
+                if (newText !== data.text) {
+                    this.widget.inputEditor.executeEdits(this.id, [{
+                        range: newRange,
+                        text: ""
+                    }]);
+                    this.widget.refreshParsedInput();
+                    removed.push(ref);
+                    return null;
+                }
+                if (newRange.equalsRange(ref.range)) {
+                    return ref;
+                }
+                didChange = true;
+                return {
+                    ...ref,
+                    range: newRange
+                };
+            })));
+            dispose(removed.filter(isDisposable));
+            if (didChange || removed.length > 0) {
+                this.widget.refreshParsedInput();
+            }
+            this.updateDecorations();
+        }));
+    }
+    getInputState(contrib) {
+        contrib[ChatDynamicVariableModel_1.ID] = this.variables;
+    }
+    setInputState(contrib) {
+        let s = contrib[ChatDynamicVariableModel_1.ID];
+        if (!Array.isArray(s)) {
+            s = [];
+        }
+        this.disposeVariables();
+        this._variables = [];
+        for (const variable of s) {
+            if (!isDynamicVariable(variable)) {
+                continue;
+            }
+            this.addReference(variable);
+        }
+    }
+    addReference(ref) {
+        this._variables.push(ref);
+        this.updateDecorations();
+        this.widget.refreshParsedInput();
+    }
+    updateDecorations() {
+        const decorationIds = this.widget.inputEditor.setDecorationsByType("chat", dynamicVariableDecorationType, ( this._variables.map(r => ({
+            range: r.range,
+            hoverMessage: this.getHoverForReference(r)
+        }))));
+        this.decorationData = [];
+        for (let i = 0; i < decorationIds.length; i++) {
+            this.decorationData.push({
+                id: decorationIds[i],
+                text: this.widget.inputEditor.getModel().getValueInRange(this._variables[i].range)
+            });
+        }
+    }
+    getHoverForReference(ref) {
+        const value = ref.data;
+        if (URI.isUri(value)) {
+            return ( new MarkdownString(this.labelService.getUriLabel(value, {
+                relative: true
+            })));
+        } else if (isLocation(value)) {
+            const prefix = ref.fullName ? ` ${ref.fullName}` : "";
+            const rangeString = `#${value.range.startLineNumber}-${value.range.endLineNumber}`;
+            return ( new MarkdownString(prefix + this.labelService.getUriLabel(value.uri, {
+                relative: true
+            }) + rangeString));
+        } else {
+            return undefined;
+        }
+    }
+    disposeVariables() {
+        for (const variable of this._variables) {
+            if (isDisposable(variable)) {
+                variable.dispose();
+            }
+        }
+    }
+    dispose() {
+        this.disposeVariables();
+        super.dispose();
+    }
+};
+ChatDynamicVariableModel = ChatDynamicVariableModel_1 = ( __decorate([( __param(1, ILabelService))], ChatDynamicVariableModel));
+function isDynamicVariable(obj) {
+    return obj && typeof obj.id === "string" && Range.isIRange(obj.range) && "data" in obj;
+}
+function isAddDynamicVariableContext(context) {
+    return "widget" in context && "range" in context && "variableData" in context;
+}
+class AddDynamicVariableAction extends Action2 {
+    static {
+        this.ID = addDynamicVariableActionId;
+    }
+    constructor() {
+        super({
+            id: AddDynamicVariableAction.ID,
+            title: ""
+        });
+    }
+    async run(accessor, ...args) {
+        const context = args[0];
+        if (!isAddDynamicVariableContext(context)) {
+            return;
+        }
+        let range = context.range;
+        const variableData = context.variableData;
+        const doCleanup = () => {
+            context.widget.inputEditor.executeEdits("chatInsertDynamicVariableWithArguments", [{
+                range: context.range,
+                text: ``
+            }]);
+        };
+        if (context.command) {
+            const commandService = accessor.get(ICommandService);
+            const selection = await commandService.executeCommand(context.command.id, ...(context.command.arguments ?? []));
+            if (!selection) {
+                doCleanup();
+                return;
+            }
+            const insertText = ":" + selection;
+            const insertRange = ( new Range(
+                range.startLineNumber,
+                range.endColumn,
+                range.endLineNumber,
+                range.endColumn + insertText.length
+            ));
+            range = ( new Range(
+                range.startLineNumber,
+                range.startColumn,
+                range.endLineNumber,
+                range.endColumn + insertText.length
+            ));
+            const editor = context.widget.inputEditor;
+            const success = editor.executeEdits("chatInsertDynamicVariableWithArguments", [{
+                range: insertRange,
+                text: insertText + " "
+            }]);
+            if (!success) {
+                doCleanup();
+                return;
+            }
+        }
+        context.widget.getContrib(ChatDynamicVariableModel.ID)?.addReference({
+            id: context.id,
+            range: range,
+            isFile: true,
+            data: variableData
+        });
+    }
+}
+registerAction2(AddDynamicVariableAction);
+
+export { AddDynamicVariableAction, ChatDynamicVariableModel, dynamicVariableDecorationType };