@codingame/monaco-vscode-api 36.2.7 → 37.1.0

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

@@ -2,9 +2,10 @@
 import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
 import { CancellationToken } from '../../../../../../base/common/cancellation.js';
 import { Codicon } from '../../../../../../base/common/codicons.js';
-import { Emitter, Event } from '../../../../../../base/common/event.js';
+import { Emitter } from '../../../../../../base/common/event.js';
 import { MarkdownString } from '../../../../../../base/common/htmlContent.js';
 import { Disposable, DisposableStore } from '../../../../../../base/common/lifecycle.js';
+import { isEqual } from '../../../../../../base/common/resources.js';
 import { ThemeIcon } from '../../../../../../base/common/themables.js';
 import { generateUuid } from '../../../../../../base/common/uuid.js';
 import { localize } from '../../../../../../nls.js';
@@ -12,11 +13,12 @@ import { IConfigurationService } from '../../../../../../platform/configuration/
 import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
 import { ILogService } from '../../../../../../platform/log/common/log.service.js';
 import { IProductService } from '../../../../../../platform/product/common/productService.service.js';
+import { ITelemetryService } from '../../../../../../platform/telemetry/common/telemetry.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, COPILOT_VENDOR_ID } from '../../languageModels.js';
+import { ChatAgentLocation, ChatModeKind, ChatConfiguration } from '../../constants.js';
+import { ILanguageModelChatMetadata, COPILOT_VENDOR_ID, AUTO_RAW_MODEL_ID } from '../../languageModels.js';
 import { ILanguageModelsService } from '../../languageModels.service.js';
 import { getChatSessionType } from '../../model/chatUri.js';
 import { IChatAgentService } from '../../participants/chatAgents.service.js';
@@ -56,7 +58,8 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         configurationService,
         promptsService,
         instantiationService,
