@codingame/monaco-vscode-api 1.83.16 → 1.85.0-next.0

package/vscode/src/vs/workbench/contrib/accessibility/browser/accessibleView.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { addDisposableListener, EventType } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { addDisposableListener, EventType, isActiveElement, getActiveWindow } from 'monaco-editor/esm/vs/base/browser/dom.js';
 import { StandardKeyboardEvent } from 'monaco-editor/esm/vs/base/browser/keyboardEvent.js';
 import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
@@ -53,6 +53,9 @@ let AccessibleView = class AccessibleView extends Disposable {
         this._onLastLine = accessibleViewOnLastLine.bindTo(this._contextKeyService);
         this._container = document.createElement('div');
         this._container.classList.add('accessible-view');
+        if (this._configurationService.getValue("accessibility.hideAccessibleView" )) {
+            this._container.classList.add('hide');
+        }
         const codeEditorWidgetOptions = {
             contributions: EditorExtensionsRegistry.getEditorContributions().filter(c => c.id !== CodeActionController.ID)
         };
@@ -97,6 +100,9 @@ let AccessibleView = class AccessibleView extends Disposable {
                 this._accessibleViewVerbosityEnabled.set(this._configurationService.getValue(this._currentProvider.verbositySettingKey));
                 this._updateToolbar(this._currentProvider.actions, this._currentProvider.options.type);
             }
+            if (e.affectsConfiguration("accessibility.hideAccessibleView" )) {
+                this._container.classList.toggle('hide', this._configurationService.getValue("accessibility.hideAccessibleView" ));
+            }
         }));
         this._register(this._editorWidget.onDidDispose(() => this._resetContextKeys()));
         this._register(this._editorWidget.onDidChangeCursorPosition(() => {
@@ -111,34 +117,63 @@ let AccessibleView = class AccessibleView extends Disposable {
         this._accessibleViewGoToSymbolSupported.reset();
         this._accessibleViewCurrentProviderId.reset();
     }
-    show(provider, symbol, showAccessibleViewHelp, lineNumber) {
+    getPosition(id) {
+        if (!id || !this._lastProvider || this._lastProvider.id !== id) {
+            return undefined;
+        }
+        return this._editorWidget.getPosition() || undefined;
+    }
+    setPosition(position, reveal) {
+        this._editorWidget.setPosition(position);
+        if (reveal) {
+            this._editorWidget.revealPosition(position);
+        }
+    }
+    showLastProvider(id) {
+        if (!this._lastProvider || this._lastProvider.options.id !== id) {
+            return;
+        }
+        this.show(this._lastProvider);
+    }
+    show(provider, symbol, showAccessibleViewHelp, position) {
         provider = provider ?? this._currentProvider;
         if (!provider) {
             return;
         }
         const delegate = {
-            getAnchor: () => { return { x: (window.innerWidth / 2) - ((Math.min(this._layoutService.dimension.width * 0.62 , 600 )) / 2), y: this._layoutService.offset.quickPickTop }; },
+            getAnchor: () => { return { x: (getActiveWindow().innerWidth / 2) - ((Math.min(this._layoutService.activeContainerDimension.width * 0.62 , 600 )) / 2), y: this._layoutService.activeContainerOffset.quickPickTop }; },
             render: (container) => {
                 container.classList.add('accessible-view-container');
                 return this._render(provider, container, showAccessibleViewHelp);
             },
             onHide: () => {
                 if (!showAccessibleViewHelp) {
+                    this._updateLastProvider();
                     this._currentProvider = undefined;
                     this._resetContextKeys();
                 }
             }
         };
         this._contextViewService.showContextView(delegate);
-        if (lineNumber) {
+        if (position) {
             setTimeout(() => {
-                this._editorWidget.revealLine(lineNumber);
-                this._editorWidget.setSelection({ startLineNumber: lineNumber, startColumn: 1, endLineNumber: lineNumber, endColumn: 1 });
-            }, 50);
+                this._editorWidget.revealLine(position.lineNumber);
+                this._editorWidget.setSelection({ startLineNumber: position.lineNumber, startColumn: position.column, endLineNumber: position.lineNumber, endColumn: position.column });
+            }, 10);
         }
         if (symbol && this._currentProvider) {
             this.showSymbol(this._currentProvider, symbol);
         }
+        if (provider.onDidRequestClearLastProvider) {
+            this._register(provider.onDidRequestClearLastProvider((id) => {
+                if (this._lastProvider?.options.id === id) {
+                    this._lastProvider = undefined;
+                }
+            }));
+        }
+        if (provider.options.id) {
+            this._lastProvider = provider;
+        }
     }
     previous() {
         if (!this._currentProvider) {
@@ -234,7 +269,7 @@ let AccessibleView = class AccessibleView extends Disposable {
         if (lineNumber === undefined) {
             return;
         }
-        this.show(provider, undefined, undefined, lineNumber);
+        this.show(provider, undefined, undefined, { lineNumber, column: 1 });
         this._updateContextKeys(provider, true);
     }
     disableHint() {
@@ -271,7 +306,7 @@ let AccessibleView = class AccessibleView extends Disposable {
     _render(provider, container, showAccessibleViewHelp) {
         if (!showAccessibleViewHelp) {
             this._currentProvider = provider;
-            this._accessibleViewCurrentProviderId.set(provider.verbositySettingKey.replaceAll('accessibility.verbosity.', ''));
+            this._accessibleViewCurrentProviderId.set(provider.id);
         }
         const value = this._configurationService.getValue(provider.verbositySettingKey);
         const readMoreLink = provider.options.readMoreUrl ? ( localizeWithPath(
@@ -299,7 +334,7 @@ let AccessibleView = class AccessibleView extends Disposable {
             }
         }
         const verbose = this._configurationService.getValue(provider.verbositySettingKey);
-        const exitThisDialogHint = verbose && !provider.options.positionBottom ? ( localizeWithPath(
+        const exitThisDialogHint = verbose && !provider.options.position ? ( localizeWithPath(
             'vs/workbench/contrib/accessibility/browser/accessibleView',
             'exit',
             '\n\nExit this dialog (Escape).'
@@ -323,7 +358,7 @@ let AccessibleView = class AccessibleView extends Disposable {
             const verbose = this._configurationService.getValue(provider.verbositySettingKey);
             const hasActions = this._accessibleViewSupportsNavigation.get() || this._accessibleViewVerbosityEnabled.get() || this._accessibleViewGoToSymbolSupported.get() || this._currentProvider?.actions;
             if (verbose && !showAccessibleViewHelp && hasActions) {
-                actionsHint = provider.options.positionBottom ? ( localizeWithPath(
+                actionsHint = provider.options.position ? ( localizeWithPath(
                     'vs/workbench/contrib/accessibility/browser/accessibleView',
                     'ariaAccessibleViewActionsBottom',
                     'Explore actions such as disabling this hint (Shift+Tab), use Escape to exit this dialog.'
@@ -361,27 +396,30 @@ let AccessibleView = class AccessibleView extends Disposable {
             }
             this._editorWidget.updateOptions({ ariaLabel });
             this._editorWidget.focus();
-            if (this._currentProvider?.options.positionBottom) {
-                const lastLine = this.editorWidget.getModel()?.getLineCount();
-                const position = lastLine !== undefined && lastLine > 0 ? ( new Position(lastLine, 1)) : undefined;
-                if (position) {
-                    this._editorWidget.setPosition(position);
-                    this._editorWidget.revealLine(position.lineNumber);
+            if (this._currentProvider?.options.position) {
+                const position = this._editorWidget.getPosition();
+                const isDefaultPosition = position?.lineNumber === 1 && position.column === 1;
+                if (this._currentProvider.options.position === 'bottom' || this._currentProvider.options.position === 'initial-bottom' && isDefaultPosition) {
+                    const lastLine = this.editorWidget.getModel()?.getLineCount();
+                    const position = lastLine !== undefined && lastLine > 0 ? ( new Position(lastLine, 1)) : undefined;
+                    if (position) {
+                        this._editorWidget.setPosition(position);
+                        this._editorWidget.revealLine(position.lineNumber);
+                    }
                 }
             }
         });
         this._updateToolbar(provider.actions, provider.options.type);
-        const handleEscape = (e) => {
+        const hide = (e) => {
+            provider.onClose();
             e.stopPropagation();
             this._contextViewService.hideContextView();
             this._updateContextKeys(provider, false);
-            setTimeout(() => provider.onClose(), 100);
         };
         const disposableStore = ( new DisposableStore());
-        disposableStore.add(this._editorWidget.onKeyUp((e) => provider.onKeyUp?.(e)));
         disposableStore.add(this._editorWidget.onKeyDown((e) => {
-            if (e.keyCode === 9 ) {
-                handleEscape(e);
+            if (e.keyCode === 9  || shouldHide(e.browserEvent, this._keybindingService, this._configurationService)) {
+                hide(e);
             }
             else if (e.keyCode === 38  && provider.options.readMoreUrl) {
                 const url = provider.options.readMoreUrl;
@@ -390,20 +428,21 @@ let AccessibleView = class AccessibleView extends Disposable {
                 e.preventDefault();
                 e.stopPropagation();
             }
+            provider.onKeyDown?.(e);
         }));
         disposableStore.add(addDisposableListener(this._toolbar.getElement(), EventType.KEY_DOWN, (e) => {
             const keyboardEvent = ( new StandardKeyboardEvent(e));
             if (keyboardEvent.equals(9 )) {
-                handleEscape(e);
+                hide(e);
             }
         }));
         disposableStore.add(this._editorWidget.onDidBlurEditorWidget(() => {
-            if (document.activeElement !== this._toolbar.getElement()) {
+            if (!isActiveElement(this._toolbar.getElement())) {
                 this._contextViewService.hideContextView();
             }
         }));
         disposableStore.add(this._editorWidget.onDidContentSizeChange(() => this._layout()));
-        disposableStore.add(this._layoutService.onDidLayout(() => this._layout()));
+        disposableStore.add(this._layoutService.onDidLayoutActiveContainer(() => this._layout()));
         return disposableStore;
     }
     _updateToolbar(providedActions, type) {
@@ -431,7 +470,7 @@ let AccessibleView = class AccessibleView extends Disposable {
         }
     }
     _layout() {
-        const dimension = this._layoutService.dimension;
+        const dimension = this._layoutService.activeContainerDimension;
         const maxHeight = dimension.height && dimension.height * .4;
         const height = Math.min(maxHeight, this._editorWidget.getContentHeight());
         const width = Math.min(dimension.width * 0.62 , 600 );
@@ -450,18 +489,27 @@ let AccessibleView = class AccessibleView extends Disposable {
         }
         return this._currentProvider.options.type === "help"  || this._currentProvider.options.language === 'markdown' || this._currentProvider.options.language === undefined || !!this._currentProvider.getSymbols?.();
     }
-    showAccessibleViewHelp() {
+    _updateLastProvider() {
         if (!this._currentProvider) {
             return;
         }
-        const currentProvider = Object.assign({}, this._currentProvider);
-        currentProvider.provideContent = this._currentProvider.provideContent.bind(currentProvider);
-        currentProvider.options = Object.assign({}, currentProvider.options);
+        const lastProvider = Object.assign({}, this._currentProvider);
+        lastProvider.provideContent = this._currentProvider.provideContent.bind(lastProvider);
+        lastProvider.options = Object.assign({}, this._currentProvider.options);
+        lastProvider.verbositySettingKey = this._currentProvider.verbositySettingKey;
+        return lastProvider;
+    }
+    showAccessibleViewHelp() {
+        const lastProvider = this._updateLastProvider();
+        if (!lastProvider) {
+            return;
+        }
         const accessibleViewHelpProvider = {
-            provideContent: () => currentProvider.options.customHelp ? currentProvider?.options.customHelp() : this._getAccessibleViewHelpDialogContent(this._goToSymbolsSupported()),
-            onClose: () => this.show(currentProvider),
+            id: lastProvider.id,
+            provideContent: () => lastProvider.options.customHelp ? lastProvider?.options.customHelp() : this._getAccessibleViewHelpDialogContent(this._goToSymbolsSupported()),
+            onClose: () => this.show(lastProvider),
             options: { type: "help"  },
-            verbositySettingKey: this._currentProvider.verbositySettingKey
+            verbositySettingKey: lastProvider.verbositySettingKey
         };
         this._contextViewService.hideContextView();
         setTimeout(() => this.show(accessibleViewHelpProvider, undefined, true), 100);
@@ -577,11 +625,14 @@ let AccessibleViewService = class AccessibleViewService extends Disposable {
         this._configurationService = _configurationService;
         this._keybindingService = _keybindingService;
     }
-    show(provider) {
+    show(provider, position) {
         if (!this._accessibleView) {
             this._accessibleView = this._register(this._instantiationService.createInstance(AccessibleView));
         }
-        this._accessibleView.show(provider);
+        this._accessibleView.show(provider, undefined, undefined, position);
+    }
+    showLastProvider(id) {
+        this._accessibleView?.showLastProvider(id);
     }
     next() {
         this._accessibleView?.next();
@@ -621,8 +672,8 @@ let AccessibleViewService = class AccessibleViewService extends Disposable {
     showAccessibleViewHelp() {
         this._accessibleView?.showAccessibleViewHelp();
     }
-    getPosition() {
-        return this._accessibleView?.editorWidget.getPosition() ?? undefined;
+    getPosition(id) {
+        return this._accessibleView?.getPosition(id) ?? undefined;
     }
     getLastPosition() {
         const lastLine = this._accessibleView?.editorWidget.getModel()?.getLineCount();
@@ -681,4 +732,19 @@ let AccessibleViewSymbolQuickPick = class AccessibleViewSymbolQuickPick {
 AccessibleViewSymbolQuickPick = ( __decorate([
     ( __param(1, IQuickInputService))
 ], AccessibleViewSymbolQuickPick));
+function shouldHide(event, keybindingService, configurationService) {
+    if (!configurationService.getValue("accessibility.accessibleView.closeOnKeyPress" )) {
+        return false;
+    }
+    const standardKeyboardEvent = ( new StandardKeyboardEvent(event));
+    const resolveResult = keybindingService.softDispatch(standardKeyboardEvent, standardKeyboardEvent.target);
+    const isValidChord = resolveResult.kind === 1 ;
+    if (keybindingService.inChordMode || isValidChord) {
+        return false;
+    }
+    return shouldHandleKey(event) && !event.ctrlKey && !event.altKey && !event.metaKey && !event.shiftKey;
+}
+function shouldHandleKey(event) {
+    return !!event.code.match(/^(Key[A-Z]|Digit[0-9]|Equal|Comma|Period|Slash|Quote|Backquote|Backslash|Minus|Semicolon|Space|Enter)$/);
+}
 export { AccessibleView, AccessibleViewService, IAccessibleViewService };

package/vscode/src/vs/workbench/contrib/accessibility/browser/accessibleViewActions.js

@@ -7,7 +7,6 @@ import { accessibleViewIsShown, accessibleViewSupportsNavigation, accessibilityH
 import { IAccessibleViewService } from './accessibleView.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import { InlineCompletionsController } from 'monaco-editor/esm/vs/editor/contrib/inlineCompletions/browser/inlineCompletionsController.js';
-import { alert } from 'monaco-editor/esm/vs/base/browser/ui/aria/aria.js';
 const accessibleViewMenu = {
     id: MenuId.AccessibleView,
     group: 'navigation',
@@ -119,7 +118,8 @@ const AccessibilityHelpAction = registerCommand(( new MultiCommand({
         linux: {
             primary: 512  | 1024  | 59 ,
             secondary: [512  | 59 ]
-        }
+        },
+        kbExpr: ( accessibilityHelpIsShown.toNegated())
     },
     menuOpts: [{
             menuId: MenuId.CommandPalette,
@@ -229,7 +229,6 @@ class AccessibleViewAcceptInlineCompletionAction extends Action2 {
             return;
         }
         await model.accept(editor);
-        alert('Accepted');
         model.stop();
         editor.focus();
     }

package/vscode/src/vs/workbench/contrib/accessibility/browser/editorAccessibilityHelp.js

@@ -0,0 +1,127 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { AccessibilityHelpNLS } from 'monaco-editor/esm/vs/editor/common/standaloneStrings.js';
+import { ToggleTabFocusModeAction } from 'monaco-editor/esm/vs/editor/contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
+import { AudioCue } from 'monaco-editor/esm/vs/platform/audioCues/browser/audioCueService.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.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 { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { descriptionForCommand } from './accessibilityContributions.js';
+import { IAccessibleViewService } from './accessibleView.js';
+import { AccessibilityHelpAction } from './accessibleViewActions.js';
+import { CommentAccessibilityHelpNLS } from '../../comments/browser/comments.contribution.js';
+import { CommentContextKeys } from '../../comments/common/commentContextKeys.js';
+import { NEW_UNTITLED_FILE_COMMAND_ID } from '../../files/browser/fileConstants.js';
+class EditorAccessibilityHelpContribution extends Disposable {
+    constructor() {
+        super();
+        this._register(AccessibilityHelpAction.addImplementation(95, 'editor', async (accessor) => {
+            const codeEditorService = accessor.get(ICodeEditorService);
+            const accessibleViewService = accessor.get(IAccessibleViewService);
+            const instantiationService = accessor.get(IInstantiationService);
+            const commandService = accessor.get(ICommandService);
+            let codeEditor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor();
+            if (!codeEditor) {
+                await commandService.executeCommand(NEW_UNTITLED_FILE_COMMAND_ID);
+                codeEditor = codeEditorService.getActiveCodeEditor();
+            }
+            accessibleViewService.show(instantiationService.createInstance(EditorAccessibilityHelpProvider, codeEditor));
+        }, EditorContextKeys.focus));
+    }
+}
+let EditorAccessibilityHelpProvider = class EditorAccessibilityHelpProvider {
+    onClose() {
+        this._editor.focus();
+    }
+    constructor(_editor, _keybindingService, _contextKeyService, _configurationService) {
+        this._editor = _editor;
+        this._keybindingService = _keybindingService;
+        this._contextKeyService = _contextKeyService;
+        this._configurationService = _configurationService;
+        this.id = "editor" ;
+        this.options = { type: "help" , readMoreUrl: 'https://go.microsoft.com/fwlink/?linkid=851010' };
+        this.verbositySettingKey = "accessibility.verbosity.editor" ;
+    }
+    provideContent() {
+        const options = this._editor.getOptions();
+        const content = [];
+        if (options.get(61 )) {
+            if (options.get(90 )) {
+                content.push(AccessibilityHelpNLS.readonlyDiffEditor);
+            }
+            else {
+                content.push(AccessibilityHelpNLS.editableDiffEditor);
+            }
+        }
+        else {
+            if (options.get(90 )) {
+                content.push(AccessibilityHelpNLS.readonlyEditor);
+            }
+            else {
+                content.push(AccessibilityHelpNLS.editableEditor);
+            }
+        }
+        const saveAudioCue = this._configurationService.getValue(AudioCue.save.settingsKey);
+        switch (saveAudioCue) {
+            case 'never':
+                content.push(AccessibilityHelpNLS.saveAudioCueDisabled);
+                break;
+            case 'always':
+                content.push(AccessibilityHelpNLS.saveAudioCueAlways);
+                break;
+            case 'userGesture':
+                content.push(AccessibilityHelpNLS.saveAudioCueUserGesture);
+                break;
+        }
+        const formatAudioCue = this._configurationService.getValue(AudioCue.format.settingsKey);
+        switch (formatAudioCue) {
+            case 'never':
+                content.push(AccessibilityHelpNLS.formatAudioCueDisabled);
+                break;
+            case 'always':
+                content.push(AccessibilityHelpNLS.formatAudioCueAlways);
+                break;
+            case 'userGesture':
+                content.push(AccessibilityHelpNLS.formatAudioCueUserGesture);
+                break;
+        }
+        const commentCommandInfo = getCommentCommandInfo(this._keybindingService, this._contextKeyService, this._editor);
+        if (commentCommandInfo) {
+            content.push(commentCommandInfo);
+        }
+        if (options.get(114 ).enabled) {
+            content.push(descriptionForCommand('editor.action.focusStickyScroll', AccessibilityHelpNLS.stickScrollKb, AccessibilityHelpNLS.stickScrollNoKb, this._keybindingService));
+        }
+        if (options.get(142 )) {
+            content.push(descriptionForCommand(ToggleTabFocusModeAction.ID, AccessibilityHelpNLS.tabFocusModeOnMsg, AccessibilityHelpNLS.tabFocusModeOnMsgNoKb, this._keybindingService));
+        }
+        else {
+            content.push(descriptionForCommand(ToggleTabFocusModeAction.ID, AccessibilityHelpNLS.tabFocusModeOffMsg, AccessibilityHelpNLS.tabFocusModeOffMsgNoKb, this._keybindingService));
+        }
+        return content.join('\n\n');
+    }
+};
+EditorAccessibilityHelpProvider = ( __decorate([
+    ( __param(1, IKeybindingService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IConfigurationService))
+], EditorAccessibilityHelpProvider));
+function getCommentCommandInfo(keybindingService, contextKeyService, editor) {
+    const editorContext = contextKeyService.getContext(editor.getDomNode());
+    if (editorContext.getValue(CommentContextKeys.activeEditorHasCommentingRange.key)) {
+        const commentCommandInfo = [];
+        commentCommandInfo.push(CommentAccessibilityHelpNLS.intro);
+        commentCommandInfo.push(descriptionForCommand("workbench.action.addComment" , CommentAccessibilityHelpNLS.addComment, CommentAccessibilityHelpNLS.addCommentNoKb, keybindingService));
+        commentCommandInfo.push(descriptionForCommand("editor.action.nextCommentThreadAction" , CommentAccessibilityHelpNLS.nextCommentThreadKb, CommentAccessibilityHelpNLS.nextCommentThreadNoKb, keybindingService));
+        commentCommandInfo.push(descriptionForCommand("editor.action.previousCommentThreadAction" , CommentAccessibilityHelpNLS.previousCommentThreadKb, CommentAccessibilityHelpNLS.previousCommentThreadNoKb, keybindingService));
+        commentCommandInfo.push(descriptionForCommand("editor.action.nextCommentingRange" , CommentAccessibilityHelpNLS.nextRange, CommentAccessibilityHelpNLS.nextRangeNoKb, keybindingService));
+        commentCommandInfo.push(descriptionForCommand("editor.action.previousCommentingRange" , CommentAccessibilityHelpNLS.previousRange, CommentAccessibilityHelpNLS.previousRangeNoKb, keybindingService));
+        return commentCommandInfo.join('\n');
+    }
+    return;
+}
+export { EditorAccessibilityHelpContribution, getCommentCommandInfo };

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

@@ -0,0 +1,71 @@
+import { EditorAction2 } from 'monaco-editor/esm/vs/editor/browser/editorExtensions.js';
+import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
+import { localize2WithPath, localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IChatWidgetService } from '../chat.js';
+import { IChatAgentService } from '../../common/chatAgents.js';
+import { CONTEXT_IN_CHAT_INPUT } from '../../common/chatContextKeys.js';
+import { chatAgentLeader } from '../../common/chatParserTypes.js';
+const CHAT_CATEGORY = { value: ( localizeWithPath(
+    'vs/workbench/contrib/chat/browser/actions/chatActions',
+    'chat.category',
+    "Chat"
+)), original: 'Chat' };
+const CHAT_OPEN_ACTION_ID = 'workbench.action.chat.open';
+class ChatSubmitSecondaryAgentEditorAction extends EditorAction2 {
+    static { this.ID = 'workbench.action.chat.submitSecondaryAgent'; }
+    constructor() {
+        super({
+            id: ChatSubmitSecondaryAgentEditorAction.ID,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/chat/browser/actions/chatActions',
+                { key: 'actions.chat.submitSecondaryAgent', comment: ['Send input from the chat input box to the secondary agent'] },
+                "Submit to Secondary Agent"
+            )),
+            precondition: CONTEXT_IN_CHAT_INPUT,
+            keybinding: {
+                when: EditorContextKeys.textInputFocus,
+                primary: 2048  | 3 ,
+                weight: 100
+            }
+        });
+    }
+    runEditorCommand(accessor, editor) {
+        const editorUri = editor.getModel()?.uri;
+        if (editorUri) {
+            const agentService = accessor.get(IChatAgentService);
+            const secondaryAgent = agentService.getSecondaryAgent();
+            if (!secondaryAgent) {
+                return;
+            }
+            const widgetService = accessor.get(IChatWidgetService);
+            widgetService.getWidgetByInputUri(editorUri)?.acceptInputWithPrefix(`${chatAgentLeader}${secondaryAgent.id}`);
+        }
+    }
+}
+class ChatSubmitEditorAction extends EditorAction2 {
+    static { this.ID = 'workbench.action.chat.acceptInput'; }
+    constructor() {
+        super({
+            id: ChatSubmitEditorAction.ID,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/chat/browser/actions/chatActions',
+                { key: 'actions.chat.submit', comment: ['Apply input from the chat input box'] },
+                "Submit"
+            )),
+            precondition: CONTEXT_IN_CHAT_INPUT,
+            keybinding: {
+                when: EditorContextKeys.textInputFocus,
+                primary: 3 ,
+                weight: 100
+            }
+        });
+    }
+    runEditorCommand(accessor, editor) {
+        const editorUri = editor.getModel()?.uri;
+        if (editorUri) {
+            const widgetService = accessor.get(IChatWidgetService);
+            widgetService.getWidgetByInputUri(editorUri)?.acceptInput();
+        }
+    }
+}
+export { CHAT_CATEGORY, CHAT_OPEN_ACTION_ID, ChatSubmitEditorAction, ChatSubmitSecondaryAgentEditorAction };

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

@@ -1,4 +1,5 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const IChatWidgetService = ( createDecorator('chatWidgetService'));
 const IQuickChatService = ( createDecorator('quickChatService'));
-export { IChatWidgetService, IQuickChatService };
+const IChatAccessibilityService = ( createDecorator('chatAccessibilityService'));
+export { IChatAccessibilityService, IChatWidgetService, IQuickChatService };