@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,269 @@
+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

@@ -0,0 +1,316 @@
+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

@@ -0,0 +1,58 @@
+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 };