@codingame/monaco-vscode-api 5.2.0 → 6.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatRequestParser.js

@@ -7,7 +7,7 @@ import { IChatAgentService } from './chatAgents.service.js';
 import { chatVariableLeader, chatAgentLeader, chatSubcommandLeader, ChatRequestTextPart, ChatRequestAgentPart, ChatRequestVariablePart, ChatRequestSlashCommandPart, ChatRequestAgentSubcommandPart, ChatRequestDynamicVariablePart } from './chatParserTypes.js';
 import { IChatSlashCommandService } from './chatSlashCommands.service.js';
 import { IChatVariablesService } from './chatVariables.service.js';
-const agentReg = /^@([\w_\-]+)(?=(\s|$|\b))/i;
+const agentReg = /^@([\w_\-\.]+)(?=(\s|$|\b))/i;
 const variableReg = /^#([\w_\-]+)(:\d+)?(?=(\s|$|\b))/i;
 const slashReg = /\/([\w_\-]+)(?=(\s|$|\b))/i;
 let ChatRequestParser = class ChatRequestParser {
@@ -90,7 +90,13 @@ let ChatRequestParser = class ChatRequestParser {
             position.lineNumber,
             position.column + full.length
         ));
-        const agents = this.agentService.getAgentsByName(name);
+        let agents = this.agentService.getAgentsByName(name);
+        if (!agents.length) {
+            const fqAgent = this.agentService.getAgentByFullyQualifiedId(name);
+            if (fqAgent) {
+                agents = [fqAgent];
+            }
+        }
         const agent = agents.length > 1 && context?.selectedAgent ?
             context.selectedAgent :
             agents[0];
@@ -127,8 +133,11 @@ let ChatRequestParser = class ChatRequestParser {
             position.lineNumber,
             position.column + full.length
         ));
-        if (this.variableService.hasVariable(name)) {
-            return ( new ChatRequestVariablePart(varRange, varEditorRange, name, variableArg));
+        const usedAgent = parts.find((p) => p instanceof ChatRequestAgentPart);
+        const allowSlow = !usedAgent || usedAgent.agent.metadata.supportsSlowVariables;
+        const variable = this.variableService.getVariable(name);
+        if (variable && (!variable.isSlow || allowSlow)) {
+            return ( new ChatRequestVariablePart(varRange, varEditorRange, name, variableArg, variable.id));
         }
         return;
     }
@@ -182,7 +191,14 @@ let ChatRequestParser = class ChatRequestParser {
             const length = refAtThisPosition.range.endColumn - refAtThisPosition.range.startColumn;
             const text = message.substring(0, length);
             const range = ( new OffsetRange(offset, offset + length));
-            return ( new ChatRequestDynamicVariablePart(range, refAtThisPosition.range, text, refAtThisPosition.data));
+            return ( new ChatRequestDynamicVariablePart(
+                range,
+                refAtThisPosition.range,
+                text,
+                refAtThisPosition.id,
+                refAtThisPosition.modelDescription,
+                refAtThisPosition.data
+            ));
         }
         return;
     }

package/vscode/src/vs/workbench/contrib/chat/common/chatService.js

@@ -14,14 +14,14 @@ function isIUsedContext(obj) {
         Array.isArray(obj.documents) &&
         obj.documents.every(isIDocumentContext));
 }
-var InteractiveSessionVoteDirection;
-( (function(InteractiveSessionVoteDirection) {
-    InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Down"] = 0] = "Down";
-    InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Up"] = 1] = "Up";
-})(InteractiveSessionVoteDirection || (InteractiveSessionVoteDirection = {})));
+var ChatAgentVoteDirection;
+( (function(ChatAgentVoteDirection) {
+    ChatAgentVoteDirection[ChatAgentVoteDirection["Down"] = 0] = "Down";
+    ChatAgentVoteDirection[ChatAgentVoteDirection["Up"] = 1] = "Up";
+})(ChatAgentVoteDirection || (ChatAgentVoteDirection = {})));
 var ChatCopyKind;
 ( (function(ChatCopyKind) {
     ChatCopyKind[ChatCopyKind["Action"] = 1] = "Action";
     ChatCopyKind[ChatCopyKind["Toolbar"] = 2] = "Toolbar";
 })(ChatCopyKind || (ChatCopyKind = {})));
