@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpPromptArgumentPick.d.ts

@@ -0,0 +1,41 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICodeEditorService } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
+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 { IQuickInputService } from "@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { ISearchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service";
+import { ITerminalGroupService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { ITerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service";
+import { IMcpPrompt } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
+export declare class McpPromptArgumentPick extends Disposable {
+    private readonly prompt;
+    private readonly _quickInputService;
+    private readonly _terminalService;
+    private readonly _searchService;
+    private readonly _workspaceContextService;
+    private readonly _labelService;
+    private readonly _fileService;
+    private readonly _modelService;
+    private readonly _languageService;
+    private readonly _terminalGroupService;
+    private readonly _instantiationService;
+    private readonly _codeEditorService;
+    private readonly _editorService;
+    private readonly quickPick;
+    private _terminal?;
+    constructor(prompt: IMcpPrompt, _quickInputService: IQuickInputService, _terminalService: ITerminalService, _searchService: ISearchService, _workspaceContextService: IWorkspaceContextService, _labelService: ILabelService, _fileService: IFileService, _modelService: IModelService, _languageService: ILanguageService, _terminalGroupService: ITerminalGroupService, _instantiationService: IInstantiationService, _codeEditorService: ICodeEditorService, _editorService: IEditorService);
+    createArgs(token?: CancellationToken): Promise<Record<string, string | undefined> | undefined>;
+    private _getArg;
+    private _promptCompletions;
+    private _fileCompletions;
+    private _activeFileCompletions;
+    private _asyncCompletions;
+    private _getTerminalOutput;
+    private _getTerminalOutputInner;
+}

package/vscode/src/vs/workbench/contrib/mcp/browser/mcpPromptArgumentPick.js

@@ -0,0 +1,424 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { timeout, disposableTimeout, RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+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 { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+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 { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { getIconClasses } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/getIconClasses';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 { IQuickInputService } from '@codingame/monaco-vscode-api/vscode/vs/platform/quickinput/common/quickInput.service';
+import { TerminalCapability } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities';
+import { TerminalLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { QueryBuilder } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/queryBuilder';
+import { ISearchService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/search.service';
+import { ITerminalService, ITerminalGroupService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/terminal.service';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
+
+const SHELL_INTEGRATION_TIMEOUT = 5000;
+const NO_SHELL_INTEGRATION_IDLE = 1000;
+const SUGGEST_DEBOUNCE = 200;
+let McpPromptArgumentPick = class McpPromptArgumentPick extends Disposable {
+    constructor(
+        prompt,
+        _quickInputService,
+        _terminalService,
+        _searchService,
+        _workspaceContextService,
+        _labelService,
+        _fileService,
+        _modelService,
+        _languageService,
+        _terminalGroupService,
+        _instantiationService,
+        _codeEditorService,
+        _editorService
+    ) {
+        super();
+        this.prompt = prompt;
+        this._quickInputService = _quickInputService;
+        this._terminalService = _terminalService;
+        this._searchService = _searchService;
+        this._workspaceContextService = _workspaceContextService;
+        this._labelService = _labelService;
+        this._fileService = _fileService;
+        this._modelService = _modelService;
+        this._languageService = _languageService;
+        this._terminalGroupService = _terminalGroupService;
+        this._instantiationService = _instantiationService;
+        this._codeEditorService = _codeEditorService;
+        this._editorService = _editorService;
+        this.quickPick = this._register(_quickInputService.createQuickPick({
+            useSeparators: true
+        }));
+    }
+    async createArgs(token) {
+        const {
+            quickPick,
+            prompt
+        } = this;
+        quickPick.totalSteps = prompt.arguments.length;
+        quickPick.step = 0;
+        quickPick.ignoreFocusOut = true;
+        quickPick.sortByLabel = false;
+        const args = {};
+        const backSnapshots = [];
+        for (let i = 0; i < prompt.arguments.length; i++) {
+            const arg = prompt.arguments[i];
+            const restore = backSnapshots.at(i);
+            quickPick.step = i + 1;
+            quickPick.placeholder = arg.required ? arg.description : `${arg.description || ""} (${( localize(9194, "Optional"))})`;
+            quickPick.title = ( localize(9195, "Value for: {0}", arg.title || arg.name));
+            quickPick.value = restore?.value ?? ((args.hasOwnProperty(arg.name) && args[arg.name]) || "");
+            quickPick.items = restore?.items ?? [];
+            quickPick.activeItems = restore?.activeItems ?? [];
+            quickPick.buttons = i > 0 ? [this._quickInputService.backButton] : [];
+            const value = await this._getArg(arg, !!restore, args, token);
+            if (value.type === "back") {
+                i -= 2;
+            } else if (value.type === "cancel") {
+                return undefined;
+            } else if (value.type === "arg") {
+                backSnapshots[i] = {
+                    value: quickPick.value,
+                    items: quickPick.items.slice(),
+                    activeItems: quickPick.activeItems.slice()
+                };
+                args[arg.name] = value.value;
+            } else {
+                assertNever();
+            }
+        }
+        quickPick.value = "";
+        quickPick.placeholder = ( localize(9196, "Loading..."));
+        quickPick.busy = true;
+        return args;
+    }
+    async _getArg(arg, didRestoreState, argsSoFar, token) {
+        const {
+            quickPick
+        } = this;
+        const store = ( new DisposableStore());
+        const input$ = observableValue(this, quickPick.value);
+        const asyncPicks = [{
+            name: ( localize(9197, "Suggestions")),
+            observer: this._promptCompletions(arg, input$, argsSoFar)
+        }, {
+            name: ( localize(9198, "Active File")),
+            observer: this._activeFileCompletions()
+        }, {
+            name: ( localize(9199, "Files")),
+            observer: this._fileCompletions(input$)
+        }];
+        store.add(autorun(reader => {
+            if (didRestoreState) {
+                input$.read(reader);
+                return;
+            }
+            let items = [];
+            items.push({
+                id: "insert-text",
+                label: ( localize(9200, "Insert as text")),
+                iconClass: ThemeIcon.asClassName(Codicon.textSize),
+                action: "text",
+                alwaysShow: true
+            });
+            items.push({
+                id: "run-command",
+                label: ( localize(9201, "Run as Command")),
+                description: ( localize(9202, "Inserts the command output as the prompt argument")),
+                iconClass: ThemeIcon.asClassName(Codicon.terminal),
+                action: "command",
+                alwaysShow: true
+            });
+            let busy = false;
+            for (const pick of asyncPicks) {
+                const state = pick.observer.read(reader);
+                busy ||= state.busy;
+                if (state.picks) {
+                    items.push({
+                        label: pick.name,
+                        type: "separator"
+                    });
+                    items = items.concat(state.picks);
+                }
+            }
+            const previouslyActive = quickPick.activeItems;
+            quickPick.busy = busy;
+            quickPick.items = items;
+            const lastActive = items.find(i => ( previouslyActive.some(a => a.id === i.id)));
+            const serverSuggestions = asyncPicks[0].observer;
+            if (lastActive) {
+                quickPick.activeItems = [lastActive];
+            } else if (serverSuggestions.read(reader).picks?.length) {
+                quickPick.activeItems = [items[3]];
+            } else if (busy) {
+                quickPick.activeItems = [];
+            } else {
+                quickPick.activeItems = [items[0]];
+            }
+        }));
+        try {
+            const value = await ( new Promise(resolve => {
+                if (token) {
+                    store.add(token.onCancellationRequested(() => {
+                        resolve(undefined);
+                    }));
+                }
+                store.add(quickPick.onDidChangeValue(value => {
+                    quickPick.validationMessage = undefined;
+                    input$.set(value, undefined);
+                }));
+                store.add(quickPick.onDidAccept(() => {
+                    const item = quickPick.selectedItems[0];
+                    if (!quickPick.value && arg.required && (!item || item.action === "text" || item.action === "command")) {
+                        quickPick.validationMessage = ( localize(9203, "This argument is required"));
+                    } else if (!item) {
+                        resolve({
+                            id: "insert-text",
+                            label: "",
+                            action: "text"
+                        });
+                    } else {
+                        resolve(item);
+                    }
+                }));
+                store.add(quickPick.onDidTriggerButton(() => {
+                    resolve("back");
+                }));
+                store.add(quickPick.onDidHide(() => {
+                    resolve(undefined);
+                }));
+                quickPick.show();
+            }));
+            if (value === "back") {
+                return {
+                    type: "back"
+                };
+            }
+            if (value === undefined) {
+                return {
+                    type: "cancel"
+                };
+            }
+            store.clear();
+            const cts = ( new CancellationTokenSource());
+            store.add(toDisposable(() => cts.dispose(true)));
+            store.add(quickPick.onDidHide(() => store.dispose()));
+            switch (value.action) {
+            case "text":
+                return {
+                    type: "arg",
+                    value: quickPick.value || undefined
+                };
+            case "command":
+                if (!quickPick.value) {
+                    return {
+                        type: "arg",
+                        value: undefined
+                    };
+                }
+                quickPick.busy = true;
+                return {
+                    type: "arg",
+                    value: await this._getTerminalOutput(quickPick.value, cts.token)
+                };
+            case "suggest":
+                return {
+                    type: "arg",
+                    value: value.label
+                };
+            case "file":
+                quickPick.busy = true;
+                return {
+                    type: "arg",
+                    value: await this._fileService.readFile(value.uri).then(c => ( c.value.toString()))
+                };
+            case "selectedText":
+                return {
+                    type: "arg",
+                    value: value.selectedText
+                };
+            default:
+                assertNever(value);
+            }
+        } finally {
+            store.dispose();
+        }
+    }
+    _promptCompletions(arg, input, argsSoFar) {
+        const alreadyResolved = {};
+        for (const [key, value] of Object.entries(argsSoFar)) {
+            if (value) {
+                alreadyResolved[key] = value;
+            }
+        }
+        return this._asyncCompletions(input, async (i, t) => {
+            const items = await this.prompt.complete(arg.name, i, alreadyResolved, t);
+            return ( items.map(i => ({
+                id: `suggest:${i}`,
+                label: i,
+                action: "suggest"
+            })));
+        });
+    }
+    _fileCompletions(input) {
+        const qb = this._instantiationService.createInstance(QueryBuilder);
+        return this._asyncCompletions(input, async (i, token) => {
+            if (!i) {
+                return [];
+            }
+            const query = qb.file(this._workspaceContextService.getWorkspace().folders, {
+                filePattern: i,
+                maxResults: 10
+            });
+            const {
+                results
+            } = await this._searchService.fileSearch(query, token);
+            return ( results.map(i => ({
+                id: ( i.resource.toString()),
+                label: basename(i.resource),
+                description: this._labelService.getUriLabel(i.resource),
+                iconClasses: getIconClasses(this._modelService, this._languageService, i.resource),
+                uri: i.resource,
+                action: "file"
+            })));
+        });
+    }
+    _activeFileCompletions() {
+        const activeEditorChange = observableSignalFromEvent(this, this._editorService.onDidActiveEditorChange);
+        const activeEditor = derived(reader => {
+            activeEditorChange.read(reader);
+            return this._codeEditorService.getActiveCodeEditor();
+        });
+        const resourceObs = ( ( activeEditor.map(e => e ? ( observableSignalFromEvent(this, e.onDidChangeModel).map(() => e.getModel()?.uri)) : undefined)).map((o, reader) => o?.read(reader)));
+        const selectionObs = ( ( activeEditor.map(e => e ? ( observableSignalFromEvent(this, e.onDidChangeCursorSelection).map(() => ({
+            range: e.getSelection(),
+            model: e.getModel()
+        }))) : undefined)).map((o, reader) => o?.read(reader)));
+        return derived(reader => {
+            const resource = resourceObs.read(reader);
+            if (!resource) {
+                return {
+                    busy: false,
+                    picks: []
+                };
+            }
+            const items = [];
+            items.push({
+                id: "active-file",
+                label: ( localize(9204, "Active File")),
+                description: this._labelService.getUriLabel(resource),
+                iconClasses: getIconClasses(this._modelService, this._languageService, resource),
+                uri: resource,
+                action: "file"
+            });
+            const selection = selectionObs.read(reader);
+            if (selection && selection.model && selection.range && !selection.range.isEmpty()) {
+                const selectedText = selection.model.getValueInRange(selection.range);
+                const lineCount = selection.range.endLineNumber - selection.range.startLineNumber + 1;
+                const description = lineCount === 1 ? ( localize(9205, "line {0}", selection.range.startLineNumber)) : ( localize(9206, "{0} lines", lineCount));
+                items.push({
+                    id: "selected-text",
+                    label: ( localize(9207, "Selected Text")),
+                    description,
+                    selectedText,
+                    iconClass: ThemeIcon.asClassName(Codicon.selection),
+                    uri: resource,
+                    action: "selectedText"
+                });
+            }
+            return {
+                picks: items,
+                busy: false
+            };
+        });
+    }
+    _asyncCompletions(input, mapper) {
+        const promise = derived(reader => {
+            const queryValue = input.read(reader);
+            const cts = ( new CancellationTokenSource());
+            reader.store.add(toDisposable(() => cts.dispose(true)));
+            return ( new ObservablePromise(
+                timeout(SUGGEST_DEBOUNCE, cts.token).then(() => mapper(queryValue, cts.token)).catch(() => [])
+            ));
+        });
+        return ( promise.map((value, reader) => {
+            const result = value.promiseResult.read(reader);
+            return {
+                picks: result?.data || [],
+                busy: result === undefined
+            };
+        }));
+    }
+    async _getTerminalOutput(command, token) {
+        const terminal = (this._terminal ??= this._register(await this._terminalService.createTerminal({
+            config: {
+                name: ( localize(9208, "MCP Terminal")),
+                isTransient: true,
+                forceShellIntegration: true,
+                isFeatureTerminal: true
+            },
+            location: TerminalLocation.Panel
+        })));
+        this._terminalService.setActiveInstance(terminal);
+        this._terminalGroupService.showPanel(false);
+        const shellIntegration = terminal.capabilities.get(TerminalCapability.CommandDetection);
+        if (shellIntegration) {
+            return this._getTerminalOutputInner(terminal, command, shellIntegration, token);
+        }
+        const store = ( new DisposableStore());
+        return await ( new Promise(resolve => {
+            store.add(terminal.capabilities.onDidAddCapability(e => {
+                if (e.id === TerminalCapability.CommandDetection) {
+                    store.dispose();
+                    resolve(this._getTerminalOutputInner(terminal, command, e.capability, token));
+                }
+            }));
+            store.add(token.onCancellationRequested(() => {
+                store.dispose();
+                resolve(undefined);
+            }));
+            store.add(disposableTimeout(() => {
+                store.dispose();
+                resolve(this._getTerminalOutputInner(terminal, command, undefined, token));
+            }, SHELL_INTEGRATION_TIMEOUT));
+        }));
+    }
+    async _getTerminalOutputInner(terminal, command, shellIntegration, token) {
+        const store = ( new DisposableStore());
+        return ( new Promise(resolve => {
+            let allData = "";
+            store.add(terminal.onLineData(d => allData += d + "\n"));
+            if (shellIntegration) {
+                store.add(shellIntegration.onCommandFinished(e => resolve(e.getOutput() || allData)));
+            } else {
+                const done = store.add(( new RunOnceScheduler(() => resolve(allData), NO_SHELL_INTEGRATION_IDLE)));
+                store.add(terminal.onData(() => done.schedule()));
+            }
+            store.add(token.onCancellationRequested(() => resolve(undefined)));
+            store.add(terminal.onDisposed(() => resolve(undefined)));
+            terminal.runCommand(command, true);
+        })).finally(() => {
+            store.dispose();
+        });
+    }
+};
+McpPromptArgumentPick = ( __decorate([( __param(1, IQuickInputService)), ( __param(2, ITerminalService)), ( __param(3, ISearchService)), ( __param(4, IWorkspaceContextService)), ( __param(5, ILabelService)), ( __param(6, IFileService)), ( __param(7, IModelService)), ( __param(8, ILanguageService)), ( __param(9, ITerminalGroupService)), ( __param(10, IInstantiationService)), ( __param(11, ICodeEditorService)), ( __param(12, IEditorService))], McpPromptArgumentPick));
+
+export { McpPromptArgumentPick };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chat/notebookChatUtils.d.ts

@@ -0,0 +1,4 @@
+import { INotebookOutputVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries";
+import { ICellOutputViewModel, INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+export declare const NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT_CONST: string[];
+export declare function createNotebookOutputVariableEntry(outputViewModel: ICellOutputViewModel, mimeType: string, notebookEditor: INotebookEditor): INotebookOutputVariableEntry | undefined;

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chat/notebookChatUtils.js

@@ -0,0 +1,58 @@
+
+import { normalizeDriveLetter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/labels';
+import { basenameOrAuthority } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+
+const NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT_CONST = [
+    "text/plain",
+    "text/html",
+    "application/vnd.code.notebook.error",
+    "application/vnd.code.notebook.stdout",
+    "application/x.notebook.stdout",
+    "application/x.notebook.stream",
+    "application/vnd.code.notebook.stderr",
+    "application/x.notebook.stderr",
+    "image/png",
+    "image/jpeg",
+    "image/svg"
+];
+function createNotebookOutputVariableEntry(outputViewModel, mimeType, notebookEditor) {
+    const cellFromViewModelHandle = outputViewModel.cellViewModel.handle;
+    const notebookModel = notebookEditor.textModel;
+    const cell = notebookEditor.getCellByHandle(cellFromViewModelHandle);
+    if (!cell || cell.outputsViewModels.length === 0 || !notebookModel) {
+        return;
+    }
+    const notebookUri = notebookModel.uri;
+    const cellUri = cell.uri;
+    const cellIndex = notebookModel.cells.indexOf(cell.model);
+    const outputId = outputViewModel?.model.outputId;
+    let outputIndex = 0;
+    if (outputId !== undefined) {
+        outputIndex = cell.outputsViewModels.findIndex(output => {
+            return output.model.outputId === outputId;
+        });
+    }
+    const outputCellUri = CellUri.generateCellOutputUriWithIndex(notebookUri, cellUri, outputIndex);
+    const fileName = normalizeDriveLetter(basenameOrAuthority(notebookUri));
+    const l = {
+        value: outputCellUri,
+        id: ( outputCellUri.toString()),
+        name: ( localize(
+            9573,
+            "{0} • Cell {1} • Output {2}",
+            fileName,
+            `${cellIndex + 1}`,
+            `${outputIndex + 1}`
+        )),
+        icon: mimeType === "application/vnd.code.notebook.error" ? ThemeIcon.fromId("error") : undefined,
+        kind: "notebookOutput",
+        outputIndex,
+        mimeType
+    };
+    return l;
+}
+
+export { NOTEBOOK_CELL_OUTPUT_MIME_TYPE_LIST_FOR_CHAT_CONST, createNotebookOutputVariableEntry };

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/chat/cellChatActions.d.ts

@@ -0,0 +1,7 @@
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { EditorAction2 } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions";
+export declare class AcceptChangesAndRun extends EditorAction2 {
+    constructor();
+    runEditorCommand(accessor: ServicesAccessor, codeEditor: ICodeEditor): Promise<void> | undefined;
+}