@codingame/monaco-vscode-chat-service-override 3.2.3 → 4.1.0

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

@@ -1,179 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
-import { registerAction2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
-import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/views';
-import { getHistoryAction, getOpenChatEditorAction } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
-import { getNewChatAction } from './actions/chatClearActions.js';
-import { getMoveToEditorAction, getMoveToNewWindowAction } from './actions/chatMoveActions.js';
-import { getQuickChatActionForProvider } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatQuickInputActions';
-import { ChatViewPane, CHAT_SIDEBAR_PANEL_ID } from './chatViewPane.js';
-import { IChatContributionService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContributionService';
-import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
-
-const chatExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'interactiveSession',
-    jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/contrib/chat/browser/chatContributionServiceImpl',
-            'vscode.extension.contributes.interactiveSession',
-            'Contributes an Interactive Session provider'
-        )),
-        type: 'array',
-        items: {
-            additionalProperties: false,
-            type: 'object',
-            defaultSnippets: [{ body: { id: '', program: '', runtime: '' } }],
-            required: ['id', 'label'],
-            properties: {
-                id: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/chat/browser/chatContributionServiceImpl',
-                        'vscode.extension.contributes.interactiveSession.id',
-                        "Unique identifier for this Interactive Session provider."
-                    )),
-                    type: 'string'
-                },
-                label: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/chat/browser/chatContributionServiceImpl',
-                        'vscode.extension.contributes.interactiveSession.label',
-                        "Display name for this Interactive Session provider."
-                    )),
-                    type: 'string'
-                },
-                icon: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/chat/browser/chatContributionServiceImpl',
-                        'vscode.extension.contributes.interactiveSession.icon',
-                        "An icon for this Interactive Session provider."
-                    )),
-                    type: 'string'
-                },
-                when: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/chat/browser/chatContributionServiceImpl',
-                        'vscode.extension.contributes.interactiveSession.when',
-                        "A condition which must be true to enable this Interactive Session provider."
-                    )),
-                    type: 'string'
-                },
-            }
-        }
-    },
-    activationEventsGenerator: (contributions, result) => {
-        for (const contrib of contributions) {
-            result.push(`onInteractiveSession:${contrib.id}`);
-        }
-    },
-});
-let ChatExtensionPointHandler = class ChatExtensionPointHandler {
-    static { this.ID = 'workbench.contrib.chatExtensionPointHandler'; }
-    constructor(_chatContributionService) {
-        this._chatContributionService = _chatContributionService;
-        this._registrationDisposables = ( new Map());
-        this._viewContainer = this.registerViewContainer();
-        this.handleAndRegisterChatExtensions();
-    }
-    handleAndRegisterChatExtensions() {
-        chatExtensionPoint.setHandler((extensions, delta) => {
-            for (const extension of delta.added) {
-                const extensionDisposable = ( new DisposableStore());
-                for (const providerDescriptor of extension.value) {
-                    this.registerChatProvider(providerDescriptor);
-                    this._chatContributionService.registerChatProvider(providerDescriptor);
-                }
-                this._registrationDisposables.set(extension.description.identifier.value, extensionDisposable);
-            }
-            for (const extension of delta.removed) {
-                const registration = this._registrationDisposables.get(extension.description.identifier.value);
-                if (registration) {
-                    registration.dispose();
-                    this._registrationDisposables.delete(extension.description.identifier.value);
-                }
-                for (const providerDescriptor of extension.value) {
-                    this._chatContributionService.deregisterChatProvider(providerDescriptor.id);
-                }
-            }
-        });
-    }
-    registerViewContainer() {
-        const title = ( localize2WithPath(
-            'vs/workbench/contrib/chat/browser/chatContributionServiceImpl',
-            'chat.viewContainer.label',
-            "Chat"
-        ));
-        const icon = Codicon.commentDiscussion;
-        const viewContainerId = CHAT_SIDEBAR_PANEL_ID;
-        const viewContainer = ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
-            id: viewContainerId,
-            title,
-            icon,
-            ctorDescriptor: ( new SyncDescriptor(
-                ViewPaneContainer,
-                [viewContainerId, { mergeViewWithContainerWhenSingleView: true }]
-            )),
-            storageId: viewContainerId,
-            hideIfEmpty: true,
-            order: 100,
-        }, 0 );
-        return viewContainer;
-    }
-    registerChatProvider(providerDescriptor) {
-        const viewId = this._chatContributionService.getViewIdForProvider(providerDescriptor.id);
-        const viewDescriptor = [{
-                id: viewId,
-                containerIcon: this._viewContainer.icon,
-                containerTitle: this._viewContainer.title.value,
-                name: { value: providerDescriptor.label, original: providerDescriptor.label },
-                canToggleVisibility: false,
-                canMoveView: true,
-                ctorDescriptor: ( new SyncDescriptor(ChatViewPane, [{ providerId: providerDescriptor.id }])),
-                when: ContextKeyExpr.deserialize(providerDescriptor.when)
-            }];
-        ( Registry.as(Extensions.ViewsRegistry)).registerViews(viewDescriptor, this._viewContainer);
-        const disposables = ( new DisposableStore());
-        disposables.add(registerAction2(getHistoryAction(viewId, providerDescriptor.id)));
-        disposables.add(registerAction2(getNewChatAction(viewId, providerDescriptor.id)));
-        disposables.add(registerAction2(getMoveToEditorAction(viewId, providerDescriptor.id)));
-        disposables.add(registerAction2(getMoveToNewWindowAction(viewId, providerDescriptor.id)));
-        disposables.add(registerAction2(getOpenChatEditorAction(providerDescriptor.id, providerDescriptor.label, providerDescriptor.when)));
-        disposables.add(registerAction2(getQuickChatActionForProvider(providerDescriptor.id, providerDescriptor.label)));
-        return {
-            dispose: () => {
-                ( Registry.as(Extensions.ViewsRegistry)).deregisterViews(viewDescriptor, this._viewContainer);
-                ( Registry.as(Extensions.ViewContainersRegistry)).deregisterViewContainer(this._viewContainer);
-                disposables.dispose();
-            }
-        };
-    }
-};
-ChatExtensionPointHandler = ( __decorate([
-    ( __param(0, IChatContributionService))
-], ChatExtensionPointHandler));
-registerWorkbenchContribution2(ChatExtensionPointHandler.ID, ChatExtensionPointHandler, 1 );
-class ChatContributionService {
-    constructor() {
-        this._registeredProviders = ( new Map());
-    }
-    getViewIdForProvider(providerId) {
-        return ChatViewPane.ID + '.' + providerId;
-    }
-    registerChatProvider(provider) {
-        this._registeredProviders.set(provider.id, provider);
-    }
-    deregisterChatProvider(providerId) {
-        this._registeredProviders.delete(providerId);
-    }
-    get registeredProviders() {
-        return Array.from(( this._registeredProviders.values()));
-    }
-}
-
-export { ChatContributionService, ChatExtensionPointHandler };

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

