@codingame/monaco-vscode-chat-service-override 37.1.0 → 37.3.0

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

@@ -0,0 +1,577 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ChatRequestVariableSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
+import { isByokModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSelectedModel';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatAgentLocation, ChatModeKind, ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelChatMetadata, COPILOT_VENDOR_ID, AUTO_RAW_MODEL_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
+import { ComputeAutomaticInstructions } from '../../promptSyntax/computeAutomaticInstructions.js';
+import { mergeHooks } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookSchema';
+import { HookType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/hookTypes';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { isBuiltinAgent } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/utils/promptsServiceUtils';
+import { ToolDataSource, VSCodeToolReference, isToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { ManageTodoListToolToolId } from './manageTodoListTool.js';
+import { createToolSimpleTextResult } from './toolHelpers.js';
+
+var RunSubagentTool_1;
+const BaseModelDescription = `Launch a new agent to handle complex, multi-step tasks autonomously. This tool is good at researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries, use this agent to perform the search for you.
+
+- Agents do not run async or in the background, you will wait for the agent\'s result.
+- 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
+- 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 {
+        RunSubagentTool_1 = this;
+    }
+    static {
+        this.Id = "runSubagent";
+    }
+    constructor(
+        chatAgentService,
+        chatService,
+        languageModelToolsService,
+        languageModelsService,
+        logService,
+        configurationService,
+        promptsService,
+        instantiationService,
+        productService,
+        telemetryService
+    ) {
+        super();
+        this.chatAgentService = chatAgentService;
+        this.chatService = chatService;
+        this.languageModelToolsService = languageModelToolsService;
+        this.languageModelsService = languageModelsService;
+        this.logService = logService;
+        this.configurationService = configurationService;
+        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(
+            this.languageModelsService.onDidChangeLanguageModels(() => this._autoModelResolution = undefined)
+        );
+    }
+    getToolData() {
+        const modelDescription = BaseModelDescription;
+        const 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"
+            }
+        };
+        properties.agentName = {
+            type: "string",
+            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 inputSchema = {
+            type: "object",
+            properties,
+            required: ["prompt", "description"]
+        };
+        const runSubagentToolData = {
+            id: RunSubagentTool_1.Id,
+            toolReferenceName: VSCodeToolReference.runSubagent,
+            icon: ThemeIcon.fromId(Codicon.organization.id),
+            displayName: ( localize(12893, "Run Subagent")),
+            userDescription: ( localize(
+                12894,
+                "Run a task within an isolated subagent context to enable efficient organization of tasks and context window management."
+            )),
+            modelDescription: modelDescription,
+            source: ToolDataSource.Internal,
+            inputSchema: inputSchema
+        };
+        return runSubagentToolData;
+    }
+    async invoke(invocation, _countTokens, _progress, token) {
+        const args = invocation.parameters;
+        this.logService.debug(
+            `RunSubagentTool: Invoking with prompt: ${args.prompt.substring(0, 100)}...`
+        );
+        if (!invocation.context) {
+            throw ( new Error("toolInvocationToken is required for this tool"));
+        }
+        const model = this.chatService.getSession(invocation.context.sessionResource);
+        if (!model) {
+            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);
+            if (!defaultAgent) {
+                return createToolSimpleTextResult("Error: No default agent available");
+            }
+            let modeModelId = invocation.modelId;
+            let modeTools = invocation.userSelectedTools;
+            let modeInstructions;
+            let subagent;
+            let resolvedModelName;
+            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);
+                    if (cached) {
+                        this._resolvedModels.delete(invocation.callId);
+                        modeModelId = cached.modeModelId;
+                        resolvedModelName = cached.resolvedModelName;
+                        modelSelectionSource = cached.selectionSource;
+                    } else {
+                        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) {
+                        const enablementMap = this.languageModelToolsService.toToolAndToolSetEnablementMap(modeCustomTools, undefined);
+                        modeTools = {};
+                        for (const [tool, enabled] of enablementMap) {
+                            if (!isToolSet(tool)) {
+                                modeTools[tool.id] = enabled;
+                            }
+                        }
+                    }
+                    const instructions = subagent.agentInstructions;
+                    modeInstructions = instructions && {
+                        name: subAgentName,
+                        content: instructions.content,
+                        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);
+                    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 = 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 inEdit = false;
+            const progressCallback = parts => {
+                for (const part of parts) {
+                    if (part.kind === "usage") {
+                        if (typeof part.copilotCredits === "number" && Number.isFinite(part.copilotCredits) && part.copilotCredits >= 0) {
+                            subagentCredits = Math.max(subagentCredits ?? 0, part.copilotCredits);
+                        }
+                        continue;
+                    }
+                    if (part.kind === "textEdit" || part.kind === "notebookEdit" || part.kind === "codeblockUri") {
+                        if (part.kind === "codeblockUri" && !inEdit) {
+                            inEdit = true;
+                            model.acceptResponseProgress(request, {
+                                kind: "markdownContent",
+                                content: ( new MarkdownString("```\n"))
+                            });
+                        }
+                        if (part.kind === "codeblockUri") {
+                            model.acceptResponseProgress(request, {
+                                ...part,
+                                subAgentInvocationId
+                            });
+                        } else {
+                            model.acceptResponseProgress(request, part);
+                        }
+                    } else if (part.kind === "hook") {
+                        model.acceptResponseProgress(request, {
+                            ...part,
+                            subAgentInvocationId
+                        });
+                    } else if (part.kind === "markdownContent") {
+                        if (inEdit) {
+                            model.acceptResponseProgress(request, {
+                                kind: "markdownContent",
+                                content: ( new MarkdownString("\n```\n\n"))
+                            });
+                            inEdit = false;
+                        }
+                        markdownParts.push(part.content.value);
+                    }
+                }
+            };
+            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());
+            if (this.configurationService.getValue(ChatConfiguration.CollectInstructionsInExtension) !== true) {
+                const computer = this.instantiationService.createInstance(
+                    ComputeAutomaticInstructions,
+                    ChatModeKind.Agent,
+                    modeTools,
+                    modeInstructions?.allowedSubagents,
+                    getChatSessionType(invocation.context.sessionResource)
+                );
+                await computer.collect(variableSet, token);
+            }
+            let collectedHooks;
+            try {
+                const info = await this.promptsService.getHooks(token);
+                collectedHooks = info?.hooks;
+            } catch (error) {
+                this.logService.warn("[ChatService] Failed to collect hooks:", error);
+            }
+            if (subagent?.hooks) {
+                const remapped = {
+                    ...subagent.hooks
+                };
+                if (remapped[HookType.Stop]) {
+                    const stopHooks = remapped[HookType.Stop];
+                    remapped[HookType.SubagentStop] = remapped[HookType.SubagentStop] ? [...remapped[HookType.SubagentStop], ...stopHooks] : stopHooks;
+                    remapped[HookType.Stop] = undefined;
+                }
+                collectedHooks = mergeHooks(collectedHooks, remapped);
+            }
+            const agentRequest = {
+                sessionResource: invocation.context.sessionResource,
+                requestId: invocation.callId ?? `subagent-${Date.now()}`,
+                agentId: defaultAgent.id,
+                message: args.prompt,
+                variables: {
+                    variables: variableSet.asArray()
+                },
+                location: ChatAgentLocation.Chat,
+                subAgentInvocationId: subAgentInvocationId,
+                subAgentName: effectiveSubAgentName,
+                userSelectedModelId: modeModelId,
+                modelConfiguration: modeModelId ? this.languageModelsService.getModelConfiguration(modeModelId) : undefined,
+                userSelectedTools: modeTools,
+                modeInstructions,
+                parentRequestId: invocation.chatRequestId,
+                hooks: collectedHooks,
+                hasHooksEnabled: !!collectedHooks && ( ( Object.values(collectedHooks)).some(arr => arr && arr.length > 0))
+            };
+            store.add(this.languageModelToolsService.onDidInvokeTool(e => {
+                if (e.subagentInvocationId === subAgentInvocationId) {
+                    markdownParts.length = 0;
+                }
+            }));
+            this.telemetryService.publicLog2("chat.subagentModelSelection", {
+                selectionSource: modelSelectionSource
+            });
+            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";
+            if (invocation.toolSpecificData?.kind === "subagent") {
+                invocation.toolSpecificData.result = resultText;
+                invocation.toolSpecificData.modelName = resolvedModelName;
+            }
+            return {
+                content: [{
+                    kind: "text",
+                    value: resultText
+                }],
+                toolMetadata: {
+                    subAgentInvocationId,
+                    description: args.description,
+                    agentName: agentRequest.subAgentName,
+                    modelName: resolvedModelName
+                }
+            };
+        } catch (error) {
+            const errorMessage = `Error invoking subagent: ${error instanceof Error ? error.message : "Unknown error"}`;
+            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();
+        }
+    }
+    async getSubAgentByName(name) {
+        const agents = await this.promptsService.getCustomAgents(CancellationToken.None);
+        return agents.find(agent => agent.name === name && agent.enabled);
+    }
+    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 && this.isSelectableForAgentMode(m.metadata));
+        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.";
+    }
+    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)}`
+                ));
+            }
+        }
+        if (subagent && !explicitModelResolved) {
+            const modeModelQualifiedNames = subagent.model;
+            if (modeModelQualifiedNames) {
+                const mainModelIsByok = !!mainModelMetadata && isByokModel(mainModelMetadata);
+                const skipCopilotFallbacks = mainModelIsByok && isBuiltinAgent(subagent.source, subagent.uri, this.productService);
+                for (const qualifiedName of modeModelQualifiedNames) {
+                    const lmByQualifiedName = this.languageModelsService.lookupLanguageModelByQualifiedName(qualifiedName);
+                    if (lmByQualifiedName?.identifier) {
+                        if (skipCopilotFallbacks && lmByQualifiedName.metadata.vendor === COPILOT_VENDOR_ID) {
+                            continue;
+                        }
+                        modeModelId = lmByQualifiedName.identifier;
+                        selectionSource = "agentModel";
+                        break;
+                    }
+                }
+            }
+        }
+        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);
+                throw ( new Error(
+                    `Requested model '${modelMetadata?.name}' ${check.reason}. ${this.getAvailableModelsInfo(mainModelId)}`
+                ));
+            }
+        }
+        const resolvedModelMetadata = modeModelId ? this.languageModelsService.lookupLanguageModel(modeModelId) : undefined;
+        return {
+            modeModelId,
+            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 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: 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)), ( __param(9, ITelemetryService))], 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 "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IToolData, IToolImpl, IToolInvocation, IToolResult, IToolInvocationPreparationContext, IPreparedToolInvocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
+import { IChatArtifactsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/chatArtifactsService.service";
+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>;
+}