@codingame/monaco-vscode-chat-service-override 23.3.0 → 24.1.1

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

@@ -0,0 +1,43 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IViewDescriptorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service";
+import { IChatModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
+export interface IChatViewTitleDelegate {
+    updateTitle(title: string): void;
+    focusChat(): void;
+}
+export declare class ChatViewTitleControl extends Disposable {
+    private readonly container;
+    private readonly delegate;
+    private readonly configurationService;
+    private readonly viewDescriptorService;
+    private readonly instantiationService;
+    private static readonly DEFAULT_TITLE;
+    private readonly _onDidChangeHeight;
+    readonly onDidChangeHeight: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private get viewContainerModel();
+    private title;
+    private titleContainer;
+    private titleLabel;
+    private titleIcon;
+    private model;
+    private modelDisposables;
+    private navigationToolbar?;
+    private actionsToolbar?;
+    private lastKnownHeight;
+    constructor(container: HTMLElement, delegate: IChatViewTitleDelegate, configurationService: IConfigurationService, viewDescriptorService: IViewDescriptorService, instantiationService: IInstantiationService);
+    private registerListeners;
+    private render;
+    update(model: IChatModel | undefined): void;
+    private doUpdate;
+    private updateIcon;
+    private getIcon;
+    private getIconHoverContent;
+    private updateTitle;
+    private shouldRender;
+    private isEnabled;
+    getSingleViewPaneContainerTitle(): string | undefined;
+    private getTitleWithPrefix;
+    getHeight(): number;
+}

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

@@ -0,0 +1,204 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import * as chatViewTitleControl from './media/chatViewTitleControl.css';
+import { h, EventType as EventType$1, addDisposableListener } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/markdownRenderer';
+import { Gesture, EventType } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+import { getBaseLayerHoverDelegate } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/hover/hoverDelegate2';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { MarshalledId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IViewDescriptorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/views.service';
+import { LayoutSettings, ActivityBarPosition } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
+import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatViewId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { AgentSessionProviders, getAgentSessionProviderIcon, getAgentSessionProviderName } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+
+var ChatViewTitleControl_1;
+registerCss(chatViewTitleControl);
+let ChatViewTitleControl = class ChatViewTitleControl extends Disposable {
+    static { ChatViewTitleControl_1 = this; }
+    static { this.DEFAULT_TITLE = ( localize(5650, "Chat")); }
+    get viewContainerModel() {
+        const viewContainer = this.viewDescriptorService.getViewContainerByViewId(ChatViewId);
+        if (viewContainer) {
+            return this.viewDescriptorService.getViewContainerModel(viewContainer);
+        }
+        return undefined;
+    }
+    constructor(container, delegate, configurationService, viewDescriptorService, instantiationService) {
+        super();
+        this.container = container;
+        this.delegate = delegate;
+        this.configurationService = configurationService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.instantiationService = instantiationService;
+        this._onDidChangeHeight = this._register(( new Emitter()));
+        this.onDidChangeHeight = this._onDidChangeHeight.event;
+        this.title = undefined;
+        this.modelDisposables = this._register(( new MutableDisposable()));
+        this.lastKnownHeight = 0;
+        this.render(this.container);
+        this.registerListeners();
+    }
+    registerListeners() {
+        if (this.viewContainerModel) {
+            this._register(this.viewContainerModel.onDidAddVisibleViewDescriptors(() => this.doUpdate()));
+            this._register(this.viewContainerModel.onDidRemoveVisibleViewDescriptors(() => this.doUpdate()));
+        }
+        this._register(this.configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(LayoutSettings.ACTIVITY_BAR_LOCATION) ||
+                e.affectsConfiguration(ChatConfiguration.ChatViewTitleEnabled)) {
+                this.doUpdate();
+            }
+        }));
+    }
+    render(parent) {
+        const elements = h('div.chat-view-title-container', [
+            h('div.chat-view-title-navigation-toolbar@navigationToolbar'),
+            h('span.chat-view-title-icon@icon'),
+            h('span.chat-view-title-label@label'),
+            h('div.chat-view-title-actions-toolbar@actionsToolbar'),
+        ]);
+        this.navigationToolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, elements.navigationToolbar, MenuId.ChatViewSessionTitleNavigationToolbar, {
+            menuOptions: { shouldForwardArgs: true },
+            hiddenItemStrategy: HiddenItemStrategy.NoHide
+        }));
+        this.actionsToolbar = this._register(this.instantiationService.createInstance(MenuWorkbenchToolBar, elements.actionsToolbar, MenuId.ChatViewSessionTitleToolbar, {
+            menuOptions: { shouldForwardArgs: true },
+            hiddenItemStrategy: HiddenItemStrategy.NoHide
+        }));
+        this.titleContainer = elements.root;
+        this.titleLabel = elements.label;
+        this.titleIcon = elements.icon;
+        this._register(getBaseLayerHoverDelegate().setupDelayedHoverAtMouse(this.titleIcon, () => ({
+            content: this.getIconHoverContent() ?? '',
+            appearance: { compact: true }
+        })));
+        this._register(Gesture.addTarget(this.titleContainer));
+        for (const eventType of [EventType.Tap, EventType$1.CLICK]) {
+            this._register(addDisposableListener(this.titleContainer, eventType, () => {
+                this.delegate.focusChat();
+            }));
+        }
+        parent.appendChild(this.titleContainer);
+    }
+    update(model) {
+        this.model = model;
+        this.modelDisposables.value = model?.onDidChange(e => {
+            if (e.kind === 'setCustomTitle' || e.kind === 'addRequest') {
+                this.doUpdate();
+            }
+        });
+        this.doUpdate();
+    }
+    doUpdate() {
+        const markdownTitle = ( new MarkdownString(this.model?.title ?? ''));
+        this.title = renderAsPlaintext(markdownTitle);
+        this.delegate.updateTitle(this.getTitleWithPrefix());
+        this.updateTitle(this.title ?? ChatViewTitleControl_1.DEFAULT_TITLE);
+        this.updateIcon();
+        const context = this.model && {
+            $mid: MarshalledId.ChatViewContext,
+            sessionResource: this.model.sessionResource
+        };
+        if (this.navigationToolbar) {
+            this.navigationToolbar.context = context;
+        }
+        if (this.actionsToolbar) {
+            this.actionsToolbar.context = context;
+        }
+    }
+    updateIcon() {
+        if (!this.titleIcon) {
+            return;
+        }
+        const icon = this.getIcon();
+        if (icon) {
+            this.titleIcon.className = `chat-view-title-icon ${ThemeIcon.asClassName(icon)}`;
+        }
+        else {
+            this.titleIcon.className = 'chat-view-title-icon';
+        }
+    }
+    getIcon() {
+        const sessionType = this.model?.contributedChatSession?.chatSessionType;
+        switch (sessionType) {
+            case AgentSessionProviders.Background:
+            case AgentSessionProviders.Cloud:
+                return getAgentSessionProviderIcon(sessionType);
+        }
+        return undefined;
+    }
+    getIconHoverContent() {
+        const sessionType = this.model?.contributedChatSession?.chatSessionType;
+        switch (sessionType) {
+            case AgentSessionProviders.Background:
+            case AgentSessionProviders.Cloud:
+                return localize(5651, "{0} Agent Session", getAgentSessionProviderName(sessionType));
+        }
+        return undefined;
+    }
+    updateTitle(title) {
+        if (!this.titleContainer || !this.titleLabel) {
+            return;
+        }
+        this.titleContainer.classList.toggle('visible', this.shouldRender());
+        this.titleLabel.textContent = title;
+        const currentHeight = this.getHeight();
+        if (currentHeight !== this.lastKnownHeight) {
+            this.lastKnownHeight = currentHeight;
+            this._onDidChangeHeight.fire();
+        }
+    }
+    shouldRender() {
+        if (!this.isEnabled()) {
+            return false;
+        }
+        if (this.viewContainerModel && this.viewContainerModel.visibleViewDescriptors.length > 1) {
+            return false;
+        }
+        if (this.configurationService.getValue(LayoutSettings.ACTIVITY_BAR_LOCATION) !== ActivityBarPosition.DEFAULT) {
+            return false;
+        }
+        return !!this.model?.title;
+    }
+    isEnabled() {
+        return this.configurationService.getValue(ChatConfiguration.ChatViewTitleEnabled) === true;
+    }
+    getSingleViewPaneContainerTitle() {
+        if (!this.isEnabled() ||
+            this.shouldRender()
+        ) {
+            return undefined;
+        }
+        return this.getTitleWithPrefix();
+    }
+    getTitleWithPrefix() {
+        if (this.title) {
+            return localize(5652, "Chat: {0}", this.title);
+        }
+        return ChatViewTitleControl_1.DEFAULT_TITLE;
+    }
+    getHeight() {
+        if (!this.titleContainer || this.titleContainer.style.display === 'none') {
+            return 0;
+        }
+        return this.titleContainer.offsetHeight;
+    }
+};
+ChatViewTitleControl = ChatViewTitleControl_1 = ( __decorate([
+    ( __param(2, IConfigurationService)),
+    ( __param(3, IViewDescriptorService)),
+    ( __param(4, IInstantiationService))
+], ChatViewTitleControl));
+
+export { ChatViewTitleControl };

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

