@codingame/monaco-vscode-api 34.1.3 → 35.0.0

package/vscode/src/vs/workbench/contrib/chat/common/tools/builtinTools/reviewPlanTool.js

@@ -72,8 +72,8 @@ function createReviewPlanToolData() {
         toolReferenceName: "reviewPlan",
         canBeReferencedInPrompt: false,
         icon: ThemeIcon.fromId(Codicon.checklist.id),
-        displayName: ( localize(8348, "Review Plan")),
-        userDescription: ( localize(8349, "Ask the user to review and approve a plan before proceeding.")),
+        displayName: ( localize(8965, "Review Plan")),
+        userDescription: ( localize(8966, "Ask the user to review and approve a plan before proceeding.")),
         modelDescription: "Use this tool to present a plan to the user for review. Provide the plan content as markdown, a list of approval actions (with optional default), and whether the user can provide freeform feedback. Optionally provide a URI to the backing plan file so the user can edit it. The tool returns the chosen action, whether the plan was rejected, and any feedback.",
         source: ToolDataSource.Internal,
         inputSchema
@@ -96,7 +96,7 @@ let ReviewPlanTool = class ReviewPlanTool extends Disposable {
             canProvideFeedback
         } = parameters;
         if (!actions || actions.length === 0) {
-            throw ( new Error(( localize(8350, "At least one approval action must be provided."))));
+            throw ( new Error(( localize(8967, "At least one approval action must be provided."))));
         }
         const {
             request
@@ -119,7 +119,7 @@ let ReviewPlanTool = class ReviewPlanTool extends Disposable {
                 }
             }
         }
