@codingame/monaco-vscode-api 28.4.1 → 29.1.0

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

@@ -35,6 +35,7 @@ const BaseModelDescription = `Launch a new agent to handle complex, multi-step t
 - Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
 - The agent's outputs should generally be trusted
 - Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user\'s intent`;
+const RUN_SUBAGENT_MAX_NESTING_DEPTH = 5;
 let RunSubagentTool = class RunSubagentTool extends Disposable {
     static {
         RunSubagentTool_1 = this;
@@ -66,6 +67,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         this.instantiationService = instantiationService;
         this.productService = productService;
         this._resolvedModels = ( new Map());
+        this._sessionDepth = ( new Map());
         this.onDidUpdateToolData = Event.filter(
             this.configurationService.onDidChangeConfiguration,
             e => e.affectsConfiguration(ChatConfiguration.SubagentToolCustomAgents)
@@ -98,9 +100,9 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             id: RunSubagentTool_1.Id,
             toolReferenceName: VSCodeToolReference.runSubagent,
             icon: ThemeIcon.fromId(Codicon.organization.id),
-            displayName: ( localize(7374, "Run Subagent")),
+            displayName: ( localize(7596, "Run Subagent")),
             userDescription: ( localize(
-                7375,
+                7597,
                 "Run a task within an isolated subagent context to enable efficient organization of tasks and context window management."
             )),
             modelDescription: modelDescription,
@@ -181,7 +183,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                 }
             }
             const markdownParts = [];
-            const subAgentInvocationId = invocation.callId ?? `subagent-${generateUuid()}`;
+            const subAgentInvocationId = invocation.chatStreamToolCallId ?? invocation.callId ?? `subagent-${generateUuid()}`;
             let inEdit = false;
             const progressCallback = parts => {
                 for (const part of parts) {
@@ -218,10 +220,24 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                     }
                 }
             };
-            if (modeTools) {
-                modeTools[RunSubagentTool_1.Id] = false;
-                modeTools[ManageTodoListToolToolId] = false;
-                modeTools["copilot_askQuestions"] = false;
+            const allowInvocationsFromSubagents = this.configurationService.getValue(ChatConfiguration.SubagentsAllowInvocationsFromSubagents) ?? false;
+            const maxDepth = allowInvocationsFromSubagents ? RUN_SUBAGENT_MAX_NESTING_DEPTH : 0;
+            const sessionKey = ( invocation.context.sessionResource.toString());
+            const currentDepth = this._sessionDepth.get(sessionKey) ?? 0;
+            const depthAllowed = currentDepth + 1 <= maxDepth;
+            if (!modeTools) {
+                modeTools = {};
+            }
+            const existingRunSubagentEnablement = modeTools[RunSubagentTool_1.Id];
+            if (existingRunSubagentEnablement !== false) {
+                modeTools[RunSubagentTool_1.Id] = depthAllowed;
+            }
+            modeTools[ManageTodoListToolToolId] = false;
+            modeTools["copilot_askQuestions"] = false;
+            if (maxDepth > 0) {
+                this.logService.debug(
+                    `RunSubagentTool: Nested subagents enabling ${modeTools[RunSubagentTool_1.Id]}: session ${sessionKey}, currentDepth: ${currentDepth}, maxDepth: ${maxDepth}, allowInvocationsFromSubagents: ${allowInvocationsFromSubagents}`
+                );
             }
             const variableSet = ( new ChatRequestVariableSet());
             const computer = this.instantiationService.createInstance(
@@ -259,9 +275,10 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                     variables: variableSet.asArray()
                 },
                 location: ChatAgentLocation.Chat,
-                subAgentInvocationId: invocation.callId,
+                subAgentInvocationId: subAgentInvocationId,
                 subAgentName: subAgentName,
                 userSelectedModelId: modeModelId,
+                modelConfiguration: modeModelId ? this.languageModelsService.getModelConfiguration(modeModelId) : undefined,
                 userSelectedTools: modeTools,
                 modeInstructions,
                 parentRequestId: invocation.chatRequestId,
@@ -273,8 +290,19 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                     markdownParts.length = 0;
                 }
             }));