@@ -0,0 +1,44 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILayoutService } from "@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service";
+import { type PreferredGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IViewsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service";
+import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ChatViewPaneTarget, IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IQuickChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { IChatEditorOptions } from "./chatEditor.js";
+export declare class ChatWidgetService extends Disposable implements IChatWidgetService {
+    private readonly editorGroupsService;
+    private readonly viewsService;
+    private readonly quickChatService;
+    private readonly layoutService;
+    private readonly editorService;
+    readonly _serviceBrand: undefined;
+    private _widgets;
+    private _lastFocusedWidget;
+    private readonly _onDidAddWidget;
+    readonly onDidAddWidget: Event<IChatWidget>;
+    constructor(editorGroupsService: IEditorGroupsService, viewsService: IViewsService, quickChatService: IQuickChatService, layoutService: ILayoutService, editorService: IEditorService);
+    get lastFocusedWidget(): IChatWidget | undefined;
+    getAllWidgets(): ReadonlyArray<IChatWidget>;
+    getWidgetsByLocations(location: ChatAgentLocation): ReadonlyArray<IChatWidget>;
+    getWidgetByInputUri(uri: URI): IChatWidget | undefined;
+    getWidgetBySessionResource(sessionResource: URI): IChatWidget | undefined;
+    revealWidget(preserveFocus?: boolean): Promise<IChatWidget | undefined>;
+    reveal(widget: IChatWidget, preserveFocus?: boolean): Promise<boolean>;
+    /**
+     * Reveal the session if already open, otherwise open it.
+     */
+    openSession(sessionResource: URI, target?: typeof ChatViewPaneTarget): Promise<IChatWidget | undefined>;
+    openSession(sessionResource: URI, target?: PreferredGroup, options?: IChatEditorOptions): Promise<IChatWidget | undefined>;
+    private revealSessionIfAlreadyOpen;
+    private prepareSessionForMove;
+    private findExistingChatEditorByUri;
+    private isSameEditorTarget;
+    private setLastFocusedWidget;
+    register(newWidget: IChatWidget): IDisposable;
+}

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

@@ -0,0 +1,187 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { raceCancellablePromises, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Emitter, Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, combinedDisposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ILayoutService } from '@codingame/monaco-vscode-api/vscode/vs/platform/layout/browser/layoutService.service';
+import { ACTIVE_GROUP } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { isEditorGroup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { ChatViewId, isIChatViewViewContext, ChatViewPaneTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IQuickChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatEditor } from './chatEditor.js';
+import { ChatEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+
+let ChatWidgetService = class ChatWidgetService extends Disposable {
+    constructor(editorGroupsService, viewsService, quickChatService, layoutService, editorService) {
+        super();
+        this.editorGroupsService = editorGroupsService;
+        this.viewsService = viewsService;
+        this.quickChatService = quickChatService;
+        this.layoutService = layoutService;
+        this.editorService = editorService;
+        this._widgets = [];
+        this._lastFocusedWidget = undefined;
+        this._onDidAddWidget = this._register(( new Emitter()));
+        this.onDidAddWidget = this._onDidAddWidget.event;
+    }
+    get lastFocusedWidget() {
+        return this._lastFocusedWidget;
+    }
+    getAllWidgets() {
+        return this._widgets;
+    }
+    getWidgetsByLocations(location) {
+        return this._widgets.filter(w => w.location === location);
+    }
+    getWidgetByInputUri(uri) {
+        return this._widgets.find(w => isEqual(w.input.inputUri, uri));
+    }
+    getWidgetBySessionResource(sessionResource) {
+        return this._widgets.find(w => isEqual(w.viewModel?.sessionResource, sessionResource));
+    }
+    async revealWidget(preserveFocus) {
+        const last = this.lastFocusedWidget;
+        if (last && (await this.reveal(last, preserveFocus))) {
+            return last;
+        }
+        return (await this.viewsService.openView(ChatViewId, !preserveFocus))?.widget;
+    }
+    async reveal(widget, preserveFocus) {
+        if (widget.viewModel?.sessionResource) {
+            const alreadyOpenWidget = await this.revealSessionIfAlreadyOpen(widget.viewModel.sessionResource, { preserveFocus });
+            if (alreadyOpenWidget) {
+                return true;
+            }
+        }
+        if (isIChatViewViewContext(widget.viewContext)) {
+            const view = await this.viewsService.openView(widget.viewContext.viewId, !preserveFocus);
+            if (!preserveFocus) {
+                view?.focus();
+            }
+            return !!view;
+        }
+        return false;
+    }
+    async openSession(sessionResource, target, options) {
+        if (typeof target === 'undefined' || options?.revealIfOpened) {
+            const alreadyOpenWidget = await this.revealSessionIfAlreadyOpen(sessionResource, options);
+            if (alreadyOpenWidget) {
+                return alreadyOpenWidget;
+            }
+        }
+        else {
+            await this.prepareSessionForMove(sessionResource, target);
+        }
+        if (target === ChatViewPaneTarget) {
+            const chatView = await this.viewsService.openView(ChatViewId, !options?.preserveFocus);
+            if (chatView) {
+                await chatView.loadSession(sessionResource);
+                if (!options?.preserveFocus) {
+                    chatView.focusInput();
+                }
+            }
+            return chatView?.widget;
+        }
+        const pane = await this.editorService.openEditor({
+            resource: sessionResource,
+            options: {
+                ...options,
+                revealIfOpened: options?.revealIfOpened ?? true
+            }
+        }, target);
+        return pane instanceof ChatEditor ? pane.widget : undefined;
+    }
+    async revealSessionIfAlreadyOpen(sessionResource, options) {
+        const chatView = this.viewsService.getViewWithId(ChatViewId);
+        if (chatView?.widget.viewModel?.sessionResource && isEqual(chatView.widget.viewModel.sessionResource, sessionResource)) {
+            const view = await this.viewsService.openView(ChatViewId, !options?.preserveFocus);
+            if (!options?.preserveFocus) {
+                view?.focus();
+            }
+            return chatView.widget;
+        }
+        const existingEditor = this.findExistingChatEditorByUri(sessionResource);
+        if (existingEditor) {
+            const existingEditorWindowId = existingEditor.group.windowId;
+            const isGroupActive = () => getWindow(this.layoutService.activeContainer).vscodeWindowId === existingEditorWindowId;
+            let ensureFocusTransfer;
+            if (!isGroupActive()) {
+                ensureFocusTransfer = raceCancellablePromises([
+                    timeout(500),
+                    Event.toPromise(Event.once(Event.filter(this.layoutService.onDidChangeActiveContainer, isGroupActive))),
+                ]);
+            }
+            const pane = await existingEditor.group.openEditor(existingEditor.editor, options);
+            await ensureFocusTransfer;
+            return pane instanceof ChatEditor ? pane.widget : undefined;
+        }
+        if (isEqual(sessionResource, this.quickChatService.sessionResource)) {
+            this.quickChatService.focus();
+            return undefined;
+        }
+        return undefined;
+    }
+    async prepareSessionForMove(sessionResource, target) {
+        const existingWidget = this.getWidgetBySessionResource(sessionResource);
+        if (existingWidget) {
+            const existingEditor = isIChatViewViewContext(existingWidget.viewContext) ?
+                undefined :
+                this.findExistingChatEditorByUri(sessionResource);
+            if (isIChatViewViewContext(existingWidget.viewContext) && target === ChatViewPaneTarget) {
+                return;
+            }
+            if (!isIChatViewViewContext(existingWidget.viewContext) && target !== ChatViewPaneTarget && existingEditor && this.isSameEditorTarget(existingEditor.group.id, target)) {
+                return;
+            }
+            if (existingEditor) {
+                await this.editorService.closeEditor({ editor: existingEditor.editor, groupId: existingEditor.group.id }, { preserveFocus: true });
+            }
+            else {
+                await existingWidget.clear();
+            }
+        }
+    }
+    findExistingChatEditorByUri(sessionUri) {
+        for (const group of this.editorGroupsService.groups) {
+            for (const editor of group.editors) {
+                if (editor instanceof ChatEditorInput && isEqual(editor.sessionResource, sessionUri)) {
+                    return { editor, group };
+                }
+            }
+        }
+        return undefined;
+    }
+    isSameEditorTarget(currentGroupId, target) {
+        return typeof target === 'number' && target === currentGroupId ||
+            target === ACTIVE_GROUP && this.editorGroupsService.activeGroup?.id === currentGroupId ||
+            isEditorGroup(target) && target.id === currentGroupId;
+    }
+    setLastFocusedWidget(widget) {
+        if (widget === this._lastFocusedWidget) {
+            return;
+        }
+        this._lastFocusedWidget = widget;
+    }
+    register(newWidget) {
+        if (( this._widgets.some(widget => widget === newWidget))) {
+            throw ( new Error('Cannot register the same widget multiple times'));
+        }
+        this._widgets.push(newWidget);
+        this._onDidAddWidget.fire(newWidget);
+        return combinedDisposable(newWidget.onDidFocus(() => this.setLastFocusedWidget(newWidget)), toDisposable(() => this._widgets.splice(this._widgets.indexOf(newWidget), 1)));
+    }
+};
+ChatWidgetService = ( __decorate([
+    ( __param(0, IEditorGroupsService)),
+    ( __param(1, IViewsService)),
+    ( __param(2, IQuickChatService)),
+    ( __param(3, ILayoutService)),
+    ( __param(4, IEditorService))
+], ChatWidgetService));
+
+export { ChatWidgetService };

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

@@ -1,5 +1,5 @@
 import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ICodeBlockActionContextProvider } from "@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/browser/chat";
+import { ICodeBlockActionContextProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
 import { IChatCodeBlockContextProviderService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
 export declare class ChatCodeBlockContextProviderService implements IChatCodeBlockContextProviderService {
     _serviceBrand: undefined;