@codingame/monaco-vscode-api 22.1.8 → 23.0.0

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service.d.ts

@@ -1,12 +1,13 @@
 import { CancellationToken } from "../../../../../../base/common/cancellation.js";
 import { Event } from "../../../../../../base/common/event.js";
 import { IDisposable } from "../../../../../../base/common/lifecycle.js";
+import { ResourceSet } from "../../../../../../base/common/map.js";
 import { URI } from "../../../../../../base/common/uri.js";
 import { ITextModel } from "../../../../../../editor/common/model.js";
 import { IExtensionDescription } from "../../../../../../platform/extensions/common/extensions.js";
-import { PromptsType } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
-import { ParsedPromptFile } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/newPromptsParser";
-import { IPromptPath, PromptsStorage, IChatPromptSlashCommand, ICustomChatMode } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { ParsedPromptFile } from "@codingame/monaco-vscode-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptFileParser";
+import { PromptsType } from "@codingame/monaco-vscode-8d4ef243-d8c1-540d-9f11-38df46f54c9f-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { IPromptPath, PromptsStorage, IChatPromptSlashCommand, ICustomAgent } from "@codingame/monaco-vscode-2339d6ac-d6bb-53cd-95ee-81911735d1c7-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
 /**
 * Provides prompt services.
 */
