@codingame/monaco-vscode-api 32.0.1 → 33.0.3

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(7570, "Icon of the chat editor label.")));
+const ChatEditorIcon = registerIcon("chat-editor-label-icon", Codicon.chatSparkle, ( localize(7656, "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(7571, "Close Chat Editor"));
-        const messageOverride = ( localize(7572, "Closing the chat editor will end your current edit session."));
+        const titleOverride = ( localize(7657, "Close Chat Editor"));
+        const messageOverride = ( localize(7658, "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(7573, "Chat"));
+        return this.options.title?.fallback ?? ( localize(7659, "Chat"));
     }
     getTitle(verbosity) {
         const name = this.getName();
@@ -316,25 +316,25 @@ async function showClearEditingSessionConfirmation(model, dialogService, options
     if (!undecidedEdits) {
         return true;
     }
-    const defaultPhrase = ( localize(7574, "Starting a new chat will end your current edit session."));
-    const defaultTitle = ( localize(7575, "Start new chat?"));
+    const defaultPhrase = ( localize(7660, "Starting a new chat will end your current edit session."));
+    const defaultTitle = ( localize(7661, "Start new chat?"));
     const phrase = options?.messageOverride ?? defaultPhrase;
     const title = options?.titleOverride ?? defaultTitle;
     const {
         result
     } = await dialogService.prompt({
         title,
-        message: phrase + " " + ( localize(7576, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
+        message: phrase + " " + ( localize(7662, "Do you want to keep pending edits to {0} files?", undecidedEdits)),
         type: "info",
         cancelButton: true,
         buttons: [{
-            label: ( localize(7577, "Keep & Continue")),
+            label: ( localize(7663, "Keep & Continue")),
             run: async () => {
                 await model.editingSession.accept();
                 return true;
             }
         }, {
-            label: ( localize(7578, "Undo & Continue")),
+            label: ( localize(7664, "Undo & Continue")),
             run: async () => {
                 await model.editingSession.reject();
                 return true;

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

@@ -66,6 +66,7 @@ export declare namespace ChatContextKeys {
     const chatEditingCanUndo: RawContextKey<boolean>;
     const chatEditingCanRedo: RawContextKey<boolean>;
     const languageModelsAreUserSelectable: RawContextKey<boolean>;
+    const nonCopilotLanguageModelsAreUserSelectable: RawContextKey<boolean>;
     const chatSessionHasModels: RawContextKey<boolean>;
     const chatSessionOptionsValid: RawContextKey<boolean>;
     const extensionInvalid: RawContextKey<boolean>;

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

@@ -12,44 +12,44 @@ var ChatContextKeys;
     ChatContextKeys.responseVote = ( new RawContextKey("chatSessionResponseVote", "", {
         type: "string",
         description: ( localize(
-            7594,
+            7680,
             "When the response has been voted up, is set to 'up'. When voted down, is set to 'down'. Otherwise an empty string."
         ))
     }));
     ChatContextKeys.responseDetectedAgentCommand = ( new RawContextKey("chatSessionResponseDetectedAgentOrCommand", false, {
         type: "boolean",
-        description: ( localize(7595, "When the agent or command was automatically detected"))
+        description: ( localize(7681, "When the agent or command was automatically detected"))
     }));
     ChatContextKeys.responseSupportsIssueReporting = ( new RawContextKey("chatResponseSupportsIssueReporting", false, {
         type: "boolean",
-        description: ( localize(7596, "True when the current chat response supports issue reporting."))
+        description: ( localize(7682, "True when the current chat response supports issue reporting."))
     }));
     ChatContextKeys.responseIsFiltered = ( new RawContextKey("chatSessionResponseFiltered", false, {
         type: "boolean",
-        description: ( localize(7597, "True when the chat response was filtered out by the server."))
+        description: ( localize(7683, "True when the chat response was filtered out by the server."))
     }));
     ChatContextKeys.responseHasError = ( new RawContextKey("chatSessionResponseError", false, {
         type: "boolean",
-        description: ( localize(7598, "True when the chat response resulted in an error."))
+        description: ( localize(7684, "True when the chat response resulted in an error."))
     }));
     ChatContextKeys.requestInProgress = ( new RawContextKey("chatSessionRequestInProgress", false, {
         type: "boolean",
-        description: ( localize(7599, "True when the current request is still in progress."))
+        description: ( localize(7685, "True when the current request is still in progress."))
     }));
     ChatContextKeys.hasActiveRequest = ( new RawContextKey("chatSessionHasActiveRequest", false, {
         type: "boolean",
         description: ( localize(
-            7600,
+            7686,
             "True when the current chat response has not completed, regardless of intermediate states like tool calls or elicitations."
         ))
     }));
     ChatContextKeys.currentlyEditing = ( new RawContextKey("chatSessionCurrentlyEditing", false, {
         type: "boolean",
-        description: ( localize(7601, "True when the current request is being edited."))
+        description: ( localize(7687, "True when the current request is being edited."))
     }));
     ChatContextKeys.currentlyEditingInput = ( new RawContextKey("chatSessionCurrentlyEditingInput", false, {
         type: "boolean",
-        description: ( localize(7602, "True when the current request input at the bottom is being edited."))
+        description: ( localize(7688, "True when the current request input at the bottom is being edited."))
     }));
     (function(EditingRequestType) {
         EditingRequestType["Sent"] = "s";
@@ -60,99 +60,99 @@ var ChatContextKeys;
     );
     ChatContextKeys.editingRequestType = ( new RawContextKey("chatEditingSentRequest", undefined, {
         type: "string",
-        description: ( localize(7603, "The type of the current editing request."))
+        description: ( localize(7689, "The type of the current editing request."))
     }));
     ChatContextKeys.isResponse = ( new RawContextKey("chatResponse", false, {
         type: "boolean",
-        description: ( localize(7604, "The chat item is a response."))
+        description: ( localize(7690, "The chat item is a response."))
     }));
     ChatContextKeys.isRequest = ( new RawContextKey("chatRequest", false, {
         type: "boolean",
-        description: ( localize(7605, "The chat item is a request"))
+        description: ( localize(7691, "The chat item is a request"))
     }));
     ChatContextKeys.isFirstRequest = ( new RawContextKey("chatFirstRequest", false, {
         type: "boolean",
-        description: ( localize(7606, "The chat item is the first request in the session."))
+        description: ( localize(7692, "The chat item is the first request in the session."))
     }));
     ChatContextKeys.isPendingRequest = ( new RawContextKey("chatRequestIsPending", false, {
         type: "boolean",
-        description: ( localize(7607, "True when the chat request item is pending in the queue."))
+        description: ( localize(7693, "True when the chat request item is pending in the queue."))
     }));
     ChatContextKeys.itemId = ( new RawContextKey("chatItemId", "", {
         type: "string",
-        description: ( localize(7608, "The id of the chat item."))
+        description: ( localize(7694, "The id of the chat item."))
     }));
     ChatContextKeys.lastItemId = ( new RawContextKey("chatLastItemId", [], {
         type: "string",
-        description: ( localize(7609, "The id of the last chat item."))
+        description: ( localize(7695, "The id of the last chat item."))
     }));
     ChatContextKeys.editApplied = ( new RawContextKey("chatEditApplied", false, {
         type: "boolean",
-        description: ( localize(7610, "True when the chat text edits have been applied."))
+        description: ( localize(7696, "True when the chat text edits have been applied."))
     }));
     ChatContextKeys.inputHasText = ( new RawContextKey("chatInputHasText", false, {
         type: "boolean",
-        description: ( localize(7611, "True when the chat input has text."))
+        description: ( localize(7697, "True when the chat input has text."))
     }));
     ChatContextKeys.inputHasFocus = ( new RawContextKey("chatInputHasFocus", false, {
         type: "boolean",
-        description: ( localize(7612, "True when the chat input has focus."))
+        description: ( localize(7698, "True when the chat input has focus."))
     }));
     ChatContextKeys.inChatInput = ( new RawContextKey("inChatInput", false, {
         type: "boolean",
-        description: ( localize(7613, "True when focus is in the chat input, false otherwise."))
+        description: ( localize(7699, "True when focus is in the chat input, false otherwise."))
     }));
     ChatContextKeys.inChatSession = ( new RawContextKey("inChat", false, {
         type: "boolean",
-        description: ( localize(7614, "True when focus is in the chat widget, false otherwise."))
+        description: ( localize(7700, "True when focus is in the chat widget, false otherwise."))
     }));
     ChatContextKeys.inChatQuestionCarousel = ( new RawContextKey("inChatQuestionCarousel", false, {
         type: "boolean",
-        description: ( localize(7615, "True when focus is in the chat question carousel."))
+        description: ( localize(7701, "True when focus is in the chat question carousel."))
     }));
     ChatContextKeys.chatQuestionCarouselHasTerminal = ( new RawContextKey("chatQuestionCarouselHasTerminal", false, {
         type: "boolean",
         description: ( localize(
-            7616,
+            7702,
             "True when the chat question carousel was triggered by a terminal and has a terminal to focus."
         ))
     }));
     ChatContextKeys.inChatEditor = ( new RawContextKey("inChatEditor", false, {
         type: "boolean",
-        description: ( localize(7617, "Whether focus is in a chat editor."))
+        description: ( localize(7703, "Whether focus is in a chat editor."))
     }));
     ChatContextKeys.inChatTodoList = ( new RawContextKey("inChatTodoList", false, {
         type: "boolean",
-        description: ( localize(7618, "True when focus is in the chat todo list."))
+        description: ( localize(7704, "True when focus is in the chat todo list."))
     }));
     ChatContextKeys.inChatTip = ( new RawContextKey("inChatTip", false, {
         type: "boolean",
-        description: ( localize(7619, "True when focus is in a chat tip."))
+        description: ( localize(7705, "True when focus is in a chat tip."))
     }));
     ChatContextKeys.multipleChatTips = ( new RawContextKey("multipleChatTips", false, {
         type: "boolean",
-        description: ( localize(7620, "True when there are multiple chat tips available."))
+        description: ( localize(7706, "True when there are multiple chat tips available."))
     }));
     ChatContextKeys.inChatTerminalToolOutput = ( new RawContextKey("inChatTerminalToolOutput", false, {
         type: "boolean",
-        description: ( localize(7621, "True when focus is in the chat terminal output region."))
+        description: ( localize(7707, "True when focus is in the chat terminal output region."))
     }));
     ChatContextKeys.chatModeKind = ( new RawContextKey("chatAgentKind", ChatModeKind.Ask, {
         type: "string",
-        description: ( localize(7622, "The 'kind' of the current agent."))
+        description: ( localize(7708, "The 'kind' of the current agent."))
     }));
     ChatContextKeys.chatPermissionLevel = ( new RawContextKey("chatPermissionLevel", ChatPermissionLevel.Default, {
         type: "string",
-        description: ( localize(7623, "The current permission level for tool auto-approval."))
+        description: ( localize(7709, "The current permission level for tool auto-approval."))
     }));
     ChatContextKeys.chatModeName = ( new RawContextKey("chatModeName", "", {
         type: "string",
-        description: ( localize(7624, "The name of the current chat mode (e.g. 'Plan' for custom modes)."))
+        description: ( localize(7710, "The name of the current chat mode (e.g. 'Plan' for custom modes)."))
     }));
     ChatContextKeys.chatModelId = ( new RawContextKey("chatModelId", "", {
         type: "string",
         description: ( localize(
-            7625,
+            7711,
             "The short id of the currently selected chat model (for example 'gpt-4.1')."
         ))
     }));
@@ -160,95 +160,102 @@ var ChatContextKeys;
     ChatContextKeys.enabled = ( new RawContextKey("chatIsEnabled", false, {
         type: "boolean",
         description: ( localize(
-            7626,
+            7712,
             "True when chat is enabled because a default chat participant is activated with an implementation."
         ))
     }));
     ChatContextKeys.accountPolicyGateActive = ChatAccountPolicyGateActiveContext;
     ChatContextKeys.lockedToCodingAgent = ( new RawContextKey("lockedToCodingAgent", false, {
         type: "boolean",
-        description: ( localize(7627, "True when the chat widget is locked to the coding agent session."))
+        description: ( localize(7713, "True when the chat widget is locked to the coding agent session."))
     }));
     ChatContextKeys.lockedCodingAgentId = ( new RawContextKey("lockedCodingAgentId", "", {
         type: "string",
         description: ( localize(
-            7628,
+            7714,
             "The agent ID when the chat widget is locked to a coding agent session."
         ))
     }));
     ChatContextKeys.chatSessionHasCustomAgentTarget = ( new RawContextKey("chatSessionHasCustomAgentTarget", false, {
         type: "boolean",
         description: ( localize(
-            7629,
+            7715,
             "True when the chat session has a customAgentTarget defined to filter modes."
         ))
     }));
     ChatContextKeys.chatSessionHasTargetedModels = ( new RawContextKey("chatSessionHasTargetedModels", false, {
         type: "boolean",
         description: ( localize(
-            7630,
+            7716,
             "True when the chat session has language models that target it via targetChatSessionType."
         ))
     }));
     ChatContextKeys.agentSupportsAttachments = ( new RawContextKey("agentSupportsAttachments", false, {
         type: "boolean",
-        description: ( localize(7631, "True when the chat agent supports attachments."))
+        description: ( localize(7717, "True when the chat agent supports attachments."))
     }));
     ChatContextKeys.withinEditSessionDiff = ( new RawContextKey("withinEditSessionDiff", false, {
         type: "boolean",
-        description: ( localize(7632, "True when the chat widget dispatches to the edit session chat."))
+        description: ( localize(7718, "True when the chat widget dispatches to the edit session chat."))
     }));
     ChatContextKeys.filePartOfEditSession = ( new RawContextKey("filePartOfEditSession", false, {
         type: "boolean",
-        description: ( localize(7633, "True when the chat widget is within a file with an edit session."))
+        description: ( localize(7719, "True when the chat widget is within a file with an edit session."))
     }));
     ChatContextKeys.extensionParticipantRegistered = ( new RawContextKey("chatPanelExtensionParticipantRegistered", false, {
         type: "boolean",
         description: ( localize(
-            7634,
+            7720,
             "True when a default chat participant is registered for the panel from an extension."
         ))
     }));
     ChatContextKeys.panelParticipantRegistered = ( new RawContextKey("chatPanelParticipantRegistered", false, {
         type: "boolean",
-        description: ( localize(7635, "True when a default chat participant is registered for the panel."))
+        description: ( localize(7721, "True when a default chat participant is registered for the panel."))
     }));
     ChatContextKeys.chatEditingCanUndo = ( new RawContextKey("chatEditingCanUndo", false, {
         type: "boolean",
         description: ( localize(
-            7636,
+            7722,
             "True when it is possible to undo an interaction in the editing panel."
         ))
     }));
     ChatContextKeys.chatEditingCanRedo = ( new RawContextKey("chatEditingCanRedo", false, {
         type: "boolean",
         description: ( localize(
-            7637,
+            7723,
             "True when it is possible to redo an interaction in the editing panel."
         ))
     }));
     ChatContextKeys.languageModelsAreUserSelectable = ( new RawContextKey("chatModelsAreUserSelectable", false, {
         type: "boolean",
-        description: ( localize(7638, "True when the chat model can be selected manually by the user."))
+        description: ( localize(7724, "True when the chat model can be selected manually by the user."))
+    }));
+    ChatContextKeys.nonCopilotLanguageModelsAreUserSelectable = ( new RawContextKey("chatNonCopilotModelsAreUserSelectable", false, {
+        type: "boolean",
+        description: ( localize(
+            7725,
+            "True when a user-selectable chat model from a non-Copilot vendor is available."
+        ))
     }));
     ChatContextKeys.chatSessionHasModels = ( new RawContextKey("chatSessionHasModels", false, {
         type: "boolean",
         description: ( localize(
-            7639,
+            7726,
             "True when the chat is in a contributed chat session that has available 'models' to display."
         ))
     }));
     ChatContextKeys.chatSessionOptionsValid = ( new RawContextKey("chatSessionOptionsValid", true, {
         type: "boolean",
         description: ( localize(
-            7640,
+            7727,
             "True when all selected session options exist in their respective option group items."
         ))
     }));
     ChatContextKeys.extensionInvalid = ( new RawContextKey("chatExtensionInvalid", false, {
         type: "boolean",
         description: ( localize(
-            7641,
+            7728,
             "True when the installed chat extension is invalid and needs to be updated."
         ))
     }));
@@ -257,58 +264,58 @@ var ChatContextKeys;
     ChatContextKeys.location = ( new RawContextKey("chatLocation", undefined));
     ChatContextKeys.inQuickChat = ( new RawContextKey("quickChatHasFocus", false, {
         type: "boolean",
-        description: ( localize(7642, "True when the quick chat UI has focus, false otherwise."))
+        description: ( localize(7729, "True when the quick chat UI has focus, false otherwise."))
     }));
     ChatContextKeys.inAgentSessionsWelcome = ( new RawContextKey("inAgentSessionsWelcome", false, {
         type: "boolean",
         description: ( localize(
-            7643,
+            7730,
             "True when the chat input is within the agent sessions welcome page."
         ))
     }));
     ChatContextKeys.chatSessionType = ( new RawContextKey("chatSessionType", "", {
         type: "string",
-        description: ( localize(7644, "The type of the current chat session."))
+        description: ( localize(7731, "The type of the current chat session."))
     }));
     ChatContextKeys.hasFileAttachments = ( new RawContextKey("chatHasFileAttachments", false, {
         type: "boolean",
-        description: ( localize(7645, "True when the chat has file attachments."))
+        description: ( localize(7732, "True when the chat has file attachments."))
     }));
     ChatContextKeys.chatSessionIsEmpty = ( new RawContextKey("chatSessionIsEmpty", true, {
         type: "boolean",
-        description: ( localize(7646, "True when the current chat session has no requests."))
+        description: ( localize(7733, "True when the current chat session has no requests."))
     }));
     ChatContextKeys.hasPendingRequests = ( new RawContextKey("chatHasPendingRequests", false, {
         type: "boolean",
-        description: ( localize(7647, "True when there are pending requests in the queue."))
+        description: ( localize(7734, "True when there are pending requests in the queue."))
     }));
     ChatContextKeys.chatSessionHasDebugData = ( new RawContextKey("chatSessionHasDebugData", false, {
         type: "boolean",
-        description: ( localize(7648, "True when the current chat session has debug log data."))
+        description: ( localize(7735, "True when the current chat session has debug log data."))
     }));
     ChatContextKeys.chatSessionHasDebugTools = ( new RawContextKey("chatSessionHasDebugTools", false, {
         type: "boolean",
-        description: ( localize(7649, "True when debug tools are enabled in the current chat session."))
+        description: ( localize(7736, "True when debug tools are enabled in the current chat session."))
     }));
     ChatContextKeys.remoteJobCreating = ( new RawContextKey("chatRemoteJobCreating", false, {
         type: "boolean",
-        description: ( localize(7650, "True when a remote coding agent job is being created."))
+        description: ( localize(7737, "True when a remote coding agent job is being created."))
     }));
-    ChatContextKeys.hasRemoteCodingAgent = ( new RawContextKey("hasRemoteCodingAgent", false, ( localize(7651, "Whether any remote coding agent is available"))));
+    ChatContextKeys.hasRemoteCodingAgent = ( new RawContextKey("hasRemoteCodingAgent", false, ( localize(7738, "Whether any remote coding agent is available"))));
     ChatContextKeys.hasCanDelegateProviders = ( new RawContextKey("chatHasCanDelegateProviders", false, {
         type: "boolean",
         description: ( localize(
-            7652,
+            7739,
             "True when there are chat session providers with delegation support available."
         ))
     }));
     ChatContextKeys.enableRemoteCodingAgentPromptFileOverlay = ( new RawContextKey("enableRemoteCodingAgentPromptFileOverlay", false, ( localize(
-        7653,
+        7740,
         "Whether the remote coding agent prompt file overlay feature is enabled"
     ))));
     ChatContextKeys.skipChatRequestInProgressMessage = ( new RawContextKey("chatSkipRequestInProgressMessage", false, {
         type: "boolean",
-        description: ( localize(7654, "True when the chat request in progress message should be skipped."))
+        description: ( localize(7741, "True when the chat request in progress message should be skipped."))
     }));
     ChatContextKeys.Setup = ChatEntitlementContextKeys.Setup;
     ChatContextKeys.Entitlement = ChatEntitlementContextKeys.Entitlement;
@@ -317,115 +324,115 @@ var ChatContextKeys;
     ChatContextKeys.Editing = {
         hasToolConfirmation: ( new RawContextKey("chatHasToolConfirmation", false, {
             type: "boolean",
-            description: ( localize(7655, "True when a tool confirmation is present."))
+            description: ( localize(7742, "True when a tool confirmation is present."))
         })),
         hasElicitationRequest: ( new RawContextKey("chatHasElicitationRequest", false, {
             type: "boolean",
-            description: ( localize(7656, "True when a chat elicitation request is pending."))
+            description: ( localize(7743, "True when a chat elicitation request is pending."))
         })),
         hasQuestionCarousel: ( new RawContextKey("chatHasQuestionCarousel", false, {
             type: "boolean",
-            description: ( localize(7657, "True when a question carousel is rendered in the chat input."))
+            description: ( localize(7744, "True when a question carousel is rendered in the chat input."))
         }))
     };
     ChatContextKeys.Tools = {
         toolsCount: ( new RawContextKey("toolsCount", 0, {
             type: "number",
-            description: ( localize(7658, "The count of tools available in the chat."))
+            description: ( localize(7745, "The count of tools available in the chat."))
         }))
     };
     ChatContextKeys.foregroundSessionCount = ( new RawContextKey("chatForegroundSessionCount", 0, {
         type: "number",
         description: ( localize(
-            7659,
+            7746,
             "The number of foreground chat sessions visible across chat surfaces."
         ))
     }));
     ChatContextKeys.Modes = {
         hasCustomChatModes: ( new RawContextKey("chatHasCustomAgents", false, {
             type: "boolean",
-            description: ( localize(7660, "True when the chat has custom agents available."))
+            description: ( localize(7747, "True when the chat has custom agents available."))
         })),
         agentModeDisabledByPolicy: ( new RawContextKey("chatAgentModeDisabledByPolicy", false, {
             type: "boolean",
-            description: ( localize(7661, "True when agent mode is disabled by organization policy."))
+            description: ( localize(7748, "True when agent mode is disabled by organization policy."))
         }))
     };
     ChatContextKeys.panelLocation = ( new RawContextKey("chatPanelLocation", undefined, {
         type: "number",
-        description: ( localize(7662, "The location of the chat panel."))
+        description: ( localize(7749, "The location of the chat panel."))
     }));
     ChatContextKeys.agentSessionsViewerFocused = ( new RawContextKey("agentSessionsViewerFocused", true, {
         type: "boolean",
-        description: ( localize(7663, "If the agent sessions view in the chat view is focused."))
+        description: ( localize(7750, "If the agent sessions view in the chat view is focused."))
     }));
     ChatContextKeys.agentSessionsViewerOrientation = ( new RawContextKey("agentSessionsViewerOrientation", undefined, {
         type: "number",
-        description: ( localize(7664, "Orientation of the agent sessions view in the chat view."))
+        description: ( localize(7751, "Orientation of the agent sessions view in the chat view."))
     }));
     ChatContextKeys.agentSessionsViewerPosition = ( new RawContextKey("agentSessionsViewerPosition", undefined, {
         type: "number",
-        description: ( localize(7665, "Position of the agent sessions view in the chat view."))
+        description: ( localize(7752, "Position of the agent sessions view in the chat view."))
     }));
     ChatContextKeys.agentSessionsViewerVisible = ( new RawContextKey("agentSessionsViewerVisible", undefined, {
         type: "boolean",
-        description: ( localize(7666, "Visibility of the agent sessions view in the chat view."))
+        description: ( localize(7753, "Visibility of the agent sessions view in the chat view."))
     }));
     ChatContextKeys.agentSessionType = ( new RawContextKey("chatSessionType", "", {
         type: "string",
-        description: ( localize(7667, "The type of the current agent session item."))
+        description: ( localize(7754, "The type of the current agent session item."))
     }));
     ChatContextKeys.chatSessionSupportsDelegation = ( new RawContextKey("chatSessionSupportsDelegation", true, {
         type: "boolean",
-        description: ( localize(7668, "True when the current session type supports delegation."))
+        description: ( localize(7755, "True when the current session type supports delegation."))
     }));
     ChatContextKeys.chatSessionSupportsFork = ( new RawContextKey("chatSessionSupportsFork", false, {
         type: "boolean",
         description: ( localize(
-            7669,
+            7756,
             "True when the current chat session provider supports forking conversations."
         ))
     }));
     ChatContextKeys.agentSessionSection = ( new RawContextKey("agentSessionSection", "", {
         type: "string",
-        description: ( localize(7670, "The section of the current agent session section item."))
+        description: ( localize(7757, "The section of the current agent session section item."))
     }));
     ChatContextKeys.isArchivedAgentSession = ( new RawContextKey("agentSessionIsArchived", false, {
         type: "boolean",
-        description: ( localize(7671, "True when the agent session item is archived."))
+        description: ( localize(7758, "True when the agent session item is archived."))
     }));
     ChatContextKeys.isPinnedAgentSession = ( new RawContextKey("agentSessionIsPinned", false, {
         type: "boolean",
-        description: ( localize(7672, "True when the agent session item is pinned."))
+        description: ( localize(7759, "True when the agent session item is pinned."))
     }));
     ChatContextKeys.isReadAgentSession = ( new RawContextKey("agentSessionIsRead", false, {
         type: "boolean",
-        description: ( localize(7673, "True when the agent session item is read."))
+        description: ( localize(7760, "True when the agent session item is read."))
     }));
     ChatContextKeys.hasMultipleAgentSessionsSelected = ( new RawContextKey("agentSessionHasMultipleSelected", false, {
         type: "boolean",
-        description: ( localize(7674, "True when multiple agent sessions are selected."))
+        description: ( localize(7761, "True when multiple agent sessions are selected."))
     }));
     ChatContextKeys.hasAgentSessionChanges = ( new RawContextKey("agentSessionHasChanges", false, {
         type: "boolean",
-        description: ( localize(7675, "True when the current agent session item has changes."))
+        description: ( localize(7762, "True when the current agent session item has changes."))
     }));
     ChatContextKeys.isKatexMathElement = ( new RawContextKey("chatIsKatexMathElement", false, {
         type: "boolean",
-        description: ( localize(7676, "True when focusing a KaTeX math element."))
+        description: ( localize(7763, "True when focusing a KaTeX math element."))
     }));
     ChatContextKeys.hasUsedCreateSlashCommands = ( new RawContextKey("chatHasUsedCreateSlashCommands", false, {
         type: "boolean",
-        description: ( localize(7677, "True when the user has used any of the /create-* slash commands."))
+        description: ( localize(7764, "True when the user has used any of the /create-* slash commands."))
     }));
     ChatContextKeys.contextUsageHasBeenOpened = ( new RawContextKey("chatContextUsageHasBeenOpened", false, {
         type: "boolean",
-        description: ( localize(7678, "True when the user has opened the context window usage details."))
+        description: ( localize(7765, "True when the user has opened the context window usage details."))
     }));
     ChatContextKeys.newChatButtonExperimentIcon = ( new RawContextKey("chatNewChatButtonExperimentIcon", "", {
         type: "string",
         description: ( localize(
-            7679,
+            7766,
             "The icon variant for the new chat button, controlled by experiment. Values: 'copilot', 'new-session', 'comment', or empty for default."
         ))
     }));

package/vscode/src/vs/workbench/contrib/chat/common/attachments/chatVariableEntries.js

@@ -83,9 +83,9 @@ var IDiagnosticVariableEntryFilterData;
             }
             return data.problemMessage.substring(0, lastSpace) + "…";
         }
-        let labelStr = ( localize(7680, "All Problems"));
+        let labelStr = ( localize(7767, "All Problems"));
         if (data.filterUri) {
-            labelStr = ( localize(7681, "Problems in {0}", basename(data.filterUri)));
+            labelStr = ( localize(7768, "Problems in {0}", basename(data.filterUri)));
         }
         return labelStr;
     }

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

@@ -1,5 +1,5 @@
 import { Event } from "../../../../base/common/event.js";
-import { Disposable } from "../../../../base/common/lifecycle.js";
+import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IOffsetRange } from "../../../../editor/common/core/ranges/offsetRange.js";
@@ -17,7 +17,6 @@ import { IChatModeService } from "./chatModes.service.js";
  * into builtin and custom modes, with helpers for lookup by id or name.
  */
 export interface IChatModes {
-    readonly sessionType: string;
     readonly onDidChange: Event<void>;
     readonly builtin: readonly IChatMode[];
     readonly custom: readonly IChatMode[];
@@ -35,11 +34,10 @@ export declare class ChatModeService extends Disposable implements IChatModeServ
     private readonly configurationService;
     readonly _serviceBrand: undefined;
     private readonly agentModeDisabledByPolicy;
-    /** Cached per-sessionType {@link ChatModes} instances. */
-    private readonly _modesBySessionType;
+    private localMode;
     constructor(instantiationService: IInstantiationService, contextKeyService: IContextKeyService, configurationService: IConfigurationService);
-    getModes(sessionType: string): IChatModes;
-    awaitModes(sessionType: string): Promise<IChatModes>;
+    createModes(sessionResource: URI): IChatModes & IDisposable;
+    getLocalModes(): Promise<IChatModes>;
     private updateAgentModePolicyContextKey;
     private isAgentModeDisabledByPolicy;
 }