@codingame/monaco-vscode-api 30.0.1 → 31.0.1

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

@@ -2,7 +2,7 @@
 import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
 import { CancellationToken } from '../../../../../../base/common/cancellation.js';
 import { Codicon } from '../../../../../../base/common/codicons.js';
-import { Event } from '../../../../../../base/common/event.js';
+import { Emitter, Event } from '../../../../../../base/common/event.js';
 import { MarkdownString } from '../../../../../../base/common/htmlContent.js';
 import { Disposable, DisposableStore } from '../../../../../../base/common/lifecycle.js';
 import { ThemeIcon } from '../../../../../../base/common/themables.js';
@@ -14,8 +14,10 @@ import { ILogService } from '../../../../../../platform/log/common/log.service.j
 import { IProductService } from '../../../../../../platform/product/common/productService.service.js';
 import { ChatRequestVariableSet } from '../../attachments/chatVariableEntries.js';
 import { IChatService } from '../../chatService/chatService.service.js';
-import { ChatConfiguration, ChatAgentLocation, ChatModeKind } from '../../constants.js';
+import { ChatConfiguration, ChatAgentLocation, ChatModeKind, GeneralPurposeAgentName } from '../../constants.js';
+import { ILanguageModelChatMetadata } from '../../languageModels.js';
 import { ILanguageModelsService } from '../../languageModels.service.js';
+import { getChatSessionType } from '../../model/chatUri.js';
 import { IChatAgentService } from '../../participants/chatAgents.service.js';
 import { ComputeAutomaticInstructions } from '../../promptSyntax/computeAutomaticInstructions.js';
 import { mergeHooks } from '../../promptSyntax/hookSchema.js';
@@ -34,7 +36,8 @@ const BaseModelDescription = `Launch a new agent to handle complex, multi-step t
 - When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
 - 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`;