@@ -43,6 +44,16 @@ export interface IPromptsService extends IDisposable {
     */
     resolvePromptSlashCommand(data: IChatPromptSlashCommand, _token: CancellationToken): Promise<ParsedPromptFile | undefined>;
     /**
+    * Gets the prompt file for a slash command from cache if available.
+    * @param command - name of the prompt command without slash
+    */
+    resolvePromptSlashCommandFromCache(command: string): ParsedPromptFile | undefined;
+    /**
+    * Event that is triggered when slash command -> ParsedPromptFile cache is updated.
+    * Event handler can call resolvePromptSlashCommandFromCache in case there is new value populated.
+    */
+    readonly onDidChangeParsedPromptFilesCache: Event<void>;
+    /**
     * Returns a prompt command if the command name is valid.
     */
     findPromptSlashCommands(): Promise<IChatPromptSlashCommand[]>;
@@ -51,13 +62,13 @@ export interface IPromptsService extends IDisposable {
     */
     getPromptCommandName(uri: URI): Promise<string>;
     /**
-    * Event that is triggered when the list of custom chat modes changes.
+    * Event that is triggered when the list of custom agents changes.
     */
-    readonly onDidChangeCustomChatModes: Event<void>;
+    readonly onDidChangeCustomAgents: Event<void>;
     /**
-    * Finds all available custom chat modes
+    * Finds all available custom agents
     */
-    getCustomChatModes(token: CancellationToken): Promise<readonly ICustomChatMode[]>;
+    getCustomAgents(token: CancellationToken): Promise<readonly ICustomAgent[]>;
     /**
     * Parses the provided URI
     * @param uris
@@ -74,5 +85,30 @@ export interface IPromptsService extends IDisposable {
     */
     registerContributedFile(type: PromptsType, name: string, description: string, uri: URI, extension: IExtensionDescription): IDisposable;
     getPromptLocationLabel(promptPath: IPromptPath): string;
+    /**
+    * Gets list of all AGENTS.md files in the workspace.
+    */
     findAgentMDsInWorkspace(token: CancellationToken): Promise<URI[]>;
+    /**
+    * Gets list of AGENTS.md files.
+    * @param includeNested Whether to include AGENTS.md files from subfolders, or only from the root.
+    */
+    listAgentMDs(token: CancellationToken, includeNested: boolean): Promise<URI[]>;
+    /**
+    * Gets list of .github/copilot-instructions.md files.
+    */
+    listCopilotInstructionsMDs(token: CancellationToken): Promise<URI[]>;
+    /**
+    * For a chat mode file URI, return the name of the agent file that it should use.
+    * @param oldURI
+    */
+    getAgentFileURIFromModeFile(oldURI: URI): URI | undefined;
+    /**
+    * Returns the list of disabled prompt file URIs for a given type. By default no prompt files are disabled.
+    */
+    getDisabledPromptFiles(type: PromptsType): ResourceSet;
+    /**
+    * Persists the set of disabled prompt file URIs for the given type.
+    */
+    setDisabledPromptFiles(type: PromptsType, uris: ResourceSet): void;
 }

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

@@ -57,7 +57,7 @@ class ConfirmationTool {
             confirmationMessages: {
                 title: parameters.title,
                 message: ( new MarkdownString(parameters.message)),
-                allowAutoConfirm: false
+                allowAutoConfirm: true
             },
             toolSpecificData,
             presentation: ToolInvocationPresentation.HiddenAfterComplete

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

@@ -8,6 +8,7 @@ import { INotebookService } from '../../../notebook/common/notebookService.servi
 import { ICodeMapperService } from '../chatCodeMapperService.service.js';
 import { IChatService } from '../chatService.service.js';
 import { ToolDataSource, ToolInvocationPresentation } from '../languageModelToolsService.js';
+import { LocalChatSessionUri } from '../chatUri.js';
 import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
 
 const ExtensionEditToolId = 'vscode_editFile';
@@ -31,7 +32,7 @@ let EditTool = class EditTool {
         const parameters = invocation.parameters;
         const fileUri = URI.revive(parameters.uri);
         const uri = CellUri.parse(fileUri)?.notebook || fileUri;
-        const model = this.chatService.getSession(invocation.context?.sessionId);
+        const model = this.chatService.getSession(LocalChatSessionUri.forSession(invocation.context?.sessionId));
         const request = model.getRequests().at(-1);
         model.acceptResponseProgress(request, {
             kind: 'markdownContent',

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

@@ -9,6 +9,7 @@ import { ITelemetryService } from '../../../../../platform/telemetry/common/tele
 import { IChatTodoListService } from '../chatTodoListService.service.js';
 import { localize } from '../../../../../nls.js';
 import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { LocalChatSessionUri, chatSessionResourceToId } from '../chatUri.js';
 
 const TodoListToolWriteOnlySettingId = 'chat.todoListTool.writeOnly';
 const TodoListToolDescriptionFieldSettingId = 'chat.todoListTool.descriptionField';
@@ -61,8 +62,8 @@ function createManageTodoListToolData(writeOnly, includeDescription = true) {
         toolReferenceName: 'todos',
         canBeReferencedInPrompt: true,
         icon: ThemeIcon.fromId(Codicon.checklist.id),
-        displayName: ( localize(5711, 'Manage and track todo items for task planning')),
-        userDescription: ( localize(5712, 'Tool for managing and tracking todo items for task planning')),
+        displayName: ( localize(5952, 'Manage and track todo items for task planning')),
+        userDescription: ( localize(5953, 'Tool for managing and tracking todo items for task planning')),
         modelDescription: 'Manage a structured todo list to track progress and plan tasks throughout your coding session. Use this tool VERY frequently to ensure task visibility and proper planning.\n\nWhen to use this tool:\n- Complex multi-step work requiring planning and tracking\n- When user provides multiple tasks or requests (numbered/comma-separated)\n- After receiving new instructions that require multiple steps\n- BEFORE starting work on any todo (mark as in-progress)\n- IMMEDIATELY after completing each todo (mark completed individually)\n- When breaking down larger tasks into smaller actionable steps\n- To give users visibility into your progress and planning\n\nWhen NOT to use:\n- Single, trivial tasks that can be completed in one step\n- Purely conversational/informational requests\n- When just reading files or performing simple searches\n\nCRITICAL workflow:\n1. Plan tasks by writing todo list with specific, actionable items\n2. Mark ONE todo as in-progress before starting work\n3. Complete the work for that specific todo\n4. Mark that todo as completed IMMEDIATELY\n5. Move to next todo and repeat\n\nTodo states:\n- not-started: Todo not yet begun\n- in-progress: Currently working (limit ONE at a time)\n- completed: Finished successfully\n\nIMPORTANT: Mark todos completed as soon as they are done. Do not batch completions.',
         source: ToolDataSource.Internal,
         inputSchema: {
@@ -98,10 +99,10 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
                 };
             }
             if (operation === 'read') {
-                return this.handleReadOperation(chatSessionId);
+                return this.handleReadOperation(LocalChatSessionUri.forSession(chatSessionId));
             }
             else if (operation === 'write') {
-                return this.handleWriteOperation(args, chatSessionId);
+                return this.handleWriteOperation(args, LocalChatSessionUri.forSession(chatSessionId));
             }
             else {
                 return {
@@ -126,7 +127,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
         const args = context.parameters;
         const DEFAULT_TODO_SESSION_ID = 'default';
         const chatSessionId = context.chatSessionId ?? args.chatSessionId ?? DEFAULT_TODO_SESSION_ID;
-        const currentTodoItems = this.chatTodoListService.getTodos(chatSessionId);
+        const currentTodoItems = this.chatTodoListService.getTodos(LocalChatSessionUri.forSession(chatSessionId));
         let message;
         const operation = this.writeOnly ? 'write' : args.operation;
         switch (operation) {
@@ -137,7 +138,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
                 break;
             }
             case 'read': {
-                message = ( localize(5713, "Read todo list"));
+                message = ( localize(5954, "Read todo list"));
                 break;
             }
         }
@@ -149,7 +150,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             status: todo.status
         })));
         return {
-            pastTenseMessage: ( new MarkdownString(message ?? ( localize(5714, "Updated todo list")))),
+            pastTenseMessage: ( new MarkdownString(message ?? ( localize(5955, "Updated todo list")))),
             toolSpecificData: {
                 kind: 'todoList',
                 sessionId: chatSessionId,
@@ -160,8 +161,8 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
     generatePastTenseMessage(currentTodos, newTodos) {
         if (currentTodos.length === 0) {
             return newTodos.length === 1
-                ? ( localize(5715, "Created 1 todo"))
-                : ( localize(5716, "Created {0} todos", newTodos.length));
+                ? ( localize(5956, "Created 1 todo"))
+                : ( localize(5957, "Created {0} todos", newTodos.length));
         }
         const currentTodoMap = ( new Map(( currentTodos.map(todo => [todo.id, todo]))));
         const startedTodos = newTodos.filter(newTodo => {
@@ -173,11 +174,11 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             const totalTodos = newTodos.length;
             const currentPosition = newTodos.findIndex(todo => todo.id === startedTodo.id) + 1;
             return localize(
-                5717,
-                "Starting ({0}/{1}) *{2}*",
+                5958,
+                "Starting: *{0}* ({1}/{2})",
+                startedTodo.title,
                 currentPosition,
-                totalTodos,
-                startedTodo.title
+                totalTodos
             );
         }
         const completedTodos = newTodos.filter(newTodo => {
@@ -189,38 +190,38 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             const totalTodos = newTodos.length;
             const currentPosition = newTodos.findIndex(todo => todo.id === completedTodo.id) + 1;
             return localize(
-                5718,
-                "Completed ({0}/{1}) *{2}*",
+                5959,
+                "Completed: *{0}* ({1}/{2})",
+                completedTodo.title,
                 currentPosition,
-                totalTodos,
-                completedTodo.title
+                totalTodos
             );
         }
         const addedTodos = newTodos.filter(newTodo => !( currentTodoMap.has(newTodo.id)));
         if (addedTodos.length > 0) {
             return addedTodos.length === 1
-                ? ( localize(5719, "Added 1 todo"))
-                : ( localize(5720, "Added {0} todos", addedTodos.length));
+                ? ( localize(5960, "Added 1 todo"))
+                : ( localize(5961, "Added {0} todos", addedTodos.length));
         }
-        return localize(5721, "Updated todo list");
+        return localize(5962, "Updated todo list");
     }
-    handleRead(todoItems, sessionId) {
+    handleRead(todoItems, sessionResource) {
         if (todoItems.length === 0) {
             return 'No todo list found.';
         }
         const markdownTaskList = this.formatTodoListAsMarkdownTaskList(todoItems);
         return `# Todo List\n\n${markdownTaskList}`;
     }
-    handleReadOperation(chatSessionId) {
-        const todoItems = this.chatTodoListService.getTodos(chatSessionId);
-        const readResult = this.handleRead(todoItems, chatSessionId);
+    handleReadOperation(chatSessionResource) {
+        const todoItems = this.chatTodoListService.getTodos(chatSessionResource);
+        const readResult = this.handleRead(todoItems, chatSessionResource);
         const statusCounts = this.calculateStatusCounts(todoItems);
         this.telemetryService.publicLog2('todoListToolInvoked', {
             operation: 'read',
             notStartedCount: statusCounts.notStartedCount,
             inProgressCount: statusCounts.inProgressCount,
             completedCount: statusCounts.completedCount,
-            chatSessionId: chatSessionId
+            chatSessionId: chatSessionResourceToId(chatSessionResource)
         });
         return {
             content: [{
@@ -229,7 +230,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
                 }]
         };
     }
-    handleWriteOperation(args, chatSessionId) {
+    handleWriteOperation(args, chatSessionResource) {
         if (!args.todoList) {
             return {
                 content: [{
@@ -244,9 +245,9 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             description: parsedTodo.description || '',
             status: parsedTodo.status
         })));
-        const existingTodos = this.chatTodoListService.getTodos(chatSessionId);
+        const existingTodos = this.chatTodoListService.getTodos(chatSessionResource);
         const changes = this.calculateTodoChanges(existingTodos, todoList);
-        this.chatTodoListService.setTodos(chatSessionId, todoList);
+        this.chatTodoListService.setTodos(chatSessionResource, todoList);
         const statusCounts = this.calculateStatusCounts(todoList);
         const warnings = [];
         if (todoList.length < 3) {
@@ -263,13 +264,16 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             notStartedCount: statusCounts.notStartedCount,
             inProgressCount: statusCounts.inProgressCount,
             completedCount: statusCounts.completedCount,
-            chatSessionId: chatSessionId
+            chatSessionId: chatSessionResourceToId(chatSessionResource)
         });
         return {
             content: [{
                     kind: 'text',
                     value: `Successfully wrote todo list${warnings.length ? '\n\n' + warnings.join('\n') : ''}`
-                }]
+                }],
+            toolMetadata: {
+                warnings: warnings
+            }
         };
     }
     calculateStatusCounts(todos) {

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

@@ -0,0 +1,25 @@
+import { CancellationToken } from "../../../../../base/common/cancellation.js";
+import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
+import { ILogService } from "../../../../../platform/log/common/log.service.js";
+import { IChatAgentService } from "../chatAgents.service.js";
+import { IChatModeService } from "../chatModes.service.js";
+import { IChatService } from "../chatService.service.js";
+import { ILanguageModelsService } from "../languageModels.service.js";
+import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "../languageModelToolsService.js";
+import { ILanguageModelToolsService } from "../languageModelToolsService.service.js";
+export declare const RunSubagentToolId = "runSubagent";
+export declare class RunSubagentTool extends Disposable implements IToolImpl {
+    private readonly chatAgentService;
+    private readonly chatService;
+    private readonly chatModeService;
+    private readonly languageModelToolsService;
+    private readonly languageModelsService;
+    private readonly logService;
+    private readonly toolsService;
+    private readonly configurationService;
+    constructor(chatAgentService: IChatAgentService, chatService: IChatService, chatModeService: IChatModeService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, logService: ILogService, toolsService: ILanguageModelToolsService, configurationService: IConfigurationService);
+    getToolData(): IToolData;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+}

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

@@ -0,0 +1,203 @@
+
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Codicon } from '../../../../../base/common/codicons.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { ThemeIcon } from '../../../../../base/common/themables.js';
+import { localize } from '../../../../../nls.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
+import { ILogService } from '../../../../../platform/log/common/log.service.js';
+import { IChatAgentService } from '../chatAgents.service.js';
+import { IChatModeService } from '../chatModes.service.js';
+import { IChatService } from '../chatService.service.js';
+import { LocalChatSessionUri } from '../chatUri.js';
+import { ChatConfiguration, ChatAgentLocation, ChatModeKind } from '../constants.js';
+import { ILanguageModelChatMetadata } from '../languageModels.js';
+import { ILanguageModelsService } from '../languageModels.service.js';
+import { ToolDataSource, VSCodeToolReference, ToolSet } from '../languageModelToolsService.js';
+import { ILanguageModelToolsService } from '../languageModelToolsService.service.js';
+import { ManageTodoListToolToolId } from './manageTodoListTool.js';
+import { createToolSimpleTextResult } from './toolHelpers.js';
+
+const RunSubagentToolId = 'runSubagent';
+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`;
+let RunSubagentTool = class RunSubagentTool extends Disposable {
+    constructor(chatAgentService, chatService, chatModeService, languageModelToolsService, languageModelsService, logService, toolsService, configurationService) {
+        super();
+        this.chatAgentService = chatAgentService;
+        this.chatService = chatService;
+        this.chatModeService = chatModeService;
+        this.languageModelToolsService = languageModelToolsService;
+        this.languageModelsService = languageModelsService;
+        this.logService = logService;
+        this.toolsService = toolsService;
+        this.configurationService = configurationService;
+    }
+    getToolData() {
+        const runSubagentToolData = {
+            id: RunSubagentToolId,
+            toolReferenceName: VSCodeToolReference.runSubagent,
+            canBeReferencedInPrompt: true,
+            icon: ThemeIcon.fromId(Codicon.organization.id),
+            displayName: ( localize(5963, 'Run Subagent')),
+            userDescription: ( localize(
+                5964,
+                'Runs a task within an isolated subagent context. Enables efficient organization of tasks and context window management.'
+            )),
+            modelDescription: BaseModelDescription,
+            source: ToolDataSource.Internal,
+            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'
+                    }
+                },
+                required: ['prompt', 'description']
+            }
+        };
+        if (this.configurationService.getValue(ChatConfiguration.SubagentToolCustomAgents)) {
+            runSubagentToolData.inputSchema.properties['subagentType'] = {
+                type: 'string',
+                description: 'Optional ID of a specific agent to invoke. If not provided, uses the current agent.'
+            };
+            runSubagentToolData.modelDescription += `\n- If the user asks for a certain agent by name, you MUST provide that EXACT subagentType (case-sensitive) to invoke that specific agent.`;
+        }
+        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(LocalChatSessionUri.forSession(invocation.context.sessionId));
+        if (!model) {
+            throw ( new Error('Chat model not found for session'));
+        }
+        const request = model.getRequests().at(-1);
+        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;
+            if (args.subagentType) {
+                const mode = this.chatModeService.findModeByName(args.subagentType);
+                if (mode) {
+                    const modeModelQualifiedName = mode.model?.get();
+                    if (modeModelQualifiedName) {
+                        const modelIds = this.languageModelsService.getLanguageModelIds();
+                        for (const modelId of modelIds) {
+                            const metadata = this.languageModelsService.lookupLanguageModel(modelId);
+                            if (metadata && ILanguageModelChatMetadata.matchesQualifiedName(modeModelQualifiedName, metadata)) {
+                                modeModelId = modelId;
+                                break;
+                            }
+                        }
+                    }
+                    const modeCustomTools = mode.customTools?.get();
+                    if (modeCustomTools) {
+                        const enablementMap = this.languageModelToolsService.toToolAndToolSetEnablementMap(modeCustomTools, mode.target?.get());
+                        modeTools = {};
+                        for (const [tool, enabled] of enablementMap) {
+                            if (!(tool instanceof ToolSet)) {
+                                modeTools[tool.id] = enabled;
+                            }
+                        }
+                    }
+                    const instructions = mode.modeInstructions?.get();
+                    modeInstructions = instructions && {
+                        name: mode.name.get(),
+                        content: instructions.content,
+                        toolReferences: this.toolsService.toToolReferences(instructions.toolReferences),
+                        metadata: instructions.metadata,
+                    };
+                }
+                else {
+                    this.logService.warn(`RunSubagentTool: Agent '${args.subagentType}' not found, using current configuration`);
+                }
+            }
+            const markdownParts = [];
+            let inEdit = false;
+            const progressCallback = (parts) => {
+                for (const part of parts) {
+                    if (part.kind === 'prepareToolInvocation' || 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')), fromSubagent: true });
+                        }
+                        model.acceptResponseProgress(request, part);
+                        if (part.kind === 'prepareToolInvocation') {
+                            markdownParts.length = 0;
+                        }
+                    }
+                    else if (part.kind === 'markdownContent') {
+                        if (inEdit) {
+                            model.acceptResponseProgress(request, { kind: 'markdownContent', content: ( new MarkdownString('\n```\n\n')), fromSubagent: true });
+                            inEdit = false;
+                        }
+                        markdownParts.push(part.content.value);
+                    }
+                }
+            };
+            if (modeTools) {
+                modeTools[RunSubagentToolId] = false;
+                modeTools[ManageTodoListToolToolId] = false;
+            }
+            const agentRequest = {
+                sessionId: invocation.context.sessionId,
+                requestId: invocation.callId ?? `subagent-${Date.now()}`,
+                agentId: defaultAgent.id,
+                message: args.prompt,
+                variables: { variables: [] },
+                location: ChatAgentLocation.Chat,
+                isSubagent: true,
+                userSelectedModelId: modeModelId,
+                userSelectedTools: modeTools,
+                modeInstructions,
+            };
+            const result = await this.chatAgentService.invokeAgent(defaultAgent.id, agentRequest, progressCallback, [], token);
+            if (result.errorDetails) {
+                return createToolSimpleTextResult(`Agent error: ${result.errorDetails.message}`);
+            }
+            return createToolSimpleTextResult(markdownParts.join('') || 'Agent completed with no output');
+        }
+        catch (error) {
+            const errorMessage = `Error invoking subagent: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            this.logService.error(errorMessage, error);
+            return createToolSimpleTextResult(errorMessage);
+        }
+    }
+    async prepareToolInvocation(context, _token) {
+        const args = context.parameters;
+        return {
+            invocationMessage: args.description,
+        };
+    }
+};
+RunSubagentTool = ( __decorate([
+    ( __param(0, IChatAgentService)),
+    ( __param(1, IChatService)),
+    ( __param(2, IChatModeService)),
+    ( __param(3, ILanguageModelToolsService)),
+    ( __param(4, ILanguageModelsService)),
+    ( __param(5, ILogService)),
+    ( __param(6, ILanguageModelToolsService)),
+    ( __param(7, IConfigurationService))
+], RunSubagentTool));
+
+export { RunSubagentTool, RunSubagentToolId };

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

@@ -0,0 +1,5 @@
+import { IToolResult } from "../languageModelToolsService.js";
+/**
+ * Creates a tool result with a single text content part.
+ */
+export declare function createToolSimpleTextResult(value: string): IToolResult;

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

@@ -0,0 +1,12 @@
+
+
+function createToolSimpleTextResult(value) {
+    return {
+        content: [{
+                kind: 'text',
+                value
+            }]
+    };
+}
+
+export { createToolSimpleTextResult };

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

@@ -7,6 +7,7 @@ import { ILanguageModelToolsService } from '../languageModelToolsService.service
 import { ConfirmationTool, ConfirmationToolData } from './confirmationTool.js';
 import { EditTool, EditToolData } from './editFileTool.js';
 import { TodoListToolWriteOnlySettingId, TodoListToolDescriptionFieldSettingId, createManageTodoListToolData, ManageTodoListTool } from './manageTodoListTool.js';
+import { RunSubagentTool } from './runSubagentTool.js';
 
 let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable {
     static { this.ID = 'chat.builtinTools'; }
@@ -22,6 +23,8 @@ let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable
         this._register(toolsService.registerTool(todoToolData, manageTodoListTool));
         const confirmationTool = instantiationService.createInstance(ConfirmationTool);
         this._register(toolsService.registerTool(ConfirmationToolData, confirmationTool));
+        const runSubagentTool = instantiationService.createInstance(RunSubagentTool);
+        this._register(toolsService.registerTool(runSubagentTool.getToolData(), runSubagentTool));
     }
 };
 BuiltinToolsContribution = ( __decorate([

package/vscode/src/vs/workbench/contrib/codeActions/browser/codeActionsContribution.js

@@ -18,17 +18,17 @@ const createCodeActionsAutoSave = (description) => {
         enum: ['always', 'explicit', 'never', true, false],
         enumDescriptions: [
             ( localize(
-            5723,
+            5966,
             'Triggers Code Actions on explicit saves and auto saves triggered by window or focus changes.'
         )),
-            ( localize(5724, 'Triggers Code Actions only when explicitly saved')),
-            ( localize(5725, 'Never triggers Code Actions on save')),
+            ( localize(5967, 'Triggers Code Actions only when explicitly saved')),
+            ( localize(5968, 'Never triggers Code Actions on save')),
             ( localize(
-            5726,
+            5969,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
         )),
             ( localize(
-            5727,
+            5970,
             'Never triggers Code Actions on save. This value will be deprecated in favor of "never".'
         ))
         ],
@@ -41,14 +41,14 @@ const createNotebookCodeActionsAutoSave = (description) => {
         type: ['string', 'boolean'],
         enum: ['explicit', 'never', true, false],
         enumDescriptions: [
-            ( localize(5728, 'Triggers Code Actions only when explicitly saved.')),
-            ( localize(5729, 'Never triggers Code Actions on save.')),
+            ( localize(5971, 'Triggers Code Actions only when explicitly saved.')),
+            ( localize(5972, 'Never triggers Code Actions on save.')),
             ( localize(
-            5730,
+            5973,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
         )),
             ( localize(
-            5731,
+            5974,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "never".'
         ))
         ],
@@ -70,7 +70,7 @@ const codeActionsOnSaveSchema = {
         }
     ],
     markdownDescription: ( localize(
-        5732,
+        5975,
         'Run Code Actions for the editor on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `"source.organizeImports": "explicit" `',
         '`#files.autoSave#`'
     )),
@@ -102,7 +102,7 @@ const notebookCodeActionsOnSaveSchema = {
         }
     ],
     markdownDescription: ( localize(
-        5733,
+        5976,
         'Run a series of Code Actions for a notebook on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `"notebook.source.organizeImports": "explicit"`',
         '`#files.autoSave#`'
     )),
@@ -150,12 +150,12 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
         for (const codeActionKind of allProvidedKinds) {
             if (CodeActionKind.Source.contains(codeActionKind) && !properties[codeActionKind.value]) {
                 properties[codeActionKind.value] = createCodeActionsAutoSave(( localize(
-                    5734,
+                    5977,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));
                 notebookProperties[codeActionKind.value] = createNotebookCodeActionsAutoSave(( localize(
-                    5734,
+                    5977,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));