@codingame/monaco-vscode-chat-service-override 9.0.3 → 10.0.1

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

@@ -1,7 +1,6 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
 import { Extensions } from 'vscode/vscode/vs/workbench/services/extensionManagement/common/extensionFeatures';
@@ -21,7 +20,7 @@ let LanguageModelStatsService = class LanguageModelStatsService extends Disposab
         this._onDidChangeStats = this._register(( (new Emitter())));
         this.onDidChangeLanguageMoelStats = this._onDidChangeStats.event;
         this.sessionStats = ( (new Map()));
-        this._register(_storageService.onDidChangeValue(StorageScope.APPLICATION, undefined, this._store)(e => {
+        this._register(_storageService.onDidChangeValue(-1 , undefined, this._store)(e => {
             const model = this.getModel(e.key);
             if (model) {
                 this._onDidChangeStats.fire(model);
@@ -48,12 +47,12 @@ let LanguageModelStatsService = class LanguageModelStatsService extends Disposab
         const extensions = this.getAccessExtensions(model);
         if (!extensions.includes(extensionId)) {
             extensions.push(extensionId);
-            this._storageService.store(this.getAccessKey(model), JSON.stringify(extensions), StorageScope.APPLICATION, StorageTarget.USER);
+            this._storageService.store(this.getAccessKey(model), JSON.stringify(extensions), -1 , 0 );
         }
     }
     getAccessExtensions(model) {
         const key = this.getAccessKey(model);
-        const data = this._storageService.get(key, StorageScope.APPLICATION);
+        const data = this._storageService.get(key, -1 );
         try {
             if (data) {
                 const parsed = JSON.parse(data);
@@ -69,7 +68,7 @@ let LanguageModelStatsService = class LanguageModelStatsService extends Disposab
     async write(model, extensionId, participant, tokenCount) {
         const modelStats = await this.read(model);
         this.add(modelStats, extensionId, participant, tokenCount);
-        this._storageService.store(this.getKey(model), JSON.stringify(modelStats), StorageScope.APPLICATION, StorageTarget.USER);
+        this._storageService.store(this.getKey(model), JSON.stringify(modelStats), -1 , 0 );
     }
     add(modelStats, extensionId, participant, tokenCount) {
         let extensionStats = modelStats.extensions.find(e => ExtensionIdentifier.equals(e.extensionId, extensionId));
@@ -93,7 +92,7 @@ let LanguageModelStatsService = class LanguageModelStatsService extends Disposab
     }
     async read(model) {
         try {
-            const value = this._storageService.get(this.getKey(model), StorageScope.APPLICATION);
+            const value = this._storageService.get(this.getKey(model), -1 );
             if (value) {
                 return JSON.parse(value);
             }
@@ -121,8 +120,8 @@ LanguageModelStatsService = LanguageModelStatsService_1 = ( (__decorate([
 ], LanguageModelStatsService)));
 ( (Registry.as(Extensions.ExtensionFeaturesRegistry))).registerExtensionFeature({
     id: 'languageModels',
-    label: ( localize(3060, "Language Models")),
-    description: ( localize(3061, "Language models usage statistics of this extension.")),
+    label: ( localize(3164, "Language Models")),
+    description: ( localize(3165, "Language models usage statistics of this extension.")),
     access: {
         canToggle: false
     },

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

@@ -1,21 +1,26 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
+import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
 import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { localize } from 'vscode/vscode/vs/nls';
 import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { ChatToolInvocation } from './chatProgressTypes/chatToolInvocation.js';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService.service';
 
 let LanguageModelToolsService = class LanguageModelToolsService extends Disposable {
-    constructor(_extensionService, _contextKeyService) {
+    constructor(_extensionService, _contextKeyService, _chatService) {
         super();
         this._extensionService = _extensionService;
         this._contextKeyService = _contextKeyService;
-        this._onDidChangeTools = ( new Emitter());
+        this._chatService = _chatService;
+        this._onDidChangeTools = ( (new Emitter()));
         this.onDidChangeTools = this._onDidChangeTools.event;
-        this._onDidChangeToolsScheduler = ( new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750));
-        this._tools = ( new Map());
-        this._toolContextKeys = ( new Set());
+        this._onDidChangeToolsScheduler = ( (new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750)));
+        this._tools = ( (new Map()));
+        this._toolContextKeys = ( (new Set()));
         this._register(this._contextKeyService.onDidChangeContext(e => {
             if (e.affectsSome(this._toolContextKeys)) {
                 this._onDidChangeToolsScheduler.schedule();
@@ -23,8 +28,11 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }));
     }
     registerToolData(toolData) {
-        if (( this._tools.has(toolData.id))) {
-            throw ( new Error(`Tool "${toolData.id}" is already registered.`));
+        if (( (this._tools.has(toolData.id)))) {
+            throw ( (new Error(`Tool "${toolData.id}" is already registered.`)));
+        }
+        if (!toolData.supportedContentTypes.includes('text/plain')) {
+            toolData.supportedContentTypes.push('text/plain');
         }
         this._tools.set(toolData.id, { data: toolData });
         this._onDidChangeToolsScheduler.schedule();
@@ -37,17 +45,17 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     }
     _refreshAllToolContextKeys() {
         this._toolContextKeys.clear();
-        for (const tool of ( this._tools.values())) {
+        for (const tool of ( (this._tools.values()))) {
             tool.data.when?.keys().forEach(key => this._toolContextKeys.add(key));
         }
     }
-    registerToolImplementation(name, tool) {
-        const entry = this._tools.get(name);
+    registerToolImplementation(id, tool) {
+        const entry = this._tools.get(id);
         if (!entry) {
-            throw ( new Error(`Tool "${name}" was not contributed.`));
+            throw ( (new Error(`Tool "${id}" was not contributed.`)));
         }
         if (entry.impl) {
-            throw ( new Error(`Tool "${name}" already has an implementation.`));
+            throw ( (new Error(`Tool "${id}" already has an implementation.`)));
         }
         entry.impl = tool;
         return toDisposable(() => {
@@ -55,7 +63,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         });
     }
     getTools() {
-        const toolDatas = ( Iterable.map(( this._tools.values()), i => i.data));
+        const toolDatas = ( (Iterable.map( (this._tools.values()), i => i.data)));
         return Iterable.filter(toolDatas, toolData => !toolData.when || this._contextKeyService.contextMatchesRules(toolData.when));
     }
     getTool(id) {
@@ -81,21 +89,63 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     async invokeTool(dto, countTokens, token) {
         let tool = this._tools.get(dto.toolId);
         if (!tool) {
-            throw ( new Error(`Tool ${dto.toolId} was not contributed`));
+            throw ( (new Error(`Tool ${dto.toolId} was not contributed`)));
         }
         if (!tool.impl) {
             await this._extensionService.activateByEvent(`onLanguageModelTool:${dto.toolId}`);
             tool = this._tools.get(dto.toolId);
             if (!tool?.impl) {
-                throw ( new Error(`Tool ${dto.toolId} does not have an implementation registered.`));
+                throw ( (new Error(`Tool ${dto.toolId} does not have an implementation registered.`)));
+            }
+        }
+        let toolInvocation;
+        if (dto.context) {
+            const model = this._chatService.getSession(dto.context?.sessionId);
+            const request = model.getRequests().at(-1);
+            const participantName = request.response?.agent?.fullName ?? '';
+            const getConfirmationMessages = async () => {
+                if (!tool.data.requiresConfirmation) {
+                    return undefined;
+                }
+                return (await tool.impl.provideToolConfirmationMessages(participantName, dto.parameters, token)) ?? {
+                    title: ( localize(3185, "Use {0}?", `"${tool.data.displayName ?? tool.data.id}"`)),
+                    message: ( localize(
+                        3186,
+                        "{0} will use {1}.",
+                        participantName,
+                        `"${tool.data.displayName ?? tool.data.id}"`
+                    )),
+                };
+            };
+            const [invocationMessage, confirmationMessages] = await Promise.all([
+                tool.impl.provideToolInvocationMessage(dto.parameters, token),
+                getConfirmationMessages()
+            ]);
+            const defaultMessage = ( localize(3187, "Using {0}", `"${tool.data.displayName ?? tool.data.id}"`));
+            toolInvocation = ( (new ChatToolInvocation(invocationMessage ?? defaultMessage, confirmationMessages)));
+            token.onCancellationRequested(() => {
+                toolInvocation.confirmed.complete(false);
+            });
+            model.acceptResponseProgress(request, toolInvocation);
+            if (tool.data.requiresConfirmation) {
+                const userConfirmed = await toolInvocation.confirmed.p;
+                if (!userConfirmed) {
+                    throw ( (new CancellationError()));
+                }
             }
         }
-        return tool.impl.invoke(dto, countTokens, token);
+        try {
+            return tool.impl.invoke(dto, countTokens, token);
+        }
+        finally {
+            toolInvocation?.complete();
+        }
     }
 };
-LanguageModelToolsService = ( __decorate([
-    ( __param(0, IExtensionService)),
-    ( __param(1, IContextKeyService))
-], LanguageModelToolsService));
+LanguageModelToolsService = ( (__decorate([
+    ( (__param(0, IExtensionService))),
+    ( (__param(1, IContextKeyService))),
+    ( (__param(2, IChatService)))
+], LanguageModelToolsService)));
 
 export { LanguageModelToolsService };

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

@@ -0,0 +1,172 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
+import { DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isFalsyOrWhitespace } from 'vscode/vscode/vs/base/common/strings';
+import { localize } from 'vscode/vscode/vs/nls';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ExtensionIdentifier } from 'vscode/vscode/vs/platform/extensions/common/extensions';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { isProposedApiEnabled } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { CONTEXT_LANGUAGE_MODELS_ARE_USER_SELECTABLE } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+
+const languageModelType = {
+    type: 'object',
+    properties: {
+        vendor: {
+            type: 'string',
+            description: ( localize(3156, "A globally unique vendor of language models."))
+        }
+    }
+};
+const languageModelExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'languageModels',
+    jsonSchema: {
+        description: ( localize(3157, "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, _contextKeyService) {
+        this._extensionService = _extensionService;
+        this._logService = _logService;
+        this._contextKeyService = _contextKeyService;
+        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._hasUserSelectableModels = CONTEXT_LANGUAGE_MODELS_ARE_USER_SELECTABLE.bindTo(this._contextKeyService);
+        this._store.add(languageModelExtensionPoint.setHandler((extensions) => {
+            this._vendors.clear();
+            for (const extension of extensions) {
+                if (!isProposedApiEnabled(extension.description, 'chatProvider')) {
+                    extension.collector.error(( localize(3158, "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(( localize(
+                            3159,
+                            "The vendor '{0}' is already registered and cannot be registered twice",
+                            item.vendor
+                        )));
+                        continue;
+                    }
+                    if (isFalsyOrWhitespace(item.vendor)) {
+                        extension.collector.error(( localize(3160, "The vendor field cannot be empty.")));
+                        continue;
+                    }
+                    if (item.vendor.trim() !== item.vendor) {
+                        extension.collector.error(( localize(3161, "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 }] });
+        this.updateUserSelectableModelsContext();
+        return toDisposable(() => {
+            this.updateUserSelectableModelsContext();
+            if (this._providers.delete(identifier)) {
+                this._onDidChangeProviders.fire({ removed: [identifier] });
+                this._logService.trace('[LM] UNregistered language model chat', identifier, provider.metadata);
+            }
+        });
+    }
+    updateUserSelectableModelsContext() {
+        const hasUserSelectableModels = ( (Array.from(( (this._providers.values()))).some(p => p.metadata.isUserSelectable && !p.metadata.isDefault)));
+        const hasDefaultModel = ( (Array.from(( (this._providers.values()))).some(p => p.metadata.isDefault)));
+        this._hasUserSelectableModels.set(hasUserSelectableModels && hasDefaultModel);
+    }
+    async sendChatRequest(identifier, from, messages, options, token) {
+        const provider = this._providers.get(identifier);
+        if (!provider) {
+            throw ( (new Error(`Chat response provider with identifier ${identifier} is not registered.`)));
+        }
+        return provider.sendChatRequest(messages, from, options, 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))),
+    ( (__param(2, IContextKeyService)))
+], LanguageModelsService)));
+
+export { LanguageModelsService, languageModelExtensionPoint };

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsContribution.js

@@ -16,7 +16,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
         }
     },
     jsonSchema: {
-        description: ( localize(7163, 'Contributes a tool that can be invoked by a language model.')),
+        description: ( localize(7275, 'Contributes a tool that can be invoked by a language model.')),
         type: 'array',
         items: {
             additionalProperties: false,
@@ -25,13 +25,13 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
             required: ['id', 'modelDescription'],
             properties: {
                 id: {
-                    description: ( localize(7164, "A unique id for this tool.")),
+                    description: ( localize(7276, "A unique id for this tool.")),
                     type: 'string',
                     pattern: '^[\\w-]+$'
                 },
                 name: {
                     description: ( localize(
-                        7165,
+                        7277,
                         "If {0} is enabled for this tool, the user may use '#' with this name to invoke the tool in a query. Otherwise, the name is not required. Name must not contain whitespace.",
                         '`canBeInvokedManually`'
                     )),
@@ -40,34 +40,34 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 displayName: {
                     description: ( localize(
-                        7166,
+                        7278,
                         "A human-readable name for this tool that may be used to describe it in the UI."
                     )),
                     type: 'string'
                 },
                 userDescription: {
-                    description: ( localize(7167, "A description of this tool that may be shown to the user.")),
+                    description: ( localize(7279, "A description of this tool that may be shown to the user.")),
                     type: 'string'
                 },
                 modelDescription: {
-                    description: ( localize(7168, "A description of this tool that may be passed to a language model.")),
+                    description: ( localize(7280, "A description of this tool that may be passed to a language model.")),
                     type: 'string'
                 },
                 parametersSchema: {
-                    description: ( localize(7169, "A JSON schema for the parameters this tool accepts.")),
+                    description: ( localize(7281, "A JSON schema for the parameters this tool accepts.")),
                     type: 'object',
                     $ref: 'http://json-schema.org/draft-07/schema#'
                 },
                 canBeInvokedManually: {
                     description: ( localize(
-                        7170,
+                        7282,
                         "Whether this tool can be invoked manually by the user through the chat UX."
                     )),
                     type: 'boolean'
                 },
                 icon: {
                     description: ( localize(
-                        7171,
+                        7283,
                         "An icon that represents this tool. Either a file path, an object with file paths for dark and light themes, or a theme icon reference, like `\\$(zap)`"
                     )),
                     anyOf: [{
@@ -77,11 +77,11 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                             type: 'object',
                             properties: {
                                 light: {
-                                    description: ( localize(7172, 'Icon path when a light theme is used')),
+                                    description: ( localize(7284, 'Icon path when a light theme is used')),
                                     type: 'string'
                                 },
                                 dark: {
-                                    description: ( localize(7173, 'Icon path when a dark theme is used')),
+                                    description: ( localize(7285, 'Icon path when a dark theme is used')),
                                     type: 'string'
                                 }
                             }
@@ -89,10 +89,27 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 when: {
                     markdownDescription: ( localize(
-                        7174,
+                        7286,
                         "Condition which must be true for this tool to be enabled. Note that a tool may still be invoked by another extension even when its `when` condition is false."
                     )),
                     type: 'string'
+                },
+                supportedContentTypes: {
+                    markdownDescription: ( localize(
+                        7287,
+                        "The list of content types that this tool can return. It's required that tools support `text/plain`, and that is assumed even if not specified here. Another example could be the contentType exported by the `@vscode/prompt-tsx` library."
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                },
+                requiresConfirmation: {
+                    description: ( localize(
+                        7288,
+                        "Whether this tool requires user confirmation before being executed."
+                    )),
+                    type: 'boolean'
                 }
             }
         }
@@ -138,6 +155,7 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                         ...rawTool,
                         icon,
                         when: rawTool.when ? ContextKeyExpr.deserialize(rawTool.when) : undefined,
+                        supportedContentTypes: rawTool.supportedContentTypes ? rawTool.supportedContentTypes : [],
                     };
                     const disposable = languageModelToolsService.registerToolData(tool);
                     this._registrationDisposables.set(toToolKey(extension.description.identifier, rawTool.id), disposable);

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

@@ -20,7 +20,7 @@ var PhraseTextType;
 const VoiceChatInProgress = ( (new RawContextKey(
     'voiceChatInProgress',
     false,
-    { type: 'boolean', description: ( localize(7175, "A speech-to-text session is in progress for chat.")) }
+    { type: 'boolean', description: ( localize(7289, "A speech-to-text session is in progress for chat.")) }
 )));
 let VoiceChatService = class VoiceChatService extends Disposable {
     static { VoiceChatService_1 = this; }

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

@@ -1,13 +1,11 @@
-import { registerEditorContribution, EditorContributionInstantiation } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { registerEditorContribution } from 'vscode/vscode/vs/editor/browser/editorExtensions';
 import { registerAction2, MenuRegistry } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
 import { StartSessionAction, CloseAction, ConfigureInlineChatAction, UnstashSessionAction, DiscardHunkAction, DiscardAction, RerunAction, MoveToNextHunk, MoveToPreviousHunk, ArrowOutUpAction, ArrowOutDownAction, FocusInlineChat, ViewInChatAction, ToggleDiffForChange, AcceptChanges } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatActions';
-import { INLINE_CHAT_ID, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_EDITING, MENU_INLINE_CHAT_CONTENT_STATUS, MENU_INLINE_CHAT_WIDGET_STATUS } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
-import 'vscode/vscode/vs/platform/instantiation/common/extensions';
+import { INLINE_CHAT_ID, CTX_INLINE_CHAT_REQUEST_IN_PROGRESS, CTX_INLINE_CHAT_EDITING, MENU_INLINE_CHAT_WIDGET_STATUS } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { InlineChatNotebookContribution } from './inlineChatNotebook.js';
-import { Extensions, registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
+import { Extensions, registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
 import './inlineChatSavingServiceImpl.js';
 import { InlineChatAccessibleView } from './inlineChatAccessibleView.js';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
@@ -20,15 +18,15 @@ import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/cont
 import { InlineChatAccessibilityHelp } from './inlineChatAccessibilityHelp.js';
 import { InlineChatExansionContextKey, InlineChatExpandLineAction } from './inlineChatCurrentLine.js';
 
-registerEditorContribution(INLINE_CHAT_ID, InlineChatController, EditorContributionInstantiation.Eager);
-registerEditorContribution(InlineChatExansionContextKey.Id, InlineChatExansionContextKey, EditorContributionInstantiation.BeforeFirstInteraction);
+registerEditorContribution(INLINE_CHAT_ID, InlineChatController, 0 );
+registerEditorContribution(InlineChatExansionContextKey.Id, InlineChatExansionContextKey, 2 );
 registerAction2(InlineChatExpandLineAction);
 const editActionMenuItem = {
     group: '0_main',
     order: 0,
     command: {
         id: SubmitAction.ID,
-        title: ( localize(3076, "Edit Code")),
+        title: ( localize(3181, "Edit Code")),
     },
     when: ( (ContextKeyExpr.and(
         CONTEXT_CHAT_INPUT_HAS_TEXT,
@@ -41,7 +39,7 @@ const generateActionMenuItem = {
     order: 0,
     command: {
         id: SubmitAction.ID,
-        title: ( localize(3077, "Generate")),
+        title: ( localize(3182, "Generate")),
     },
     when: ( (ContextKeyExpr.and(
         CONTEXT_CHAT_INPUT_HAS_TEXT,
@@ -49,8 +47,6 @@ const generateActionMenuItem = {
          (CTX_INLINE_CHAT_EDITING.toNegated())
     ))),
 };
-MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_CONTENT_STATUS, editActionMenuItem);
-MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_CONTENT_STATUS, generateActionMenuItem);
 MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_WIDGET_STATUS, editActionMenuItem);
 MenuRegistry.appendMenuItem(MENU_INLINE_CHAT_WIDGET_STATUS, generateActionMenuItem);
 const cancelActionMenuItem = {
@@ -58,8 +54,8 @@ const cancelActionMenuItem = {
     order: 0,
     command: {
         id: CancelAction.ID,
-        title: ( localize(3078, "Stop Request")),
-        shortTitle: ( localize(3079, "Stop")),
+        title: ( localize(3183, "Cancel Request")),
+        shortTitle: ( localize(3184, "Cancel")),
     },
     when: ( (ContextKeyExpr.and(CTX_INLINE_CHAT_REQUEST_IN_PROGRESS))),
 };
@@ -80,7 +76,7 @@ registerAction2(ViewInChatAction);
 registerAction2(ToggleDiffForChange);
 registerAction2(AcceptChanges);
 const workbenchContributionsRegistry = ( (Registry.as(Extensions.Workbench)));
-workbenchContributionsRegistry.registerWorkbenchContribution(InlineChatNotebookContribution, LifecyclePhase.Restored);
-registerWorkbenchContribution2(InlineChatEnabler.Id, InlineChatEnabler, WorkbenchPhase.AfterRestored);
+workbenchContributionsRegistry.registerWorkbenchContribution(InlineChatNotebookContribution, 3 );
+registerWorkbenchContribution2(InlineChatEnabler.Id, InlineChatEnabler, 3 );
 AccessibleViewRegistry.register(( (new InlineChatAccessibleView())));
 AccessibleViewRegistry.register(( (new InlineChatAccessibilityHelp())));

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatAccessibilityHelp.js

@@ -1,5 +1,4 @@
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
-import { AccessibleViewType } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { getChatAccessibilityHelpProvider } from '../../chat/browser/actions/chatAccessibilityHelp.js';
 import { CONTEXT_CHAT_INPUT_HAS_FOCUS } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
@@ -9,7 +8,7 @@ class InlineChatAccessibilityHelp {
     constructor() {
         this.priority = 106;
         this.name = 'inlineChat';
-        this.type = AccessibleViewType.Help;
+        this.type = "help" ;
         this.when = ( ContextKeyExpr.or(CTX_INLINE_CHAT_RESPONSE_FOCUSED, CONTEXT_CHAT_INPUT_HAS_FOCUS));
     }
     getProvider(accessor) {

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatAccessibleView.js

@@ -2,17 +2,16 @@ import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineC
 import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { AccessibleViewType, AccessibleContentProvider, AccessibleViewProviderId } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
+import { AccessibleContentProvider } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
 import { renderMarkdownAsPlaintext } from 'vscode/vscode/vs/base/browser/markdownRenderer';
-import { AccessibilityVerbositySettingId } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
 
 class InlineChatAccessibleView {
     constructor() {
         this.priority = 100;
         this.name = 'inlineChat';
         this.when = ( ContextKeyExpr.or(CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_RESPONSE_FOCUSED));
-        this.type = AccessibleViewType.View;
+        this.type = "view" ;
     }
     getProvider(accessor) {
         const codeEditorService = accessor.get(ICodeEditorService);
@@ -29,11 +28,11 @@ class InlineChatAccessibleView {
             return;
         }
         return ( new AccessibleContentProvider(
-            AccessibleViewProviderId.InlineChat,
-            { type: AccessibleViewType.View },
+            "inlineChat" ,
+            { type: "view"  },
             () => renderMarkdownAsPlaintext(( new MarkdownString(responseContent)), true),
             () => controller.focus(),
-            AccessibilityVerbositySettingId.InlineChat
+            "accessibility.verbosity.inlineChat"
         ));
     }
 }