@codingame/monaco-vscode-chat-service-override 1.85.1

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

@@ -0,0 +1,110 @@
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import '../../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { CHAT_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatEditorInput } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { CONTEXT_PROVIDER_EXISTS } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { isExportableSessionData } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IFileDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+const defaultFileName = 'chat.json';
+const filters = [{ name: ( localizeWithPath(
+    'vs/workbench/contrib/chat/browser/actions/chatImportExport',
+    'chat.file.label',
+    "Chat Session"
+)), extensions: ['json'] }];
+function registerChatExportActions() {
+    registerAction2(class ExportChatAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.export',
+                category: CHAT_CATEGORY,
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatImportExport',
+                        'chat.export.label',
+                        "Export Session"
+                    )) + '...',
+                    original: 'Export Session...'
+                },
+                precondition: CONTEXT_PROVIDER_EXISTS,
+                f1: true,
+            });
+        }
+        async run(accessor, ...args) {
+            const widgetService = accessor.get(IChatWidgetService);
+            const fileDialogService = accessor.get(IFileDialogService);
+            const fileService = accessor.get(IFileService);
+            const chatService = accessor.get(IChatService);
+            const widget = widgetService.lastFocusedWidget;
+            if (!widget || !widget.viewModel) {
+                return;
+            }
+            const defaultUri = joinPath(await fileDialogService.defaultFilePath(), defaultFileName);
+            const result = await fileDialogService.showSaveDialog({
+                defaultUri,
+                filters
+            });
+            if (!result) {
+                return;
+            }
+            const model = chatService.getSession(widget.viewModel.sessionId);
+            if (!model) {
+                return;
+            }
+            const content = VSBuffer.fromString(JSON.stringify(model.toExport(), undefined, 2));
+            await fileService.writeFile(result, content);
+        }
+    });
+    registerAction2(class ImportChatAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.import',
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatImportExport',
+                        'chat.import.label',
+                        "Import Session"
+                    )) + '...',
+                    original: 'Import Session...'
+                },
+                category: CHAT_CATEGORY,
+                precondition: CONTEXT_PROVIDER_EXISTS,
+                f1: true,
+            });
+        }
+        async run(accessor, ...args) {
+            const fileDialogService = accessor.get(IFileDialogService);
+            const fileService = accessor.get(IFileService);
+            const editorService = accessor.get(IEditorService);
+            const defaultUri = joinPath(await fileDialogService.defaultFilePath(), defaultFileName);
+            const result = await fileDialogService.showOpenDialog({
+                defaultUri,
+                canSelectFiles: true,
+                filters
+            });
+            if (!result) {
+                return;
+            }
+            const content = await fileService.readFile(result[0]);
+            try {
+                const data = JSON.parse(( content.value.toString()));
+                if (!isExportableSessionData(data)) {
+                    throw new Error('Invalid chat session data');
+                }
+                await editorService.openEditor({ resource: ChatEditorInput.getNewEditorUri(), options: { target: { data }, pinned: true } });
+            }
+            catch (err) {
+                throw err;
+            }
+        }
+    });
+}
+
+export { registerChatExportActions };

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

