@codingame/monaco-vscode-chat-service-override 5.3.0 → 6.0.1

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

@@ -1,7 +1,8 @@
 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, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+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';
@@ -10,13 +11,18 @@ 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 } from 'vscode/vscode/vs/workbench/common/views';
+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 { 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({
@@ -38,21 +44,23 @@ const chatParticipantExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
                     description: ( localizeWithPath(
                         _moduleId,
                         2,
-                        "User-facing display name for this chat participant. The user will use '@' with this name to invoke the participant."
+                        "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'
+                    type: 'string',
+                    pattern: '^[\\w0-9_-]+$'
                 },
-                description: {
-                    description: ( localizeWithPath(_moduleId, 3, "A description of this chat participant, shown in the UI.")),
-                    type: 'string'
-                },
-                isDefault: {
+                fullName: {
                     markdownDescription: ( localizeWithPath(
                         _moduleId,
-                        4,
-                        "**Only** allowed for extensions that have the `defaultChatParticipant` proposal."
+                        3,
+                        "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: 'boolean',
+                    type: 'string'
+                },
+                description: {
+                    description: ( localizeWithPath(_moduleId, 4, "A description of this chat participant, shown in the UI.")),
+                    type: 'string'
                 },
                 isSticky: {
                     description: ( localizeWithPath(
@@ -62,17 +70,18 @@ const chatParticipantExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
                     )),
                     type: 'boolean'
                 },
-                defaultImplicitVariables: {
-                    markdownDescription: '**Only** allowed for extensions that have the `chatParticipantAdditions` proposal. The names of the variables that are invoked by default',
-                    type: 'array',
-                    items: {
-                        type: 'string'
-                    }
+                sampleRequest: {
+                    description: ( localizeWithPath(
+                        _moduleId,
+                        6,
+                        "When the user clicks this participant in `/help`, this text will be submitted to the participant."
+                    )),
+                    type: 'string'
                 },
                 commands: {
                     markdownDescription: ( localizeWithPath(
                         _moduleId,
-                        6,
+                        7,
                         "Commands available for this chat participant, which the user can invoke with a `/`."
                     )),
                     type: 'array',
@@ -85,24 +94,24 @@ const chatParticipantExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
                             name: {
                                 description: ( localizeWithPath(
                                     _moduleId,
-                                    7,
+                                    8,
                                     "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, 8, "A description of this command.")),
+                                description: ( localizeWithPath(_moduleId, 9, "A description of this command.")),
                                 type: 'string'
                             },
                             when: {
-                                description: ( localizeWithPath(_moduleId, 9, "A condition which must be true to enable this command.")),
+                                description: ( localizeWithPath(_moduleId, 10, "A condition which must be true to enable this command.")),
                                 type: 'string'
                             },
                             sampleRequest: {
                                 description: ( localizeWithPath(
                                     _moduleId,
-                                    10,
-                                    "When the user clicks this command in `/help`, this text will be submitted to this participant."
+                                    11,
+                                    "When the user clicks this command in `/help`, this text will be submitted to the participant."
                                 )),
                                 type: 'string'
                             },
@@ -114,29 +123,9 @@ const chatParticipantExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
                                 )),
                                 type: 'boolean'
                             },
-                            defaultImplicitVariables: {
-                                markdownDescription: ( localizeWithPath(
-                                    _moduleId,
-                                    11,
-                                    "**Only** allowed for extensions that have the `chatParticipantAdditions` proposal. The names of the variables that are invoked by default"
-                                )),
-                                type: 'array',
-                                items: {
-                                    type: 'string'
-                                }
-                            },
                         }
                     }
                 },
-                locations: {
-                    markdownDescription: ( localizeWithPath(_moduleId, 12, "Locations in which this chat participant is available.")),
-                    type: 'array',
-                    default: ['panel'],
-                    items: {
-                        type: 'string',
-                        enum: ['panel', 'terminal', 'notebook']
-                    }
-                }
             }
         }
     },
@@ -148,13 +137,16 @@ const chatParticipantExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
 });
 let ChatExtensionPointHandler = class ChatExtensionPointHandler {
     static { this.ID = 'workbench.contrib.chatExtensionPointHandler'; }
-    constructor(_chatAgentService, productService, contextService, logService) {
+    constructor(_chatAgentService, productService, contextService, logService, notificationService, commandService) {
         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();
@@ -193,12 +185,48 @@ let ChatExtensionPointHandler = class ChatExtensionPointHandler {
     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,
+                            12,
+                            "Chat failed to load. Please ensure that the GitHub Copilot Chat extension is up to date."
+                        )),
+                        actions: {
+                            primary: [
+                                ( (new Action('showExtension', ( localizeWithPath(_moduleId, 13, "Show Extension")), undefined, true, () => {
+                                return this.commandService.executeCommand('workbench.extensions.action.showExtensionsWithIds', ['GitHub.copilot-chat']);
+                            })))
+                            ]
+                        }
+                    });
+                    continue;
+                }
+                if (this.productService.quality === 'stable' && !isProposedApiEnabled(extension.description, 'chatParticipantPrivate')) {
+                    this.logService.warn(`Chat participants are not yet enabled in VS Code Stable (${extension.description.identifier.value})`);
+                    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_-]+$/.`);
+                        continue;
+                    }
+                    if (providerDescriptor.fullName && AmbiguousCharacters.getInstance(( (new Set()))).containsAmbiguousCharacter(providerDescriptor.fullName)) {
+                        this.logService.error(`Extension '${extension.description.identifier.value}' CANNOT register participant with fullName that contains ambiguous characters: ${providerDescriptor.fullName}.`);
+                        continue;
+                    }
+                    if (providerDescriptor.fullName && InvisibleCharacters.containsInvisibleCharacter(providerDescriptor.fullName.replace(/ /g, ''))) {
+                        this.logService.error(`Extension '${extension.description.identifier.value}' CANNOT register participant with fullName that contains invisible characters: ${providerDescriptor.fullName}.`);
+                        continue;
+                    }
                     if (providerDescriptor.isDefault && !isProposedApiEnabled(extension.description, 'defaultChatParticipant')) {
                         this.logService.error(`Extension '${extension.description.identifier.value}' CANNOT use API proposal: defaultChatParticipant.`);
                         continue;
                     }
-                    if (providerDescriptor.defaultImplicitVariables && !isProposedApiEnabled(extension.description, 'chatParticipantAdditions')) {
+                    if ((providerDescriptor.defaultImplicitVariables || providerDescriptor.locations) && !isProposedApiEnabled(extension.description, 'chatParticipantAdditions')) {
                         this.logService.error(`Extension '${extension.description.identifier.value}' CANNOT use API proposal: chatParticipantAdditions.`);
                         continue;
                     }
@@ -210,17 +238,24 @@ let ChatExtensionPointHandler = class ChatExtensionPointHandler {
                     if (providerDescriptor.isDefault && (!providerDescriptor.locations || providerDescriptor.locations?.includes(ChatAgentLocation.Panel))) {
                         store.add(this.registerDefaultParticipantView(providerDescriptor));
                     }
+                    if (providerDescriptor.when && !isProposedApiEnabled(extension.description, 'chatParticipantAdditions')) {
+                        this.logService.error(`Extension '${extension.description.identifier.value}' CANNOT use API proposal: chatParticipantAdditions.`);
+                        continue;
+                    }
                     store.add(this._chatAgentService.registerAgent(providerDescriptor.id, {
                         extensionId: extension.description.identifier,
-                        extensionPublisherDisplayName: extension.description.publisherDisplayName ?? extension.description.publisher,
+                        publisherDisplayName: extension.description.publisherDisplayName ?? extension.description.publisher,
                         extensionPublisherId: extension.description.publisher,
                         extensionDisplayName: extension.description.displayName ?? extension.description.name,
                         id: providerDescriptor.id,
                         description: providerDescriptor.description,
+                        when: providerDescriptor.when,
                         metadata: {
                             isSticky: providerDescriptor.isSticky,
+                            sampleRequest: providerDescriptor.sampleRequest,
                         },
                         name: providerDescriptor.name,
+                        fullName: providerDescriptor.fullName,
                         isDefault: providerDescriptor.isDefault,
                         defaultImplicitVariables: providerDescriptor.defaultImplicitVariables,
                         locations: isNonEmptyArray(providerDescriptor.locations) ?
@@ -239,7 +274,7 @@ let ChatExtensionPointHandler = class ChatExtensionPointHandler {
         });
     }
     registerViewContainer() {
-        const title = ( localize2WithPath(_moduleId, 13, "Chat"));
+        const title = ( localize2WithPath(_moduleId, 14, "Chat"));
         const icon = Codicon.commentDiscussion;
         const viewContainerId = CHAT_SIDEBAR_PANEL_ID;
         const viewContainer = ( (Registry.as(Extensions.ViewContainersRegistry))).registerViewContainer({
@@ -253,22 +288,29 @@ let ChatExtensionPointHandler = class ChatExtensionPointHandler {
             storageId: viewContainerId,
             hideIfEmpty: true,
             order: 100,
-        }, 0 );
+        }, ViewContainerLocation.Sidebar);
         return viewContainer;
     }
     registerDefaultParticipantView(defaultParticipantDescriptor) {
+        if (this.hasRegisteredDefaultParticipantView) {
+            this.logService.warn(`Tried to register a second default chat participant view for "${defaultParticipantDescriptor.id}"`);
+            return Disposable.None;
+        }
+        const name = defaultParticipantDescriptor.fullName ?? defaultParticipantDescriptor.name;
         const viewDescriptor = [{
                 id: CHAT_VIEW_ID,
                 containerIcon: this._viewContainer.icon,
                 containerTitle: this._viewContainer.title.value,
                 singleViewPaneContainerTitle: this._viewContainer.title.value,
-                name: { value: defaultParticipantDescriptor.name, original: defaultParticipantDescriptor.name },
+                name: { value: name, original: name },
                 canToggleVisibility: false,
                 canMoveView: true,
                 ctorDescriptor: ( (new SyncDescriptor(ChatViewPane))),
             }];
+        this.hasRegisteredDefaultParticipantView = true;
         ( (Registry.as(Extensions.ViewsRegistry))).registerViews(viewDescriptor, this._viewContainer);
         return toDisposable(() => {
+            this.hasRegisteredDefaultParticipantView = false;
             ( (Registry.as(Extensions.ViewsRegistry))).deregisterViews(viewDescriptor, this._viewContainer);
         });
     }
@@ -277,7 +319,9 @@ ChatExtensionPointHandler = ( (__decorate([
     ( (__param(0, IChatAgentService))),
     ( (__param(1, IProductService))),
     ( (__param(2, IContextKeyService))),
-    ( (__param(3, ILogService)))
+    ( (__param(3, ILogService))),
+    ( (__param(4, INotificationService))),
+    ( (__param(5, ICommandService)))
 ], ChatExtensionPointHandler)));
 function getParticipantKey(extensionId, participantName) {
     return `${extensionId.value}_${participantName}`;

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

@@ -1,6 +1,6 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { isAncestorOfActiveElement, $ } from 'vscode/vscode/vs/base/browser/dom';
-import { Sash } from 'vscode/vscode/vs/base/browser/ui/sash/sash';
+import { Sash, Orientation } from 'vscode/vscode/vs/base/browser/ui/sash/sash';
 import { disposableTimeout } from 'vscode/vscode/vs/base/common/async';
 import { CancellationToken } from 'vscode/vscode/vs/base/common/cancellation';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
@@ -174,10 +174,10 @@ let QuickChat = class QuickChat extends Disposable {
         if (this.widget) {
             throw ( new Error('Cannot render quick chat twice'));
         }
-        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([
+        const scopedInstantiationService = this._register(this.instantiationService.createChild(( new ServiceCollection([
             IContextKeyService,
             this._register(this.contextKeyService.createScoped(parent))
-        ])));
+        ]))));
         this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, ChatAgentLocation.Panel, { resource: true }, { renderInputOnTop: true, renderStyle: 'compact', menus: { inputSideToolbar: MenuId.ChatInputSide } }, {
             listForeground: quickInputForeground,
             listBackground: quickInputBackground,
@@ -191,7 +191,7 @@ let QuickChat = class QuickChat extends Disposable {
         this.sash = this._register(( new Sash(
             parent,
             { getHorizontalSashTop: () => parent.offsetHeight },
-            { orientation: 1  }
+            { orientation: Orientation.HORIZONTAL }
         )));
         this.registerListeners(parent);
     }

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

@@ -0,0 +1,94 @@
+import { renderMarkdownAsPlaintext } from 'vscode/vscode/vs/base/browser/markdownRenderer';
+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';
+
+class ChatResponseAccessibleView {
+    constructor() {
+        this.priority = 100;
+        this.name = 'panelChat';
+        this.type = AccessibleViewType.View;
+        this.when = CONTEXT_IN_CHAT_SESSION;
+    }
+    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);
+                    }
+                }
+                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 }
+            };
+        }
+    }
+    dispose() { }
+}
+
+export { ChatResponseAccessibleView };

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

@@ -1,18 +1,25 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { basename } from 'vscode/vscode/vs/base/common/path';
 import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
 import { onUnexpectedExternalError } from 'vscode/vscode/vs/base/common/errors';
 import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
 import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { showChatView } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
 import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat.service';
 import { ChatDynamicVariableModel } from 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
+import { ChatAgentLocation } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatAgents';
 import { ChatRequestVariablePart, ChatRequestDynamicVariablePart } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+import { ChatContextAttachments } from './contrib/chatContextAttachments.js';
+import { IViewsService } from 'vscode/vscode/vs/workbench/services/views/common/viewsService.service';
 
 let ChatVariablesService = class ChatVariablesService {
-    constructor(chatWidgetService) {
+    constructor(chatWidgetService, viewsService) {
         this.chatWidgetService = chatWidgetService;
+        this.viewsService = viewsService;
         this._resolver = ( new Map());
     }
-    async resolveVariables(prompt, model, progress, token) {
+    async resolveVariables(prompt, attachedContextVariables, model, progress, token) {
         let resolvedVariables = [];
         const jobs = [];
         prompt.parts
@@ -28,18 +35,44 @@ let ChatVariablesService = class ChatVariablesService {
                         }
                         progress(item);
                     };
-                    jobs.push(data.resolver(prompt.text, part.variableArg, model, variableProgressCallback, token).then(values => {
-                        resolvedVariables[i] = { name: part.variableName, range: part.range, values: values ?? [], references };
+                    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 };
+                        }
                     }).catch(onUnexpectedExternalError));
                 }
             }
             else if (part instanceof ChatRequestDynamicVariablePart) {
-                resolvedVariables[i] = { name: part.referenceText, range: part.range, values: part.data };
+                resolvedVariables[i] = { id: part.id, name: part.referenceText, range: part.range, value: part.data };
+            }
+        });
+        const resolvedAttachedContext = [];
+        attachedContextVariables
+            ?.forEach((attachment, i) => {
+            const data = this._resolver.get(attachment.name?.toLowerCase());
+            if (data) {
+                const references = [];
+                const variableProgressCallback = (item) => {
+                    if (item.kind === 'reference') {
+                        references.push(item);
+                        return;
+                    }
+                    progress(item);
+                };
+                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 };
+                    }
+                }).catch(onUnexpectedExternalError));
+            }
+            else if (attachment.isDynamic) {
+                resolvedAttachedContext[i] = { id: attachment.id, name: attachment.name, value: attachment.value };
             }
         });
         await Promise.allSettled(jobs);
         resolvedVariables = coalesce(resolvedVariables);
         resolvedVariables.sort((a, b) => b.range.start - a.range.start);
+        resolvedVariables.push(...resolvedAttachedContext);
         return {
             variables: resolvedVariables,
         };
@@ -47,9 +80,9 @@ let ChatVariablesService = class ChatVariablesService {
     async resolveVariable(variableName, promptText, model, progress, token) {
         const data = this._resolver.get(variableName.toLowerCase());
         if (!data) {
-            return Promise.resolve([]);
+            return undefined;
         }
-        return (await data.resolver(promptText, undefined, model, progress, token)) ?? [];
+        return (await data.resolver(promptText, undefined, model, progress, token));
     }
     hasVariable(name) {
         return ( this._resolver.has(name.toLowerCase()));
@@ -82,9 +115,32 @@ let ChatVariablesService = class ChatVariablesService {
             this._resolver.delete(key);
         });
     }
+    async attachContext(name, value, location) {
+        if (location !== ChatAgentLocation.Panel) {
+            return;
+        }
+        await showChatView(this.viewsService);
+        const widget = this.chatWidgetService.lastFocusedWidget;
+        if (!widget || !widget.viewModel) {
+            return;
+        }
+        const key = name.toLowerCase();
+        if (key === 'file' && typeof value !== 'string') {
+            const uri = URI.isUri(value) ? value : value.uri;
+            const range = 'range' in value ? value.range : undefined;
+            widget.getContrib(ChatContextAttachments.ID)?.setContext(false, { value, id: ( uri.toString()) + (range?.toString() ?? ''), name: basename(uri.path), isFile: true, isDynamic: true });
+            return;
+        }
+        const resolved = this._resolver.get(key);
+        if (!resolved) {
+            return;
+        }
+        widget.getContrib(ChatContextAttachments.ID)?.setContext(false, { ...resolved.data, value });
+    }
 };
 ChatVariablesService = ( __decorate([
-    ( __param(0, IChatWidgetService))
+    ( __param(0, IChatWidgetService)),
+    ( __param(1, IViewsService))
 ], ChatVariablesService));
 
 export { ChatVariablesService };

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

@@ -10,6 +10,7 @@ import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/commo
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding.service';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener.service';
+import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import 'vscode/vscode/vs/platform/theme/common/colorUtils';
@@ -48,7 +49,7 @@ let ChatViewPane = class ChatViewPane extends ViewPane {
         this.didProviderRegistrationFail = false;
         this.didUnregisterProvider = false;
         this.memento = ( new Memento('interactive-session-view-' + CHAT_PROVIDER_ID, this.storageService));
-        this.viewState = this.memento.getMemento(1 , 1 );
+        this.viewState = this.memento.getMemento(StorageScope.WORKSPACE, StorageTarget.MACHINE);
         this._register(this.chatAgentService.onDidChangeAgents(() => {
             if (this.chatAgentService.getDefaultAgent(ChatAgentLocation.Panel)) {
                 if (!this._widget?.viewModel) {

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

@@ -0,0 +1,50 @@
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
+
+class ChatContextAttachments extends Disposable {
+    static { this.ID = 'chatContextAttachments'; }
+    get id() {
+        return ChatContextAttachments.ID;
+    }
+    constructor(widget) {
+        super();
+        this.widget = widget;
+        this._attachedContext = ( new Set());
+        this._register(this.widget.onDidDeleteContext((e) => {
+            this._removeContext(e);
+        }));
+        this._register(this.widget.onDidSubmitAgent(() => {
+            this._clearAttachedContext();
+        }));
+    }
+    getInputState() {
+        return [...( this._attachedContext.values())];
+    }
+    setInputState(s) {
+        if (!Array.isArray(s)) {
+            return;
+        }
+        this.widget.setContext(true, ...s);
+    }
+    getContext() {
+        return ( new Set(( [...( this._attachedContext.values())].map((v) => v.id))));
+    }
+    setContext(overwrite, ...attachments) {
+        if (overwrite) {
+            this._attachedContext.clear();
+        }
+        for (const attachment of attachments) {
+            this._attachedContext.add(attachment);
+        }
+        this.widget.setContext(overwrite, ...attachments);
+    }
+    _removeContext(attachment) {
+        this._attachedContext.delete(attachment);
+    }
+    _clearAttachedContext() {
+        this._attachedContext.clear();
+    }
+}
+ChatWidget.CONTRIBS.push(ChatContextAttachments);
+
+export { ChatContextAttachments };