-        productService
+        productService,
+        telemetryService
     ) {
         super();
         this.chatAgentService = chatAgentService;
@@ -68,18 +71,17 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         this.promptsService = promptsService;
         this.instantiationService = instantiationService;
         this.productService = productService;
+        this.telemetryService = telemetryService;
         this._onDidUpdateToolData = this._register(( new Emitter()));
         this.onDidUpdateToolData = this._onDidUpdateToolData.event;
         this._resolvedModels = ( new Map());
         this._sessionDepth = ( new Map());
-        this._register(Event.filter(
-            this.configurationService.onDidChangeConfiguration,
-            e => e.affectsConfiguration(ChatConfiguration.GeneralPurposeAgentEnabled)
-        )(() => this._onDidUpdateToolData.fire()));
+        this._register(
+            this.languageModelsService.onDidChangeLanguageModels(() => this._autoModelResolution = undefined)
+        );
     }
     getToolData() {
         const modelDescription = BaseModelDescription;
-        const generalPurposeAgentEnabled = this.configurationService.getValue(ChatConfiguration.GeneralPurposeAgentEnabled);
         const properties = {
             prompt: {
                 type: "string",
@@ -92,28 +94,24 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         };
         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."
+            description: "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
+            required: ["prompt", "description"]
         };
         const runSubagentToolData = {
             id: RunSubagentTool_1.Id,
             toolReferenceName: VSCodeToolReference.runSubagent,
             icon: ThemeIcon.fromId(Codicon.organization.id),
-            displayName: ( localize(8971, "Run Subagent")),
+            displayName: ( localize(10894, "Run Subagent")),
             userDescription: ( localize(
-                8972,
+                10895,
                 "Run a task within an isolated subagent context to enable efficient organization of tasks and context window management."
             )),
             modelDescription: modelDescription,
@@ -135,6 +133,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             throw ( new Error("Chat model not found for session"));
         }
         const request = model.getRequests().at(-1);
+        let subagentCredits;
         const store = ( new DisposableStore());
         try {
             const defaultAgent = this.chatAgentService.getDefaultAgent(ChatAgentLocation.Chat, ChatModeKind.Agent);
@@ -146,11 +145,12 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             let modeInstructions;
             let subagent;
             let resolvedModelName;
-            const subAgentName = args.agentName;
-            const gpEnabled = this.configurationService.getValue(ChatConfiguration.GeneralPurposeAgentEnabled);
-            const isGeneralPurpose = gpEnabled && (!subAgentName || subAgentName === GeneralPurposeAgentName);
-            const effectiveSubAgentName = isGeneralPurpose ? GeneralPurposeAgentName : subAgentName;
-            if (subAgentName && !isGeneralPurpose) {
+            let modelSelectionSource = "mainModel";
+            const currentModeInstructions = request.modeInfo?.modeInstructions;
+            const subAgentName = this.normalizeRequestedAgentName(args.agentName);
+            const effectiveSubAgentName = subAgentName ?? currentModeInstructions?.name;
+            if (subAgentName) {
+                this.validateSubagentAllowed(subAgentName, currentModeInstructions);
                 subagent = await this.getSubAgentByName(subAgentName);
                 if (subagent) {
                     const cached = this._resolvedModels.get(invocation.callId);
@@ -158,10 +158,12 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                         this._resolvedModels.delete(invocation.callId);
                         modeModelId = cached.modeModelId;
                         resolvedModelName = cached.resolvedModelName;
+                        modelSelectionSource = cached.selectionSource;
                     } else {
-                        const resolved = this.resolveSubagentModel(subagent, invocation.modelId, args.model);
+                        const resolved = await this.resolveSubagentModel(subagent, invocation.modelId, args.model);
                         modeModelId = resolved.modeModelId;
                         resolvedModelName = resolved.resolvedModelName;
+                        modelSelectionSource = resolved.selectionSource;
                     }
                     const modeCustomTools = subagent.tools;
                     if (modeCustomTools) {
@@ -177,38 +179,40 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                     modeInstructions = instructions && {
                         name: subAgentName,
                         content: instructions.content,
-                        toolReferences: this.languageModelToolsService.toToolReferences(instructions.toolReferences),
-                        allowedSubagents: undefined,
+                        toolReferences: instructions.toolReferences.length ? this.languageModelToolsService.toToolReferences(instructions.toolReferences) : [],
+                        allowedSubagents: subagent.agents,
                         metadata: instructions.metadata,
                         isBuiltin: isBuiltinAgent(subagent.source, subagent.uri, this.productService)
                     };
                 } else {
                     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}`));
+                    throw ( new Error(
+                        `Requested agent '${subAgentName}' not found. Try again with the correct agent name, or omit agentName to use the current agent.`
+                    ));
                 }
             } else {
+                modeInstructions = currentModeInstructions;
                 const cached = this._resolvedModels.get(invocation.callId);
                 if (cached) {
                     this._resolvedModels.delete(invocation.callId);
                     modeModelId = cached.modeModelId;
                     resolvedModelName = cached.resolvedModelName;
+                    modelSelectionSource = cached.selectionSource;
                 } else {
-                    const resolved = this.resolveSubagentModel(undefined, invocation.modelId, args.model);
+                    const resolved = await this.resolveSubagentModel(undefined, invocation.modelId, args.model, currentModeInstructions);
                     modeModelId = resolved.modeModelId;
                     resolvedModelName = resolved.resolvedModelName;
+                    modelSelectionSource = resolved.selectionSource;
                 }
             }
             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;
+                        if (typeof part.copilotCredits === "number" && Number.isFinite(part.copilotCredits) && part.copilotCredits >= 0) {
+                            subagentCredits = Math.max(subagentCredits ?? 0, part.copilotCredits);
                         }
                         continue;
                     }
@@ -270,7 +274,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                     ComputeAutomaticInstructions,
                     ChatModeKind.Agent,
                     modeTools,
-                    undefined,
+                    modeInstructions?.allowedSubagents,
                     getChatSessionType(invocation.context.sessionResource)
                 );
                 await computer.collect(variableSet, token);
@@ -317,6 +321,9 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                     markdownParts.length = 0;
                 }
             }));
+            this.telemetryService.publicLog2("chat.subagentModelSelection", {
+                selectionSource: modelSelectionSource
+            });
             this._sessionDepth.set(sessionKey, currentDepth + 1);
             let result;
             try {
@@ -336,9 +343,6 @@ 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: [{
@@ -357,6 +361,12 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             this.logService.error(errorMessage, error);
             return createToolSimpleTextResult(errorMessage);
         } finally {
+            if (subagentCredits !== undefined) {
+                request.response?.setSubagentCopilotCredits(invocation.callId, subagentCredits);
+                if (invocation.toolSpecificData?.kind === "subagent") {
+                    invocation.toolSpecificData.credits = subagentCredits;
+                }
+            }
             store.dispose();
         }
     }
@@ -388,9 +398,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         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
-        );
+        }))).filter(m => !!m.metadata && this.isSelectableForAgentMode(m.metadata));
         if (models.length === 0) {
             return "No models available.";
         }
@@ -419,14 +427,18 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         }
         return parts.join(". ") || "No models available.";
     }
-    resolveSubagentModel(subagent, mainModelId, explicitModelQualifiedName) {
+    async resolveSubagentModel(subagent, mainModelId, explicitModelQualifiedName, currentModeInstructions) {
         let modeModelId = mainModelId;
         let explicitModelResolved = false;
+        let usesAutoDefault = false;
+        let selectionSource = "mainModel";
+        const mainModelMetadata = mainModelId ? this.languageModelsService.lookupLanguageModel(mainModelId) : undefined;
         if (explicitModelQualifiedName) {
             const lm = this.languageModelsService.lookupLanguageModelByQualifiedName(explicitModelQualifiedName);
             if (lm?.identifier) {
                 modeModelId = lm.identifier;
                 explicitModelResolved = true;
+                selectionSource = "explicitModel";
             } else {
                 throw ( new Error(
                     `Requested model '${explicitModelQualifiedName}' not found. ${this.getAvailableModelsInfo(mainModelId)}`
@@ -436,7 +448,6 @@ 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) {
@@ -446,12 +457,21 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                             continue;
                         }
                         modeModelId = lmByQualifiedName.identifier;
+                        selectionSource = "agentModel";
                         break;
                     }
                 }
             }
         }
-        if (modeModelId) {
+        if (!explicitModelResolved && !subagent?.model?.length && (!mainModelId || (!!mainModelMetadata && !isByokModel(mainModelMetadata))) && this.configurationService.getValue(ChatConfiguration.SubagentsDefaultToAuto) === true && !(await this.inheritedAgentHasModel(subagent, currentModeInstructions))) {
+            const autoModelId = await this.resolveAutoModelId();
+            if (autoModelId) {
+                modeModelId = autoModelId;
+                usesAutoDefault = true;
+                selectionSource = "autoDefault";
+            }
+        }
+        if (modeModelId && !usesAutoDefault) {
             const check = this.checkMultiplierConstraint(modeModelId, mainModelId);
             if (check.exceeds) {
                 const modelMetadata = this.languageModelsService.lookupLanguageModel(modeModelId);
@@ -463,28 +483,95 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         const resolvedModelMetadata = modeModelId ? this.languageModelsService.lookupLanguageModel(modeModelId) : undefined;
         return {
             modeModelId,
-            resolvedModelName: resolvedModelMetadata?.name
+            resolvedModelName: resolvedModelMetadata?.name,
+            selectionSource
         };
     }
+    async inheritedAgentHasModel(subagent, currentModeInstructions) {
+        if (subagent || !currentModeInstructions) {
+            return false;
+        }
+        const {
+            uri,
+            name
+        } = currentModeInstructions;
+        const agents = await this.promptsService.getCustomAgents(CancellationToken.None);
+        const currentAgent = agents.find(
+            agent => uri ? isEqual(agent.uri, uri) : agent.name === name && agent.enabled
+        );
+        return !!currentAgent?.model?.length;
+    }
+    isSelectableForAgentMode(metadata) {
+        return ILanguageModelChatMetadata.suitableForAgentMode(metadata) && metadata.isUserSelectable !== false && !metadata.targetChatSessionType;
+    }
+    findEligibleAutoModelId(modelIds) {
+        return modelIds.find(modelId => {
+            const metadata = this.languageModelsService.lookupLanguageModel(modelId);
+            return metadata?.vendor === COPILOT_VENDOR_ID && metadata.id === AUTO_RAW_MODEL_ID && this.isSelectableForAgentMode(metadata);
+        });
+    }
+    resolveAutoModelId() {
+        const cachedModelId = this.findEligibleAutoModelId(this.languageModelsService.getLanguageModelIds());
+        if (cachedModelId || this.languageModelsService.hasResolvedVendor(COPILOT_VENDOR_ID)) {
+            return Promise.resolve(cachedModelId);
+        }
+        this._autoModelResolution ??= this.activateAutoModel();
+        return this._autoModelResolution;
+    }
+    async activateAutoModel() {
+        try {
+            const modelIds = await this.languageModelsService.selectLanguageModels({
+                vendor: COPILOT_VENDOR_ID,
+                id: AUTO_RAW_MODEL_ID
+            });
+            return this.findEligibleAutoModelId(modelIds);
+        } catch (error) {
+            this.logService.warn(
+                "RunSubagentTool: Failed to resolve the Auto model, keeping the main model",
+                error
+            );
+            return undefined;
+        }
+    }
     async prepareToolInvocation(context, _token) {
         const args = context.parameters;
-        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);
+        const requestedAgentName = this.normalizeRequestedAgentName(args.agentName);
+        const currentModeInstructions = context.chatSessionResource ? this.getCurrentModeInstructions(context.chatSessionResource) : undefined;
+        if (requestedAgentName) {
+            this.validateSubagentAllowed(requestedAgentName, currentModeInstructions);
+        }
+        const subagent = requestedAgentName ? await this.getSubAgentByName(requestedAgentName) : undefined;
+        const resolved = await this.resolveSubagentModel(subagent, context.modelId, args.model, currentModeInstructions);
         this._resolvedModels.set(context.toolCallId, resolved);
         return {
             invocationMessage: args.description,
             toolSpecificData: {
                 kind: "subagent",
                 description: args.description,
-                agentName: isGeneralPurpose ? GeneralPurposeAgentName : (subagent?.name ?? args.agentName),
+                agentName: subagent?.name ?? requestedAgentName ?? currentModeInstructions?.name,
                 prompt: args.prompt,
                 modelName: resolved.resolvedModelName
             }
         };
     }
+    normalizeRequestedAgentName(agentName) {
+        const normalized = agentName?.trim();
+        return normalized ? normalized : undefined;
+    }
+    getCurrentModeInstructions(sessionResource) {
+        if (typeof this.chatService.getSession !== "function") {
+            return undefined;
+        }
+        const model = this.chatService.getSession(sessionResource);
+        return model?.getRequests().at(-1)?.modeInfo?.modeInstructions;
+    }
+    validateSubagentAllowed(subAgentName, currentModeInstructions) {
+        const allowedSubagents = currentModeInstructions?.allowedSubagents;
+        if (allowedSubagents && !allowedSubagents.includes("*") && !allowedSubagents.includes(subAgentName)) {
+            throw ( new Error(`Requested agent '${subAgentName}' is not allowed by the current agent.`));
+        }
+    }
 };
-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));
+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)), ( __param(9, ITelemetryService))], RunSubagentTool));
 
 export { RUN_SUBAGENT_MAX_NESTING_DEPTH, RunSubagentTool };

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(8973, "Set Artifact Rules")),
+    displayName: ( localize(10896, "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(8974, "Updated artifact rules")))),
+            pastTenseMessage: ( new MarkdownString(( localize(10897, "Updated artifact rules")))),
             presentation: ToolInvocationPresentation.Hidden
         };
     }
@@ -80,7 +80,7 @@ let SetArtifactRulesTool = class SetArtifactRulesTool {
         return {
             content: [{
                 kind: "text",
-                value: ( localize(8975, "Updated artifact rules"))
+                value: ( localize(10898, "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(8976, "Set Session Artifacts")),
+    displayName: ( localize(10899, "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(8977, "Updated session artifacts")))),
+            pastTenseMessage: ( new MarkdownString(( localize(10900, "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(8978, "Artifact URI does not exist: {0}", uri))));
+                        throw ( new Error(( localize(10901, "Artifact URI does not exist: {0}", uri))));
                     }
                 }
             }
@@ -102,7 +102,7 @@ let SetArtifactsTool = class SetArtifactsTool {
         return {
             content: [{
                 kind: "text",
-                value: ( localize(8979, "Set {0} artifact(s)", artifacts.length))
+                value: ( localize(10902, "Set {0} artifact(s)", artifacts.length))
             }]
         };
     }