@@ -0,0 +1,223 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ViewAction } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { ActiveEditorContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { CHAT_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatEditorInput } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import { CONTEXT_PROVIDER_EXISTS } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IChatContributionService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContributionService';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+var MoveToNewLocation;
+( (function(MoveToNewLocation) {
+    MoveToNewLocation["Editor"] = "Editor";
+    MoveToNewLocation["Window"] = "Window";
+})(MoveToNewLocation || (MoveToNewLocation = {})));
+const getMoveToChatActionDescriptorForViewTitle = (viewId, providerId, moveTo) => ({
+    id: `workbench.action.chat.${providerId}.openIn${moveTo}`,
+    title: {
+        value: moveTo === MoveToNewLocation.Editor ? ( localizeWithPath(
+            'vs/workbench/contrib/chat/browser/actions/chatMoveActions',
+            'chat.openInEditor.label',
+            "Open Session in Editor"
+        )) : ( localizeWithPath(
+            'vs/workbench/contrib/chat/browser/actions/chatMoveActions',
+            'chat.openInNewWindow.label',
+            "Open Session in New Window"
+        )),
+        original: moveTo === MoveToNewLocation.Editor ? 'Open Session in Editor' : 'Open Session in New Window',
+    },
+    category: CHAT_CATEGORY,
+    precondition: CONTEXT_PROVIDER_EXISTS,
+    f1: false,
+    viewId,
+    menu: {
+        id: MenuId.ViewTitle,
+        when: ( ContextKeyExpr.equals('view', viewId)),
+        order: 0
+    },
+});
+function getMoveToEditorAction(viewId, providerId) {
+    return getMoveToAction(viewId, providerId, MoveToNewLocation.Editor);
+}
+function getMoveToNewWindowAction(viewId, providerId) {
+    return getMoveToAction(viewId, providerId, MoveToNewLocation.Window);
+}
+function getMoveToAction(viewId, providerId, moveTo) {
+    return class MoveToAction extends ViewAction {
+        constructor() {
+            super(getMoveToChatActionDescriptorForViewTitle(viewId, providerId, moveTo));
+        }
+        async runInView(accessor, view) {
+            const viewModel = view.widget.viewModel;
+            if (!viewModel) {
+                return;
+            }
+            const editorGroupService = accessor.get(IEditorGroupsService);
+            const instantiationService = accessor.get(IInstantiationService);
+            const editorService = accessor.get(IEditorService);
+            const sessionId = viewModel.sessionId;
+            view.clear();
+            switch (moveTo) {
+                case (MoveToNewLocation.Editor): {
+                    await editorService.openEditor({ resource: ChatEditorInput.getNewEditorUri(), options: { target: { sessionId: viewModel.sessionId }, pinned: true } });
+                    break;
+                }
+                case (MoveToNewLocation.Window): {
+                    await openInNewWindow(instantiationService, editorGroupService, { target: { sessionId } });
+                    break;
+                }
+                default: {
+                    throw new Error(`Unexpected move to location : ${moveTo}`);
+                }
+            }
+        }
+    };
+}
+function registerMoveActions() {
+    registerAction2(class GlobalMoveToEditorAction extends Action2 {
+        constructor() {
+            super({
+                id: `workbench.action.chat.openInEditor`,
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatMoveActions',
+                        'interactiveSession.openInEditor.label',
+                        "Open Session in Editor"
+                    )),
+                    original: 'Open Session in Editor'
+                },
+                category: CHAT_CATEGORY,
+                precondition: CONTEXT_PROVIDER_EXISTS,
+                f1: true
+            });
+        }
+        async run(accessor, ...args) {
+            executeMoveToAction(accessor, MoveToNewLocation.Editor);
+        }
+    });
+    registerAction2(class GlobalMoveToNewWindowAction extends Action2 {
+        constructor() {
+            super({
+                id: `workbench.action.chat.openInNewWindow`,
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatMoveActions',
+                        'interactiveSession.openInNewWindow.label',
+                        "Open Session in New Window"
+                    )),
+                    original: 'Open Session In New Window'
+                },
+                category: CHAT_CATEGORY,
+                precondition: CONTEXT_PROVIDER_EXISTS,
+                f1: true
+            });
+        }
+        async run(accessor, ...args) {
+            executeMoveToAction(accessor, MoveToNewLocation.Window);
+        }
+    });
+    registerAction2(class GlobalMoveToSidebarAction extends Action2 {
+        constructor() {
+            super({
+                id: `workbench.action.chat.openInSidebar`,
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatMoveActions',
+                        'interactiveSession.openInSidebar.label',
+                        "Open Session in Side Bar"
+                    )),
+                    original: 'Open Session in Side Bar'
+                },
+                category: CHAT_CATEGORY,
+                precondition: CONTEXT_PROVIDER_EXISTS,
+                f1: true,
+                menu: [{
+                        id: MenuId.EditorTitle,
+                        order: 0,
+                        when: ( ActiveEditorContext.isEqualTo(ChatEditorInput.EditorID)),
+                    }]
+            });
+        }
+        async run(accessor, ...args) {
+            return moveToSidebar(accessor);
+        }
+    });
+}
+async function executeMoveToAction(accessor, moveTo) {
+    const widgetService = accessor.get(IChatWidgetService);
+    const viewService = accessor.get(IViewsService);
+    const chatService = accessor.get(IChatService);
+    const editorService = accessor.get(IEditorService);
+    const instantiationService = accessor.get(IInstantiationService);
+    const editorGroupService = accessor.get(IEditorGroupsService);
+    const widget = widgetService.lastFocusedWidget;
+    if (!widget || !('viewId' in widget.viewContext)) {
+        const providerId = chatService.getProviderInfos()[0].id;
+        switch (moveTo) {
+            case (MoveToNewLocation.Editor): {
+                await editorService.openEditor({ resource: ChatEditorInput.getNewEditorUri(), options: { target: { providerId }, pinned: true } });
+                break;
+            }
+            case (MoveToNewLocation.Window): {
+                await openInNewWindow(instantiationService, editorGroupService, { target: { providerId } });
+                break;
+            }
+            default: {
+                throw new Error(`Unexpected move to location : ${moveTo}`);
+            }
+        }
+        return;
+    }
+    const viewModel = widget.viewModel;
+    if (!viewModel) {
+        return;
+    }
+    const sessionId = viewModel.sessionId;
+    const view = await viewService.openView(widget.viewContext.viewId);
+    view.clear();
+    switch (moveTo) {
+        case (MoveToNewLocation.Editor): {
+            await editorService.openEditor({ resource: ChatEditorInput.getNewEditorUri(), options: { target: { sessionId: sessionId }, pinned: true } });
+            break;
+        }
+        case (MoveToNewLocation.Window): {
+            await openInNewWindow(instantiationService, editorGroupService, { target: { sessionId } });
+        }
+        default: {
+            throw new Error(`Unexpected move to location : ${moveTo}`);
+        }
+    }
+}
+async function openInNewWindow(intstantiationService, editorGroupService, options) {
+    const auxiliaryEditorPart = await editorGroupService.createAuxiliaryEditorPart();
+    const chatEditorInput = intstantiationService.createInstance(ChatEditorInput, ChatEditorInput.getNewEditorUri(), options);
+    await auxiliaryEditorPart.activeGroup.openEditor(chatEditorInput, { pinned: true });
+}
+async function moveToSidebar(accessor) {
+    const viewsService = accessor.get(IViewsService);
+    const editorService = accessor.get(IEditorService);
+    const chatContribService = accessor.get(IChatContributionService);
+    const editorGroupService = accessor.get(IEditorGroupsService);
+    const chatEditorInput = editorService.activeEditor;
+    if (chatEditorInput instanceof ChatEditorInput && chatEditorInput.sessionId && chatEditorInput.providerId) {
+        await editorService.closeEditor({ editor: chatEditorInput, groupId: editorGroupService.activeGroup.id });
+        const viewId = chatContribService.getViewIdForProvider(chatEditorInput.providerId);
+        const view = await viewsService.openView(viewId);
+        view.loadSession(chatEditorInput.sessionId);
+    }
+    else {
+        const chatService = accessor.get(IChatService);
+        const providerId = chatService.getProviderInfos()[0].id;
+        const viewId = chatContribService.getViewIdForProvider(providerId);
+        await viewsService.openView(viewId);
+    }
+}
+
+export { getMoveToAction, getMoveToEditorAction, getMoveToNewWindowAction, registerMoveActions };

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