@@ -1,87 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
-import { editorForeground, editorBackground, inputBackground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
-import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
-import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
-import { ChatEditorInput } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
-import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
-import { clearChatEditor } from './actions/chatClear.js';
-
-let ChatEditor = class ChatEditor extends EditorPane {
-    get scopedContextKeyService() {
-        return this._scopedContextKeyService;
-    }
-    constructor(telemetryService, themeService, instantiationService, storageService, contextKeyService) {
-        super(ChatEditorInput.EditorID, telemetryService, themeService, storageService);
-        this.instantiationService = instantiationService;
-        this.storageService = storageService;
-        this.contextKeyService = contextKeyService;
-    }
-    async clear() {
-        return this.instantiationService.invokeFunction(clearChatEditor);
-    }
-    createEditor(parent) {
-        this._scopedContextKeyService = this._register(this.contextKeyService.createScoped(parent));
-        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
-        this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, { resource: true }, { supportsFileReferences: true }, {
-            listForeground: editorForeground,
-            listBackground: editorBackground,
-            inputEditorBackground: inputBackground,
-            resultEditorBackground: editorBackground
-        }));
-        this._register(this.widget.onDidClear(() => this.clear()));
-        this.widget.render(parent);
-        this.widget.setVisible(true);
-    }
-    focus() {
-        super.focus();
-        this.widget?.focusInput();
-    }
-    clearInput() {
-        this.saveState();
-        super.clearInput();
-    }
-    async setInput(input, options, context, token) {
-        super.setInput(input, options, context, token);
-        const editorModel = await input.resolve();
-        if (!editorModel) {
-            throw new Error(`Failed to get model for chat editor. id: ${input.sessionId}`);
-        }
-        if (!this.widget) {
-            throw new Error('ChatEditor lifecycle issue: no editor widget');
-        }
-        this.updateModel(editorModel.model, options?.viewState ?? input.options.viewState);
-    }
-    updateModel(model, viewState) {
-        this._memento = ( new Memento('interactive-session-editor-' + model.providerId, this.storageService));
-        this._viewState = viewState ?? this._memento.getMemento(1 , 1 );
-        this.widget.setModel(model, { ...this._viewState });
-    }
-    saveState() {
-        this.widget?.saveState();
-        if (this._memento && this._viewState) {
-            const widgetViewState = this.widget.getViewState();
-            this._viewState.inputValue = widgetViewState.inputValue;
-            this._memento.saveMemento();
-        }
-    }
-    layout(dimension, position) {
-        if (this.widget) {
-            this.widget.layout(dimension.height, dimension.width);
-        }
-    }
-};
-ChatEditor = ( __decorate([
-    ( __param(0, ITelemetryService)),
-    ( __param(1, IThemeService)),
-    ( __param(2, IInstantiationService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, IContextKeyService))
-], ChatEditor));
-
-export { ChatEditor };

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