-            const result = await this.chatAgentService.invokeAgent(defaultAgent.id, agentRequest, progressCallback, [], token);
-            if (result.errorDetails) {
+            this._sessionDepth.set(sessionKey, currentDepth + 1);
+            let result;
+            try {
+                result = await this.chatAgentService.invokeAgent(defaultAgent.id, agentRequest, progressCallback, [], token);
+            } finally {
+                const newDepth = (this._sessionDepth.get(sessionKey) ?? 1) - 1;
+                if (newDepth <= 0) {
+                    this._sessionDepth.delete(sessionKey);
+                } else {
+                    this._sessionDepth.set(sessionKey, newDepth);
+                }
+            }
+            if (result?.errorDetails) {
                 return createToolSimpleTextResult(`Agent error: ${result.errorDetails.message}`);
             }
             const resultText = markdownParts.join("").replace(/^\n*```\n+```\n*/g, "").trim() || "Agent completed with no output";
@@ -358,4 +386,4 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
 };
 RunSubagentTool = RunSubagentTool_1 = ( __decorate([( __param(0, IChatAgentService)), ( __param(1, IChatService)), ( __param(2, ILanguageModelToolsService)), ( __param(3, ILanguageModelsService)), ( __param(4, ILogService)), ( __param(5, ILanguageModelToolsService)), ( __param(6, IConfigurationService)), ( __param(7, IPromptsService)), ( __param(8, IInstantiationService)), ( __param(9, IProductService))], RunSubagentTool));
 
-export { RunSubagentTool };
+export { RUN_SUBAGENT_MAX_NESTING_DEPTH, RunSubagentTool };

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

@@ -0,0 +1,13 @@
+import { CancellationToken } from "../../../../../../base/common/cancellation.js";
+import { IFileService } from "../../../../../../platform/files/common/files.service.js";
+import { IToolData, IToolImpl, IToolInvocation, IToolResult, IToolInvocationPreparationContext, IPreparedToolInvocation } from "../languageModelToolsService.js";
+import { IChatArtifactsService } from "../chatArtifactsService.service.js";
+export declare const SetArtifactsToolId = "setArtifacts";
+export declare const SetArtifactsToolData: IToolData;
+export declare class SetArtifactsTool implements IToolImpl {
+    private readonly _chatArtifactsService;
+    private readonly _fileService;
+    constructor(_chatArtifactsService: IChatArtifactsService, _fileService: IFileService);
+    prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: never, _progress: never, _token: CancellationToken): Promise<IToolResult>;
+}

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

@@ -0,0 +1,103 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { URI } from '../../../../../../base/common/uri.js';
+import { localize } from '../../../../../../nls.js';
+import { IFileService } from '../../../../../../platform/files/common/files.service.js';
+import { ToolDataSource, ToolInvocationPresentation } from '../languageModelToolsService.js';
+import { IChatArtifactsService } from '../chatArtifactsService.service.js';
+import { MarkdownString } from '../../../../../../base/common/htmlContent.js';
+
+const SetArtifactsToolId = "setArtifacts";
+const inputSchema = {
+    type: "object",
+    properties: {
+        artifacts: {
+            type: "array",
+            description: "The complete list of artifacts for this session. Overwrites any existing artifacts.",
+            items: {
+                type: "object",
+                properties: {
+                    label: {
+                        type: "string",
+                        description: "Display label for the artifact."
+                    },
+                    uri: {
+                        type: "string",
+                        description: "Fully qualified URI of the artifact (e.g. https://localhost:3000 or file:///path/to/file). Must include the scheme."
+                    },
+                    type: {
+                        type: "string",
+                        enum: ["devServer", "screenshot", "plan"],
+                        description: "The type of artifact."
+                    }
+                },
+                required: ["label"]
+            }
+        }
+    },
+    required: ["artifacts"]
+};
+const SetArtifactsToolData = {
+    id: SetArtifactsToolId,
+    toolReferenceName: "artifacts",
+    legacyToolReferenceFullNames: ["Set Session Artifacts"],
+    displayName: ( localize(7598, "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. Use this to surface important links, screenshots, plans, drafts, or temporary markdown documents to the user. 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.",
+    canBeReferencedInPrompt: true,
+    source: ToolDataSource.Internal,
+    inputSchema
+};
+let SetArtifactsTool = class SetArtifactsTool {
+    constructor(_chatArtifactsService, _fileService) {
+        this._chatArtifactsService = _chatArtifactsService;
+        this._fileService = _fileService;
+    }
+    async prepareToolInvocation(_context, _token) {
+        return {
+            pastTenseMessage: ( new MarkdownString(( localize(7599, "Updated session artifacts")))),
+            presentation: ToolInvocationPresentation.Hidden
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const args = invocation.parameters;
+        const chatSessionResource = invocation.context?.sessionResource;
+        if (!chatSessionResource) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: No session resource available"
+                }]
+            };
+        }
+        const artifacts = [];
+        for (const a of args.artifacts ?? []) {
+            let uri = a.uri;
+            if (!uri) {
+                uri = "";
+            }
+            if (uri) {
+                const parsed = ( URI.parse(uri));
+                if (parsed.scheme !== "http" && parsed.scheme !== "https") {
+                    if (!(await this._fileService.exists(parsed))) {
+                        throw ( new Error(( localize(7600, "Artifact URI does not exist: {0}", uri))));
+                    }
+                }
+            }
+            artifacts.push({
+                label: a.label,
+                uri,
+                type: a.type
+            });
+        }
+        this._chatArtifactsService.setArtifacts(chatSessionResource, artifacts);
+        return {
+            content: [{
+                kind: "text",
+                value: ( localize(7601, "Set {0} artifact(s)", artifacts.length))
+            }]
+        };
+    }
+};
+SetArtifactsTool = ( __decorate([( __param(0, IChatArtifactsService)), ( __param(1, IFileService))], SetArtifactsTool));
+
+export { SetArtifactsTool, SetArtifactsToolData, SetArtifactsToolId };

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