+- 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
+- If the user asks for a certain agent, you MUST provide that EXACT agent name (case-sensitive) to invoke that specific agent.`;
 const RUN_SUBAGENT_MAX_NESTING_DEPTH = 5;
 let RunSubagentTool = class RunSubagentTool extends Disposable {
     static {
@@ -49,7 +52,6 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         languageModelToolsService,
         languageModelsService,
         logService,
-        toolsService,
         configurationService,
         promptsService,
         instantiationService,
@@ -61,48 +63,56 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         this.languageModelToolsService = languageModelToolsService;
         this.languageModelsService = languageModelsService;
         this.logService = logService;
-        this.toolsService = toolsService;
         this.configurationService = configurationService;
         this.promptsService = promptsService;
         this.instantiationService = instantiationService;
         this.productService = productService;
+        this._onDidUpdateToolData = this._register(( new Emitter()));
+        this.onDidUpdateToolData = this._onDidUpdateToolData.event;
         this._resolvedModels = ( new Map());
         this._sessionDepth = ( new Map());
-        this.onDidUpdateToolData = Event.filter(
+        this._register(Event.filter(
             this.configurationService.onDidChangeConfiguration,
-            e => e.affectsConfiguration(ChatConfiguration.SubagentToolCustomAgents)
-        );
+            e => e.affectsConfiguration(ChatConfiguration.GeneralPurposeAgentEnabled)
+        )(() => this._onDidUpdateToolData.fire()));
     }
     getToolData() {
-        let modelDescription = BaseModelDescription;
-        const inputSchema = {
-            type: "object",
-            properties: {
-                prompt: {
-                    type: "string",
-                    description: "A detailed description of the task for the agent to perform"
-                },
-                description: {
-                    type: "string",
-                    description: "A short (3-5 word) description of the task"
-                }
+        const modelDescription = BaseModelDescription;
+        const generalPurposeAgentEnabled = this.configurationService.getValue(ChatConfiguration.GeneralPurposeAgentEnabled);
+        const properties = {
+            prompt: {
+                type: "string",
+                description: "A detailed description of the task for the agent to perform"
             },
-            required: ["prompt", "description"]
-        };
-        if (this.configurationService.getValue(ChatConfiguration.SubagentToolCustomAgents)) {
-            inputSchema.properties.agentName = {
+            description: {
                 type: "string",
-                description: "Optional name of a specific agent to invoke. If not provided, uses the current agent."
-            };
-            modelDescription += `\n- If the user asks for a certain agent, you MUST provide that EXACT agent name (case-sensitive) to invoke that specific agent.`;
+                description: "A short (3-5 word) description of the task"
+            }
+        };
+        properties.agentName = {
+            type: "string",
+            description: generalPurposeAgentEnabled ? "Name of the agent to invoke." : "Optional name of a specific agent to invoke. If not provided, uses the current agent."
+        };
+        properties.model = {
+            type: "string",
+            description: "Optional model for the subagent. Format: \"Model Name (Vendor)\", vendor is usually \"copilot\". Only use to enforce a specific model."
+        };
+        const required = ["prompt", "description"];
+        if (generalPurposeAgentEnabled) {
+            required.push("agentName");
         }
+        const inputSchema = {
+            type: "object",
+            properties,
+            required
+        };
         const runSubagentToolData = {
             id: RunSubagentTool_1.Id,
             toolReferenceName: VSCodeToolReference.runSubagent,
             icon: ThemeIcon.fromId(Codicon.organization.id),
-            displayName: ( localize(7661, "Run Subagent")),
+            displayName: ( localize(7777, "Run Subagent")),
             userDescription: ( localize(
-                7662,
+                7778,
                 "Run a task within an isolated subagent context to enable efficient organization of tasks and context window management."
             )),
             modelDescription: modelDescription,
@@ -136,7 +146,10 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             let subagent;
             let resolvedModelName;
             const subAgentName = args.agentName;
-            if (subAgentName) {
+            const gpEnabled = this.configurationService.getValue(ChatConfiguration.GeneralPurposeAgentEnabled);
+            const isGeneralPurpose = gpEnabled && (!subAgentName || subAgentName === GeneralPurposeAgentName);
+            const effectiveSubAgentName = isGeneralPurpose ? GeneralPurposeAgentName : subAgentName;
+            if (subAgentName && !isGeneralPurpose) {
                 subagent = await this.getSubAgentByName(subAgentName);
                 if (subagent) {
                     const cached = this._resolvedModels.get(invocation.callId);
@@ -145,7 +158,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                         modeModelId = cached.modeModelId;
                         resolvedModelName = cached.resolvedModelName;
                     } else {
-                        const resolved = this.resolveSubagentModel(subagent, invocation.modelId);
+                        const resolved = this.resolveSubagentModel(subagent, invocation.modelId, args.model);
                         modeModelId = resolved.modeModelId;
                         resolvedModelName = resolved.resolvedModelName;
                     }
@@ -163,23 +176,26 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                     modeInstructions = instructions && {
                         name: subAgentName,
                         content: instructions.content,
-                        toolReferences: this.toolsService.toToolReferences(instructions.toolReferences),
+                        toolReferences: this.languageModelToolsService.toToolReferences(instructions.toolReferences),
                         metadata: instructions.metadata,
                         isBuiltin: isBuiltinAgent(subagent.source, subagent.uri, this.productService)
                     };
                 } else {
-                    throw ( new Error(
-                        `Requested agent '${subAgentName}' not found. Try again with the correct agent name, or omit the agentName to use the current agent.`
-                    ));
+                    this._resolvedModels.delete(invocation.callId);
+                    const baseHint = " Try again with the correct agent name, or omit agentName to use the current agent.";
+                    const gpHint = gpEnabled ? ` Additionally, you can use '${GeneralPurposeAgentName}' for a full-capability agent.` : "";
+                    throw ( new Error(`Requested agent '${subAgentName}' not found.${baseHint}${gpHint}`));
                 }
             } else {
                 const cached = this._resolvedModels.get(invocation.callId);
                 if (cached) {
                     this._resolvedModels.delete(invocation.callId);
+                    modeModelId = cached.modeModelId;
                     resolvedModelName = cached.resolvedModelName;
                 } else {
-                    const resolvedModelMetadata = modeModelId ? this.languageModelsService.lookupLanguageModel(modeModelId) : undefined;
-                    resolvedModelName = resolvedModelMetadata?.name;
+                    const resolved = this.resolveSubagentModel(undefined, invocation.modelId, args.model);
+                    modeModelId = resolved.modeModelId;
+                    resolvedModelName = resolved.resolvedModelName;
                 }
             }
             const markdownParts = [];
@@ -245,12 +261,12 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                 ChatModeKind.Agent,
                 modeTools,
                 undefined,
-                invocation.context.sessionResource
+                getChatSessionType(invocation.context.sessionResource)
             );
             await computer.collect(variableSet, token);
             let collectedHooks;
             try {
-                const info = await this.promptsService.getHooks(token, invocation.context.sessionResource);
+                const info = await this.promptsService.getHooks(token);
                 collectedHooks = info?.hooks;
             } catch (error) {
                 this.logService.warn("[ChatService] Failed to collect hooks:", error);
@@ -276,7 +292,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                 },
                 location: ChatAgentLocation.Chat,
                 subAgentInvocationId: subAgentInvocationId,
-                subAgentName: subAgentName,
+                subAgentName: effectiveSubAgentName,
                 userSelectedModelId: modeModelId,
                 modelConfiguration: modeModelId ? this.languageModelsService.getModelConfiguration(modeModelId) : undefined,
                 userSelectedTools: modeTools,
@@ -334,31 +350,94 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         const agents = await this.promptsService.getCustomAgents(CancellationToken.None);
         return agents.find(agent => agent.name === name);
     }
-    resolveSubagentModel(subagent, mainModelId) {
+    checkMultiplierConstraint(modelId, mainModelId) {
+        if (!mainModelId || modelId === mainModelId) {
+            return {
+                exceeds: false
+            };
+        }
+        const mainModelMetadata = this.languageModelsService.lookupLanguageModel(mainModelId);
+        const modelMetadata = this.languageModelsService.lookupLanguageModel(modelId);
+        const mainMultiplier = mainModelMetadata?.multiplierNumeric;
+        const modelMultiplier = modelMetadata?.multiplierNumeric;
+        if (mainMultiplier !== undefined && modelMultiplier !== undefined && modelMultiplier > mainMultiplier) {
+            return {
+                exceeds: true,
+                reason: `exceeds the current model's cost tier (${modelMultiplier}x vs ${mainMultiplier}x)`
+            };
+        }
+        return {
+            exceeds: false
+        };
+    }
+    getAvailableModelsInfo(mainModelId) {
+        const models = ( this.languageModelsService.getLanguageModelIds().map(id => ({
+            id,
+            metadata: this.languageModelsService.lookupLanguageModel(id)
+        }))).filter(
+            m => !!m.metadata && ILanguageModelChatMetadata.suitableForAgentMode(m.metadata) && m.metadata.isUserSelectable !== false && !m.metadata.targetChatSessionType
+        );
+        if (models.length === 0) {
+            return "No models available.";
+        }
+        const available = [];
+        const unavailableDueToMultiplier = [];
+        for (const {
+            id,
+            metadata
+        } of models) {
+            const qualifiedName = ILanguageModelChatMetadata.asQualifiedName(metadata);
+            const check = this.checkMultiplierConstraint(id, mainModelId);
+            if (check.exceeds) {
+                unavailableDueToMultiplier.push(qualifiedName);
+            } else {
+                available.push(qualifiedName);
+            }
+        }
+        const parts = [];
+        if (available.length > 0) {
+            parts.push(`Available models: ${available.join(", ")}`);
+        }
+        if (unavailableDueToMultiplier.length > 0) {
+            parts.push(
+                `Unavailable (exceeds current model's cost tier): ${unavailableDueToMultiplier.join(", ")}`
+            );
+        }
+        return parts.join(". ") || "No models available.";
+    }
+    resolveSubagentModel(subagent, mainModelId, explicitModelQualifiedName) {
         let modeModelId = mainModelId;
-        if (subagent) {
+        let explicitModelResolved = false;
+        if (explicitModelQualifiedName) {
+            const lm = this.languageModelsService.lookupLanguageModelByQualifiedName(explicitModelQualifiedName);
+            if (lm?.identifier) {
+                modeModelId = lm.identifier;
+                explicitModelResolved = true;
+            } else {
+                throw ( new Error(
+                    `Requested model '${explicitModelQualifiedName}' not found. ${this.getAvailableModelsInfo(mainModelId)}`
+                ));
+            }
+        }
+        if (subagent && !explicitModelResolved) {
             const modeModelQualifiedNames = subagent.model;
             if (modeModelQualifiedNames) {
-                outer:
                 for (const qualifiedName of modeModelQualifiedNames) {
                     const lmByQualifiedName = this.languageModelsService.lookupLanguageModelByQualifiedName(qualifiedName);
                     if (lmByQualifiedName?.identifier) {
                         modeModelId = lmByQualifiedName.identifier;
-                        break outer;
+                        break;
                     }
                 }
             }
-            if (modeModelId && modeModelId !== mainModelId) {
-                const mainModelMetadata = mainModelId ? this.languageModelsService.lookupLanguageModel(mainModelId) : undefined;
-                const subagentModelMetadata = this.languageModelsService.lookupLanguageModel(modeModelId);
-                const mainMultiplier = mainModelMetadata?.multiplierNumeric;
-                const subagentMultiplier = subagentModelMetadata?.multiplierNumeric;
-                if (mainMultiplier !== undefined && subagentMultiplier !== undefined && subagentMultiplier > mainMultiplier) {
-                    this.logService.warn(
-                        `[RunSubagentTool] Subagent '${subagent.name}' requested model '${subagentModelMetadata?.name}' (multiplier: ${subagentMultiplier}) which has a larger multiplier than the main agent model '${mainModelMetadata?.name}' (multiplier: ${mainMultiplier}). Falling back to the main agent model.`
-                    );
-                    modeModelId = mainModelId;
-                }
+        }
+        if (modeModelId) {
+            const check = this.checkMultiplierConstraint(modeModelId, mainModelId);
+            if (check.exceeds) {
+                const modelMetadata = this.languageModelsService.lookupLanguageModel(modeModelId);
+                throw ( new Error(
+                    `Requested model '${modelMetadata?.name}' ${check.reason}. ${this.getAvailableModelsInfo(mainModelId)}`
+                ));
             }
         }
         const resolvedModelMetadata = modeModelId ? this.languageModelsService.lookupLanguageModel(modeModelId) : undefined;
@@ -369,21 +448,23 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
     }
     async prepareToolInvocation(context, _token) {
         const args = context.parameters;
-        const subagent = args.agentName ? await this.getSubAgentByName(args.agentName) : undefined;
-        const resolved = this.resolveSubagentModel(subagent, context.modelId);
+        const gpEnabled = this.configurationService.getValue(ChatConfiguration.GeneralPurposeAgentEnabled);
+        const isGeneralPurpose = gpEnabled && (!args.agentName || args.agentName === GeneralPurposeAgentName);
+        const subagent = (args.agentName && !isGeneralPurpose) ? await this.getSubAgentByName(args.agentName) : undefined;
+        const resolved = this.resolveSubagentModel(subagent, context.modelId, args.model);
         this._resolvedModels.set(context.toolCallId, resolved);
         return {
             invocationMessage: args.description,
             toolSpecificData: {
                 kind: "subagent",
                 description: args.description,
-                agentName: subagent?.name,
+                agentName: isGeneralPurpose ? GeneralPurposeAgentName : (subagent?.name ?? args.agentName),
                 prompt: args.prompt,
                 modelName: resolved.resolvedModelName
             }
         };
     }
 };
-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));
+RunSubagentTool = RunSubagentTool_1 = ( __decorate([( __param(0, IChatAgentService)), ( __param(1, IChatService)), ( __param(2, ILanguageModelToolsService)), ( __param(3, ILanguageModelsService)), ( __param(4, ILogService)), ( __param(5, IConfigurationService)), ( __param(6, IPromptsService)), ( __param(7, IInstantiationService)), ( __param(8, IProductService))], RunSubagentTool));
 
 export { RUN_SUBAGENT_MAX_NESTING_DEPTH, RunSubagentTool };

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