@@ -1,271 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { isAncestorOfActiveElement, $ } from 'vscode/vscode/vs/base/browser/dom';
-import { Sash } from 'vscode/vscode/vs/base/browser/ui/sash/sash';
-import { disposableTimeout } from 'vscode/vscode/vs/base/common/async';
-import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { Disposable, MutableDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
-import { ILayoutService } from 'vscode/vscode/vs/platform/layout/browser/layoutService';
-import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput';
-import { quickInputForeground, quickInputBackground, inputBackground, editorBackground } from 'vscode/vscode/vs/platform/theme/common/colorRegistry';
-import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
-import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
-import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
-
-var QuickChat_1;
-let QuickChatService = class QuickChatService extends Disposable {
-    constructor(quickInputService, chatService, instantiationService) {
-        super();
-        this.quickInputService = quickInputService;
-        this.chatService = chatService;
-        this.instantiationService = instantiationService;
-        this._onDidClose = this._register(( new Emitter()));
-        this.onDidClose = this._onDidClose.event;
-    }
-    get enabled() {
-        return this.chatService.getProviderInfos().length > 0;
-    }
-    get focused() {
-        const widget = this._input?.widget;
-        if (!widget) {
-            return false;
-        }
-        return isAncestorOfActiveElement(widget);
-    }
-    toggle(providerId, options) {
-        if (this.focused && !options?.query) {
-            this.close();
-        }
-        else {
-            this.open(providerId, options);
-            if (options?.isPartialQuery) {
-                const disposable = this._store.add(Event.once(this.onDidClose)(() => {
-                    this._currentChat?.clearValue();
-                    this._store.delete(disposable);
-                }));
-            }
-        }
-    }
-    open(providerId, options) {
-        if (this._input) {
-            if (this._currentChat && options?.query) {
-                this._currentChat.setValue(options.query, options.selection);
-                if (!options.isPartialQuery) {
-                    this._currentChat.acceptInput();
-                }
-            }
-            return this.focus();
-        }
-        const providerInfo = providerId
-            ? this.chatService.getProviderInfos().find(info => info.id === providerId)
-            : this.chatService.getProviderInfos()[0];
-        if (!providerInfo) {
-            return;
-        }
-        const disposableStore = ( new DisposableStore());
-        this._input = this.quickInputService.createQuickWidget();
-        this._input.contextKey = 'chatInputVisible';
-        this._input.ignoreFocusOut = true;
-        disposableStore.add(this._input);
-        this._container ??= $('.interactive-session');
-        this._input.widget = this._container;
-        this._input.show();
-        if (!this._currentChat) {
-            this._currentChat = this.instantiationService.createInstance(QuickChat, {
-                providerId: providerInfo.id,
-            });
-            this._currentChat.render(this._container);
-        }
-        else {
-            this._currentChat.show();
-        }
-        disposableStore.add(this._input.onDidHide(() => {
-            disposableStore.dispose();
-            this._currentChat.hide();
-            this._input = undefined;
-            this._onDidClose.fire();
-        }));
-        this._currentChat.focus();
-        if (options?.query) {
-            this._currentChat.setValue(options.query, options.selection);
-            if (!options.isPartialQuery) {
-                this._currentChat.acceptInput();
-            }
-        }
-    }
-    focus() {
-        this._currentChat?.focus();
-    }
-    close() {
-        this._input?.dispose();
-        this._input = undefined;
-    }
-    async openInChatView() {
-        await this._currentChat?.openChatView();
-        this.close();
-    }
-};
-QuickChatService = ( __decorate([
-    ( __param(0, IQuickInputService)),
-    ( __param(1, IChatService)),
-    ( __param(2, IInstantiationService))
-], QuickChatService));
-let QuickChat = class QuickChat extends Disposable {
-    static { QuickChat_1 = this; }
-    static { this.DEFAULT_MIN_HEIGHT = 200; }
-    static { this.DEFAULT_HEIGHT_OFFSET = 100; }
-    constructor(_options, instantiationService, contextKeyService, chatService, _chatWidgetService, layoutService) {
-        super();
-        this._options = _options;
-        this.instantiationService = instantiationService;
-        this.contextKeyService = contextKeyService;
-        this.chatService = chatService;
-        this._chatWidgetService = _chatWidgetService;
-        this.layoutService = layoutService;
-        this.maintainScrollTimer = this._register(( new MutableDisposable()));
-        this._deferUpdatingDynamicLayout = false;
-    }
-    clear() {
-        this.model?.dispose();
-        this.model = undefined;
-        this.updateModel();
-        this.widget.inputEditor.setValue('');
-    }
-    focus(selection) {
-        if (this.widget) {
-            this.widget.focusInput();
-            const value = this.widget.inputEditor.getValue();
-            if (value) {
-                this.widget.inputEditor.setSelection(selection ?? {
-                    startLineNumber: 1,
-                    startColumn: 1,
-                    endLineNumber: 1,
-                    endColumn: value.length + 1
-                });
-            }
-        }
-    }
-    hide() {
-        this.widget.setVisible(false);
-        this.maintainScrollTimer.value = disposableTimeout(() => {
-            this.maintainScrollTimer.clear();
-        }, 30 * 1000);
-    }
-    show() {
-        this.widget.setVisible(true);
-        if (this._deferUpdatingDynamicLayout) {
-            this._deferUpdatingDynamicLayout = false;
-            this.widget.updateDynamicChatTreeItemLayout(2, this.maxHeight);
-        }
-        if (!this.maintainScrollTimer.value) {
-            this.widget.layoutDynamicChatTreeItemMode();
-        }
-    }
-    render(parent) {
-        if (this.widget) {
-            throw new Error('Cannot render quick chat twice');
-        }
-        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([
-            IContextKeyService,
-            this._register(this.contextKeyService.createScoped(parent))
-        ])));
-        this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, { resource: true }, { renderInputOnTop: true, renderStyle: 'compact' }, {
-            listForeground: quickInputForeground,
-            listBackground: quickInputBackground,
-            inputEditorBackground: inputBackground,
-            resultEditorBackground: editorBackground
-        }));
-        this.widget.render(parent);
-        this.widget.setVisible(true);
-        this.widget.setDynamicChatTreeItemLayout(2, this.maxHeight);
-        this.updateModel();
-        this.sash = this._register(( new Sash(
-            parent,
-            { getHorizontalSashTop: () => parent.offsetHeight },
-            { orientation: 1  }
-        )));
-        this.registerListeners(parent);
-    }
-    get maxHeight() {
-        return this.layoutService.mainContainerDimension.height - QuickChat_1.DEFAULT_HEIGHT_OFFSET;
-    }
-    registerListeners(parent) {
-        this._register(this.layoutService.onDidLayoutMainContainer(() => {
-            if (this.widget.visible) {
-                this.widget.updateDynamicChatTreeItemLayout(2, this.maxHeight);
-            }
-            else {
-                this._deferUpdatingDynamicLayout = true;
-            }
-        }));
-        this._register(this.widget.inputEditor.onDidChangeModelContent((e) => {
-            this._currentQuery = this.widget.inputEditor.getValue();
-        }));
-        this._register(this.widget.onDidClear(() => this.clear()));
-        this._register(this.widget.onDidChangeHeight((e) => this.sash.layout()));
-        const width = parent.offsetWidth;
-        this._register(this.sash.onDidStart(() => {
-            this.widget.isDynamicChatTreeItemLayoutEnabled = false;
-        }));
-        this._register(this.sash.onDidChange((e) => {
-            if (e.currentY < QuickChat_1.DEFAULT_MIN_HEIGHT || e.currentY > this.maxHeight) {
-                return;
-            }
-            this.widget.layout(e.currentY, width);
-            this.sash.layout();
-        }));
-        this._register(this.sash.onDidReset(() => {
-            this.widget.isDynamicChatTreeItemLayoutEnabled = true;
-            this.widget.layoutDynamicChatTreeItemMode();
-        }));
-    }
-    async acceptInput() {
-        return this.widget.acceptInput();
-    }
-    async openChatView() {
-        const widget = await this._chatWidgetService.revealViewForProvider(this._options.providerId);
-        if (!widget?.viewModel || !this.model) {
-            return;
-        }
-        for (const request of this.model.getRequests()) {
-            if (request.response?.response.value || request.response?.result) {
-                this.chatService.addCompleteRequest(widget.viewModel.sessionId, request.message, request.variableData, {
-                    message: request.response.response.value,
-                    result: request.response.result,
-                    followups: request.response.followups
-                });
-            }
-        }
-        const value = this.widget.inputEditor.getValue();
-        if (value) {
-            widget.inputEditor.setValue(value);
-        }
-        widget.focusInput();
-    }
-    setValue(value, selection) {
-        this.widget.inputEditor.setValue(value);
-        this.focus(selection);
-    }
-    clearValue() {
-        this.widget.inputEditor.setValue('');
-    }
-    updateModel() {
-        this.model ??= this.chatService.startSession(this._options.providerId, CancellationToken.None);
-        if (!this.model) {
-            throw new Error('Could not start chat session');
-        }
-        this.widget.setModel(this.model, { inputValue: this._currentQuery });
-    }
-};
-QuickChat = QuickChat_1 = ( __decorate([
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IChatService)),
-    ( __param(4, IChatWidgetService)),
-    ( __param(5, ILayoutService))
-], QuickChat));
-
-export { QuickChatService };

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

