@codingame/monaco-vscode-api 28.4.1 → 29.0.0

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

@@ -11,128 +11,129 @@ var ChatContextKeys;
     ChatContextKeys.responseVote = ( new RawContextKey("chatSessionResponseVote", "", {
         type: "string",
         description: ( localize(
-            6900,
+            7107,
             "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(6901, "When the agent or command was automatically detected"))
+        description: ( localize(7108, "When the agent or command was automatically detected"))
     }));
     ChatContextKeys.responseSupportsIssueReporting = ( new RawContextKey("chatResponseSupportsIssueReporting", false, {
         type: "boolean",
-        description: ( localize(6902, "True when the current chat response supports issue reporting."))
+        description: ( localize(7109, "True when the current chat response supports issue reporting."))
     }));
     ChatContextKeys.responseIsFiltered = ( new RawContextKey("chatSessionResponseFiltered", false, {
         type: "boolean",
-        description: ( localize(6903, "True when the chat response was filtered out by the server."))
+        description: ( localize(7110, "True when the chat response was filtered out by the server."))
     }));
     ChatContextKeys.responseHasError = ( new RawContextKey("chatSessionResponseError", false, {
         type: "boolean",
-        description: ( localize(6904, "True when the chat response resulted in an error."))
+        description: ( localize(7111, "True when the chat response resulted in an error."))
     }));
     ChatContextKeys.requestInProgress = ( new RawContextKey("chatSessionRequestInProgress", false, {
         type: "boolean",
-        description: ( localize(6905, "True when the current request is still in progress."))
+        description: ( localize(7112, "True when the current request is still in progress."))
     }));
     ChatContextKeys.currentlyEditing = ( new RawContextKey("chatSessionCurrentlyEditing", false, {
         type: "boolean",
-        description: ( localize(6906, "True when the current request is being edited."))
+        description: ( localize(7113, "True when the current request is being edited."))
     }));
     ChatContextKeys.currentlyEditingInput = ( new RawContextKey("chatSessionCurrentlyEditingInput", false, {
         type: "boolean",
-        description: ( localize(6907, "True when the current request input at the bottom is being edited."))
+        description: ( localize(7114, "True when the current request input at the bottom is being edited."))
     }));
     (function(EditingRequestType) {
         EditingRequestType["Sent"] = "s";
-        EditingRequestType["QueueOrSteer"] = "qs";
+        EditingRequestType["Queue"] = "q";
+        EditingRequestType["Steer"] = "st";
     })(
         ChatContextKeys.EditingRequestType || (ChatContextKeys.EditingRequestType = {})
     );
     ChatContextKeys.editingRequestType = ( new RawContextKey("chatEditingSentRequest", undefined, {
         type: "string",
-        description: ( localize(6908, "The type of the current editing request."))
+        description: ( localize(7115, "The type of the current editing request."))
     }));
     ChatContextKeys.isResponse = ( new RawContextKey("chatResponse", false, {
         type: "boolean",
-        description: ( localize(6909, "The chat item is a response."))
+        description: ( localize(7116, "The chat item is a response."))
     }));
     ChatContextKeys.isRequest = ( new RawContextKey("chatRequest", false, {
         type: "boolean",
-        description: ( localize(6910, "The chat item is a request"))
+        description: ( localize(7117, "The chat item is a request"))
     }));
     ChatContextKeys.isPendingRequest = ( new RawContextKey("chatRequestIsPending", false, {
         type: "boolean",
-        description: ( localize(6911, "True when the chat request item is pending in the queue."))
+        description: ( localize(7118, "True when the chat request item is pending in the queue."))
     }));
     ChatContextKeys.itemId = ( new RawContextKey("chatItemId", "", {
         type: "string",
-        description: ( localize(6912, "The id of the chat item."))
+        description: ( localize(7119, "The id of the chat item."))
     }));
     ChatContextKeys.lastItemId = ( new RawContextKey("chatLastItemId", [], {
         type: "string",
-        description: ( localize(6913, "The id of the last chat item."))
+        description: ( localize(7120, "The id of the last chat item."))
     }));
     ChatContextKeys.editApplied = ( new RawContextKey("chatEditApplied", false, {
         type: "boolean",
-        description: ( localize(6914, "True when the chat text edits have been applied."))
+        description: ( localize(7121, "True when the chat text edits have been applied."))
     }));
     ChatContextKeys.inputHasText = ( new RawContextKey("chatInputHasText", false, {
         type: "boolean",
-        description: ( localize(6915, "True when the chat input has text."))
+        description: ( localize(7122, "True when the chat input has text."))
     }));
     ChatContextKeys.inputHasFocus = ( new RawContextKey("chatInputHasFocus", false, {
         type: "boolean",
-        description: ( localize(6916, "True when the chat input has focus."))
+        description: ( localize(7123, "True when the chat input has focus."))
     }));
     ChatContextKeys.inChatInput = ( new RawContextKey("inChatInput", false, {
         type: "boolean",
-        description: ( localize(6917, "True when focus is in the chat input, false otherwise."))
+        description: ( localize(7124, "True when focus is in the chat input, false otherwise."))
     }));
     ChatContextKeys.inChatSession = ( new RawContextKey("inChat", false, {
         type: "boolean",
-        description: ( localize(6918, "True when focus is in the chat widget, false otherwise."))
+        description: ( localize(7125, "True when focus is in the chat widget, false otherwise."))
     }));
     ChatContextKeys.inChatQuestionCarousel = ( new RawContextKey("inChatQuestionCarousel", false, {
         type: "boolean",
-        description: ( localize(6919, "True when focus is in the chat question carousel."))
+        description: ( localize(7126, "True when focus is in the chat question carousel."))
     }));
     ChatContextKeys.inChatEditor = ( new RawContextKey("inChatEditor", false, {
         type: "boolean",
-        description: ( localize(6920, "Whether focus is in a chat editor."))
+        description: ( localize(7127, "Whether focus is in a chat editor."))
     }));
     ChatContextKeys.inChatTodoList = ( new RawContextKey("inChatTodoList", false, {
         type: "boolean",
-        description: ( localize(6921, "True when focus is in the chat todo list."))
+        description: ( localize(7128, "True when focus is in the chat todo list."))
     }));
     ChatContextKeys.inChatTip = ( new RawContextKey("inChatTip", false, {
         type: "boolean",
-        description: ( localize(6922, "True when focus is in a chat tip."))
+        description: ( localize(7129, "True when focus is in a chat tip."))
     }));
     ChatContextKeys.multipleChatTips = ( new RawContextKey("multipleChatTips", false, {
         type: "boolean",
-        description: ( localize(6923, "True when there are multiple chat tips available."))
+        description: ( localize(7130, "True when there are multiple chat tips available."))
     }));
     ChatContextKeys.inChatTerminalToolOutput = ( new RawContextKey("inChatTerminalToolOutput", false, {
         type: "boolean",
-        description: ( localize(6924, "True when focus is in the chat terminal output region."))
+        description: ( localize(7131, "True when focus is in the chat terminal output region."))
     }));
     ChatContextKeys.chatModeKind = ( new RawContextKey("chatAgentKind", ChatModeKind.Ask, {
         type: "string",
-        description: ( localize(6925, "The 'kind' of the current agent."))
+        description: ( localize(7132, "The 'kind' of the current agent."))
     }));
     ChatContextKeys.chatPermissionLevel = ( new RawContextKey("chatPermissionLevel", ChatPermissionLevel.Default, {
         type: "string",
-        description: ( localize(6926, "The current permission level for tool auto-approval."))
+        description: ( localize(7133, "The current permission level for tool auto-approval."))
     }));
     ChatContextKeys.chatModeName = ( new RawContextKey("chatModeName", "", {
         type: "string",
-        description: ( localize(6927, "The name of the current chat mode (e.g. 'Plan' for custom modes)."))
+        description: ( localize(7134, "The name of the current chat mode (e.g. 'Plan' for custom modes)."))
     }));
     ChatContextKeys.chatModelId = ( new RawContextKey("chatModelId", "", {
         type: "string",
         description: ( localize(
-            6928,
+            7135,
             "The short id of the currently selected chat model (for example 'gpt-4.1')."
         ))
     }));
@@ -140,87 +141,94 @@ var ChatContextKeys;
     ChatContextKeys.enabled = ( new RawContextKey("chatIsEnabled", false, {
         type: "boolean",
         description: ( localize(
-            6929,
+            7136,
             "True when chat is enabled because a default chat participant is activated with an implementation."
         ))
     }));
     ChatContextKeys.lockedToCodingAgent = ( new RawContextKey("lockedToCodingAgent", false, {
         type: "boolean",
-        description: ( localize(6930, "True when the chat widget is locked to the coding agent session."))
+        description: ( localize(7137, "True when the chat widget is locked to the coding agent session."))
+    }));
+    ChatContextKeys.lockedCodingAgentId = ( new RawContextKey("lockedCodingAgentId", "", {
+        type: "string",
+        description: ( localize(
+            7138,
+            "The agent ID when the chat widget is locked to a coding agent session."
+        ))
     }));
     ChatContextKeys.chatSessionHasCustomAgentTarget = ( new RawContextKey("chatSessionHasCustomAgentTarget", false, {
         type: "boolean",
         description: ( localize(
-            6931,
+            7139,
             "True when the chat session has a customAgentTarget defined to filter modes."
         ))
     }));
     ChatContextKeys.chatSessionHasTargetedModels = ( new RawContextKey("chatSessionHasTargetedModels", false, {
         type: "boolean",
         description: ( localize(
-            6932,
+            7140,
             "True when the chat session has language models that target it via targetChatSessionType."
         ))
     }));
     ChatContextKeys.agentSupportsAttachments = ( new RawContextKey("agentSupportsAttachments", false, {
         type: "boolean",
-        description: ( localize(6933, "True when the chat agent supports attachments."))
+        description: ( localize(7141, "True when the chat agent supports attachments."))
     }));
     ChatContextKeys.withinEditSessionDiff = ( new RawContextKey("withinEditSessionDiff", false, {
         type: "boolean",
-        description: ( localize(6934, "True when the chat widget dispatches to the edit session chat."))
+        description: ( localize(7142, "True when the chat widget dispatches to the edit session chat."))
     }));
     ChatContextKeys.filePartOfEditSession = ( new RawContextKey("filePartOfEditSession", false, {
         type: "boolean",
-        description: ( localize(6935, "True when the chat widget is within a file with an edit session."))
+        description: ( localize(7143, "True when the chat widget is within a file with an edit session."))
     }));
     ChatContextKeys.extensionParticipantRegistered = ( new RawContextKey("chatPanelExtensionParticipantRegistered", false, {
         type: "boolean",
         description: ( localize(
-            6936,
+            7144,
             "True when a default chat participant is registered for the panel from an extension."
         ))
     }));
     ChatContextKeys.panelParticipantRegistered = ( new RawContextKey("chatPanelParticipantRegistered", false, {
         type: "boolean",
-        description: ( localize(6937, "True when a default chat participant is registered for the panel."))
+        description: ( localize(7145, "True when a default chat participant is registered for the panel."))
     }));
     ChatContextKeys.chatEditingCanUndo = ( new RawContextKey("chatEditingCanUndo", false, {
         type: "boolean",
         description: ( localize(
-            6938,
+            7146,
             "True when it is possible to undo an interaction in the editing panel."
         ))
     }));
     ChatContextKeys.chatEditingCanRedo = ( new RawContextKey("chatEditingCanRedo", false, {
         type: "boolean",
         description: ( localize(
-            6939,
+            7147,
             "True when it is possible to redo an interaction in the editing panel."
         ))
     }));
     ChatContextKeys.languageModelsAreUserSelectable = ( new RawContextKey("chatModelsAreUserSelectable", false, {
         type: "boolean",
-        description: ( localize(6940, "True when the chat model can be selected manually by the user."))
+        description: ( localize(7148, "True when the chat model can be selected manually by the user."))
     }));
     ChatContextKeys.chatSessionHasModels = ( new RawContextKey("chatSessionHasModels", false, {
         type: "boolean",
         description: ( localize(
-            6941,
+            7149,
             "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(
-            6942,
+            7150,
             "True when all selected session options exist in their respective option group items."
         ))
     }));
     ChatContextKeys.extensionInvalid = ( new RawContextKey("chatExtensionInvalid", false, {
         type: "boolean",
         description: ( localize(
-            6943,
+            7151,
             "True when the installed chat extension is invalid and needs to be updated."
         ))
     }));
@@ -229,61 +237,58 @@ var ChatContextKeys;
     ChatContextKeys.location = ( new RawContextKey("chatLocation", undefined));
     ChatContextKeys.inQuickChat = ( new RawContextKey("quickChatHasFocus", false, {
         type: "boolean",
-        description: ( localize(6944, "True when the quick chat UI has focus, false otherwise."))
+        description: ( localize(7152, "True when the quick chat UI has focus, false otherwise."))
     }));
     ChatContextKeys.inAgentSessionsWelcome = ( new RawContextKey("inAgentSessionsWelcome", false, {
         type: "boolean",
         description: ( localize(
-            6945,
+            7153,
             "True when the chat input is within the agent sessions welcome page."
         ))
     }));
     ChatContextKeys.chatSessionType = ( new RawContextKey("chatSessionType", "", {
         type: "string",
-        description: ( localize(6946, "The type of the current chat session."))
+        description: ( localize(7154, "The type of the current chat session."))
     }));
     ChatContextKeys.hasFileAttachments = ( new RawContextKey("chatHasFileAttachments", false, {
         type: "boolean",
-        description: ( localize(6947, "True when the chat has file attachments."))
+        description: ( localize(7155, "True when the chat has file attachments."))
     }));
     ChatContextKeys.chatSessionIsEmpty = ( new RawContextKey("chatSessionIsEmpty", true, {
         type: "boolean",
-        description: ( localize(6948, "True when the current chat session has no requests."))
+        description: ( localize(7156, "True when the current chat session has no requests."))
     }));
     ChatContextKeys.hasPendingRequests = ( new RawContextKey("chatHasPendingRequests", false, {
         type: "boolean",
-        description: ( localize(6949, "True when there are pending requests in the queue."))
+        description: ( localize(7157, "True when there are pending requests in the queue."))
     }));
     ChatContextKeys.chatSessionHasDebugData = ( new RawContextKey("chatSessionHasDebugData", false, {
         type: "boolean",
-        description: ( localize(6950, "True when the current chat session has debug log data."))
+        description: ( localize(7158, "True when the current chat session has debug log data."))
     }));
-    ChatContextKeys.chatSessionHasAttachedDebugData = ( new RawContextKey("chatSessionHasAttachedDebugData", false, {
+    ChatContextKeys.chatSessionHasDebugTools = ( new RawContextKey("chatSessionHasDebugTools", false, {
         type: "boolean",
-        description: ( localize(
-            6951,
-            "True when a debug events snapshot has been attached in the current chat session."
-        ))
+        description: ( localize(7159, "True when debug tools are enabled in the current chat session."))
     }));
     ChatContextKeys.remoteJobCreating = ( new RawContextKey("chatRemoteJobCreating", false, {
         type: "boolean",
-        description: ( localize(6952, "True when a remote coding agent job is being created."))
+        description: ( localize(7160, "True when a remote coding agent job is being created."))
     }));
-    ChatContextKeys.hasRemoteCodingAgent = ( new RawContextKey("hasRemoteCodingAgent", false, ( localize(6953, "Whether any remote coding agent is available"))));
+    ChatContextKeys.hasRemoteCodingAgent = ( new RawContextKey("hasRemoteCodingAgent", false, ( localize(7161, "Whether any remote coding agent is available"))));
     ChatContextKeys.hasCanDelegateProviders = ( new RawContextKey("chatHasCanDelegateProviders", false, {
         type: "boolean",
         description: ( localize(
-            6954,
+            7162,
             "True when there are chat session providers with delegation support available."
         ))
     }));
     ChatContextKeys.enableRemoteCodingAgentPromptFileOverlay = ( new RawContextKey("enableRemoteCodingAgentPromptFileOverlay", false, ( localize(
-        6955,
+        7163,
         "Whether the remote coding agent prompt file overlay feature is enabled"
     ))));
     ChatContextKeys.skipChatRequestInProgressMessage = ( new RawContextKey("chatSkipRequestInProgressMessage", false, {
         type: "boolean",
-        description: ( localize(6956, "True when the chat request in progress message should be skipped."))
+        description: ( localize(7164, "True when the chat request in progress message should be skipped."))
     }));
     ChatContextKeys.Setup = ChatEntitlementContextKeys.Setup;
     ChatContextKeys.Entitlement = ChatEntitlementContextKeys.Entitlement;
@@ -292,100 +297,115 @@ var ChatContextKeys;
     ChatContextKeys.Editing = {
         hasToolConfirmation: ( new RawContextKey("chatHasToolConfirmation", false, {
             type: "boolean",
-            description: ( localize(6957, "True when a tool confirmation is present."))
+            description: ( localize(7165, "True when a tool confirmation is present."))
         })),
         hasElicitationRequest: ( new RawContextKey("chatHasElicitationRequest", false, {
             type: "boolean",
-            description: ( localize(6958, "True when a chat elicitation request is pending."))
+            description: ( localize(7166, "True when a chat elicitation request is pending."))
         })),
         hasQuestionCarousel: ( new RawContextKey("chatHasQuestionCarousel", false, {
             type: "boolean",
-            description: ( localize(6959, "True when a question carousel is rendered in the chat input."))
+            description: ( localize(7167, "True when a question carousel is rendered in the chat input."))
         }))
     };
     ChatContextKeys.Tools = {
         toolsCount: ( new RawContextKey("toolsCount", 0, {
             type: "number",
-            description: ( localize(6960, "The count of tools available in the chat."))
+            description: ( localize(7168, "The count of tools available in the chat."))
         }))
     };
     ChatContextKeys.foregroundSessionCount = ( new RawContextKey("chatForegroundSessionCount", 0, {
         type: "number",
         description: ( localize(
-            6961,
+            7169,
             "The number of foreground chat sessions visible across chat surfaces."
         ))
     }));
     ChatContextKeys.Modes = {
         hasCustomChatModes: ( new RawContextKey("chatHasCustomAgents", false, {
             type: "boolean",
-            description: ( localize(6962, "True when the chat has custom agents available."))
+            description: ( localize(7170, "True when the chat has custom agents available."))
         })),
         agentModeDisabledByPolicy: ( new RawContextKey("chatAgentModeDisabledByPolicy", false, {
             type: "boolean",
-            description: ( localize(6963, "True when agent mode is disabled by organization policy."))
+            description: ( localize(7171, "True when agent mode is disabled by organization policy."))
         }))
     };
     ChatContextKeys.panelLocation = ( new RawContextKey("chatPanelLocation", undefined, {
         type: "number",
-        description: ( localize(6964, "The location of the chat panel."))
+        description: ( localize(7172, "The location of the chat panel."))
     }));
     ChatContextKeys.agentSessionsViewerFocused = ( new RawContextKey("agentSessionsViewerFocused", true, {
         type: "boolean",
-        description: ( localize(6965, "If the agent sessions view in the chat view is focused."))
+        description: ( localize(7173, "If the agent sessions view in the chat view is focused."))
     }));
     ChatContextKeys.agentSessionsViewerOrientation = ( new RawContextKey("agentSessionsViewerOrientation", undefined, {
         type: "number",
-        description: ( localize(6966, "Orientation of the agent sessions view in the chat view."))
+        description: ( localize(7174, "Orientation of the agent sessions view in the chat view."))
     }));
     ChatContextKeys.agentSessionsViewerPosition = ( new RawContextKey("agentSessionsViewerPosition", undefined, {
         type: "number",
-        description: ( localize(6967, "Position of the agent sessions view in the chat view."))
+        description: ( localize(7175, "Position of the agent sessions view in the chat view."))
     }));
     ChatContextKeys.agentSessionsViewerVisible = ( new RawContextKey("agentSessionsViewerVisible", undefined, {
         type: "boolean",
-        description: ( localize(6968, "Visibility of the agent sessions view in the chat view."))
+        description: ( localize(7176, "Visibility of the agent sessions view in the chat view."))
     }));
     ChatContextKeys.agentSessionType = ( new RawContextKey("chatSessionType", "", {
         type: "string",
-        description: ( localize(6969, "The type of the current agent session item."))
+        description: ( localize(7177, "The type of the current agent session item."))
+    }));
+    ChatContextKeys.chatSessionSupportsDelegation = ( new RawContextKey("chatSessionSupportsDelegation", true, {
+        type: "boolean",
+        description: ( localize(7178, "True when the current session type supports delegation."))
+    }));
+    ChatContextKeys.chatSessionSupportsFork = ( new RawContextKey("chatSessionSupportsFork", false, {
+        type: "boolean",
+        description: ( localize(
+            7179,
+            "True when the current chat session provider supports forking conversations."
+        ))
     }));
     ChatContextKeys.agentSessionSection = ( new RawContextKey("agentSessionSection", "", {
         type: "string",
-        description: ( localize(6970, "The section of the current agent session section item."))
+        description: ( localize(7180, "The section of the current agent session section item."))
     }));
     ChatContextKeys.isArchivedAgentSession = ( new RawContextKey("agentSessionIsArchived", false, {
         type: "boolean",
-        description: ( localize(6971, "True when the agent session item is archived."))
+        description: ( localize(7181, "True when the agent session item is archived."))
+    }));
+    ChatContextKeys.isPinnedAgentSession = ( new RawContextKey("agentSessionIsPinned", false, {
+        type: "boolean",
+        description: ( localize(7182, "True when the agent session item is pinned."))
     }));
     ChatContextKeys.isReadAgentSession = ( new RawContextKey("agentSessionIsRead", false, {
         type: "boolean",
-        description: ( localize(6972, "True when the agent session item is read."))
+        description: ( localize(7183, "True when the agent session item is read."))
     }));
     ChatContextKeys.hasMultipleAgentSessionsSelected = ( new RawContextKey("agentSessionHasMultipleSelected", false, {
         type: "boolean",
-        description: ( localize(6973, "True when multiple agent sessions are selected."))
+        description: ( localize(7184, "True when multiple agent sessions are selected."))
     }));
     ChatContextKeys.hasAgentSessionChanges = ( new RawContextKey("agentSessionHasChanges", false, {
         type: "boolean",
-        description: ( localize(6974, "True when the current agent session item has changes."))
+        description: ( localize(7185, "True when the current agent session item has changes."))
     }));
     ChatContextKeys.isKatexMathElement = ( new RawContextKey("chatIsKatexMathElement", false, {
         type: "boolean",
-        description: ( localize(6975, "True when focusing a KaTeX math element."))
+        description: ( localize(7186, "True when focusing a KaTeX math element."))
     }));
     ChatContextKeys.hasUsedCreateSlashCommands = ( new RawContextKey("chatHasUsedCreateSlashCommands", false, {
         type: "boolean",
-        description: ( localize(6976, "True when the user has used any of the /create-* slash commands."))
+        description: ( localize(7187, "True when the user has used any of the /create-* slash commands."))
     }));
     ChatContextKeys.contextUsageHasBeenOpened = ( new RawContextKey("chatContextUsageHasBeenOpened", false, {
         type: "boolean",
-        description: ( localize(6977, "True when the user has opened the context window usage details."))
+        description: ( localize(7188, "True when the user has opened the context window usage details."))
     }));
     ChatContextKeys.newChatButtonExperimentIcon = ( new RawContextKey("chatNewChatButtonExperimentIcon", "", {
         type: "string",
         description: ( localize(
-            6978,
+            7189,
             "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/aiCustomizationWorkspaceService.d.ts

@@ -0,0 +1,49 @@
+import { URI } from "../../../../base/common/uri.js";
+import { PromptsStorage } from "./promptSyntax/service/promptsService.js";
+/**
+ * Extended storage type for AI Customization that includes built-in prompts
+ * shipped with the application, alongside the core `PromptsStorage` values.
+ */
+export type AICustomizationPromptsStorage = PromptsStorage | "builtin";
+/**
+ * Storage type discriminator for built-in customizations shipped with the application.
+ */
+export declare const BUILTIN_STORAGE: AICustomizationPromptsStorage;
+/**
+ * Possible section IDs for the AI Customization Management Editor sidebar.
+ */
+export declare const AICustomizationManagementSection: {
+    readonly Agents: "agents";
+    readonly Skills: "skills";
+    readonly Instructions: "instructions";
+    readonly Prompts: "prompts";
+    readonly Hooks: "hooks";
+    readonly McpServers: "mcpServers";
+    readonly Plugins: "plugins";
+    readonly Models: "models";
+};
+export type AICustomizationManagementSection = typeof AICustomizationManagementSection[keyof typeof AICustomizationManagementSection];
+/**
+ * Per-type filter policy controlling which storage sources and user file
+ * roots are visible for a given customization type.
+ */
+export interface IStorageSourceFilter {
+    /**
+     * Which storage groups to display (e.g. workspace, user, extension, builtin).
+     */
+    readonly sources: readonly string[];
+    /**
+     * If set, only user files under these roots are shown (allowlist).
+     * If `undefined`, all user file roots are included.
+     */
+    readonly includedUserFileRoots?: readonly URI[];
+}
+/**
+ * Applies a storage source filter to an array of items that have uri and storage.
+ * Removes items whose storage is not in the filter's source list,
+ * and for user-storage items, removes those not under an allowed root.
+ */
+export declare function applyStorageSourceFilter<T extends {
+    readonly uri: URI;
+    readonly storage: string;
+}>(items: readonly T[], filter: IStorageSourceFilter): readonly T[];

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

@@ -0,0 +1,29 @@
+
+import { isEqualOrParent } from '../../../../base/common/resources.js';
+import { PromptsStorage } from './promptSyntax/service/promptsService.js';
+
+const BUILTIN_STORAGE = "builtin";
+const AICustomizationManagementSection = {
+    Agents: "agents",
+    Skills: "skills",
+    Instructions: "instructions",
+    Prompts: "prompts",
+    Hooks: "hooks",
+    McpServers: "mcpServers",
+    Plugins: "plugins",
+    Models: "models"
+};
+function applyStorageSourceFilter(items, filter) {
+    const sourceSet = ( new Set(filter.sources));
+    return items.filter(item => {
+        if (!( sourceSet.has(item.storage))) {
+            return false;
+        }
+        if (item.storage === PromptsStorage.user && filter.includedUserFileRoots) {
+            return ( filter.includedUserFileRoots.some(root => isEqualOrParent(item.uri, root)));
+        }
+        return true;
+    });
+}
+
+export { AICustomizationManagementSection, BUILTIN_STORAGE, applyStorageSourceFilter };

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

@@ -1,7 +1,7 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
 import { IObservable } from "../../../../base/common/observable.js";
 import { URI } from "../../../../base/common/uri.js";
-import { AICustomizationManagementSection, IStorageSourceFilter } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService";
+import { AICustomizationManagementSection, IStorageSourceFilter } from "./aiCustomizationWorkspaceService.js";
 import { PromptsType } from "./promptSyntax/promptTypes.js";
 import { IChatPromptSlashCommand } from "./promptSyntax/service/promptsService.js";
 export declare const IAICustomizationWorkspaceService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IAICustomizationWorkspaceService>;

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

@@ -215,6 +215,9 @@ export interface IAgentFeedbackVariableEntry extends IBaseChatRequestVariableEnt
         readonly resourceUri: URI;
         readonly range: IRange;
         readonly codeSelection?: string;
+        readonly diffHunks?: string;
+        /** When this item was converted from a PR review comment, the original thread ID. */
+        readonly sourcePRReviewCommentId?: string;
     }>;
 }
 export interface IChatRequestDebugEventsVariableEntry extends IBaseChatRequestVariableEntry {
@@ -253,16 +256,16 @@ export declare function isSCMHistoryItemChangeVariableEntry(obj: IChatRequestVar
 export declare function isSCMHistoryItemChangeRangeVariableEntry(obj: IChatRequestVariableEntry): obj is ISCMHistoryItemChangeRangeVariableEntry;
 export declare function isStringImplicitContextValue(value: unknown): value is StringChatContextValue;
 export declare enum PromptFileVariableKind {
-    Instruction = "vscode.prompt.instructions.root",
-    InstructionReference = "vscode.prompt.instructions",
+    Instruction = "vscode.instructions.file.root",
+    InstructionReference = "vscode.instructions.file.reference",
     PromptFile = "vscode.prompt.file"
 }
 /**
  * Utility to convert a {@link uri} to a chat variable entry.
  * The `id` of the chat variable can be one of the following:
  *
- * - `vscode.prompt.instructions__<URI>`: for all non-root prompt instructions references
- * - `vscode.prompt.instructions.root__<URI>`: for *root* prompt instructions references
+ * - `vscode.instructions.file.reference__<URI>`: for all non-root prompt instructions references
+ * - `vscode.instructions.file.root__<URI>`: for *root* prompt instructions references
  * - `vscode.prompt.file__<URI>`: for prompt file references
  *
  * @param uri A resource URI that points to a prompt instructions file.