@@ -0,0 +1,11 @@
+import { CancellationToken } from "../../../../../../base/common/cancellation.js";
+import { IToolData, IToolImpl, IToolInvocation, IToolResult, IToolInvocationPreparationContext, IPreparedToolInvocation } from "../languageModelToolsService.js";
+import { IChatArtifactsService } from "../chatArtifactsService.service.js";
+export declare const SetArtifactRulesToolId = "setArtifactRules";
+export declare const SetArtifactRulesToolData: IToolData;
+export declare class SetArtifactRulesTool implements IToolImpl {
+    private readonly _chatArtifactsService;
+    constructor(_chatArtifactsService: IChatArtifactsService);
+    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/setArtifactRulesTool.js

@@ -0,0 +1,90 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localize } from '../../../../../../nls.js';
+import { ToolDataSource, ToolInvocationPresentation } from '../languageModelToolsService.js';
+import { IChatArtifactsService } from '../chatArtifactsService.service.js';
+import { MarkdownString } from '../../../../../../base/common/htmlContent.js';
+
+const SetArtifactRulesToolId = "setArtifactRules";
+const artifactGroupConfigSchema = {
+    type: "object",
+    properties: {
+        groupName: {
+            type: "string",
+            description: "Display name for the artifact group."
+        },
+        onlyShowGroup: {
+            type: "boolean",
+            description: "When true, show only the group header instead of individual items."
+        }
+    },
+    required: ["groupName"]
+};
+const inputSchema = {
+    type: "object",
+    properties: {
+        byMimeType: {
+            type: "object",
+            description: "Rules for extracting artifacts from tool results by MIME type. Maps MIME type patterns (e.g. 'image/*') to group configuration.",
+            additionalProperties: artifactGroupConfigSchema
+        },
+        byFilePath: {
+            type: "object",
+            description: "Rules for extracting artifacts from written files by file path glob pattern. Maps glob patterns (e.g. '**/*plan*.md') to group configuration.",
+            additionalProperties: artifactGroupConfigSchema
+        },
+        byMemoryFilePath: {
+            type: "object",
+            description: "Rules for extracting artifacts from memory tool writes by memory file path glob pattern. Maps glob patterns to group configuration.",
+            additionalProperties: artifactGroupConfigSchema
+        }
+    }
+};
+const SetArtifactRulesToolData = {
+    id: SetArtifactRulesToolId,
+    toolReferenceName: "artifactRules",
+    legacyToolReferenceFullNames: [],
+    displayName: ( localize(7779, "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,
+    inputSchema
+};
+let SetArtifactRulesTool = class SetArtifactRulesTool {
+    constructor(_chatArtifactsService) {
+        this._chatArtifactsService = _chatArtifactsService;
+    }
+    async prepareToolInvocation(_context, _token) {
+        return {
+            pastTenseMessage: ( new MarkdownString(( localize(7780, "Updated artifact rules")))),
+            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 rules = {
+            byMimeType: args.byMimeType,
+            byFilePath: args.byFilePath,
+            byMemoryFilePath: args.byMemoryFilePath
+        };
+        this._chatArtifactsService.getArtifacts(chatSessionResource).setRuleOverrides(rules);
+        return {
+            content: [{
+                kind: "text",
+                value: ( localize(7781, "Updated artifact rules"))
+            }]
+        };
+    }
+};
+SetArtifactRulesTool = ( __decorate([( __param(0, IChatArtifactsService))], SetArtifactRulesTool));
+
+export { SetArtifactRulesTool, SetArtifactRulesToolData, SetArtifactRulesToolId };

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

@@ -2,12 +2,15 @@ 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";
+import { IChatService } from "../../chatService/chatService.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);
+    private readonly _chatService;
+    constructor(_chatArtifactsService: IChatArtifactsService, _fileService: IFileService, _chatService: IChatService);
     prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
     invoke(invocation: IToolInvocation, _countTokens: never, _progress: never, _token: CancellationToken): Promise<IToolResult>;
+    private _resolveSubagentName;
 }

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

@@ -6,6 +6,7 @@ import { IFileService } from '../../../../../../platform/files/common/files.serv
 import { ToolDataSource, ToolInvocationPresentation } from '../languageModelToolsService.js';
 import { IChatArtifactsService } from '../chatArtifactsService.service.js';
 import { MarkdownString } from '../../../../../../base/common/htmlContent.js';
+import { IChatService } from '../../chatService/chatService.service.js';
 
 const SetArtifactsToolId = "setArtifacts";
 const inputSchema = {
@@ -41,20 +42,21 @@ const SetArtifactsToolData = {
     id: SetArtifactsToolId,
     toolReferenceName: "artifacts",
     legacyToolReferenceFullNames: ["Set Session Artifacts"],
-    displayName: ( localize(7663, "Set Session Artifacts")),
+    displayName: ( localize(7782, "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,
     inputSchema
 };
 let SetArtifactsTool = class SetArtifactsTool {
-    constructor(_chatArtifactsService, _fileService) {
+    constructor(_chatArtifactsService, _fileService, _chatService) {
         this._chatArtifactsService = _chatArtifactsService;
         this._fileService = _fileService;
+        this._chatService = _chatService;
     }
     async prepareToolInvocation(_context, _token) {
         return {
-            pastTenseMessage: ( new MarkdownString(( localize(7664, "Updated session artifacts")))),
+            pastTenseMessage: ( new MarkdownString(( localize(7783, "Updated session artifacts")))),
             presentation: ToolInvocationPresentation.Hidden
         };
     }
@@ -79,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(7665, "Artifact URI does not exist: {0}", uri))));
+                        throw ( new Error(( localize(7784, "Artifact URI does not exist: {0}", uri))));
                     }
                 }
             }
@@ -89,15 +91,40 @@ let SetArtifactsTool = class SetArtifactsTool {
                 type: a.type
             });
         }