-        const reviewData = ( new ChatPlanReviewData(title ?? ( localize(8351, "Review plan")), content, actions, canProvideFeedback, planUri?.toJSON(), generateUuid()));
+        const reviewData = ( new ChatPlanReviewData(title ?? ( localize(8968, "Review plan")), content, actions, canProvideFeedback, planUri?.toJSON(), generateUuid()));
         this.chatService.appendProgress(request, reviewData);
         const result = await raceCancellation(reviewData.completion.p, token);
         if (token.isCancellationRequested) {
@@ -132,11 +132,11 @@ let ReviewPlanTool = class ReviewPlanTool extends Disposable {
     async prepareToolInvocation(context, _token) {
         const parameters = context.parameters;
         if (!parameters.actions || parameters.actions.length === 0) {
-            throw ( new Error(( localize(8350, "At least one approval action must be provided."))));
+            throw ( new Error(( localize(8967, "At least one approval action must be provided."))));
         }
         return {
-            invocationMessage: ( new MarkdownString(( localize(8352, "Asking you to review the plan")))),
-            pastTenseMessage: ( new MarkdownString(( localize(8353, "Asked you to review the plan"))))
+            invocationMessage: ( new MarkdownString(( localize(8969, "Asking you to review the plan")))),
+            pastTenseMessage: ( new MarkdownString(( localize(8970, "Asked you to review the plan"))))
         };
     }
     toResult(result) {

package/vscode/src/vs/workbench/contrib/chat/common/tools/builtinTools/runSubagentTool.js

@@ -13,9 +13,10 @@ import { IInstantiationService } from '../../../../../../platform/instantiation/
 import { ILogService } from '../../../../../../platform/log/common/log.service.js';
 import { IProductService } from '../../../../../../platform/product/common/productService.service.js';
 import { ChatRequestVariableSet } from '../../attachments/chatVariableEntries.js';
+import { isByokModel } from '../../chatSelectedModel.js';
 import { IChatService } from '../../chatService/chatService.service.js';
 import { ChatConfiguration, ChatAgentLocation, ChatModeKind, GeneralPurposeAgentName } from '../../constants.js';
-import { ILanguageModelChatMetadata } from '../../languageModels.js';
+import { ILanguageModelChatMetadata, COPILOT_VENDOR_ID } from '../../languageModels.js';
 import { ILanguageModelsService } from '../../languageModels.service.js';
 import { getChatSessionType } from '../../model/chatUri.js';
 import { IChatAgentService } from '../../participants/chatAgents.service.js';
@@ -110,9 +111,9 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             id: RunSubagentTool_1.Id,
             toolReferenceName: VSCodeToolReference.runSubagent,
             icon: ThemeIcon.fromId(Codicon.organization.id),
-            displayName: ( localize(8354, "Run Subagent")),
+            displayName: ( localize(8971, "Run Subagent")),
             userDescription: ( localize(
-                8355,
+                8972,
                 "Run a task within an isolated subagent context to enable efficient organization of tasks and context window management."
             )),
             modelDescription: modelDescription,
@@ -177,6 +178,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                         name: subAgentName,
                         content: instructions.content,
                         toolReferences: this.languageModelToolsService.toToolReferences(instructions.toolReferences),
+                        allowedSubagents: undefined,
                         metadata: instructions.metadata,
                         isBuiltin: isBuiltinAgent(subagent.source, subagent.uri, this.productService)
                     };
@@ -200,9 +202,16 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             }
             const markdownParts = [];
             const subAgentInvocationId = invocation.chatStreamToolCallId ?? invocation.callId ?? `subagent-${generateUuid()}`;
+            let subagentCredits;
             let inEdit = false;
             const progressCallback = parts => {
                 for (const part of parts) {
+                    if (part.kind === "usage") {
+                        if (typeof part.copilotCredits === "number") {
+                            subagentCredits = part.copilotCredits;
+                        }
+                        continue;
+                    }
                     if (part.kind === "textEdit" || part.kind === "notebookEdit" || part.kind === "codeblockUri") {
                         if (part.kind === "codeblockUri" && !inEdit) {
                             inEdit = true;
@@ -256,14 +265,16 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                 );
             }
             const variableSet = ( new ChatRequestVariableSet());
-            const computer = this.instantiationService.createInstance(
-                ComputeAutomaticInstructions,
-                ChatModeKind.Agent,
-                modeTools,
-                undefined,
-                getChatSessionType(invocation.context.sessionResource)
-            );
-            await computer.collect(variableSet, token);
+            if (this.configurationService.getValue(ChatConfiguration.CollectInstructionsInExtension) !== true) {
+                const computer = this.instantiationService.createInstance(
+                    ComputeAutomaticInstructions,
+                    ChatModeKind.Agent,
+                    modeTools,
+                    undefined,
+                    getChatSessionType(invocation.context.sessionResource)
+                );
+                await computer.collect(variableSet, token);
+            }
             let collectedHooks;
             try {
                 const info = await this.promptsService.getHooks(token);
@@ -325,6 +336,9 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             if (invocation.toolSpecificData?.kind === "subagent") {
                 invocation.toolSpecificData.result = resultText;
                 invocation.toolSpecificData.modelName = resolvedModelName;
+                if (typeof subagentCredits === "number" && subagentCredits > 0) {
+                    invocation.toolSpecificData.credits = subagentCredits;
+                }
             }
             return {
                 content: [{
@@ -422,9 +436,15 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         if (subagent && !explicitModelResolved) {
             const modeModelQualifiedNames = subagent.model;
             if (modeModelQualifiedNames) {
+                const mainModelMetadata = mainModelId ? this.languageModelsService.lookupLanguageModel(mainModelId) : undefined;
+                const mainModelIsByok = !!mainModelMetadata && isByokModel(mainModelMetadata);
+                const skipCopilotFallbacks = mainModelIsByok && isBuiltinAgent(subagent.source, subagent.uri, this.productService);
                 for (const qualifiedName of modeModelQualifiedNames) {
                     const lmByQualifiedName = this.languageModelsService.lookupLanguageModelByQualifiedName(qualifiedName);
                     if (lmByQualifiedName?.identifier) {
+                        if (skipCopilotFallbacks && lmByQualifiedName.metadata.vendor === COPILOT_VENDOR_ID) {
+                            continue;
+                        }
                         modeModelId = lmByQualifiedName.identifier;
                         break;
                     }

package/vscode/src/vs/workbench/contrib/chat/common/tools/builtinTools/setArtifactRulesTool.js

@@ -44,7 +44,7 @@ const SetArtifactRulesToolData = {
     id: SetArtifactRulesToolId,
     toolReferenceName: "artifactRules",
     legacyToolReferenceFullNames: [],
-    displayName: ( localize(8356, "Set Artifact Rules")),
+    displayName: ( localize(8973, "Set Artifact Rules")),
     modelDescription: "Override the artifact extraction rules for this session. Rules control which tool results, files, and memory writes are automatically surfaced as artifacts.\n\nProvide rules as MIME type patterns, file path globs, or memory file path globs, each mapped to a group configuration with a groupName and optional onlyShowGroup flag.\n\nExamples:\n- byMimeType: { \"image/*\": { \"groupName\": \"Screenshots\", \"onlyShowGroup\": true } }\n- byFilePath: { \"**/*plan*.md\": { \"groupName\": \"Plans\" } }\n- byMemoryFilePath: { \"**/*plan*.md\": { \"groupName\": \"Plans\" } }\n\nThis fully replaces any settings-based rules for the duration of this session.",
     canBeReferencedInPrompt: true,
     source: ToolDataSource.Internal,
@@ -56,7 +56,7 @@ let SetArtifactRulesTool = class SetArtifactRulesTool {
     }
     async prepareToolInvocation(_context, _token) {
         return {
-            pastTenseMessage: ( new MarkdownString(( localize(8357, "Updated artifact rules")))),
+            pastTenseMessage: ( new MarkdownString(( localize(8974, "Updated artifact rules")))),
             presentation: ToolInvocationPresentation.Hidden
         };
     }
@@ -80,7 +80,7 @@ let SetArtifactRulesTool = class SetArtifactRulesTool {
         return {
             content: [{
                 kind: "text",
-                value: ( localize(8358, "Updated artifact rules"))
+                value: ( localize(8975, "Updated artifact rules"))
             }]
         };
     }

package/vscode/src/vs/workbench/contrib/chat/common/tools/builtinTools/setArtifactsTool.js

@@ -42,7 +42,7 @@ const SetArtifactsToolData = {
     id: SetArtifactsToolId,
     toolReferenceName: "artifacts",
     legacyToolReferenceFullNames: ["Set Session Artifacts"],
-    displayName: ( localize(8359, "Set Session Artifacts")),
+    displayName: ( localize(8976, "Set Session Artifacts")),
     modelDescription: "Set the list of artifacts for the current session. Each artifact has a label and either a uri or a toolCallId+dataPartIndex reference, plus an optional type (devServer, screenshot, plan). This overwrites the entire artifact list. URIs must be fully qualified with a scheme (e.g. https://localhost:3000, file:///tmp/plan.md). To reference a screenshot or image from a previous tool result, use toolCallId and dataPartIndex instead of uri.\n\nWhen to use this tool:\n- When creating or updating a plan saved to session memory — set a plan artifact so the user can view it in the artifact panel\n- When taking screenshots or producing visual output — set a screenshot artifact to surface the image\n- When starting a dev server — set a devServer artifact with the URL so the user can access it\n- When producing important documents, drafts, or temporary markdown files — set an artifact to make them easily accessible\n- After verification steps that produce visual results — update artifacts with screenshots showing the outcome\n\nWorkflow:\n- Prefer artifacts over printing long content inline in chat. Save content to a file or memory, then set an artifact pointing to it.\n- When updating plans or documents, update both the underlying file AND the artifact list.\n- Keep artifact labels concise and descriptive.",
     canBeReferencedInPrompt: true,
     source: ToolDataSource.Internal,
@@ -56,7 +56,7 @@ let SetArtifactsTool = class SetArtifactsTool {
     }
     async prepareToolInvocation(_context, _token) {
         return {
-            pastTenseMessage: ( new MarkdownString(( localize(8360, "Updated session artifacts")))),
+            pastTenseMessage: ( new MarkdownString(( localize(8977, "Updated session artifacts")))),
             presentation: ToolInvocationPresentation.Hidden
         };
     }
@@ -81,7 +81,7 @@ let SetArtifactsTool = class SetArtifactsTool {
                 const parsed = ( URI.parse(uri));
                 if (parsed.scheme !== "http" && parsed.scheme !== "https") {
                     if (!(await this._fileService.exists(parsed))) {
-                        throw ( new Error(( localize(8361, "Artifact URI does not exist: {0}", uri))));
+                        throw ( new Error(( localize(8978, "Artifact URI does not exist: {0}", uri))));
                     }
                 }
             }
@@ -102,7 +102,7 @@ let SetArtifactsTool = class SetArtifactsTool {
         return {
             content: [{
                 kind: "text",
-                value: ( localize(8362, "Set {0} artifact(s)", artifacts.length))
+                value: ( localize(8979, "Set {0} artifact(s)", artifacts.length))
             }]
         };
     }

package/vscode/src/vs/workbench/contrib/chat/common/tools/languageModelToolsContribution.js

@@ -1,6 +1,7 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { isFalsyOrEmpty } from '../../../../../base/common/arrays.js';
+import { Codicon } from '../../../../../base/common/codicons.js';
 import { MarkdownString } from '../../../../../base/common/htmlContent.js';
 import { DisposableMap, DisposableStore, Disposable } from '../../../../../base/common/lifecycle.js';
 import '../../../../../base/common/observableInternal/index.js';
@@ -30,7 +31,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
     },
     jsonSchema: {
         description: ( localize(
-            8363,
+            8980,
             "Contributes a tool that can be invoked by a language model in a chat session, or from a standalone command. Registered tools can be used by all extensions."
         )),
         type: "array",
@@ -56,7 +57,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
             properties: {
                 name: {
                     description: ( localize(
-                        8364,
+                        8981,
                         "A unique name for this tool. This name must be a globally unique identifier, and is also used as a name when presenting this tool to a language model."
                     )),
                     type: "string",
@@ -64,7 +65,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 toolReferenceName: {
                     markdownDescription: ( localize(
-                        8365,
+                        8982,
                         "If {0} is enabled for this tool, the user may use '#' with this name to invoke the tool in a query. Otherwise, the name is not required. Name must not contain whitespace.",
                         "`canBeReferencedInPrompt`"
                     )),
@@ -73,32 +74,32 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 displayName: {
                     description: ( localize(
-                        8366,
+                        8983,
                         "A human-readable name for this tool that may be used to describe it in the UI."
                     )),
                     type: "string"
                 },
                 userDescription: {
-                    description: ( localize(8367, "A description of this tool that may be shown to the user.")),
+                    description: ( localize(8984, "A description of this tool that may be shown to the user.")),
                     type: "string"
                 },
                 modelDescription: {
                     description: ( localize(
-                        8368,
+                        8985,
                         "A description of this tool that may be used by a language model to select it."
                     )),
                     type: "string"
                 },
                 inputSchema: {
                     description: ( localize(
-                        8369,
+                        8986,
                         "A JSON schema for the input this tool accepts. The input must be an object at the top level. A particular language model may not support all JSON schema features. See the documentation for the language model family you are using for more information."
                     )),
                     $ref: toolsParametersSchemaSchemaId
                 },
                 canBeReferencedInPrompt: {
                     markdownDescription: ( localize(
-                        8370,
+                        8987,
                         "If true, this tool shows up as an attachment that the user can add manually to their request. Chat participants will receive the tool in {0}.",
                         "`ChatRequest#toolReferences`"
                     )),
@@ -106,7 +107,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 icon: {
                     markdownDescription: ( localize(
-                        8371,
+                        8988,
                         "An icon that represents this tool. Either a file path, an object with file paths for dark and light themes, or a theme icon reference, like \"\\$(zap)\""
                     )),
                     anyOf: [{
@@ -115,11 +116,11 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(8372, "Icon path when a light theme is used")),
+                                description: ( localize(8989, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(8373, "Icon path when a dark theme is used")),
+                                description: ( localize(8990, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
@@ -127,14 +128,14 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 when: {
                     markdownDescription: ( localize(
-                        8374,
+                        8991,
                         "Condition which must be true for this tool to be enabled. Note that a tool may still be invoked by another extension even when its `when` condition is false."
                     )),
                     type: "string"
                 },
                 tags: {
                     description: ( localize(
-                        8375,
+                        8992,
                         "A set of tags that roughly describe the tool's capabilities. A tool user may use these to filter the set of tools to just ones that are relevant for the task at hand, or they may want to pick a tag that can be used to identify just the tools contributed by this extension."
                     )),
                     type: "array",
@@ -152,7 +153,7 @@ const languageModelToolSetsExtensionPoint = ExtensionsRegistry.registerExtension
     deps: [languageModelToolsExtensionPoint],
     jsonSchema: {
         description: ( localize(
-            8376,
+            8993,
             "Contributes a set of language model tools that can be used together."
         )),
         type: "array",
@@ -170,23 +171,23 @@ const languageModelToolSetsExtensionPoint = ExtensionsRegistry.registerExtension
             properties: {
                 name: {
                     description: ( localize(
-                        8377,
+                        8994,
                         "A name for this tool set. Used as reference and should not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 description: {
-                    description: ( localize(8378, "A description of this tool set.")),
+                    description: ( localize(8995, "A description of this tool set.")),
                     type: "string"
                 },
                 icon: {
-                    markdownDescription: ( localize(8379, "An icon that represents this tool set, like {0}", "`$(zap)`")),
+                    markdownDescription: ( localize(8996, "An icon that represents this tool set, like {0}", "`$(zap)`")),
                     type: "string"
                 },
                 tools: {
                     markdownDescription: ( localize(
-                        8380,
+                        8997,
                         "A list of tools or tool sets to include in this tool set. Cannot be empty and must reference tools by their `toolReferenceName`."
                     )),
                     type: "array",
@@ -205,6 +206,9 @@ function toToolKey(extensionIdentifier, toolName) {
 function toToolSetKey(extensionIdentifier, toolName) {
     return `toolset:${extensionIdentifier.value}/${toolName}`;
 }
+function toSyntheticToolSetKey(extensionIdentifier) {
+    return `synthetic-toolset:${extensionIdentifier.value}`;
+}
 let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionPointHandler {
     static {
         this.ID = "workbench.contrib.toolsExtensionPointHandler";
@@ -213,6 +217,8 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
         this._registrationDisposables = ( new DisposableMap());
         languageModelToolsExtensionPoint.setHandler((_extensions, delta) => {
             for (const extension of delta.added) {
+                const successfullyRegisteredTools = [];
+                let extensionSource;
                 for (const rawTool of extension.value) {
                     if (!rawTool.name || !rawTool.modelDescription || !rawTool.displayName) {
                         extension.collector.error(
@@ -283,12 +289,31 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                     try {
                         const disposable = languageModelToolsService.registerToolData(tool);
                         this._registrationDisposables.set(toToolKey(extension.description.identifier, rawTool.name), disposable);
+                        successfullyRegisteredTools.push(tool);
+                        extensionSource ??= source;
                     } catch (e) {
                         extension.collector.error(`Failed to register tool '${rawTool.name}': ${e}`);
                     }
                 }
+                const hasOwnToolSets = !isFalsyOrEmpty(extension.description.contributes?.languageModelToolSets);
+                if (!hasOwnToolSets && extensionSource?.type === "extension" && successfullyRegisteredTools.length > 0) {
+                    const syntheticKey = toSyntheticToolSetKey(extension.description.identifier);
+                    const toolSet = languageModelToolsService.createToolSet(extensionSource, syntheticKey, extension.description.identifier.value, {
+                        icon: Codicon.extensions,
+                        description: extension.description.displayName ?? extension.description.name
+                    });
+                    const store = ( new DisposableStore());
+                    store.add(toolSet);
+                    transaction(tx => {
+                        for (const t of successfullyRegisteredTools) {
+                            store.add(toolSet.addTool(t, tx));
+                        }
+                    });
+                    this._registrationDisposables.set(syntheticKey, store);
+                }
             }
             for (const extension of delta.removed) {
+                this._registrationDisposables.deleteAndDispose(toSyntheticToolSetKey(extension.description.identifier));
                 for (const tool of extension.value) {
                     this._registrationDisposables.deleteAndDispose(toToolKey(extension.description.identifier, tool.name));
                 }
@@ -363,7 +388,8 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                             {
                                 icon: toolSet.icon ? ThemeIcon.fromString(toolSet.icon) : undefined,
                                 description: toolSet.description,
-                                legacyFullNames: toolSet.legacyFullNames
+                                legacyFullNames: toolSet.legacyFullNames,
+                                deprecated: source.type !== "extension"
                             }
                         );
                     }
@@ -426,7 +452,7 @@ class LanguageModelToolDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(8381, "Name")), ( localize(8382, "Display Name")), ( localize(8383, "Description"))];
+        const headers = [( localize(8998, "Name")), ( localize(8999, "Display Name")), ( localize(9000, "Description"))];
         const rows = ( contribs.map(t => {
             return [( new MarkdownString(`\`${t.name}\``)), t.displayName, t.userDescription ?? t.modelDescription];
         }));
@@ -441,7 +467,7 @@ class LanguageModelToolDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelTools",
-    label: ( localize(8384, "Language Model Tools")),
+    label: ( localize(9001, "Language Model Tools")),
     access: {
         canToggle: false
     },
@@ -466,7 +492,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(8385, "Name")), ( localize(8386, "Reference Name")), ( localize(8387, "Tools")), ( localize(8388, "Description"))];
+        const headers = [( localize(9002, "Name")), ( localize(9003, "Reference Name")), ( localize(9004, "Tools")), ( localize(9005, "Description"))];
         const rows = ( contribs.map(t => {
             return [( new MarkdownString(`\`${t.name}\``)), t.referenceName ? ( new MarkdownString(`\`#${t.referenceName}\``)) : "none", t.tools.join(", "), t.description];
         }));
@@ -481,7 +507,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelToolSets",
-    label: ( localize(8389, "Language Model Tool Sets")),
+    label: ( localize(9006, "Language Model Tool Sets")),
     access: {
         canToggle: false
     },

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

@@ -13,7 +13,7 @@ import { ContextKeyExpression } from "../../../../../platform/contextkey/common/
 import { IContextKeyService } from "../../../../../platform/contextkey/common/contextkey.service.js";
 import { ExtensionIdentifier } from "../../../../../platform/extensions/common/extensions.js";
 import { IProgress } from "../../../../../platform/progress/common/progress.js";
-import { IChatExtensionsContent, IChatModifiedFilesConfirmationData, IChatSearchToolInvocationData, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, type IChatTerminalToolInvocationData } from "../chatService/chatService.js";
+import { IChatAgentFeedbackReviewConfirmationData, IChatExtensionsContent, IChatModifiedFilesConfirmationData, IChatSearchToolInvocationData, IChatSimpleToolInvocationData, IChatSubagentToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, type IChatTerminalToolInvocationData } from "../chatService/chatService.js";
 import { ILanguageModelChatMetadata, LanguageModelPartAudience } from "../languageModels.js";
 import { UserSelectedTools } from "../participants/chatAgents.js";
 /**
@@ -127,7 +127,7 @@ export interface IToolInvocation {
      * Lets us add some nicer UI to toolcalls that came from a sub-agent, but in the long run, this should probably just be rendered in a similar way to thinking text + tool call groups
      */
     subAgentInvocationId?: string;
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatModifiedFilesConfirmationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData;
     modelId?: string;
     userSelectedTools?: UserSelectedTools;
     /** The label of the custom button selected by the user during confirmation, if custom buttons were used. */
@@ -289,7 +289,7 @@ export interface IPreparedToolInvocation {
     confirmationMessages?: IToolConfirmationMessages;
     presentation?: ToolInvocationPresentation;
     icon?: ThemeIcon;
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatModifiedFilesConfirmationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData;
 }
 export interface IToolImpl {
     invoke(invocation: IToolInvocation, countTokens: CountTokensCallback, progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
@@ -302,10 +302,42 @@ export interface IToolSet {
     readonly icon: ThemeIcon;
     readonly source: ToolDataSource;
     readonly description?: string;
+    /** A longer, human-readable description of what the tool set is for, shown as a subtitle in the Chat Customizations "Tools" section. */
+    readonly detail?: string;
     readonly legacyFullNames?: string[];
+    /** When true, this tool set is deprecated: it is hidden from the Chat Customizations "Tools" section and these groupings will be removed when the Local harness is dropped. */
+    readonly deprecated?: boolean;
+    /** When true, this tool set is hidden from the chat tools picker (e.g. a customizations-only grouping). */
+    readonly hiddenInToolsPicker?: boolean;
     getTools(r?: IReader): Iterable<IToolData>;
 }
-export type IToolAndToolSetEnablementMap = ReadonlyMap<IToolData | IToolSet, boolean>;
+/**
+* Maps tools and tool sets to their enablement state. Use a class to control creation of the map and ensure
+* that it is not mutated after creation.
+*/
+export declare class ToolAndToolSetEnablementMap implements Iterable<[
+    IToolData | IToolSet,
+    boolean
+]> {
+    private readonly _map;
+    static fromEntries(entries: Iterable<[
+        IToolData | IToolSet,
+        boolean
+    ]>): ToolAndToolSetEnablementMap;
+    static fromMap(map: Map<IToolData | IToolSet, boolean>): ToolAndToolSetEnablementMap;
+    private constructor();
+    [Symbol.iterator](): IterableIterator<[
+        IToolData | IToolSet,
+        boolean
+    ]>;
+    get(toolOrToolSet: IToolData | IToolSet): boolean | undefined;
+    has(toolOrToolSet: IToolData | IToolSet): boolean;
+    get size(): number;
+    entries(): IterableIterator<[
+        IToolData | IToolSet,
+        boolean
+    ]>;
+}
 export declare function isToolSet(obj: IToolData | IToolSet | undefined): obj is IToolSet;
 export declare class ToolSet implements IToolSet {
     readonly id: string;
@@ -313,7 +345,10 @@ export declare class ToolSet implements IToolSet {
     readonly icon: ThemeIcon;
     readonly source: ToolDataSource;
     readonly description: string | undefined;
+    readonly detail: string | undefined;
     readonly legacyFullNames: string[] | undefined;
+    readonly deprecated: boolean | undefined;
+    readonly hiddenInToolsPicker: boolean | undefined;
     private readonly _contextKeyService;
     protected readonly _tools: ObservableSet<IToolData>;
     protected readonly _toolSets: ObservableSet<IToolSet>;
@@ -321,7 +356,7 @@ export declare class ToolSet implements IToolSet {
      * A homogenous tool set only contains tools from the same source as the tool set itself
      */
     readonly isHomogenous: IObservable<boolean>;
-    constructor(id: string, referenceName: string, icon: ThemeIcon, source: ToolDataSource, description: string | undefined, legacyFullNames: string[] | undefined, _contextKeyService: IContextKeyService);
+    constructor(id: string, referenceName: string, icon: ThemeIcon, source: ToolDataSource, description: string | undefined, detail: string | undefined, legacyFullNames: string[] | undefined, deprecated: boolean | undefined, hiddenInToolsPicker: boolean | undefined, _contextKeyService: IContextKeyService);
     addTool(data: IToolData, tx?: ITransaction): IDisposable;
     addToolSet(toolSet: IToolSet, tx?: ITransaction): IDisposable;
     getTools(r?: IReader): Iterable<IToolData>;
@@ -335,7 +370,10 @@ export declare class ToolSetForModel {
     get icon(): ThemeIcon;
     get source(): ToolDataSource;
     get description(): string | undefined;
+    get detail(): string | undefined;
     get legacyFullNames(): string[] | undefined;
+    get deprecated(): boolean | undefined;
+    get hiddenInToolsPicker(): boolean | undefined;
     constructor(_toolSet: IToolSet, model: ILanguageModelChatMetadata | undefined, toolFilter?: ((toolData: IToolData) => boolean) | undefined);
     getTools(r?: IReader): Iterable<IToolData>;
 }