@@ -0,0 +1,283 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { marked } from 'monaco-editor/esm/vs/base/common/marked/marked.js';
+import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { ResourceNotebookCellEdit } from 'vscode/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
+import { CHAT_CATEGORY } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { CONTEXT_RESPONSE_VOTE, CONTEXT_RESPONSE, CONTEXT_CHAT_RESPONSE_SUPPORT_ISSUE_REPORTING, CONTEXT_RESPONSE_FILTERED, CONTEXT_IN_CHAT_SESSION, CONTEXT_IN_CHAT_INPUT, CONTEXT_REQUEST } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { IChatService, InteractiveSessionVoteDirection } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+import { isResponseVM, isRequestVM } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { NOTEBOOK_EDITOR_ID, CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { NOTEBOOK_IS_ACTIVE_EDITOR } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+function registerChatTitleActions() {
+    registerAction2(class MarkHelpfulAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.markHelpful',
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
+                        'interactive.helpful.label',
+                        "Helpful"
+                    )),
+                    original: 'Helpful'
+                },
+                f1: false,
+                category: CHAT_CATEGORY,
+                icon: Codicon.thumbsup,
+                toggled: ( CONTEXT_RESPONSE_VOTE.isEqualTo('up')),
+                menu: {
+                    id: MenuId.ChatMessageTitle,
+                    group: 'navigation',
+                    order: 1,
+                    when: CONTEXT_RESPONSE
+                }
+            });
+        }
+        run(accessor, ...args) {
+            const item = args[0];
+            if (!isResponseVM(item)) {
+                return;
+            }
+            const chatService = accessor.get(IChatService);
+            chatService.notifyUserAction({
+                providerId: item.providerId,
+                agentId: item.agent?.id,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                action: {
+                    kind: 'vote',
+                    direction: InteractiveSessionVoteDirection.Up,
+                }
+            });
+            item.setVote(InteractiveSessionVoteDirection.Up);
+        }
+    });
+    registerAction2(class MarkUnhelpfulAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.markUnhelpful',
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
+                        'interactive.unhelpful.label',
+                        "Unhelpful"
+                    )),
+                    original: 'Unhelpful'
+                },
+                f1: false,
+                category: CHAT_CATEGORY,
+                icon: Codicon.thumbsdown,
+                toggled: ( CONTEXT_RESPONSE_VOTE.isEqualTo('down')),
+                menu: {
+                    id: MenuId.ChatMessageTitle,
+                    group: 'navigation',
+                    order: 2,
+                    when: CONTEXT_RESPONSE
+                }
+            });
+        }
+        run(accessor, ...args) {
+            const item = args[0];
+            if (!isResponseVM(item)) {
+                return;
+            }
+            const chatService = accessor.get(IChatService);
+            chatService.notifyUserAction({
+                providerId: item.providerId,
+                agentId: item.agent?.id,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                action: {
+                    kind: 'vote',
+                    direction: InteractiveSessionVoteDirection.Down,
+                }
+            });
+            item.setVote(InteractiveSessionVoteDirection.Down);
+        }
+    });
+    registerAction2(class ReportIssueForBugAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.reportIssueForBug',
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
+                        'interactive.reportIssueForBug.label',
+                        "Report Issue"
+                    )),
+                    original: 'Report Issue'
+                },
+                f1: false,
+                category: CHAT_CATEGORY,
+                icon: Codicon.report,
+                menu: {
+                    id: MenuId.ChatMessageTitle,
+                    group: 'navigation',
+                    order: 3,
+                    when: ( ContextKeyExpr.and(CONTEXT_CHAT_RESPONSE_SUPPORT_ISSUE_REPORTING, CONTEXT_RESPONSE))
+                }
+            });
+        }
+        run(accessor, ...args) {
+            const item = args[0];
+            if (!isResponseVM(item)) {
+                return;
+            }
+            const chatService = accessor.get(IChatService);
+            chatService.notifyUserAction({
+                providerId: item.providerId,
+                agentId: item.agent?.id,
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                action: {
+                    kind: 'bug'
+                }
+            });
+        }
+    });
+    registerAction2(class InsertToNotebookAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.insertIntoNotebook',
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
+                        'interactive.insertIntoNotebook.label',
+                        "Insert into Notebook"
+                    )),
+                    original: 'Insert into Notebook'
+                },
+                f1: false,
+                category: CHAT_CATEGORY,
+                icon: Codicon.insert,
+                menu: {
+                    id: MenuId.ChatMessageTitle,
+                    group: 'navigation',
+                    isHiddenByDefault: true,
+                    when: ( ContextKeyExpr.and(NOTEBOOK_IS_ACTIVE_EDITOR, CONTEXT_RESPONSE, ( CONTEXT_RESPONSE_FILTERED.negate())))
+                }
+            });
+        }
+        async run(accessor, ...args) {
+            const item = args[0];
+            if (!isResponseVM(item)) {
+                return;
+            }
+            const editorService = accessor.get(IEditorService);
+            if (editorService.activeEditorPane?.getId() === NOTEBOOK_EDITOR_ID) {
+                const notebookEditor = editorService.activeEditorPane.getControl();
+                if (!notebookEditor.hasModel()) {
+                    return;
+                }
+                if (notebookEditor.isReadOnly) {
+                    return;
+                }
+                const value = item.response.asString();
+                const splitContents = splitMarkdownAndCodeBlocks(value);
+                const focusRange = notebookEditor.getFocus();
+                const index = Math.max(focusRange.end, 0);
+                const bulkEditService = accessor.get(IBulkEditService);
+                await bulkEditService.apply([
+                    ( new ResourceNotebookCellEdit(notebookEditor.textModel.uri, {
+                        editType: 1 ,
+                        index: index,
+                        count: 0,
+                        cells: ( splitContents.map(content => {
+                            const kind = content.type === 'markdown' ? CellKind.Markup : CellKind.Code;
+                            const language = content.type === 'markdown' ? 'markdown' : content.language;
+                            const mime = content.type === 'markdown' ? 'text/markdown' : `text/x-${content.language}`;
+                            return {
+                                cellKind: kind,
+                                language,
+                                mime,
+                                source: content.content,
+                                outputs: [],
+                                metadata: {}
+                            };
+                        }))
+                    }))
+                ], { quotableLabel: 'Insert into Notebook' });
+            }
+        }
+    });
+    registerAction2(class RemoveAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.chat.remove',
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
+                        'chat.remove.label',
+                        "Remove Request and Response"
+                    )),
+                    original: 'Remove Request and Response'
+                },
+                f1: false,
+                category: CHAT_CATEGORY,
+                icon: Codicon.x,
+                keybinding: {
+                    primary: 20 ,
+                    mac: {
+                        primary: 2048  | 1 ,
+                    },
+                    when: ( ContextKeyExpr.and(CONTEXT_IN_CHAT_SESSION, ( CONTEXT_IN_CHAT_INPUT.negate()))),
+                    weight: 200 ,
+                },
+                menu: {
+                    id: MenuId.ChatMessageTitle,
+                    group: 'navigation',
+                    order: 2,
+                    when: CONTEXT_REQUEST
+                }
+            });
+        }
+        run(accessor, ...args) {
+            let item = args[0];
+            if (!isRequestVM(item)) {
+                const chatWidgetService = accessor.get(IChatWidgetService);
+                const widget = chatWidgetService.lastFocusedWidget;
+                item = widget?.getFocus();
+            }
+            const requestId = isRequestVM(item) ? item.id :
+                isResponseVM(item) ? item.requestId : undefined;
+            if (requestId) {
+                const chatService = accessor.get(IChatService);
+                chatService.removeRequest(item.sessionId, requestId);
+            }
+        }
+    });
+}
+function splitMarkdownAndCodeBlocks(markdown) {
+    const lexer = new marked.Lexer();
+    const tokens = lexer.lex(markdown);
+    const splitContent = [];
+    let markdownPart = '';
+    tokens.forEach((token) => {
+        if (token.type === 'code') {
+            if (markdownPart.trim()) {
+                splitContent.push({ type: 'markdown', content: markdownPart });
+                markdownPart = '';
+            }
+            splitContent.push({
+                type: 'code',
+                language: token.lang || '',
+                content: token.text,
+            });
+        }
+        else {
+            markdownPart += token.raw;
+        }
+    });
+    if (markdownPart.trim()) {
+        splitContent.push({ type: 'markdown', content: markdownPart });
+    }
+    return splitContent;
+}
+
+export { registerChatTitleActions };