-        this._chatArtifactsService.getArtifacts(chatSessionResource).set(artifacts);
+        const chatArtifacts = this._chatArtifactsService.getArtifacts(chatSessionResource);
+        const subAgentInvocationId = invocation.subAgentInvocationId;
+        if (subAgentInvocationId) {
+            const agentName = this._resolveSubagentName(chatSessionResource, subAgentInvocationId);
+            chatArtifacts.setSubagentArtifacts(subAgentInvocationId, agentName, artifacts);
+        } else {
+            chatArtifacts.setAgentArtifacts(artifacts);
+        }
         return {
             content: [{
                 kind: "text",
-                value: ( localize(7666, "Set {0} artifact(s)", artifacts.length))
+                value: ( localize(7785, "Set {0} artifact(s)", artifacts.length))
             }]
         };
     }
+    _resolveSubagentName(sessionResource, subAgentInvocationId) {
+        const model = this._chatService.getSession(sessionResource);
+        if (!model) {
+            return undefined;
+        }
+        for (const request of model.getRequests()) {
+            const response = request.response;
+            if (!response) {
+                continue;
+            }
+            for (const part of response.response.value) {
+                if ((part.kind === "toolInvocation" || part.kind === "toolInvocationSerialized") && part.toolCallId === subAgentInvocationId && part.toolSpecificData?.kind === "subagent") {
+                    return part.toolSpecificData.agentName;
+                }
+            }
+        }
+        return undefined;
+    }
 };
