@codingame/monaco-vscode-api 4.1.0 → 4.1.1

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

@@ -1,269 +0,0 @@
-import { Codicon } from '../../../../../base/common/codicons.js';
-import marked_1 from '../../../../../../../../external/vscode-marked/lib/marked.esm.js';
-import { IBulkEditService } from '../../../../../editor/browser/services/bulkEditService.js';
-import { localize2WithPath } from '../../../../../nls.js';
-import { registerAction2, Action2, MenuId } from '../../../../../platform/actions/common/actions.js';
-import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
-import { ResourceNotebookCellEdit } from '../../../bulkEdit/browser/bulkCellEdits.js';
-import { CHAT_CATEGORY } from './chatActions.js';
-import { IChatWidgetService } from '../chat.js';
-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 '../../common/chatContextKeys.js';
-import { IChatService, InteractiveSessionVoteDirection } from '../../common/chatService.js';
-import { isResponseVM, isRequestVM } from '../../common/chatViewModel.js';
-import { NOTEBOOK_EDITOR_ID, CellKind } from '../../../notebook/common/notebookCommon.js';
-import { NOTEBOOK_IS_ACTIVE_EDITOR } from '../../../notebook/common/notebookContextKeys.js';
-import { IEditorService } from '../../../../services/editor/common/editorService.js';
-function registerChatTitleActions() {
-    registerAction2(class MarkHelpfulAction extends Action2 {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.markHelpful',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
-                    'interactive.helpful.label',
-                    "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,
-                result: item.result,
-                action: {
-                    kind: 'vote',
-                    direction: InteractiveSessionVoteDirection.Up,
-                }
-            });
-            item.setVote(InteractiveSessionVoteDirection.Up);
-        }
-    });
-    registerAction2(class MarkUnhelpfulAction extends Action2 {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.markUnhelpful',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
-                    'interactive.unhelpful.label',
-                    "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,
-                result: item.result,
-                action: {
-                    kind: 'vote',
-                    direction: InteractiveSessionVoteDirection.Down,
-                }
-            });
-            item.setVote(InteractiveSessionVoteDirection.Down);
-        }
-    });
-    registerAction2(class ReportIssueForBugAction extends Action2 {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.reportIssueForBug',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
-                    'interactive.reportIssueForBug.label',
-                    "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,
-                result: item.result,
-                action: {
-                    kind: 'bug'
-                }
-            });
-        }
-    });
-    registerAction2(class InsertToNotebookAction extends Action2 {
-        constructor() {
-            super({
-                id: 'workbench.action.chat.insertIntoNotebook',
-                title: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
-                    'interactive.insertIntoNotebook.label',
-                    "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: ( localize2WithPath(
-                    'vs/workbench/contrib/chat/browser/actions/chatTitleActions',
-                    'chat.remove.label',
-                    "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_1.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 };

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

@@ -1,316 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { isMarkdownString, MarkdownString } from '../../../../base/common/htmlContent.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { Schemas } from '../../../../base/common/network.js';
-import { isMacintosh } from '../../../../base/common/platform.js';
-import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.js';
-import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { EditorPaneDescriptor } from '../../../browser/editor.js';
-import { registerWorkbenchContribution2, Extensions as Extensions$1 } from '../../../common/contributions.js';
-import { EditorExtensions } from '../../../common/editor.js';
-import { alertFocusChange } from '../../accessibility/browser/accessibilityContributions.js';
-import { IAccessibleViewService } from '../../accessibility/browser/accessibleView.js';
-import { AccessibleViewAction } from '../../accessibility/browser/accessibleViewActions.js';
-import { registerChatActions } from './actions/chatActions.js';
-import { registerNewChatActions, ACTION_ID_NEW_CHAT } from './actions/chatClearActions.js';
-import { registerChatCodeBlockActions } from './actions/chatCodeblockActions.js';
-import { registerChatCopyActions } from './actions/chatCopyActions.js';
-import { registerChatExecuteActions, SubmitAction } from './actions/chatExecuteActions.js';
-import { registerChatFileTreeActions } from './actions/chatFileTreeActions.js';
-import { registerChatExportActions } from './actions/chatImportExport.js';
-import { registerMoveActions } from './actions/chatMoveActions.js';
-import { registerQuickChatActions } from './actions/chatQuickInputActions.js';
-import { registerChatTitleActions } from './actions/chatTitleActions.js';
-import { IChatWidgetService } from './chat.js';
-import './chatAccessibilityService.js';
-import './chatContributionServiceImpl.js';
-import { ChatEditor } from './chatEditor.js';
-import { ChatEditorInput, ChatEditorInputSerializer } from './chatEditorInput.js';
-import './chatQuick.js';
-import './chatVariables.js';
-import './chatWidget.js';
-import './contrib/chatHistoryVariables.js';
-import './contrib/chatInputEditorContrib.js';
-import { ChatAgentLocation, IChatAgentService } from '../common/chatAgents.js';
-import { CONTEXT_IN_CHAT_SESSION } from '../common/chatContextKeys.js';
-import { ChatWelcomeMessageModel } from '../common/chatModel.js';
-import { chatSubcommandLeader, chatVariableLeader, chatAgentLeader } from '../common/chatParserTypes.js';
-import '../common/chatService.js';
-import '../common/chatServiceImpl.js';
-import { IChatSlashCommandService } from '../common/chatSlashCommands.js';
-import { IChatVariablesService } from '../common/chatVariables.js';
-import { isResponseVM } from '../common/chatViewModel.js';
-import '../common/chatWidgetHistoryService.js';
-import '../../../../base/common/event.js';
-import '../common/voiceChat.js';
-import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
-import '../common/chatColors.js';
-const configurationRegistry = ( Registry.as(Extensions.Configuration));
-configurationRegistry.registerConfiguration({
-    id: 'chatSidebar',
-    title: ( localizeWithPath(
-        'vs/workbench/contrib/chat/browser/chat.contribution',
-        'interactiveSessionConfigurationTitle',
-        "Chat"
-    )),
-    type: 'object',
-    properties: {
-        'chat.editor.fontSize': {
-            type: 'number',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/chat/browser/chat.contribution',
-                'interactiveSession.editor.fontSize',
-                "Controls the font size in pixels in chat codeblocks."
-            )),
-            default: isMacintosh ? 12 : 14,
-        },
-        'chat.editor.fontFamily': {
-            type: 'string',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/chat/browser/chat.contribution',
-                'interactiveSession.editor.fontFamily',
-                "Controls the font family in chat codeblocks."
-            )),
-            default: 'default'
-        },
-        'chat.editor.fontWeight': {
-            type: 'string',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/chat/browser/chat.contribution',
-                'interactiveSession.editor.fontWeight',
-                "Controls the font weight in chat codeblocks."
-            )),
-            default: 'default'
-        },
-        'chat.editor.wordWrap': {
-            type: 'string',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/chat/browser/chat.contribution',
-                'interactiveSession.editor.wordWrap',
-                "Controls whether lines should wrap in chat codeblocks."
-            )),
-            default: 'off',
-            enum: ['on', 'off']
-        },
-        'chat.editor.lineHeight': {
-            type: 'number',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/chat/browser/chat.contribution',
-                'interactiveSession.editor.lineHeight',
-                "Controls the line height in pixels in chat codeblocks. Use 0 to compute the line height from the font size."
-            )),
-            default: 0
-        },
-        'chat.experimental.implicitContext': {
-            type: 'boolean',
-            description: ( localizeWithPath(
-                'vs/workbench/contrib/chat/browser/chat.contribution',
-                'chat.experimental.implicitContext',
-                "Controls whether a checkbox is shown to allow the user to determine which implicit context is included with a chat participant's prompt."
-            )),
-            default: false
-        },
-    }
-});
-( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(ChatEditor, ChatEditorInput.EditorID, ( localizeWithPath('vs/workbench/contrib/chat/browser/chat.contribution', 'chat', "Chat"))), [
-    ( new SyncDescriptor(ChatEditorInput))
-]);
-let ChatResolverContribution = class ChatResolverContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.chatResolver'; }
-    constructor(editorResolverService, instantiationService) {
-        super();
-        this._register(editorResolverService.registerEditor(`${Schemas.vscodeChatSesssion}:**/**`, {
-            id: ChatEditorInput.EditorID,
-            label: ( localizeWithPath('vs/workbench/contrib/chat/browser/chat.contribution', 'chat', "Chat")),
-            priority: RegisteredEditorPriority.builtin
-        }, {
-            singlePerResource: true,
-            canSupportResource: resource => resource.scheme === Schemas.vscodeChatSesssion
-        }, {
-            createEditorInput: ({ resource, options }) => {
-                return { editor: instantiationService.createInstance(ChatEditorInput, resource, options), options };
-            }
-        }));
-    }
-};
-ChatResolverContribution = ( __decorate([
-    ( __param(0, IEditorResolverService)),
-    ( __param(1, IInstantiationService))
-], ChatResolverContribution));
-class ChatAccessibleViewContribution extends Disposable {
-    constructor() {
-        super();
-        this._register(AccessibleViewAction.addImplementation(100, 'panelChat', accessor => {
-            const accessibleViewService = accessor.get(IAccessibleViewService);
-            const widgetService = accessor.get(IChatWidgetService);
-            const codeEditorService = accessor.get(ICodeEditorService);
-            return renderAccessibleView(accessibleViewService, widgetService, codeEditorService, true);
-            function renderAccessibleView(accessibleViewService, widgetService, codeEditorService, initialRender) {
-                const widget = widgetService.lastFocusedWidget;
-                if (!widget) {
-                    return false;
-                }
-                const chatInputFocused = initialRender && !!codeEditorService.getFocusedCodeEditor();
-                if (initialRender && chatInputFocused) {
-                    widget.focusLastMessage();
-                }
-                if (!widget) {
-                    return false;
-                }
-                const verifiedWidget = widget;
-                const focusedItem = verifiedWidget.getFocus();
-                if (!focusedItem) {
-                    return false;
-                }
-                widget.focus(focusedItem);
-                const isWelcome = focusedItem instanceof ChatWelcomeMessageModel;
-                let responseContent = isResponseVM(focusedItem) ? focusedItem.response.asString() : undefined;
-                if (isWelcome) {
-                    const welcomeReplyContents = [];
-                    for (const content of focusedItem.content) {
-                        if (Array.isArray(content)) {
-                            welcomeReplyContents.push(...( content.map(m => m.message)));
-                        }
-                        else {
-                            welcomeReplyContents.push(content.value);
-                        }
-                    }
-                    responseContent = welcomeReplyContents.join('\n');
-                }
-                if (!responseContent && 'errorDetails' in focusedItem && focusedItem.errorDetails) {
-                    responseContent = focusedItem.errorDetails.message;
-                }
-                if (!responseContent) {
-                    return false;
-                }
-                const responses = verifiedWidget.viewModel?.getItems().filter(i => isResponseVM(i));
-                const length = responses?.length;
-                const responseIndex = responses?.findIndex(i => i === focusedItem);
-                accessibleViewService.show({
-                    id: "panelChat" ,
-                    verbositySettingKey: "accessibility.verbosity.panelChat" ,
-                    provideContent() { return responseContent; },
-                    onClose() {
-                        verifiedWidget.reveal(focusedItem);
-                        if (chatInputFocused) {
-                            verifiedWidget.focusInput();
-                        }
-                        else {
-                            verifiedWidget.focus(focusedItem);
-                        }
-                    },
-                    next() {
-                        verifiedWidget.moveFocus(focusedItem, 'next');
-                        alertFocusChange(responseIndex, length, 'next');
-                        renderAccessibleView(accessibleViewService, widgetService, codeEditorService);
-                    },
-                    previous() {
-                        verifiedWidget.moveFocus(focusedItem, 'previous');
-                        alertFocusChange(responseIndex, length, 'previous');
-                        renderAccessibleView(accessibleViewService, widgetService, codeEditorService);
-                    },
-                    options: { type: "view"  }
-                });
-                return true;
-            }
-        }, CONTEXT_IN_CHAT_SESSION));
-    }
-}
-let ChatSlashStaticSlashCommandsContribution = class ChatSlashStaticSlashCommandsContribution extends Disposable {
-    constructor(slashCommandService, commandService, chatAgentService, chatVariablesService) {
-        super();
-        this._store.add(slashCommandService.registerSlashCommand({
-            command: 'clear',
-            detail: ( localizeWithPath(
-                'vs/workbench/contrib/chat/browser/chat.contribution',
-                'clear',
-                "Start a new chat"
-            )),
-            sortText: 'z2_clear',
-            executeImmediately: true
-        }, async () => {
-            commandService.executeCommand(ACTION_ID_NEW_CHAT);
-        }));
-        this._store.add(slashCommandService.registerSlashCommand({
-            command: 'help',
-            detail: '',
-            sortText: 'z1_help',
-            executeImmediately: true
-        }, async (prompt, progress) => {
-            const defaultAgent = chatAgentService.getDefaultAgent(ChatAgentLocation.Panel);
-            const agents = chatAgentService.getAgents();
-            if (defaultAgent?.metadata.helpTextPrefix) {
-                if (isMarkdownString(defaultAgent.metadata.helpTextPrefix)) {
-                    progress.report({ content: defaultAgent.metadata.helpTextPrefix, kind: 'markdownContent' });
-                }
-                else {
-                    progress.report({ content: defaultAgent.metadata.helpTextPrefix, kind: 'content' });
-                }
-                progress.report({ content: '\n\n', kind: 'content' });
-            }
-            const agentText = (await Promise.all(( agents
-                .filter(a => a.id !== defaultAgent?.id)
-                .map(async (a) => {
-                const agentWithLeader = `${chatAgentLeader}${a.name}`;
-                const actionArg = { inputValue: `${agentWithLeader} ${a.metadata.sampleRequest}` };
-                const urlSafeArg = encodeURIComponent(JSON.stringify(actionArg));
-                const agentLine = `* [\`${agentWithLeader}\`](command:${SubmitAction.ID}?${urlSafeArg}) - ${a.description}`;
-                const commandText = ( a.slashCommands.map(c => {
-                    const actionArg = { inputValue: `${agentWithLeader} ${chatSubcommandLeader}${c.name} ${c.sampleRequest ?? ''}` };
-                    const urlSafeArg = encodeURIComponent(JSON.stringify(actionArg));
-                    return `\t* [\`${chatSubcommandLeader}${c.name}\`](command:${SubmitAction.ID}?${urlSafeArg}) - ${c.description}`;
-                })).join('\n');
-                return (agentLine + '\n' + commandText).trim();
-            })))).join('\n');
-            progress.report({ content: ( new MarkdownString(agentText, { isTrusted: { enabledCommands: [SubmitAction.ID] } })), kind: 'markdownContent' });
-            if (defaultAgent?.metadata.helpTextVariablesPrefix) {
-                progress.report({ content: '\n\n', kind: 'content' });
-                if (isMarkdownString(defaultAgent.metadata.helpTextVariablesPrefix)) {
-                    progress.report({ content: defaultAgent.metadata.helpTextVariablesPrefix, kind: 'markdownContent' });
-                }
-                else {
-                    progress.report({ content: defaultAgent.metadata.helpTextVariablesPrefix, kind: 'content' });
-                }
-                const variableText = ( Array.from(chatVariablesService.getVariables())
-                    .map(v => `* \`${chatVariableLeader}${v.name}\` - ${v.description}`))
-                    .join('\n');
-                progress.report({ content: '\n' + variableText, kind: 'content' });
-            }
-            if (defaultAgent?.metadata.helpTextPostfix) {
-                progress.report({ content: '\n\n', kind: 'content' });
-                if (isMarkdownString(defaultAgent.metadata.helpTextPostfix)) {
-                    progress.report({ content: defaultAgent.metadata.helpTextPostfix, kind: 'markdownContent' });
-                }
-                else {
-                    progress.report({ content: defaultAgent.metadata.helpTextPostfix, kind: 'content' });
-                }
-            }
-        }));
-    }
-};
-ChatSlashStaticSlashCommandsContribution = ( __decorate([
-    ( __param(0, IChatSlashCommandService)),
-    ( __param(1, ICommandService)),
-    ( __param(2, IChatAgentService)),
-    ( __param(3, IChatVariablesService))
-], ChatSlashStaticSlashCommandsContribution));
-const workbenchContributionsRegistry = ( Registry.as(Extensions$1.Workbench));
-registerWorkbenchContribution2(ChatResolverContribution.ID, ChatResolverContribution, 1 );
-workbenchContributionsRegistry.registerWorkbenchContribution(ChatAccessibleViewContribution, 4 );
-workbenchContributionsRegistry.registerWorkbenchContribution(ChatSlashStaticSlashCommandsContribution, 4 );
-( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(ChatEditorInput.TypeID, ChatEditorInputSerializer);
-registerChatActions();
-registerChatCopyActions();
-registerChatCodeBlockActions();
-registerChatFileTreeActions();
-registerChatTitleActions();
-registerChatExecuteActions();
-registerQuickChatActions();
-registerChatExportActions();
-registerMoveActions();
-registerNewChatActions();

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

@@ -1,58 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { status } from '../../../../base/browser/ui/aria/aria.js';
-import { RunOnceScheduler } from '../../../../base/common/async.js';
-import { Disposable, DisposableMap } from '../../../../base/common/lifecycle.js';
-import { AccessibilitySignal, IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-let ChatAccessibilityService = class ChatAccessibilityService extends Disposable {
-    constructor(_accessibilitySignalService, _instantiationService) {
-        super();
-        this._accessibilitySignalService = _accessibilitySignalService;
-        this._instantiationService = _instantiationService;
-        this._pendingSignalMap = this._register(( new DisposableMap()));
-        this._requestId = 0;
-    }
-    acceptRequest() {
-        this._requestId++;
-        this._accessibilitySignalService.playSignal(AccessibilitySignal.chatRequestSent, { allowManyInParallel: true });
-        this._pendingSignalMap.set(this._requestId, this._instantiationService.createInstance(AccessibilitySignalScheduler));
-        return this._requestId;
-    }
-    acceptResponse(response, requestId) {
-        this._pendingSignalMap.deleteAndDispose(requestId);
-        const isPanelChat = typeof response !== 'string';
-        const responseContent = typeof response === 'string' ? response : response?.response.asString();
-        this._accessibilitySignalService.playSignal(AccessibilitySignal.chatResponseReceived, { allowManyInParallel: true });
-        if (!response) {
-            return;
-        }
-        const errorDetails = isPanelChat && response.errorDetails ? ` ${response.errorDetails.message}` : '';
-        status(responseContent + errorDetails);
-    }
-};
-ChatAccessibilityService = ( __decorate([
-    ( __param(0, IAccessibilitySignalService)),
-    ( __param(1, IInstantiationService))
-], ChatAccessibilityService));
-const CHAT_RESPONSE_PENDING_AUDIO_CUE_LOOP_MS = 5000;
-const CHAT_RESPONSE_PENDING_ALLOWANCE_MS = 4000;
-let AccessibilitySignalScheduler = class AccessibilitySignalScheduler extends Disposable {
-    constructor(_accessibilitySignalService) {
-        super();
-        this._accessibilitySignalService = _accessibilitySignalService;
-        this._scheduler = ( new RunOnceScheduler(() => {
-            this._signalLoop = this._accessibilitySignalService.playSignalLoop(AccessibilitySignal.chatResponsePending, CHAT_RESPONSE_PENDING_AUDIO_CUE_LOOP_MS);
-        }, CHAT_RESPONSE_PENDING_ALLOWANCE_MS));
-        this._scheduler.schedule();
-    }
-    dispose() {
-        super.dispose();
-        this._signalLoop?.dispose();
-        this._scheduler.cancel();
-        this._scheduler.dispose();
-    }
-};
-AccessibilitySignalScheduler = ( __decorate([
-    ( __param(0, IAccessibilitySignalService))
-], AccessibilitySignalScheduler));
-export { ChatAccessibilityService };