@@ -1,74 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
-import { onUnexpectedExternalError } from 'vscode/vscode/vs/base/common/errors';
-import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
-import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
-import { ChatDynamicVariableModel } from 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
-import { ChatRequestVariablePart, ChatRequestDynamicVariablePart } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
-
-let ChatVariablesService = class ChatVariablesService {
-    constructor(chatWidgetService) {
-        this.chatWidgetService = chatWidgetService;
-        this._resolver = ( new Map());
-    }
-    async resolveVariables(prompt, model, progress, token) {
-        let resolvedVariables = [];
-        const jobs = [];
-        prompt.parts
-            .forEach((part, i) => {
-            if (part instanceof ChatRequestVariablePart) {
-                const data = this._resolver.get(part.variableName.toLowerCase());
-                if (data) {
-                    jobs.push(data.resolver(prompt.text, part.variableArg, model, progress, token).then(values => {
-                        if (values?.length) {
-                            resolvedVariables[i] = { name: part.variableName, range: part.range, values };
-                        }
-                    }).catch(onUnexpectedExternalError));
-                }
-            }
-            else if (part instanceof ChatRequestDynamicVariablePart) {
-                resolvedVariables[i] = { name: part.referenceText, range: part.range, values: part.data };
-            }
-        });
-        await Promise.allSettled(jobs);
-        resolvedVariables = coalesce(resolvedVariables);
-        resolvedVariables.sort((a, b) => b.range.start - a.range.start);
-        return {
-            variables: resolvedVariables,
-        };
-    }
-    hasVariable(name) {
-        return ( this._resolver.has(name.toLowerCase()));
-    }
-    getVariables() {
-        const all = ( Iterable.map(( this._resolver.values()), data => data.data));
-        return Iterable.filter(all, data => !data.hidden);
-    }
-    getDynamicVariables(sessionId) {
-        const widget = this.chatWidgetService.getWidgetBySessionId(sessionId);
-        if (!widget || !widget.viewModel || !widget.supportsFileReferences) {
-            return [];
-        }
-        const model = widget.getContrib(ChatDynamicVariableModel.ID);
-        if (!model) {
-            return [];
-        }
-        return model.variables;
-    }
-    registerVariable(data, resolver) {
-        const key = data.name.toLowerCase();
-        if (( this._resolver.has(key))) {
-            throw new Error(`A chat variable with the name '${data.name}' already exists.`);
-        }
-        this._resolver.set(key, { data, resolver });
-        return toDisposable(() => {
-            this._resolver.delete(key);
-        });
-    }
-};
-ChatVariablesService = ( __decorate([
-    ( __param(0, IChatWidgetService))
-], ChatVariablesService));
-
-export { ChatVariablesService };