-SetArtifactsTool = ( __decorate([( __param(0, IChatArtifactsService)), ( __param(1, IFileService))], SetArtifactsTool));
+SetArtifactsTool = ( __decorate([( __param(0, IChatArtifactsService)), ( __param(1, IFileService)), ( __param(2, IChatService))], SetArtifactsTool));
 
 export { SetArtifactsTool, SetArtifactsToolData, SetArtifactsToolId };

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

@@ -9,8 +9,10 @@ import { AskQuestionsTool, AskQuestionsToolData } from './askQuestionsTool.js';
 import { ConfirmationTool, ConfirmationToolData, ConfirmationToolWithOptionsData, ModifiedFilesConfirmationTool, ModifiedFilesConfirmationToolData } from './confirmationTool.js';
 import { EditTool, EditToolData } from './editFileTool.js';
 import { createManageTodoListToolData, ManageTodoListTool } from './manageTodoListTool.js';
+import { ReviewPlanTool, ReviewPlanToolData } from './reviewPlanTool.js';
 import { RunSubagentTool } from './runSubagentTool.js';
 import { SetArtifactsTool, SetArtifactsToolData } from './setArtifactsTool.js';
+import { SetArtifactRulesTool, SetArtifactRulesToolData } from './setArtifactRulesTool.js';
 import { TaskCompleteTool, TaskCompleteToolData } from './taskCompleteTool.js';
 
 let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable {
@@ -24,6 +26,8 @@ let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable
         const askQuestionsTool = this._register(instantiationService.createInstance(AskQuestionsTool));
         this._register(toolsService.registerTool(AskQuestionsToolData, askQuestionsTool));
         this._register(toolsService.vscodeToolSet.addTool(AskQuestionsToolData));
+        const reviewPlanTool = this._register(instantiationService.createInstance(ReviewPlanTool));
+        this._register(toolsService.registerTool(ReviewPlanToolData, reviewPlanTool));
         const todoToolData = createManageTodoListToolData();
         const manageTodoListTool = this._register(instantiationService.createInstance(ManageTodoListTool));
         this._register(toolsService.registerTool(todoToolData, manageTodoListTool));
@@ -39,19 +43,25 @@ let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable
         const taskCompleteTool = instantiationService.createInstance(TaskCompleteTool);
         this._register(toolsService.registerTool(TaskCompleteToolData, taskCompleteTool));
         const setArtifactsTool = instantiationService.createInstance(SetArtifactsTool);
+        const setArtifactRulesTool = instantiationService.createInstance(SetArtifactRulesTool);
         const setArtifactsRegistration = this._register(( new MutableDisposable()));
+        const setArtifactRulesRegistration = this._register(( new MutableDisposable()));
         const updateArtifactsRegistration = () => {
-            if (configurationService.getValue(ChatConfiguration.ArtifactsEnabled) && configurationService.getValue(ChatConfiguration.ArtifactsMode) === "tool") {
+            if (configurationService.getValue(ChatConfiguration.ArtifactsEnabled)) {
                 if (!setArtifactsRegistration.value) {
                     setArtifactsRegistration.value = toolsService.registerTool(SetArtifactsToolData, setArtifactsTool);
                 }
+                if (!setArtifactRulesRegistration.value) {
+                    setArtifactRulesRegistration.value = toolsService.registerTool(SetArtifactRulesToolData, setArtifactRulesTool);
+                }
             } else {
                 setArtifactsRegistration.clear();
+                setArtifactRulesRegistration.clear();
             }
         };
         updateArtifactsRegistration();
         this._register(configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(ChatConfiguration.ArtifactsEnabled) || e.affectsConfiguration(ChatConfiguration.ArtifactsMode)) {
+            if (e.affectsConfiguration(ChatConfiguration.ArtifactsEnabled)) {
                 updateArtifactsRegistration();
             }
         }));

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

@@ -31,6 +31,8 @@ export interface ILanguageModelToolConfirmationRef {
         label: string;
         /** Precomputed SHA-256 key for the combination */
         key: string;
+        /** String representation of the arguments for this combination */
+        arguments?: string;
     };
 }
 export interface ILanguageModelToolConfirmationActionProducer {