@codingame/monaco-vscode-chat-service-override 7.0.11 → 7.1.1

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

@@ -26,7 +26,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
     acceptResponse(response, requestId) {
         this._pendingSignalMap.deleteAndDispose(requestId);
         const isPanelChat = typeof response !== 'string';
-        const responseContent = typeof response === 'string' ? response : response?.response.asString();
+        const responseContent = typeof response === 'string' ? response : response?.response.toString();
         this._accessibilitySignalService.playSignal(AccessibilitySignal.chatResponseReceived, { allowManyInParallel: true });
         if (!response || !responseContent) {
             return;

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

@@ -21,7 +21,7 @@ import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/edit
 import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
 import { ChatEditorInput } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatEditorInput';
 import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
-import { clearChatEditor } from './actions/chatClear.js';
+import { clearChatEditor } from 'vscode/vscode/vs/workbench/contrib/chat/browser/actions/chatClear';
 import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
 import { CHAT_PROVIDER_ID } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes';
 
@@ -36,11 +36,13 @@ let ChatEditor = class ChatEditor extends EditorPane {
         this.contextKeyService = contextKeyService;
     }
     async clear() {
-        return this.instantiationService.invokeFunction(clearChatEditor);
+        if (this.input) {
+            return this.instantiationService.invokeFunction(clearChatEditor, this.input);
+        }
     }
     createEditor(parent) {
         this._scopedContextKeyService = this._register(this.contextKeyService.createScoped(parent));
-        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
+        const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService]))));
         this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, { resource: true }, { supportsFileReferences: true }, {
             listForeground: editorForeground,
             listBackground: editorBackground,

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

@@ -1,34 +1,25 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { isNonEmptyArray } from 'vscode/vscode/vs/base/common/arrays';
-import { AmbiguousCharacters, InvisibleCharacters } from 'vscode/vscode/vs/base/common/strings';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
-import { DisposableStore, DisposableMap, Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { DisposableMap, DisposableStore, Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { AmbiguousCharacters, InvisibleCharacters } from 'vscode/vscode/vs/base/common/strings';
+import { localize, localize2 } from 'vscode/vscode/vs/nls';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService.service';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
 import { Extensions, ViewContainerLocation } from 'vscode/vscode/vs/workbench/common/views';
 import { CHAT_VIEW_ID } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
-import { ChatViewPane, CHAT_SIDEBAR_PANEL_ID } from './chatViewPane.js';
+import { CHAT_SIDEBAR_PANEL_ID, ChatViewPane } from './chatViewPane.js';
 import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
 import { IChatAgentService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
 import { isProposedApiEnabled } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
-import 'vscode/vscode/vs/platform/notification/common/notification';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification.service';
-import { Action } from 'vscode/vscode/vs/base/common/actions';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
-import Severity$1 from 'vscode/vscode/vs/base/common/severity';
 
-const _moduleId = "vs/workbench/contrib/chat/browser/chatParticipantContributions";
 const chatParticipantExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'chatParticipants',
     jsonSchema: {
-        description: ( localizeWithPath(_moduleId, 0, 'Contributes a chat participant')),
+        description: ( localize(7273, 'Contributes a chat participant')),
         type: 'array',
         items: {
             additionalProperties: false,
@@ -37,55 +28,50 @@ const chatParticipantExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
             required: ['name', 'id'],
             properties: {
                 id: {
-                    description: ( localizeWithPath(_moduleId, 1, "A unique id for this chat participant.")),
+                    description: ( localize(7274, "A unique id for this chat participant.")),
                     type: 'string'
                 },
                 name: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        2,
+                    description: ( localize(
+                        7275,
                         "User-facing name for this chat participant. The user will use '@' with this name to invoke the participant. Name must not contain whitespace."
                     )),
                     type: 'string',
                     pattern: '^[\\w0-9_-]+$'
                 },
                 fullName: {
-                    markdownDescription: ( localizeWithPath(
-                        _moduleId,
-                        3,
+                    markdownDescription: ( localize(
+                        7276,
                         "The full name of this chat participant, which is shown as the label for responses coming from this participant. If not provided, {0} is used.",
                         '`name`'
                     )),
                     type: 'string'
                 },
                 description: {
-                    description: ( localizeWithPath(_moduleId, 4, "A description of this chat participant, shown in the UI.")),
+                    description: ( localize(7277, "A description of this chat participant, shown in the UI.")),
                     type: 'string'
                 },
                 isSticky: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        5,
+                    description: ( localize(
+                        7278,
                         "Whether invoking the command puts the chat into a persistent mode, where the command is automatically added to the chat input for the next message."
                     )),
                     type: 'boolean'
                 },
                 sampleRequest: {
-                    description: ( localizeWithPath(
-                        _moduleId,
-                        6,
+                    description: ( localize(
+                        7279,
                         "When the user clicks this participant in `/help`, this text will be submitted to the participant."
                     )),
                     type: 'string'
                 },
                 when: {
-                    description: ( localizeWithPath(_moduleId, 7, "A condition which must be true to enable this participant.")),
+                    description: ( localize(7280, "A condition which must be true to enable this participant.")),
                     type: 'string'
                 },
                 commands: {
-                    markdownDescription: ( localizeWithPath(
-                        _moduleId,
-                        8,
+                    markdownDescription: ( localize(
+                        7281,
                         "Commands available for this chat participant, which the user can invoke with a `/`."
                     )),
                     type: 'array',
@@ -96,33 +82,30 @@ const chatParticipantExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
                         required: ['name'],
                         properties: {
                             name: {
-                                description: ( localizeWithPath(
-                                    _moduleId,
-                                    9,
+                                description: ( localize(
+                                    7282,
                                     "A short name by which this command is referred to in the UI, e.g. `fix` or * `explain` for commands that fix an issue or explain code. The name should be unique among the commands provided by this participant."
                                 )),
                                 type: 'string'
                             },
                             description: {
-                                description: ( localizeWithPath(_moduleId, 10, "A description of this command.")),
+                                description: ( localize(7283, "A description of this command.")),
                                 type: 'string'
                             },
                             when: {
-                                description: ( localizeWithPath(_moduleId, 11, "A condition which must be true to enable this command.")),
+                                description: ( localize(7284, "A condition which must be true to enable this command.")),
                                 type: 'string'
                             },
                             sampleRequest: {
-                                description: ( localizeWithPath(
-                                    _moduleId,
-                                    12,
+                                description: ( localize(
+                                    7285,
                                     "When the user clicks this command in `/help`, this text will be submitted to the participant."
                                 )),
                                 type: 'string'
                             },
                             isSticky: {
-                                description: ( localizeWithPath(
-                                    _moduleId,
-                                    5,
+                                description: ( localize(
+                                    7285,
                                     "Whether invoking the command puts the chat into a persistent mode, where the command is automatically added to the chat input for the next message."
                                 )),
                                 type: 'boolean'
@@ -141,74 +124,17 @@ const chatParticipantExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
 });
 let ChatExtensionPointHandler = class ChatExtensionPointHandler {
     static { this.ID = 'workbench.contrib.chatExtensionPointHandler'; }
-    constructor(_chatAgentService, productService, contextService, logService, notificationService, commandService) {
+    constructor(_chatAgentService, logService) {
         this._chatAgentService = _chatAgentService;
-        this.productService = productService;
-        this.contextService = contextService;
         this.logService = logService;
-        this.notificationService = notificationService;
-        this.commandService = commandService;
-        this.disposables = ( (new DisposableStore()));
         this._participantRegistrationDisposables = ( (new DisposableMap()));
         this.hasRegisteredDefaultParticipantView = false;
         this._viewContainer = this.registerViewContainer();
-        this.registerListeners();
         this.handleAndRegisterChatExtensions();
     }
-    registerListeners() {
-        this.contextService.onDidChangeContext(e => {
-            if (!this.productService.chatWelcomeView) {
-                return;
-            }
-            const showWelcomeViewConfigKey = 'workbench.chat.experimental.showWelcomeView';
-            const keys = ( (new Set([showWelcomeViewConfigKey])));
-            if (e.affectsSome(keys)) {
-                const contextKeyExpr = ( (ContextKeyExpr.equals(showWelcomeViewConfigKey, true)));
-                const viewsRegistry = ( (Registry.as(Extensions.ViewsRegistry)));
-                if (this.contextService.contextMatchesRules(contextKeyExpr)) {
-                    this._welcomeViewDescriptor = {
-                        id: CHAT_VIEW_ID,
-                        name: { original: this.productService.chatWelcomeView.welcomeViewTitle, value: this.productService.chatWelcomeView.welcomeViewTitle },
-                        containerIcon: this._viewContainer.icon,
-                        ctorDescriptor: ( (new SyncDescriptor(ChatViewPane))),
-                        canToggleVisibility: false,
-                        canMoveView: true,
-                        order: 100
-                    };
-                    viewsRegistry.registerViews([this._welcomeViewDescriptor], this._viewContainer);
-                    viewsRegistry.registerViewWelcomeContent(CHAT_VIEW_ID, {
-                        content: this.productService.chatWelcomeView.welcomeViewContent,
-                    });
-                }
-                else if (this._welcomeViewDescriptor) {
-                    viewsRegistry.deregisterViews([this._welcomeViewDescriptor], this._viewContainer);
-                }
-            }
-        }, null, this.disposables);
-    }
     handleAndRegisterChatExtensions() {
         chatParticipantExtensionPoint.setHandler((extensions, delta) => {
             for (const extension of delta.added) {
-                if (( (extension.value.some(
-                    participant => participant.id === 'github.copilot.default' && !participant.fullName
-                )))) {
-                    this.notificationService.notify({
-                        severity: Severity$1.Error,
-                        message: ( localizeWithPath(
-                            _moduleId,
-                            13,
-                            "Chat failed to load. Please ensure that the GitHub Copilot Chat extension is up to date."
-                        )),
-                        actions: {
-                            primary: [
-                                ( (new Action('showExtension', ( localizeWithPath(_moduleId, 14, "Show Extension")), undefined, true, () => {
-                                return this.commandService.executeCommand('workbench.extensions.action.showExtensionsWithIds', ['GitHub.copilot-chat']);
-                            })))
-                            ]
-                        }
-                    });
-                    continue;
-                }
                 for (const providerDescriptor of extension.value) {
                     if (!providerDescriptor.name.match(/^[\w0-9_-]+$/)) {
                         this.logService.error(`Extension '${extension.description.identifier.value}' CANNOT register participant with invalid name: ${providerDescriptor.name}. Name must match /^[\\w0-9_-]+$/.`);
@@ -253,7 +179,6 @@ let ChatExtensionPointHandler = class ChatExtensionPointHandler {
                         name: providerDescriptor.name,
                         fullName: providerDescriptor.fullName,
                         isDefault: providerDescriptor.isDefault,
-                        defaultImplicitVariables: providerDescriptor.defaultImplicitVariables,
                         locations: isNonEmptyArray(providerDescriptor.locations) ?
                             ( (providerDescriptor.locations.map(ChatAgentLocation.fromRaw))) :
                             [ChatAgentLocation.Panel],
@@ -270,7 +195,7 @@ let ChatExtensionPointHandler = class ChatExtensionPointHandler {
         });
     }
     registerViewContainer() {
-        const title = ( localize2WithPath(_moduleId, 15, "Chat"));
+        const title = ( localize2(7286, "Chat"));
         const icon = Codicon.commentDiscussion;
         const viewContainerId = CHAT_SIDEBAR_PANEL_ID;
         const viewContainer = ( (Registry.as(Extensions.ViewContainersRegistry))).registerViewContainer({
@@ -313,11 +238,7 @@ let ChatExtensionPointHandler = class ChatExtensionPointHandler {
 };
 ChatExtensionPointHandler = ( (__decorate([
     ( (__param(0, IChatAgentService))),
-    ( (__param(1, IProductService))),
-    ( (__param(2, IContextKeyService))),
-    ( (__param(3, ILogService))),
-    ( (__param(4, INotificationService))),
-    ( (__param(5, ICommandService)))
+    ( (__param(1, ILogService)))
 ], ChatExtensionPointHandler)));
 function getParticipantKey(extensionId, participantName) {
     return `${extensionId.value}_${participantName}`;

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

@@ -2,12 +2,12 @@ import { renderMarkdownAsPlaintext } from 'vscode/vscode/vs/base/browser/markdow
 import { MarkdownString } from 'vscode/vscode/vs/base/common/htmlContent';
 import { ICodeEditorService } from 'vscode/vscode/vs/editor/browser/services/codeEditorService';
 import { AccessibleViewType, AccessibleViewProviderId } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleView';
-import { alertAccessibleViewFocusChange } from 'vscode/vscode/vs/platform/accessibility/browser/accessibleViewRegistry';
 import { AccessibilityVerbositySettingId } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
 import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { CONTEXT_IN_CHAT_SESSION } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
 import { ChatWelcomeMessageModel } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatModel';
 import { isResponseVM } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 
 class ChatResponseAccessibleView {
     constructor() {
@@ -15,80 +15,89 @@ class ChatResponseAccessibleView {
         this.name = 'panelChat';
         this.type = AccessibleViewType.View;
         this.when = CONTEXT_IN_CHAT_SESSION;
+        this._initialRender = true;
     }
     getProvider(accessor) {
         const widgetService = accessor.get(IChatWidgetService);
         const codeEditorService = accessor.get(ICodeEditorService);
-        return resolveProvider(widgetService, codeEditorService, true);
-        function resolveProvider(widgetService, codeEditorService, initialRender) {
-            const widget = widgetService.lastFocusedWidget;
-            if (!widget) {
-                return;
-            }
-            const chatInputFocused = initialRender && !!codeEditorService.getFocusedCodeEditor();
-            if (initialRender && chatInputFocused) {
-                widget.focusLastMessage();
-            }
-            if (!widget) {
-                return;
-            }
-            const verifiedWidget = widget;
-            const focusedItem = verifiedWidget.getFocus();
-            if (!focusedItem) {
-                return;
-            }
-            widget.focus(focusedItem);
-            const isWelcome = focusedItem instanceof ChatWelcomeMessageModel;
-            let responseContent = isResponseVM(focusedItem) ? focusedItem.response.asString() : undefined;
-            if (isWelcome) {
-                const welcomeReplyContents = [];
-                for (const content of focusedItem.content) {
-                    if (Array.isArray(content)) {
-                        welcomeReplyContents.push(...( content.map(m => m.message)));
-                    }
-                    else {
-                        welcomeReplyContents.push(content.value);
-                    }
+        const widget = widgetService.lastFocusedWidget;
+        if (!widget) {
+            return;
+        }
+        const chatInputFocused = this._initialRender && !!codeEditorService.getFocusedCodeEditor() || false;
+        if (this._initialRender && chatInputFocused) {
+            widget.focusLastMessage();
+            this._initialRender = false;
+        }
+        if (!widget) {
+            return;
+        }
+        const verifiedWidget = widget;
+        const focusedItem = verifiedWidget.getFocus();
+        if (!focusedItem) {
+            return;
+        }
+        return ( new ChatResponseAccessibleProvider(verifiedWidget, focusedItem, chatInputFocused));
+    }
+}
+class ChatResponseAccessibleProvider extends Disposable {
+    constructor(_widget, item, _chatInputFocused) {
+        super();
+        this._widget = _widget;
+        this._chatInputFocused = _chatInputFocused;
+        this.id = AccessibleViewProviderId.Chat;
+        this.verbositySettingKey = AccessibilityVerbositySettingId.Chat;
+        this.options = { type: AccessibleViewType.View };
+        this._focusedItem = item;
+    }
+    provideContent() {
+        return this._getContent(this._focusedItem);
+    }
+    _getContent(item) {
+        const isWelcome = item instanceof ChatWelcomeMessageModel;
+        let responseContent = isResponseVM(item) ? ( item.response.toString()) : '';
+        if (isWelcome) {
+            const welcomeReplyContents = [];
+            for (const content of item.content) {
+                if (Array.isArray(content)) {
+                    welcomeReplyContents.push(...( content.map(m => m.message)));
+                }
+                else {
+                    welcomeReplyContents.push(content.value);
                 }
-                responseContent = welcomeReplyContents.join('\n');
-            }
-            if (!responseContent && 'errorDetails' in focusedItem && focusedItem.errorDetails) {
-                responseContent = focusedItem.errorDetails.message;
-            }
-            if (!responseContent) {
-                return;
             }
-            const responses = verifiedWidget.viewModel?.getItems().filter(i => isResponseVM(i));
-            const length = responses?.length;
-            const responseIndex = responses?.findIndex(i => i === focusedItem);
-            return {
-                id: AccessibleViewProviderId.Chat,
-                verbositySettingKey: AccessibilityVerbositySettingId.Chat,
-                provideContent() { return renderMarkdownAsPlaintext(( new MarkdownString(responseContent)), true); },
-                onClose() {
-                    verifiedWidget.reveal(focusedItem);
-                    if (chatInputFocused) {
-                        verifiedWidget.focusInput();
-                    }
-                    else {
-                        verifiedWidget.focus(focusedItem);
-                    }
-                },
-                next() {
-                    verifiedWidget.moveFocus(focusedItem, 'next');
-                    alertAccessibleViewFocusChange(responseIndex, length, 'next');
-                    resolveProvider(widgetService, codeEditorService);
-                },
-                previous() {
-                    verifiedWidget.moveFocus(focusedItem, 'previous');
-                    alertAccessibleViewFocusChange(responseIndex, length, 'previous');
-                    resolveProvider(widgetService, codeEditorService);
-                },
-                options: { type: AccessibleViewType.View }
-            };
+            responseContent = welcomeReplyContents.join('\n');
+        }
+        if (!responseContent && 'errorDetails' in item && item.errorDetails) {
+            responseContent = item.errorDetails.message;
+        }
+        return renderMarkdownAsPlaintext(( new MarkdownString(responseContent)), true);
+    }
+    onClose() {
+        this._widget.reveal(this._focusedItem);
+        if (this._chatInputFocused) {
+            this._widget.focusInput();
+        }
+        else {
+            this._widget.focus(this._focusedItem);
+        }
+    }
+    provideNextContent() {
+        const next = this._widget.getSibling(this._focusedItem, 'next');
+        if (next) {
+            this._focusedItem = next;
+            return this._getContent(next);
+        }
+        return;
+    }
+    providePreviousContent() {
+        const previous = this._widget.getSibling(this._focusedItem, 'previous');
+        if (previous) {
+            this._focusedItem = previous;
+            return this._getContent(previous);
         }
+        return;
     }
-    dispose() { }
 }
 
 export { ChatResponseAccessibleView };

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

@@ -37,7 +37,7 @@ let ChatVariablesService = class ChatVariablesService {
                     };
                     jobs.push(data.resolver(prompt.text, part.variableArg, model, variableProgressCallback, token).then(value => {
                         if (value) {
-                            resolvedVariables[i] = { id: data.data.id, modelDescription: data.data.modelDescription, name: part.variableName, range: part.range, value, references };
+                            resolvedVariables[i] = { id: data.data.id, modelDescription: data.data.modelDescription, name: part.variableName, range: part.range, value, references, fullName: data.data.fullName, icon: data.data.icon };
                         }
                     }).catch(onUnexpectedExternalError));
                 }
@@ -61,12 +61,12 @@ let ChatVariablesService = class ChatVariablesService {
                 };
                 jobs.push(data.resolver(prompt.text, '', model, variableProgressCallback, token).then(value => {
                     if (value) {
-                        resolvedAttachedContext[i] = { id: data.data.id, modelDescription: data.data.modelDescription, name: attachment.name, range: attachment.range, value, references };
+                        resolvedAttachedContext[i] = { id: data.data.id, modelDescription: data.data.modelDescription, name: attachment.name, fullName: attachment.fullName, range: attachment.range, value, references, icon: attachment.icon };
                     }
                 }).catch(onUnexpectedExternalError));
             }
-            else if (attachment.isDynamic) {
-                resolvedAttachedContext[i] = { id: attachment.id, name: attachment.name, value: attachment.value };
+            else if (attachment.isDynamic || attachment.isTool) {
+                resolvedAttachedContext[i] = { ...attachment };
             }
         });
         await Promise.allSettled(jobs);
@@ -90,9 +90,11 @@ let ChatVariablesService = class ChatVariablesService {
     getVariable(name) {
         return this._resolver.get(name.toLowerCase())?.data;
     }
-    getVariables() {
+    getVariables(location) {
         const all = ( Iterable.map(( this._resolver.values()), data => data.data));
-        return Iterable.filter(all, data => !data.hidden);
+        return Iterable.filter(all, data => {
+            return location !== ChatAgentLocation.Editor || !( ( new Set(['selection', 'editor'])).has(data.name));
+        });
     }
     getDynamicVariables(sessionId) {
         const widget = this.chatWidgetService.getWidgetBySessionId(sessionId);
@@ -119,8 +121,7 @@ let ChatVariablesService = class ChatVariablesService {
         if (location !== ChatAgentLocation.Panel) {
             return;
         }
-        await showChatView(this.viewsService);
-        const widget = this.chatWidgetService.lastFocusedWidget;
+        const widget = await showChatView(this.viewsService);
         if (!widget || !widget.viewModel) {
             return;
         }

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

@@ -107,7 +107,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
     renderBody(parent) {
         try {
             super.renderBody(parent);
-            const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
+            const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService]))));
             const locationBasedColors = this.getLocationBasedColors();
             this._widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, { viewId: this.id }, { supportsFileReferences: true }, {
                 listForeground: SIDE_BAR_FOREGROUND,

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

@@ -13,8 +13,10 @@ class ChatContextAttachments extends Disposable {
         this._attachedContext = ( new Set());
         this._onDidChangeInputState = this._register(( new Emitter()));
         this.onDidChangeInputState = this._onDidChangeInputState.event;
-        this._register(this.widget.onDidDeleteContext((e) => {
-            this._removeContext(e);
+        this._register(this.widget.onDidChangeContext((e) => {
+            if (e.removed) {
+                this._removeContext(e.removed);
+            }
         }));
         this._register(this.widget.onDidSubmitAgent(() => {
             this._clearAttachedContext();
@@ -46,9 +48,11 @@ class ChatContextAttachments extends Disposable {
         this.widget.setContext(overwrite, ...attachments);
         this._onDidChangeInputState.fire();
     }
-    _removeContext(attachment) {
-        this._attachedContext.delete(attachment);
-        this._onDidChangeInputState.fire();
+    _removeContext(attachments) {
+        if (attachments.length) {
+            attachments.forEach(this._attachedContext.delete, this._attachedContext);
+            this._onDidChangeInputState.fire();
+        }
     }
     _clearAttachedContext() {
         this._attachedContext.clear();