@@ -1,9 +1,10 @@
 import { Disposable } from "../../../../../../base/common/lifecycle.js";
+import { IConfigurationService } from "../../../../../../platform/configuration/common/configuration.service.js";
 import { IInstantiationService } from "../../../../../../platform/instantiation/common/instantiation.js";
 import { IWorkbenchContribution } from "../../../../../common/contributions.js";
 import { ILanguageModelToolsService } from "../languageModelToolsService.service.js";
 export declare class BuiltinToolsContribution extends Disposable implements IWorkbenchContribution {
     static readonly ID = "chat.builtinTools";
-    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService);
+    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService, configurationService: IConfigurationService);
 }
 export declare const InternalFetchWebPageToolId = "vscode_fetchWebPage_internal";

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

@@ -1,21 +1,23 @@
 
 import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from '../../../../../../base/common/lifecycle.js';
+import { Disposable, MutableDisposable } from '../../../../../../base/common/lifecycle.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { ChatConfiguration } from '../../constants.js';
 import { ILanguageModelToolsService } from '../languageModelToolsService.service.js';
 import { AskQuestionsTool, AskQuestionsToolData } from './askQuestionsTool.js';
-import { ConfirmationTool, ConfirmationToolData, ConfirmationToolWithOptionsData } from './confirmationTool.js';
+import { ConfirmationTool, ConfirmationToolData, ConfirmationToolWithOptionsData, ModifiedFilesConfirmationTool, ModifiedFilesConfirmationToolData } from './confirmationTool.js';
 import { EditTool, EditToolData } from './editFileTool.js';
 import { createManageTodoListToolData, ManageTodoListTool } from './manageTodoListTool.js';
-import { ResolveDebugEventDetailsTool, ResolveDebugEventDetailsToolData } from './resolveDebugEventDetailsTool.js';
 import { RunSubagentTool } from './runSubagentTool.js';
