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

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

@@ -0,0 +1,283 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { isMacintosh } from 'monaco-editor/esm/vs/base/common/platform.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
+import { Extensions as Extensions$1 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { registerChatActions } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { registerChatCodeBlockActions } from './actions/chatCodeblockActions.js';
+import { registerChatCopyActions } from './actions/chatCopyActions.js';
+import { registerChatExecuteActions, SubmitAction } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatExecuteActions';
+import { registerQuickChatActions } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatQuickInputActions';
+import { registerChatTitleActions } from './actions/chatTitleActions.js';
+import { registerChatExportActions } from './actions/chatImportExport.js';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatEditor } from './chatEditor.js';
+import { ChatEditorInput, ChatEditorInputSerializer } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
+import './contrib/chatInputEditorContrib.js';
+import './contrib/chatHistoryVariables.js';
+import { RegisteredEditorPriority, IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { registerMoveActions } from './actions/chatMoveActions.js';
+import { registerClearActions, ACTION_ID_CLEAR_CHAT } from './actions/chatClearActions.js';
+import { IAccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView';
+import { isResponseVM } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { CONTEXT_IN_CHAT_SESSION } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { ChatWelcomeMessageModel } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
+import { isMarkdownString, MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { IChatSlashCommandService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatSlashCommands';
+import { alertFocusChange } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityContributions';
+import { AccessibleViewAction } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleViewActions';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { registerChatFileTreeActions } from './actions/chatFileTreeActions.js';
+import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
+import { chatAgentLeader, chatSubcommandLeader } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: 'chatSidebar',
+    title: ( nls.localizeWithPath(
+        'vs/workbench/contrib/chat/browser/chat.contribution',
+        'interactiveSessionConfigurationTitle',
+        "Chat"
+    )),
+    type: 'object',
+    properties: {
+        'chat.editor.fontSize': {
+            type: 'number',
+            description: ( nls.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: ( nls.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: ( nls.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: ( nls.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: ( nls.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
+        }
+    }
+});
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(ChatEditor, ChatEditorInput.EditorID, ( nls.localizeWithPath('vs/workbench/contrib/chat/browser/chat.contribution', 'chat', "Chat"))), [
+    ( new SyncDescriptor(ChatEditorInput))
+]);
+let ChatResolverContribution = class ChatResolverContribution extends Disposable {
+    constructor(editorResolverService, instantiationService) {
+        super();
+        this._register(editorResolverService.registerEditor(`${Schemas.vscodeChatSesssion}:**/**`, {
+            id: ChatEditorInput.EditorID,
+            label: ( nls.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) {
+        super();
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: 'clear',
+            detail: ( nls.localizeWithPath(
+                'vs/workbench/contrib/chat/browser/chat.contribution',
+                'clear',
+                "Clear the session"
+            )),
+            sortText: 'z2_clear',
+            executeImmediately: true
+        }, async () => {
+            commandService.executeCommand(ACTION_ID_CLEAR_CHAT);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: 'help',
+            detail: '',
+            sortText: 'z1_help',
+            executeImmediately: true
+        }, async (prompt, progress) => {
+            const defaultAgent = chatAgentService.getDefaultAgent();
+            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.id}`;
+                const actionArg = { inputValue: `${agentWithLeader} ${a.metadata.sampleRequest}` };
+                const urlSafeArg = encodeURIComponent(JSON.stringify(actionArg));
+                const agentLine = `* [\`${agentWithLeader}\`](command:${SubmitAction.ID}?${urlSafeArg}) - ${a.metadata.description}`;
+                const commands = await a.provideSlashCommands(CancellationToken.None);
+                const commandText = ( commands.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;
+            })))).join('\n');
+            progress.report({ content: ( new MarkdownString(agentText, { isTrusted: { enabledCommands: [SubmitAction.ID] } })), kind: 'markdownContent' });
+            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))
+], ChatSlashStaticSlashCommandsContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions$1.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(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();
+registerClearActions();

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

@@ -0,0 +1,61 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { status } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
+import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { AudioCue, IAudioCueService } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+
+let ChatAccessibilityService = class ChatAccessibilityService extends Disposable {
+    constructor(_audioCueService, _instantiationService) {
+        super();
+        this._audioCueService = _audioCueService;
+        this._instantiationService = _instantiationService;
+        this._pendingCueMap = ( new Map());
+        this._requestId = 0;
+    }
+    acceptRequest() {
+        this._requestId++;
+        this._audioCueService.playAudioCue(AudioCue.chatRequestSent, { allowManyInParallel: true });
+        this._pendingCueMap.set(this._requestId, this._register(this._instantiationService.createInstance(AudioCueScheduler)));
+        return this._requestId;
+    }
+    acceptResponse(response, requestId) {
+        this._pendingCueMap.get(requestId)?.dispose();
+        this._pendingCueMap.delete(requestId);
+        const isPanelChat = typeof response !== 'string';
+        const responseContent = typeof response === 'string' ? response : response?.response.asString();
+        this._audioCueService.playAudioCue(AudioCue.chatResponseReceived, { allowManyInParallel: true });
+        if (!response) {
+            return;
+        }
+        const errorDetails = isPanelChat && response.errorDetails ? ` ${response.errorDetails.message}` : '';
+        status(responseContent + errorDetails);
+    }
+};
+ChatAccessibilityService = ( __decorate([
+    ( __param(0, IAudioCueService)),
+    ( __param(1, IInstantiationService))
+], ChatAccessibilityService));
+const CHAT_RESPONSE_PENDING_AUDIO_CUE_LOOP_MS = 5000;
+const CHAT_RESPONSE_PENDING_ALLOWANCE_MS = 4000;
+let AudioCueScheduler = class AudioCueScheduler extends Disposable {
+    constructor(_audioCueService) {
+        super();
+        this._audioCueService = _audioCueService;
+        this._scheduler = ( new RunOnceScheduler(() => {
+            this._audioCueLoop = this._audioCueService.playAudioCueLoop(AudioCue.chatResponsePending, CHAT_RESPONSE_PENDING_AUDIO_CUE_LOOP_MS);
+        }, CHAT_RESPONSE_PENDING_ALLOWANCE_MS));
+        this._scheduler.schedule();
+    }
+    dispose() {
+        super.dispose();
+        this._audioCueLoop?.dispose();
+        this._scheduler.cancel();
+        this._scheduler.dispose();
+    }
+};
+AudioCueScheduler = ( __decorate([
+    ( __param(0, IAudioCueService))
+], AudioCueScheduler));
+
+export { ChatAccessibilityService };

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

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

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

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