-export { ChatCopyKind, InteractiveSessionVoteDirection, isIDocumentContext, isIUsedContext };
+export { ChatAgentVoteDirection, ChatCopyKind, isIDocumentContext, isIUsedContext };

package/vscode/src/vs/workbench/contrib/chat/common/chatViewModel.js

@@ -5,6 +5,8 @@ import marked_1 from '../../../../../../../external/vscode-marked/lib/marked.esm
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../../platform/log/common/log.service.js';
 import { annotateVulnerabilitiesInText } from './annotations.js';
+import { getFullyQualifiedId } from './chatAgents.js';
+import { IChatAgentNameService } from './chatAgents.service.js';
 import { ChatModelInitState } from './chatModel.js';
 import { countWords } from './chatWordCounter.js';
 function isRequestVM(item) {
@@ -124,20 +126,11 @@ let ChatViewModel = class ChatViewModel extends Disposable {
         const renderer = new marked_1.Renderer();
         renderer.code = (value, languageId) => {
             languageId ??= '';
-            const newText = this.fixCodeText(value, languageId);
-            this.codeBlockModelCollection.update(this._model.sessionId, model, codeBlockIndex++, { text: newText, languageId });
+            this.codeBlockModelCollection.update(this._model.sessionId, model, codeBlockIndex++, { text: value, languageId });
             return '';
         };
         marked_1.parse(this.ensureFencedCodeBlocksTerminated(content), { renderer });
     }
-    fixCodeText(text, languageId) {
-        if (languageId === 'php') {
-            if (!text.trim().startsWith('<')) {
-                return `<?php\n${text}\n?>`;
-            }
-        }
-        return text;
-    }
     ensureFencedCodeBlocksTerminated(content) {
         const lines = content.split('\n');
         let inCodeBlock = false;
@@ -186,6 +179,9 @@ class ChatRequestViewModel {
     }
 }
 let ChatResponseViewModel = class ChatResponseViewModel extends Disposable {
+    get model() {
+        return this._model;
+    }
     get id() {
         return this._model.id;
     }
@@ -196,6 +192,15 @@ let ChatResponseViewModel = class ChatResponseViewModel extends Disposable {
         return this._model.session.sessionId;
     }
     get username() {
+        if (this.agent) {
+            const isAllowed = this.chatAgentNameService.getAgentNameRestriction(this.agent);
+            if (isAllowed) {
+                return this.agent.fullName || this.agent.name;
+            }
+            else {
+                return getFullyQualifiedId(this.agent);
+            }
+        }
         return this._model.username;
     }
     get avatarIcon() {
@@ -264,10 +269,11 @@ let ChatResponseViewModel = class ChatResponseViewModel extends Disposable {
     get contentUpdateTimings() {
         return this._contentUpdateTimings;
     }
-    constructor(_model, logService) {
+    constructor(_model, logService, chatAgentNameService) {
         super();
         this._model = _model;
         this.logService = logService;
+        this.chatAgentNameService = chatAgentNameService;
         this._modelChangeCount = 0;
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
@@ -316,6 +322,7 @@ let ChatResponseViewModel = class ChatResponseViewModel extends Disposable {
     }
 };
 ChatResponseViewModel = ( __decorate([
-    ( __param(1, ILogService))
+    ( __param(1, ILogService)),
+    ( __param(2, IChatAgentNameService))
 ], ChatResponseViewModel));
 export { ChatRequestViewModel, ChatResponseViewModel, ChatViewModel, isRequestVM, isResponseVM, isWelcomeVM };

package/vscode/src/vs/workbench/contrib/chat/common/chatWordCounter.js

@@ -1,21 +1,14 @@
-const wordSeparatorCharPattern = /[\s\|\-]/;
 function getNWords(str, numWordsToCount) {
-    let wordCount = numWordsToCount;
-    let i = 0;
-    while (i < str.length && wordCount > 0) {
-        while (i < str.length && str[i].match(wordSeparatorCharPattern)) {
-            i++;
-        }
-        while (i < str.length && !str[i].match(wordSeparatorCharPattern)) {
-            i++;
-        }
-        wordCount--;
-    }
-    const value = str.substring(0, i);
+    const allWordMatches = Array.from(str.matchAll(/\[([^\]]+)\]\(([^)]+)\)|[^\s\|\-]+/g));
+    const targetWords = allWordMatches.slice(0, numWordsToCount);
+    const endIndex = numWordsToCount > allWordMatches.length
+        ? str.length
+        : targetWords.length ? targetWords.at(-1).index + targetWords.at(-1)[0].length : 0;
+    const value = str.substring(0, endIndex);
     return {
         value,
-        actualWordCount: numWordsToCount - wordCount,
-        isFullString: i >= str.length
+        actualWordCount: targetWords.length === 0 ? (value.length ? 1 : 0) : targetWords.length,
+        isFullString: endIndex >= str.length
     };
 }
 function countWords(str) {

package/vscode/src/vs/workbench/contrib/chat/common/codeBlockModelCollection.js

@@ -5,6 +5,7 @@ import { Schemas } from '../../../../base/common/network.js';
 import { URI } from '../../../../base/common/uri.js';
 import { Range } from '../../../../editor/common/core/range.js';
 import { ILanguageService } from '../../../../editor/common/languages/language.js';
+import { EndOfLinePreference } from '../../../../editor/common/model.js';
 import { ITextModelService } from '../../../../editor/common/services/resolverService.js';
 import { isResponseVM } from './chatViewModel.js';
 import { extractVulnerabilitiesFromText } from './annotations.js';
@@ -44,7 +45,7 @@ let CodeBlockModelCollection = class CodeBlockModelCollection extends Disposable
     async update(sessionId, chat, codeBlockIndex, content) {
         const entry = this.getOrCreate(sessionId, chat, codeBlockIndex);
         const extractedVulns = extractVulnerabilitiesFromText(content.text);
-        const newText = extractedVulns.newText;
+        const newText = fixCodeText(extractedVulns.newText, content.languageId);
         this.setVulns(sessionId, chat, codeBlockIndex, extractedVulns.vulnerabilities);
         const textModel = (await entry.model).textEditorModel;
         if (content.languageId) {
@@ -53,7 +54,7 @@ let CodeBlockModelCollection = class CodeBlockModelCollection extends Disposable
                 textModel.setLanguage(vscodeLanguageId);
             }
         }
-        const currentText = textModel.getValue(1 );
+        const currentText = textModel.getValue(EndOfLinePreference.LF);
         if (newText === currentText) {
             return;
         }
@@ -112,4 +113,12 @@ CodeBlockModelCollection = ( __decorate([
     ( __param(0, ILanguageService)),
     ( __param(1, ITextModelService))
 ], CodeBlockModelCollection));
+function fixCodeText(text, languageId) {
+    if (languageId === 'php') {
+        if (!text.trim().startsWith('<')) {
+            return `<?php\n${text}`;
+        }
+    }
+    return text;
+}
 export { CodeBlockModelCollection };

package/vscode/src/vs/workbench/contrib/chat/common/languageModels.js

@@ -0,0 +1,170 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Iterable } from '../../../../base/common/iterator.js';
+import { DisposableStore, toDisposable } from '../../../../base/common/lifecycle.js';
+import { isFalsyOrWhitespace } from '../../../../base/common/strings.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { ExtensionIdentifier } from '../../../../platform/extensions/common/extensions.js';
+import { ILogService } from '../../../../platform/log/common/log.service.js';
+import { isProposedApiEnabled } from '../../../services/extensions/common/extensions.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.service.js';
+import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+const _moduleId = "vs/workbench/contrib/chat/common/languageModels";
+var ChatMessageRole;
+( ((function(ChatMessageRole) {
+    ChatMessageRole[ChatMessageRole["System"] = 0] = "System";
+    ChatMessageRole[ChatMessageRole["User"] = 1] = "User";
+    ChatMessageRole[ChatMessageRole["Assistant"] = 2] = "Assistant";
+})(ChatMessageRole || (ChatMessageRole = {}))));
+const languageModelType = {
+    type: 'object',
+    properties: {
+        vendor: {
+            type: 'string',
+            description: ( localizeWithPath(_moduleId, 0, "A globally unique vendor of language models."))
+        }
+    }
+};
+const languageModelExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'languageModels',
+    jsonSchema: {
+        description: ( localizeWithPath(_moduleId, 1, "Contribute language models of a specific vendor.")),
+        oneOf: [
+            languageModelType,
+            {
+                type: 'array',
+                items: languageModelType
+            }
+        ]
+    },
+    activationEventsGenerator: (contribs, result) => {
+        for (const contrib of contribs) {
+            result.push(`onLanguageModelChat:${contrib.vendor}`);
+        }
+    }
+});
+let LanguageModelsService = class LanguageModelsService {
+    constructor(_extensionService, _logService) {
+        this._extensionService = _extensionService;
+        this._logService = _logService;
+        this._store = ( (new DisposableStore()));
+        this._providers = ( (new Map()));
+        this._vendors = ( (new Set()));
+        this._onDidChangeProviders = this._store.add(( (new Emitter())));
+        this.onDidChangeLanguageModels = this._onDidChangeProviders.event;
+        this._store.add(languageModelExtensionPoint.setHandler((extensions) => {
+            this._vendors.clear();
+            for (const extension of extensions) {
+                if (!isProposedApiEnabled(extension.description, 'chatProvider')) {
+                    extension.collector.error(( localizeWithPath(
+                        _moduleId,
+                        2,
+                        "This contribution point requires the 'chatProvider' proposal."
+                    )));
+                    continue;
+                }
+                for (const item of Iterable.wrap(extension.value)) {
+                    if (( (this._vendors.has(item.vendor)))) {
+                        extension.collector.error(( localizeWithPath(
+                            _moduleId,
+                            3,
+                            "The vendor '{0}' is already registered and cannot be registered twice",
+                            item.vendor
+                        )));
+                        continue;
+                    }
+                    if (isFalsyOrWhitespace(item.vendor)) {
+                        extension.collector.error(( localizeWithPath(_moduleId, 4, "The vendor field cannot be empty.")));
+                        continue;
+                    }
+                    if (item.vendor.trim() !== item.vendor) {
+                        extension.collector.error(( localizeWithPath(_moduleId, 5, "The vendor field cannot start or end with whitespace.")));
+                        continue;
+                    }
+                    this._vendors.add(item.vendor);
+                }
+            }
+            const removed = [];
+            for (const [identifier, value] of this._providers) {
+                if (!( (this._vendors.has(value.metadata.vendor)))) {
+                    this._providers.delete(identifier);
+                    removed.push(identifier);
+                }
+            }
+            if (removed.length > 0) {
+                this._onDidChangeProviders.fire({ removed });
+            }
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+        this._providers.clear();
+    }
+    getLanguageModelIds() {
+        return Array.from(( (this._providers.keys())));
+    }
+    lookupLanguageModel(identifier) {
+        return this._providers.get(identifier)?.metadata;
+    }
+    async selectLanguageModels(selector) {
+        if (selector.vendor) {
+            await this._extensionService.activateByEvent(`onLanguageModelChat:${selector.vendor}}`);
+        }
+        else {
+            const all = ( (Array.from(this._vendors).map(
+                vendor => this._extensionService.activateByEvent(`onLanguageModelChat:${vendor}`)
+            )));
+            await Promise.all(all);
+        }
+        const result = [];
+        for (const [identifier, model] of this._providers) {
+            if ((selector.vendor === undefined || model.metadata.vendor === selector.vendor)
+                && (selector.family === undefined || model.metadata.family === selector.family)
+                && (selector.version === undefined || model.metadata.version === selector.version)
+                && (selector.identifier === undefined || model.metadata.id === selector.identifier)
+                && (!model.metadata.targetExtensions || ( (model.metadata.targetExtensions.some(candidate => ExtensionIdentifier.equals(candidate, selector.extension)))))) {
+                result.push(identifier);
+            }
+        }
+        this._logService.trace('[LM] selected language models', selector, result);
+        return result;
+    }
+    registerLanguageModelChat(identifier, provider) {
+        this._logService.trace('[LM] registering language model chat', identifier, provider.metadata);
+        if (!( (this._vendors.has(provider.metadata.vendor)))) {
+            throw ( (new Error(`Chat response provider uses UNKNOWN vendor ${provider.metadata.vendor}.`)));
+        }
+        if (( (this._providers.has(identifier)))) {
+            throw ( (new Error(
+                `Chat response provider with identifier ${identifier} is already registered.`
+            )));
+        }
+        this._providers.set(identifier, provider);
+        this._onDidChangeProviders.fire({ added: [{ identifier, metadata: provider.metadata }] });
+        return toDisposable(() => {
+            if (this._providers.delete(identifier)) {
+                this._onDidChangeProviders.fire({ removed: [identifier] });
+                this._logService.trace('[LM] UNregistered language model chat', identifier, provider.metadata);
+            }
+        });
+    }
+    makeLanguageModelChatRequest(identifier, from, messages, options, progress, token) {
+        const provider = this._providers.get(identifier);
+        if (!provider) {
+            throw ( (new Error(`Chat response provider with identifier ${identifier} is not registered.`)));
+        }
+        return provider.provideChatResponse(messages, from, options, progress, token);
+    }
+    computeTokenLength(identifier, message, token) {
+        const provider = this._providers.get(identifier);
+        if (!provider) {
+            throw ( (new Error(`Chat response provider with identifier ${identifier} is not registered.`)));
+        }
+        return provider.provideTokenCount(message, token);
+    }
+};
+LanguageModelsService = ( (__decorate([
+    ( (__param(0, IExtensionService))),
+    ( (__param(1, ILogService)))
+], LanguageModelsService)));
+export { ChatMessageRole, LanguageModelsService, languageModelExtensionPoint };

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

@@ -6,6 +6,7 @@ import { Extensions as Extensions$1 } from '../../../common/contributions.js';
 import { codeActionsExtensionPointDescriptor } from '../common/codeActionsExtensionPoint.js';
 import { documentationExtensionPointDescriptor } from '../common/documentationExtensionPoint.js';
 import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
+import { LifecyclePhase } from '../../../services/lifecycle/common/lifecycle.js';
 import { editorConfiguration, CodeActionsContribution } from './codeActionsContribution.js';
 import { CodeActionDocumentationContribution } from './documentationContribution.js';
 const codeActionsExtensionPoint = ExtensionsRegistry.registerExtensionPoint(codeActionsExtensionPointDescriptor);
@@ -22,4 +23,4 @@ WorkbenchConfigurationContribution = ( __decorate([
     ( __param(0, IInstantiationService))
 ], WorkbenchConfigurationContribution));
 ( Registry.as(Extensions$1.Workbench))
-    .registerWorkbenchContribution(WorkbenchConfigurationContribution, 4 );
+    .registerWorkbenchContribution(WorkbenchConfigurationContribution, LifecyclePhase.Eventually);

package/vscode/src/vs/workbench/contrib/codeActions/browser/codeActionsContribution.js

@@ -6,7 +6,7 @@ import { editorConfigurationBaseNode } from '../../../../editor/common/config/ed
 import { codeActionCommandId, refactorCommandId, sourceActionCommandId } from '../../../../editor/contrib/codeAction/browser/codeAction.js';
 import { CodeActionKind } from '../../../../editor/contrib/codeAction/common/types.js';
 import { localizeWithPath } from '../../../../nls.js';
-import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { ConfigurationScope, Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
 import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
 import { Registry } from '../../../../platform/registry/common/platform.js';
 const _moduleId = "vs/workbench/contrib/codeActions/browser/codeActionsContribution";
@@ -69,7 +69,7 @@ const codeActionsOnSaveSchema = {
         enum: ['always', 'explicit', 'never', true, false],
     },
     default: {},
-    scope: 5 ,
+    scope: ConfigurationScope.LANGUAGE_OVERRIDABLE,
 };
 const editorConfiguration = ( (Object.freeze({
     ...editorConfigurationBaseNode,

package/vscode/src/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation.js

@@ -3,13 +3,17 @@ import './editorDictation.css.js';
 import { localize2WithPath, localizeWithPath } from '../../../../../nls.js';
 import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
 import { Disposable, MutableDisposable, toDisposable, DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { ContentWidgetPositionPreference } from '../../../../../editor/browser/editorBrowser.js';
 import { RawContextKey, ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
 import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
-import { SpeechToTextStatus, HasSpeechProvider } from '../../../speech/common/speechService.js';
+import { SpeechToTextStatus, HasSpeechProvider, SpeechToTextInProgress } from '../../../speech/common/speechService.js';
 import { ISpeechService } from '../../../speech/common/speechService.service.js';
 import { Codicon } from '../../../../../base/common/codicons.js';
-import { registerEditorContribution, EditorAction2 } from '../../../../../editor/browser/editorExtensions.js';
+import { EditorOption } from '../../../../../editor/common/config/editorOptions.js';
+import { EditorAction2, registerEditorContribution, EditorContributionInstantiation } from '../../../../../editor/browser/editorExtensions.js';
 import { EditorContextKeys } from '../../../../../editor/common/editorContextKeys.js';
+import { KeyCode, KeyMod as KeyMod$1 } from '../../../../../base/common/keyCodes.js';
+import { KeybindingWeight } from '../../../../../platform/keybinding/common/keybindingsRegistry.js';
 import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.service.js';
 import { EditOperation } from '../../../../../editor/common/core/editOperation.js';
 import { Selection } from '../../../../../editor/common/core/selection.js';
@@ -20,6 +24,7 @@ import { assertIsDefined } from '../../../../../base/common/types.js';
 import { ActionBar } from '../../../../../base/browser/ui/actionbar/actionbar.js';
 import { toAction } from '../../../../../base/common/actions.js';
 import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { isWindows } from '../../../../../base/common/platform.js';
 var EditorDictation_1;
 const _moduleId = "vs/workbench/contrib/codeEditor/browser/dictation/editorDictation";
 const EDITOR_DICTATION_IN_PROGRESS = ( (new RawContextKey('editorDictation.inProgress', false)));
@@ -32,13 +37,16 @@ class EditorDictationStartAction extends EditorAction2 {
             category: VOICE_CATEGORY,
             precondition: ( (ContextKeyExpr.and(
                 HasSpeechProvider,
-                 (EDITOR_DICTATION_IN_PROGRESS.toNegated()),
-                 (EditorContextKeys.readOnly.toNegated())
+                 (SpeechToTextInProgress.toNegated()),
+                (EditorContextKeys.readOnly.toNegated())
             ))),
             f1: true,
             keybinding: {
-                primary: 2048  | 512  | 52 ,
-                weight: 200
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Alt | KeyCode.KeyV,
+                weight: KeybindingWeight.WorkbenchContrib,
+                secondary: isWindows ? [
+                    KeyMod$1.Alt | KeyCode.Backquote
+                ] : undefined
             }
         });
     }
@@ -70,8 +78,8 @@ class EditorDictationStopAction extends EditorAction2 {
             precondition: EDITOR_DICTATION_IN_PROGRESS,
             f1: true,
             keybinding: {
-                primary: 9 ,
-                weight: 200  + 100
+                primary: KeyCode.Escape,
+                weight: KeybindingWeight.WorkbenchContrib + 100
             }
         });
     }
@@ -111,13 +119,13 @@ class DictationWidget extends Disposable {
         return {
             position: selection.getPosition(),
             preference: [
-                selection.getPosition().equals(selection.getStartPosition()) ? 1  : 2 ,
-                0
+                selection.getPosition().equals(selection.getStartPosition()) ? ContentWidgetPositionPreference.ABOVE : ContentWidgetPositionPreference.BELOW,
+                ContentWidgetPositionPreference.EXACT
             ]
         };
     }
     beforeRender() {
-        const lineHeight = this.editor.getOption(67 );
+        const lineHeight = this.editor.getOption(EditorOption.lineHeight);
         const width = this.editor.getLayoutInfo().contentWidth * 0.7;
         this.domNode.style.setProperty('--vscode-editor-dictation-widget-height', `${lineHeight}px`);
         this.domNode.style.setProperty('--vscode-editor-dictation-widget-width', `${width}px`);
@@ -236,7 +244,7 @@ EditorDictation = EditorDictation_1 = ( (__decorate([
     ( (__param(2, IContextKeyService))),
     ( (__param(3, IKeybindingService)))
 ], EditorDictation)));
-registerEditorContribution(EditorDictation.ID, EditorDictation, 4 );
+registerEditorContribution(EditorDictation.ID, EditorDictation, EditorContributionInstantiation.Lazy);
 registerAction2(EditorDictationStartAction);
 registerAction2(EditorDictationStopAction);
 export { DictationWidget, EditorDictation, EditorDictationStartAction, EditorDictationStopAction };

package/vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorAccessibilityHelp.js

@@ -0,0 +1,77 @@
+import { ICodeEditorService } from '../../../../editor/browser/services/codeEditorService.js';
+import { AccessibleDiffViewerPrev, AccessibleDiffViewerNext } from '../../../../editor/browser/widget/diffEditor/commands.js';
+import { DiffEditorWidget } from '../../../../editor/browser/widget/diffEditor/diffEditorWidget.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { AccessibleViewType, AccessibleViewProviderId } from '../../../../platform/accessibility/browser/accessibleView.js';
+import { ContextKeyEqualsExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
+import { IKeybindingService } from '../../../../platform/keybinding/common/keybinding.service.js';
+import { AccessibilityVerbositySettingId } from '../../accessibility/browser/accessibilityConfiguration.js';
+import { getCommentCommandInfo } from '../../accessibility/browser/editorAccessibilityHelp.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+const _moduleId = "vs/workbench/contrib/codeEditor/browser/diffEditorAccessibilityHelp";
+class DiffEditorAccessibilityHelp {
+    constructor() {
+        this.priority = 105;
+        this.name = 'diff-editor';
+        this.when = ContextKeyEqualsExpr.create('isInDiffEditor', true);
+        this.type = AccessibleViewType.Help;
+    }
+    getProvider(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const codeEditorService = accessor.get(ICodeEditorService);
+        const keybindingService = accessor.get(IKeybindingService);
+        const contextKeyService = accessor.get(IContextKeyService);
+        if (!(editorService.activeTextEditorControl instanceof DiffEditorWidget)) {
+            return;
+        }
+        const codeEditor = codeEditorService.getActiveCodeEditor() || codeEditorService.getFocusedCodeEditor();
+        if (!codeEditor) {
+            return;
+        }
+        const switchSides = ( localizeWithPath(
+            _moduleId,
+            0,
+            "Run the command Diff Editor: Switch Side<keybinding:diffEditor.switchSide> to toggle between the original and modified editors."
+        ));
+        const diffEditorActiveAnnouncement = ( localizeWithPath(
+            _moduleId,
+            1,
+            "The setting, accessibility.verbosity.diffEditorActive, controls if a diff editor announcement is made when it becomes the active editor."
+        ));
+        const keys = ['accessibility.signals.diffLineDeleted', 'accessibility.signals.diffLineInserted', 'accessibility.signals.diffLineModified'];
+        const content = [
+            ( localizeWithPath(_moduleId, 2, "You are in a diff editor.")),
+            ( localizeWithPath(
+                _moduleId,
+                3,
+                "View the next<keybinding:{0}> or previous<keybinding:{1}> diff in diff review mode, which is optimized for screen readers.",
+                AccessibleDiffViewerNext.id,
+                AccessibleDiffViewerPrev.id
+            )),
+            switchSides,
+            diffEditorActiveAnnouncement,
+            ( localizeWithPath(
+                _moduleId,
+                4,
+                "To control which accessibility signals should be played, the following settings can be configured: {0}.",
+                keys.join(', ')
+            )),
+        ];
+        const commentCommandInfo = getCommentCommandInfo(keybindingService, contextKeyService, codeEditor);
+        if (commentCommandInfo) {
+            content.push(commentCommandInfo);
+        }
+        return {
+            id: AccessibleViewProviderId.DiffEditor,
+            verbositySettingKey: AccessibilityVerbositySettingId.DiffEditor,
+            provideContent: () => content.join('\n\n'),
+            onClose: () => {
+                codeEditor.focus();
+            },
+            options: { type: AccessibleViewType.Help }
+        };
+    }
+    dispose() { }
+}
+export { DiffEditorAccessibilityHelp };