+import { SetArtifactsTool, SetArtifactsToolData } from './setArtifactsTool.js';
 import { TaskCompleteTool, TaskCompleteToolData } from './taskCompleteTool.js';
 
 let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable {
     static {
         this.ID = "chat.builtinTools";
     }
-    constructor(toolsService, instantiationService) {
+    constructor(toolsService, instantiationService, configurationService) {
         super();
         const editTool = instantiationService.createInstance(EditTool);
         this._register(toolsService.registerTool(EditToolData, editTool));
@@ -30,13 +32,29 @@ let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable
         this._register(
             toolsService.registerTool(ConfirmationToolWithOptionsData, confirmationTool)
         );
-        const taskCompleteTool = instantiationService.createInstance(TaskCompleteTool);
-        this._register(toolsService.registerTool(TaskCompleteToolData, taskCompleteTool));
-        const resolveDebugEventDetailsTool = instantiationService.createInstance(ResolveDebugEventDetailsTool);
+        const modifiedFilesConfirmationTool = instantiationService.createInstance(ModifiedFilesConfirmationTool);
         this._register(
-            toolsService.registerTool(ResolveDebugEventDetailsToolData, resolveDebugEventDetailsTool)
+            toolsService.registerTool(ModifiedFilesConfirmationToolData, modifiedFilesConfirmationTool)
         );
-        this._register(toolsService.readToolSet.addTool(ResolveDebugEventDetailsToolData));
+        const taskCompleteTool = instantiationService.createInstance(TaskCompleteTool);
+        this._register(toolsService.registerTool(TaskCompleteToolData, taskCompleteTool));
+        const setArtifactsTool = instantiationService.createInstance(SetArtifactsTool);
+        const setArtifactsRegistration = this._register(( new MutableDisposable()));
+        const updateArtifactsRegistration = () => {
+            if (configurationService.getValue(ChatConfiguration.ArtifactsEnabled)) {
+                if (!setArtifactsRegistration.value) {
+                    setArtifactsRegistration.value = toolsService.registerTool(SetArtifactsToolData, setArtifactsTool);
+                }
+            } else {
+                setArtifactsRegistration.clear();
+            }
+        };
+        updateArtifactsRegistration();
+        this._register(configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(ChatConfiguration.ArtifactsEnabled)) {
+                updateArtifactsRegistration();
+            }
+        }));
         const runSubagentTool = this._register(instantiationService.createInstance(RunSubagentTool));
         let runSubagentRegistration;
         let toolSetRegistration;
@@ -58,7 +76,7 @@ let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable
         });
     }
 };
-BuiltinToolsContribution = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IInstantiationService))], BuiltinToolsContribution));
+BuiltinToolsContribution = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IInstantiationService)), ( __param(2, IConfigurationService))], BuiltinToolsContribution));
 const InternalFetchWebPageToolId = "vscode_fetchWebPage_internal";
 
 export { BuiltinToolsContribution, InternalFetchWebPageToolId };

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

@@ -0,0 +1,13 @@
+import { Event } from "../../../../../base/common/event.js";
+import { IObservable } from "../../../../../base/common/observable.js";
+import { URI } from "../../../../../base/common/uri.js";
+import { IChatArtifact } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService";
+export declare const IChatArtifactsService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatArtifactsService>;
+export interface IChatArtifactsService {
+    readonly _serviceBrand: undefined;
+    readonly onDidUpdateArtifacts: Event<URI>;
+    getArtifacts(sessionResource: URI): readonly IChatArtifact[];
+    setArtifacts(sessionResource: URI, artifacts: IChatArtifact[]): void;
+    migrateArtifacts(oldSessionResource: URI, newSessionResource: URI): void;
+    artifacts(sessionResource: URI): IObservable<readonly IChatArtifact[]>;
+}

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

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+
+const IChatArtifactsService = ( createDecorator("chatArtifactsService"));
+
+export { IChatArtifactsService };

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

@@ -2,6 +2,12 @@ import { URI } from "../../../../../base/common/uri.js";
 import { IQuickInputButton, IQuickTreeItem } from "../../../../../platform/quickinput/common/quickInput.js";
 import { ConfirmedReason } from "../chatService/chatService.js";
 import { ToolDataSource } from "./languageModelToolsService.js";
