@codingame/monaco-vscode-api 33.0.8 → 34.0.0

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

@@ -56,39 +56,39 @@ import { autorun } from '../../../../../base/common/observableInternal/reactions
 const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "chatSessions",
     jsonSchema: {
-        description: ( localize(6563, "Contributes chat session integrations to the chat widget.")),
+        description: ( localize(6677, "Contributes chat session integrations to the chat widget.")),
         type: "array",
         items: {
             type: "object",
             additionalProperties: false,
             properties: {
                 type: {
-                    description: ( localize(6564, "Unique identifier for the type of chat session.")),
+                    description: ( localize(6678, "Unique identifier for the type of chat session.")),
                     type: "string"
                 },
                 name: {
                     description: ( localize(
-                        6565,
+                        6679,
                         "Name of the dynamically registered chat participant (eg: @agent). Must not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 displayName: {
-                    description: ( localize(6566, "A longer name for this item which is used for display in menus.")),
+                    description: ( localize(6680, "A longer name for this item which is used for display in menus.")),
                     type: "string"
                 },
                 description: {
-                    description: ( localize(6567, "Description of the chat session for use in menus and tooltips.")),
+                    description: ( localize(6681, "Description of the chat session for use in menus and tooltips.")),
                     type: "string"
                 },
                 when: {
-                    description: ( localize(6568, "Condition which must be true to show this item.")),
+                    description: ( localize(6682, "Condition which must be true to show this item.")),
                     type: "string"
                 },
                 icon: {
                     description: ( localize(
-                        6569,
+                        6683,
                         "Icon identifier (codicon ID) for the chat session editor tab. For example, \"{0}\" or \"{1}\".",
                         "$(github)",
                         "$(cloud)"
@@ -99,22 +99,22 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(6570, "Icon path when a light theme is used")),
+                                description: ( localize(6684, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(6571, "Icon path when a dark theme is used")),
+                                description: ( localize(6685, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
                     }]
                 },
                 order: {
-                    description: ( localize(6572, "Order in which this item should be displayed.")),
+                    description: ( localize(6686, "Order in which this item should be displayed.")),
                     type: "integer"
                 },
                 alternativeIds: {
-                    description: ( localize(6573, "Alternative identifiers for backward compatibility.")),
+                    description: ( localize(6687, "Alternative identifiers for backward compatibility.")),
                     type: "array",
                     items: {
                         type: "string"
@@ -122,95 +122,95 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 welcomeTitle: {
                     description: ( localize(
-                        6574,
+                        6688,
                         "Title text to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeMessage: {
                     description: ( localize(
-                        6575,
+                        6689,
                         "Message text (supports markdown) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 welcomeTips: {
                     description: ( localize(
-                        6576,
+                        6690,
                         "Tips text (supports markdown and theme icons) to display in the chat welcome view for this session type."
                     )),
                     type: "string"
                 },
                 inputPlaceholder: {
                     description: ( localize(
-                        6577,
+                        6691,
                         "Placeholder text to display in the chat input box for this session type."
                     )),
                     type: "string"
                 },
                 capabilities: {
-                    description: ( localize(6578, "Optional capabilities for this chat session.")),
+                    description: ( localize(6692, "Optional capabilities for this chat session.")),
                     type: "object",
                     additionalProperties: false,
                     properties: {
                         supportsFileAttachments: {
                             description: ( localize(
-                                6579,
+                                6693,
                                 "Whether this chat session supports attaching files or file references."
                             )),
                             type: "boolean"
                         },
                         supportsToolAttachments: {
                             description: ( localize(
-                                6580,
+                                6694,
                                 "Whether this chat session supports attaching tools or tool references."
                             )),
                             type: "boolean"
                         },
                         supportsMCPAttachments: {
-                            description: ( localize(6581, "Whether this chat session supports attaching MCP resources.")),
+                            description: ( localize(6695, "Whether this chat session supports attaching MCP resources.")),
                             type: "boolean"
                         },
                         supportsImageAttachments: {
-                            description: ( localize(6582, "Whether this chat session supports attaching images.")),
+                            description: ( localize(6696, "Whether this chat session supports attaching images.")),
                             type: "boolean"
                         },
                         supportsSearchResultAttachments: {
-                            description: ( localize(6583, "Whether this chat session supports attaching search results.")),
+                            description: ( localize(6697, "Whether this chat session supports attaching search results.")),
                             type: "boolean"
                         },
                         supportsInstructionAttachments: {
-                            description: ( localize(6584, "Whether this chat session supports attaching instructions.")),
+                            description: ( localize(6698, "Whether this chat session supports attaching instructions.")),
                             type: "boolean"
                         },
                         supportsSourceControlAttachments: {
                             description: ( localize(
-                                6585,
+                                6699,
                                 "Whether this chat session supports attaching source control changes."
                             )),
                             type: "boolean"
                         },
                         supportsProblemAttachments: {
-                            description: ( localize(6586, "Whether this chat session supports attaching problems.")),
+                            description: ( localize(6700, "Whether this chat session supports attaching problems.")),
                             type: "boolean"
                         },
                         supportsSymbolAttachments: {
-                            description: ( localize(6587, "Whether this chat session supports attaching symbols.")),
+                            description: ( localize(6701, "Whether this chat session supports attaching symbols.")),
                             type: "boolean"
                         },
                         supportsPromptAttachments: {
-                            description: ( localize(6588, "Whether this chat session supports attaching prompts.")),
+                            description: ( localize(6702, "Whether this chat session supports attaching prompts.")),
                             type: "boolean"
                         },
                         supportsHandOffs: {
-                            description: ( localize(6589, "Whether this chat session supports hand-off prompts.")),
+                            description: ( localize(6703, "Whether this chat session supports hand-off prompts.")),
                             type: "boolean"
                         }
                     }
                 },
                 commands: {
                     markdownDescription: ( localize(
-                        6590,
+                        6704,
                         "Commands available for this chat session, which the user can invoke with a `/`."
                     )),
                     type: "array",
@@ -227,17 +227,17 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                         properties: {
                             name: {
                                 description: ( localize(
-                                    6591,
+                                    6705,
                                     "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: ( localize(6592, "A description of this command.")),
+                                description: ( localize(6706, "A description of this command.")),
                                 type: "string"
                             },
                             when: {
-                                description: ( localize(6593, "A condition which must be true to enable this command.")),
+                                description: ( localize(6707, "A condition which must be true to enable this command.")),
                                 type: "string"
                             }
                         }
@@ -245,7 +245,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 canDelegate: {
                     description: ( localize(
-                        6594,
+                        6708,
                         "Whether delegation is supported. Default is false. Note that enabling this is experimental and may not be respected at all times."
                     )),
                     type: "boolean",
@@ -253,14 +253,14 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 customAgentTarget: {
                     description: ( localize(
-                        6595,
+                        6709,
                         "When set, the chat session will show a filtered mode picker that prefers custom agents whose target property matches this value. Custom agents without a target property are still shown in all session types. This enables the use of standard agent/mode with contributed sessions."
                     )),
                     type: "string"
                 },
                 requiresCustomModels: {
                     description: ( localize(
-                        6596,
+                        6710,
                         "When set, the chat session will show a filtered model picker that prefers custom models. This enables the use of standard model picker with contributed sessions."
                     )),
                     type: "boolean",
@@ -268,7 +268,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 autoAttachReferences: {
                     description: ( localize(
-                        6597,
+                        6711,
                         "Whether to automatically attach instruction files to chat requests for this session type."
                     )),
                     type: "boolean",
@@ -276,7 +276,7 @@ const extensionPoint = ExtensionsRegistry.registerExtensionPoint({
                 },
                 useRequestToPopulateBuiltInPickers: {
                     description: ( localize(
-                        6598,
+                        6712,
                         "Whether to use ChatRequestTurn2 to populate built-in pickers such as the Agent and Model pickers."
                     )),
                     type: "boolean",
@@ -563,7 +563,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openSessionWithPrompt.${contribution.type}`,
-                    title: ( localize2(6599, "New {0} with Prompt", contribution.displayName)),
+                    title: ( localize2(6713, "New {0} with Prompt", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -579,9 +579,9 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                 } = contribution;
                 if (chatOptions) {
                     let attachedContext = chatOptions.attachedContext;
-                    const resource = URI.revive(chatOptions.resource);
+                    const sessionResource = URI.revive(chatOptions.resource);
                     const ref = await chatService.acquireOrLoadSession(
-                        resource,
+                        sessionResource,
                         ChatAgentLocation.Chat,
                         CancellationToken.None,
                         "ChatSessionsContribution#sendPrompt"
@@ -589,14 +589,14 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
                     try {
                         const promptFile = await resolvePromptSlashCommand(
                             chatOptions.prompt,
-                            contribution.type,
+                            sessionResource,
                             customizationHarnessService,
                             toolsService
                         );
                         if (promptFile) {
                             attachedContext = [promptFile, ...(attachedContext ?? [])];
                         }
-                        const result = await chatService.sendRequest(resource, chatOptions.prompt, {
+                        const result = await chatService.sendRequest(sessionResource, chatOptions.prompt, {
                             agentIdSilent: type,
                             attachedContext
                         });
@@ -615,7 +615,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionEditor.${contribution.type}`,
-                    title: ( localize2(6600, "New {0} Session", contribution.displayName)),
+                    title: ( localize2(6714, "New {0} Session", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: true,
@@ -638,7 +638,7 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
             constructor() {
                 super({
                     id: `workbench.action.chat.openNewSessionSidebar.${contribution.type}`,
-                    title: ( localize2(6601, "New {0} Session", contribution.displayName)),
+                    title: ( localize2(6715, "New {0} Session", contribution.displayName)),
                     category: CHAT_CATEGORY,
                     icon: Codicon.plus,
                     f1: false,
@@ -1101,7 +1101,6 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         {
             const existingSessionData = this._sessions.get(sessionResource);
             if (existingSessionData) {
-                session.dispose();
                 return existingSessionData.session;
             }
         }
@@ -1229,6 +1228,18 @@ let ChatSessionsService = class ChatSessionsService extends Disposable {
         }
         return session.session.forkSession(request, token);
     }
+    sessionSupportsRename(sessionResource) {
+        const session =
+        this._sessions.get(sessionResource) ?? this._sessions.get(this._resolveResource(sessionResource));
+        return !!session?.session.renameSession;
+    }
+    async renameChatSession(sessionResource, title, token) {
+        const session = await this.getOrCreateChatSession(sessionResource, token);
+        if (!session.renameSession) {
+            throw ( new Error(`Session ${( sessionResource.toString())} does not support renaming`));
+        }
+        return session.renameSession(title, token);
+    }
     getContentProviderSchemes() {
         return Array.from(( this._contentProviders.keys()));
     }
@@ -1239,7 +1250,7 @@ function registerNewSessionInPlaceAction(type, displayName) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionInPlace.${type}`,
-                title: ( localize2(6602, "New {0} Session", displayName)),
+                title: ( localize2(6716, "New {0} Session", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1255,7 +1266,7 @@ function registerNewSessionInPlaceAction(type, displayName) {
             }
             await openChatSession(accessor, {
                 type: type,
-                displayName: ( localize(6603, "Chat")),
+                displayName: ( localize(6717, "Chat")),
                 position: chatSessionPosition,
                 replaceEditor: true
             });
@@ -1267,7 +1278,7 @@ function registerNewSessionExternalAction(type, displayName, commandId) {
         constructor() {
             super({
                 id: `workbench.action.chat.openNewChatSessionExternal.${type}`,
-                title: ( localize2(6604, "New {0} Session", displayName)),
+                title: ( localize2(6718, "New {0} Session", displayName)),
                 category: CHAT_CATEGORY,
                 f1: false,
                 precondition: ChatContextKeys.enabled
@@ -1293,16 +1304,16 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
     const editorService = accessor.get(IEditorService);
     const customizationHarnessService = accessor.get(ICustomizationHarnessService);
     const toolsService = accessor.get(ILanguageModelToolsService);
-    const resource = getResourceForNewChatSession(openOptions);
+    const sessionResource = getResourceForNewChatSession(openOptions);
     try {
         switch (openOptions.position) {
         case ChatSessionPosition.Sidebar:
             {
                 const view = await viewsService.openView(ChatViewId);
                 if (openOptions.type === AgentSessionProviders.Local) {
-                    await view.widget.clear();
+                    await view.startNewLocalSession();
                 } else {
-                    await view.loadSession(resource);
+                    await view.loadSession(sessionResource);
                 }
                 view.focus();
                 break;
@@ -1313,7 +1324,7 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
                     override: ChatEditorInput.EditorID,
                     pinned: true,
                     title: {
-                        fallback: ( localize(6605, "{0}", openOptions.displayName))
+                        fallback: ( localize(6719, "{0}", openOptions.displayName))
                     }
                 };
                 if (openOptions.replaceEditor) {
@@ -1324,13 +1335,13 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
                     await editorService.replaceEditors([{
                         editor: activeEditor,
                         replacement: {
-                            resource,
+                            resource: sessionResource,
                             options
                         }
                     }], editorGroupService.activeGroup);
                 } else {
                     await editorService.openEditor({
-                        resource,
+                        resource: sessionResource,
                         options
                     });
                 }
@@ -1352,19 +1363,22 @@ async function openChatSession(accessor, openOptions, chatSendOptions) {
     if (chatSendOptions) {
         try {
             if (chatSendOptions.initialSessionOptions) {
-                chatSessionService.updateSessionOptions(resource, normalizeSessionOptions(chatSendOptions.initialSessionOptions));
+                chatSessionService.updateSessionOptions(
+                    sessionResource,
+                    normalizeSessionOptions(chatSendOptions.initialSessionOptions)
+                );
             }
             let attachedContext = chatSendOptions.attachedContext;
             const promptFile = await resolvePromptSlashCommand(
                 chatSendOptions.prompt,
-                openOptions.type,
+                sessionResource,
                 customizationHarnessService,
                 toolsService
             );
             if (promptFile) {
                 attachedContext = [promptFile, ...(attachedContext ?? [])];
             }
-            await chatService.sendRequest(resource, chatSendOptions.prompt, {
+            await chatService.sendRequest(sessionResource, chatSendOptions.prompt, {
                 agentIdSilent: openOptions.type,
                 attachedContext
             });
@@ -1385,10 +1399,10 @@ function normalizeSessionOptions(options) {
     }
     return ChatSessionOptionsMap.fromRecord(options);
 }
-async function resolvePromptSlashCommand(prompt, sessionType, customizationHarnessService, toolsService) {
+async function resolvePromptSlashCommand(prompt, sessionResource, customizationHarnessService, toolsService) {
     const slashMatch = prompt.match(slashReg);
     if (slashMatch) {
-        const slashCommand = await customizationHarnessService.resolvePromptSlashCommand(slashMatch[1], sessionType, CancellationToken.None);
+        const slashCommand = await customizationHarnessService.resolvePromptSlashCommand(slashMatch[1], sessionResource, CancellationToken.None);
         if (slashCommand) {
             const parseResult = slashCommand.parsedPromptFile;
             const refs = parseResult.body?.variableReferences.map((

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/chatSetup.d.ts

@@ -55,6 +55,17 @@ export interface IChatSetupResult {
     readonly dialogSkipped: boolean;
 }
 export declare function refreshTokens(commandService: ICommandService): void;
+/**
+ * Builds a redirect URL that GitHub will use to return the user to VS Code
+ * after completing a plan upgrade. The redirect goes through `vscode.dev/redirect`
+ * which triggers the native protocol handler back into the desktop app.
+ *
+ * @param baseUpgradeUrl The direct GitHub upgrade URL (from `resolveGitHubUrl`).
+ * @param urlProtocol The VS Code URL protocol scheme (e.g. `vscode`, `vscode-insiders`, `code-oss`).
+ * @param quality The product quality (`stable`, `insider`, or `undefined` for OSS).
+ * @returns The upgrade URL with a `return_to` query parameter appended.
+ */
+export declare function buildUpgradeUrlWithRedirect(baseUpgradeUrl: string, urlProtocol: string, quality: string | undefined): string;
 /**
  * Ensures the authentication provider extension is enabled.
  * If the extension is found locally but disabled, it will be

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

@@ -5,6 +5,7 @@ import { localize } from '../../../../../nls.js';
 import { EnablementState } from '../../../../services/extensionManagement/common/extensionManagement.js';
 
 const defaultChat = {
+    chatExtensionId: product.defaultChatAgent?.chatExtensionId ?? "",
     chatRefreshTokenCommand: product.defaultChatAgent?.chatRefreshTokenCommand ?? "",
     providerExtensionId: product.defaultChatAgent?.providerExtensionId ?? ""
 };
@@ -30,7 +31,14 @@ var ChatSetupStrategy;
     ChatSetupStrategy[ChatSetupStrategy["SetupWithAppleProvider"] = 5] = "SetupWithAppleProvider";
 })(ChatSetupStrategy || (ChatSetupStrategy = {}));
 function refreshTokens(commandService) {
-    commandService.executeCommand(defaultChat.chatRefreshTokenCommand);
+    commandService.executeCommand(defaultChat.chatRefreshTokenCommand).catch(() => {});
+}
+function buildUpgradeUrlWithRedirect(baseUpgradeUrl, urlProtocol, quality) {
+    const vscodeUri = `${urlProtocol}://${defaultChat.chatExtensionId}/upgrade-success`;
+    const redirectHost = quality === "stable" ? "vscode.dev" : "insiders.vscode.dev";
+    const returnTo = `https://${redirectHost}/redirect?url=${encodeURIComponent(vscodeUri)}`;
+    const separator = baseUpgradeUrl.includes("?") ? "&" : "?";
+    return `${baseUpgradeUrl}${separator}return_to=${encodeURIComponent(returnTo)}`;
 }
 async function maybeEnableAuthExtension(extensionsWorkbenchService, logService) {
     if (!defaultChat.providerExtensionId) {
@@ -48,7 +56,7 @@ async function maybeEnableAuthExtension(extensionsWorkbenchService, logService)
         );
         try {
             await extensionsWorkbenchService.setEnablement([providerExtension], EnablementState.EnabledGlobally);
-            await extensionsWorkbenchService.updateRunningExtensions(( localize(6606, "Enabling GitHub Authentication")));
+            await extensionsWorkbenchService.updateRunningExtensions(( localize(6720, "Enabling GitHub Authentication")));
             return true;
         } catch (error) {
             logService.error(
@@ -61,4 +69,4 @@ async function maybeEnableAuthExtension(extensionsWorkbenchService, logService)
     return false;
 }
 
-export { ChatSetupAnonymous, ChatSetupStep, ChatSetupStrategy, maybeEnableAuthExtension, refreshTokens };
+export { ChatSetupAnonymous, ChatSetupStep, ChatSetupStrategy, buildUpgradeUrlWithRedirect, maybeEnableAuthExtension, refreshTokens };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service.d.ts

@@ -4,6 +4,8 @@ export declare const IChatInputNotificationService: import("../../../../../../pl
 export interface IChatInputNotificationService {
     readonly _serviceBrand: undefined;
     readonly onDidChange: Event<void>;
+    /** Fires when a notification is dismissed by the user (via the X button). */
+    readonly onDidDismiss: Event<string>;
     /**
     * Set or update a notification. If a notification with the same ID already
     * exists, its content is replaced and any previous user dismissal is cleared.
@@ -21,8 +23,10 @@ export interface IChatInputNotificationService {
     /**
     * Get the single active notification to display. Returns the highest-severity
     * notification that has not been dismissed. Ties are broken by most-recent insertion.
+    * An optional `filter` can be provided to restrict the set of notifications considered,
+    * so a non-matching higher-priority notification doesn't mask other eligible ones.
     */
-    getActiveNotification(): IChatInputNotification | undefined;
+    getActiveNotification(filter?: (notification: IChatInputNotification) => boolean): IChatInputNotification | undefined;
     /**
     * Called when the user sends a chat message. Auto-dismisses all notifications
     * that have {@link IChatInputNotification.autoDismissOnMessage} set.

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/editor/chatEditorInput.js

@@ -24,7 +24,7 @@ import { ModifiedFileEntryState } from '../../../common/editing/chatEditingServi
 import { LocalChatSessionUri, getChatSessionType } from '../../../common/model/chatUri.js';
 
 var ChatEditorInput_1;
-const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(7656, "Icon of the chat editor label.")));
+const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(7804, "Icon of the chat editor label.")));
 let ChatEditorInput = class ChatEditorInput extends EditorInput {
     static {
         ChatEditorInput_1 = this;
@@ -89,8 +89,8 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (!this.model?.editingSession || this.didTransferOutEditingSession || this.getSessionType() !== localChatSessionType) {
             return ConfirmResult.SAVE;
         }
-        const titleOverride = ( localize(7657, "Close Chat Editor"));
-        const messageOverride = ( localize(7658, "Closing the chat editor will end your current edit session."));
+        const titleOverride = ( localize(7805, "Close Chat Editor"));
+        const messageOverride = ( localize(7806, "Closing the chat editor will end your current edit session."));
         const result = await showClearEditingSessionConfirmation(this.model, this.dialogService, {
             titleOverride,
             messageOverride
@@ -132,7 +132,7 @@ let ChatEditorInput = class ChatEditorInput extends EditorInput {
         if (this.options.title?.preferred) {
             return this.options.title.preferred;
         }
-        return this.options.title?.fallback ?? ( localize(7659, "Chat"));
+        return this.options.title?.fallback ?? ( localize(7807, "Chat"));
     }
     getTitle(verbosity) {
         const name = this.getName();
@@ -316,25 +316,25 @@ async function showClearEditingSessionConfirmation(model, dialogService, options
     if (!undecidedEdits) {
         return true;
     }
-    const defaultPhrase = ( localize(7660, "Starting a new chat will end your current edit session."));
-    const defaultTitle = ( localize(7661, "Start new chat?"));
+    const defaultPhrase = ( localize(7808, "Starting a new chat will end your current edit session."));
+    const defaultTitle = ( localize(7809, "Start new chat?"));
     const phrase = options?.messageOverride ?? defaultPhrase;
     const title = options?.titleOverride ?? defaultTitle;
     const {
         result
     } = await dialogService.prompt({
         title,
-        message: phrase + " " + ( localize(7662, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
+        message: phrase + " " + ( localize(7810, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
         type: "info",
         cancelButton: true,
         buttons: [{
-            label: ( localize(7663, "Keep & Continue")),
+            label: ( localize(7811, "Keep & Continue")),
             run: async () => {
                 await model.editingSession.accept();
                 return true;
             }
         }, {
-            label: ( localize(7664, "Undo & Continue")),
+            label: ( localize(7812, "Undo & Continue")),
             run: async () => {
                 await model.editingSession.reject();
                 return true;

package/vscode/src/vs/workbench/contrib/chat/common/actions/chatContextKeys.d.ts

@@ -25,6 +25,7 @@ export declare namespace ChatContextKeys {
     const lastItemId: RawContextKey<string[]>;
     const editApplied: RawContextKey<boolean>;
     const inputHasText: RawContextKey<boolean>;
+    const inputHasSendableContent: RawContextKey<boolean>;
     const inputHasFocus: RawContextKey<boolean>;
     const inChatInput: RawContextKey<boolean>;
     const inChatSession: RawContextKey<boolean>;
@@ -153,7 +154,13 @@ export declare namespace ChatContextKeyExprs {
     const inEditingMode: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
     /**
      * True when the locked coding agent is an agent host session (agent-host-* or remote-*).
-     * These sessions use AgentHostEditingSession which supports checkpoint-based undo/redo.
+     * These sessions use {@link AgentHostSnapshotController} which supports checkpoint-based restore.
      */
     const isAgentHostSession: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
+    /**
+     * True when an agent session item (e.g. in the sessions viewer) is an agent
+     * host session (agent-host-* or remote-*). Keyed on {@link ChatContextKeys.agentSessionType}
+     * rather than the locked coding agent, for use in session item menus and keybindings.
+     */
+    const isAgentHostSessionItem: import("../../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
 }