+/**
+ * Computes a stable, bounded key for a tool+parameters combination
+ * using SHA-256 via SubtleCrypto. The resulting hex digest ensures
+ * raw parameter values are never leaked into storage.
+ */
+export declare function computeCombinationKey(toolId: string, parameters: unknown): Promise<string>;
 export interface ILanguageModelToolConfirmationActions {
     /** Label for the action */
     label: string;
@@ -19,6 +25,13 @@ export interface ILanguageModelToolConfirmationRef {
     source: ToolDataSource;
     parameters: unknown;
     chatSessionResource?: URI;
+    /** When set, the confirmation service will offer combination-level approval actions */
+    combination?: {
+        /** Human-readable label for the approval option */
+        label: string;
+        /** Precomputed SHA-256 key for the combination */
+        key: string;
+    };
 }
 export interface ILanguageModelToolConfirmationActionProducer {
     getPreConfirmAction(ref: ILanguageModelToolConfirmationRef): ConfirmedReason | undefined;

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

@@ -0,0 +1,11 @@
+
+
+async function computeCombinationKey(toolId, parameters) {
+    const input = toolId + ":" + JSON.stringify(parameters);
+    const encoded = ( new TextEncoder()).encode(input);
+    const buffer = await crypto.subtle.digest("SHA-256", encoded);
+    const hashHex = ( Array.from(( new Uint8Array(buffer))).map(b => ( b.toString(16)).padStart(2, "0"))).join("");
+    return toolId + ":combination:" + hashHex;
+}
+
+export { computeCombinationKey };

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

@@ -30,7 +30,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
     },
     jsonSchema: {
         description: ( localize(
-            7376,
+            7602,
             "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 +56,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
             properties: {
                 name: {
                     description: ( localize(
-                        7377,
+                        7603,
                         "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 +64,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 toolReferenceName: {
                     markdownDescription: ( localize(
-                        7378,
+                        7604,
                         "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 +73,32 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 displayName: {
                     description: ( localize(
-                        7379,
+                        7605,
                         "A human-readable name for this tool that may be used to describe it in the UI."
                     )),
                     type: "string"
                 },
                 userDescription: {
-                    description: ( localize(7380, "A description of this tool that may be shown to the user.")),
+                    description: ( localize(7606, "A description of this tool that may be shown to the user.")),
                     type: "string"
                 },
                 modelDescription: {
                     description: ( localize(
-                        7381,
+                        7607,
                         "A description of this tool that may be used by a language model to select it."
                     )),
                     type: "string"
                 },
                 inputSchema: {
                     description: ( localize(
-                        7382,
+                        7608,
                         "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(
-                        7383,
+                        7609,
                         "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 +106,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 icon: {
                     markdownDescription: ( localize(
-                        7384,
+                        7610,
                         "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 +115,11 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(7385, "Icon path when a light theme is used")),
+                                description: ( localize(7611, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(7386, "Icon path when a dark theme is used")),
+                                description: ( localize(7612, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
@@ -127,14 +127,14 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 when: {
                     markdownDescription: ( localize(
-                        7387,
+                        7613,
                         "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(
-                        7388,
+                        7614,
                         "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 +152,7 @@ const languageModelToolSetsExtensionPoint = ExtensionsRegistry.registerExtension
     deps: [languageModelToolsExtensionPoint],
     jsonSchema: {
         description: ( localize(
-            7389,
+            7615,
             "Contributes a set of language model tools that can be used together."
         )),
         type: "array",
@@ -170,23 +170,23 @@ const languageModelToolSetsExtensionPoint = ExtensionsRegistry.registerExtension
             properties: {
                 name: {
                     description: ( localize(
-                        7390,
+                        7616,
                         "A name for this tool set. Used as reference and should not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 description: {
-                    description: ( localize(7391, "A description of this tool set.")),
+                    description: ( localize(7617, "A description of this tool set.")),
                     type: "string"
                 },
                 icon: {
-                    markdownDescription: ( localize(7392, "An icon that represents this tool set, like `$(zap)`")),
+                    markdownDescription: ( localize(7618, "An icon that represents this tool set, like {0}", "`$(zap)`")),
                     type: "string"
                 },
                 tools: {
                     markdownDescription: ( localize(
-                        7393,
+                        7619,
                         "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",
@@ -232,18 +232,18 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                         );
                         continue;
                     }
-                    if ((rawTool.name.startsWith("copilot_") || rawTool.name.startsWith("vscode_")) && !isProposedApiEnabled(extension.description, "chatParticipantPrivate")) {
+                    if ((rawTool.name.startsWith("copilot_") || rawTool.name.startsWith("vscode_")) && !isProposedApiEnabled(extension.description)) {
                         extension.collector.error(
                             `Extension '${extension.description.identifier.value}' CANNOT register tool with name starting with "vscode_" or "copilot_"`
                         );
                         continue;
                     }
-                    if (rawTool.tags?.some(tag => tag.startsWith("copilot_") || tag.startsWith("vscode_")) && !isProposedApiEnabled(extension.description, "chatParticipantPrivate")) {
+                    if (rawTool.tags?.some(tag => tag.startsWith("copilot_") || tag.startsWith("vscode_")) && !isProposedApiEnabled(extension.description)) {
                         extension.collector.error(
                             `Extension '${extension.description.identifier.value}' CANNOT register tool with tags starting with "vscode_" or "copilot_"`
                         );
                     }
-                    if (rawTool.legacyToolReferenceFullNames && !isProposedApiEnabled(extension.description, "chatParticipantPrivate")) {
+                    if (rawTool.legacyToolReferenceFullNames && !isProposedApiEnabled(extension.description)) {
                         extension.collector.error(
                             `Extension '${extension.description.identifier.value}' CANNOT use 'legacyToolReferenceFullNames' without the 'chatParticipantPrivate' API proposal enabled`
                         );
@@ -265,7 +265,7 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                     const isBuiltinTool = productService.defaultChatAgent?.chatExtensionId ? ExtensionIdentifier.equals(
                         extension.description.identifier,
                         productService.defaultChatAgent.chatExtensionId
-                    ) : isProposedApiEnabled(extension.description, "chatParticipantPrivate");
+                    ) : isProposedApiEnabled(extension.description);
                     const source = isBuiltinTool ? ToolDataSource.Internal : {
                         type: "extension",
                         label: extension.description.displayName ?? extension.description.name,
@@ -296,7 +296,7 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
         });
         languageModelToolSetsExtensionPoint.setHandler((_extensions, delta) => {
             for (const extension of delta.added) {
-                if (!isProposedApiEnabled(extension.description, "contribLanguageModelToolSets")) {
+                if (!isProposedApiEnabled(extension.description)) {
                     extension.collector.error(
                         `Extension '${extension.description.identifier.value}' CANNOT register language model tools because the 'contribLanguageModelToolSets' API proposal is not enabled.`
                     );
@@ -305,7 +305,7 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                 const isBuiltinTool = productService.defaultChatAgent?.chatExtensionId ? ExtensionIdentifier.equals(
                     extension.description.identifier,
                     productService.defaultChatAgent.chatExtensionId
-                ) : isProposedApiEnabled(extension.description, "chatParticipantPrivate");
+                ) : isProposedApiEnabled(extension.description);
                 const source = isBuiltinTool ? ToolDataSource.Internal : {
                     type: "extension",
                     label: extension.description.displayName ?? extension.description.name,
@@ -316,7 +316,7 @@ let LanguageModelToolsExtensionPointHandler = class LanguageModelToolsExtensionP
                         extension.collector.error(`Tool set '${toolSet.name}' CANNOT have an empty name`);
                         continue;
                     }
-                    if (toolSet.legacyFullNames && !isProposedApiEnabled(extension.description, "contribLanguageModelToolSets")) {
+                    if (toolSet.legacyFullNames && !isProposedApiEnabled(extension.description)) {
                         extension.collector.error(
                             `Tool set '${toolSet.name}' CANNOT use 'legacyFullNames' without the 'contribLanguageModelToolSets' API proposal enabled`
                         );
@@ -426,7 +426,7 @@ class LanguageModelToolDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(7394, "Name")), ( localize(7395, "Display Name")), ( localize(7396, "Description"))];
+        const headers = [( localize(7620, "Name")), ( localize(7621, "Display Name")), ( localize(7622, "Description"))];
         const rows = ( contribs.map(t => {
             return [( new MarkdownString(`\`${t.name}\``)), t.displayName, t.userDescription ?? t.modelDescription];
         }));
@@ -441,7 +441,7 @@ class LanguageModelToolDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelTools",
-    label: ( localize(7397, "Language Model Tools")),
+    label: ( localize(7623, "Language Model Tools")),
     access: {
         canToggle: false
     },
@@ -466,7 +466,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(7398, "Name")), ( localize(7399, "Reference Name")), ( localize(7400, "Tools")), ( localize(7401, "Description"))];
+        const headers = [( localize(7624, "Name")), ( localize(7625, "Reference Name")), ( localize(7626, "Tools")), ( localize(7627, "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 +481,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelToolSets",
-    label: ( localize(7402, "Language Model Tool Sets")),
+    label: ( localize(7628, "Language Model Tool Sets")),
     access: {
         canToggle: false
     },