@codingame/monaco-vscode-api 27.0.0 → 28.0.1

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

@@ -0,0 +1,205 @@
+
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localize } from '../../../../../../nls.js';
+import { ChatContextKeys } from '../../actions/chatContextKeys.js';
+import { IChatDebugService } from '../../chatDebugService.service.js';
+import { ToolDataSource } from '../languageModelToolsService.js';
+
+const ResolveDebugEventDetailsToolId = "vscode_resolveDebugEventDetails_internal";
+const ResolveDebugEventDetailsToolData = {
+    id: ResolveDebugEventDetailsToolId,
+    toolReferenceName: "resolveDebugEventDetails",
+    displayName: ( localize(7366, "Resolve Debug Event Details")),
+    when: ChatContextKeys.chatSessionHasAttachedDebugData,
+    canBeReferencedInPrompt: false,
+    modelDescription: "Resolves the full details for a specific chat debug event by its event ID. Use this tool to get detailed information about a debug event such as tool call input/output, model turn details, user message sections, or file lists. The event ID can be found in the debug event log summary provided in the conversation context.",
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: "object",
+        properties: {
+            eventId: {
+                type: "string",
+                description: "The ID of the debug event to resolve details for."
+            }
+        },
+        required: ["eventId"]
+    }
+};
+function formatResolvedContent(content) {
+    switch (content.kind) {
+    case "text":
+        return content.value;
+    case "fileList":
+        {
+            const lines = [`File list (${content.discoveryType}):`];
+            if (content.sourceFolders) {
+                for (const folder of content.sourceFolders) {
+                    lines.push(`  Source folder: ${( folder.uri.toString())} (${folder.storage}, ${folder.fileCount} files${folder.exists ? "" : ", missing"})`);
+                }
+            }
+            for (const file of content.files) {
+                const status = file.status === "loaded" ? "loaded" : `skipped${file.skipReason ? `: ${file.skipReason}` : ""}`;
+                lines.push(`  ${( file.uri.toString())} [${status}]`);
+            }
+            return lines.join("\n");
+        }
+    case "message":
+        {
+            const lines = [
+                `${content.type === "user" ? "User" : "Agent"} message: ${content.message}`
+            ];
+            for (const section of content.sections) {
+                lines.push(`--- ${section.name} ---`);
+                lines.push(section.content);
+            }
+            return lines.join("\n");
+        }
+    case "toolCall":
+        {
+            const lines = [`Tool call: ${content.toolName}`];
+            if (content.result) {
+                lines.push(`Result: ${content.result}`);
+            }
+            if (content.durationInMillis !== undefined) {
+                lines.push(`Duration: ${content.durationInMillis}ms`);
+            }
+            if (content.input) {
+                lines.push(`Input:\n${content.input}`);
+            }
+            if (content.output) {
+                lines.push(`Output:\n${content.output}`);
+            }
+            return lines.join("\n");
+        }
+    case "modelTurn":
+        {
+            const lines = [`Model turn: ${content.requestName}`];
+            if (content.model) {
+                lines.push(`Model: ${content.model}`);
+            }
+            if (content.status) {
+                lines.push(`Status: ${content.status}`);
+            }
+            if (content.durationInMillis !== undefined) {
+                lines.push(`Duration: ${content.durationInMillis}ms`);
+            }
+            if (content.inputTokens !== undefined || content.outputTokens !== undefined) {
+                lines.push(
+                    `Tokens: input=${content.inputTokens ?? "?"}, output=${content.outputTokens ?? "?"}, cached=${content.cachedTokens ?? "?"}, total=${content.totalTokens ?? "?"}`
+                );
+            }
+            if (content.errorMessage) {
+                lines.push(`Error: ${content.errorMessage}`);
+            }
+            if (content.sections) {
+                for (const section of content.sections) {
+                    lines.push(`--- ${section.name} ---`);
+                    lines.push(section.content);
+                }
+            }
+            return lines.join("\n");
+        }
+    default:
+        {
+            const _ = content;
+            return JSON.stringify(_);
+        }
+    }
+}
+function truncate(text, maxLength = 30) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    const lastSpace = text.lastIndexOf(" ", maxLength);
+    const cutoff = lastSpace > maxLength / 2 ? lastSpace : maxLength;
+    return text.substring(0, cutoff) + "…";
+}
+function getEventLabel(event) {
+    switch (event.kind) {
+    case "generic":
+        return event.name;
+    case "toolCall":
+        return event.toolName;
+    case "modelTurn":
+        return event.requestName ?? ( localize(7367, "Model Turn"));
+    case "userMessage":
+        return localize(7368, "User Message: {0}", truncate(event.message));
+    case "agentResponse":
+        return localize(7369, "Agent Response: {0}", truncate(event.message));
+    case "subagentInvocation":
+        return event.agentName;
+    }
+}
+let ResolveDebugEventDetailsTool = class ResolveDebugEventDetailsTool {
+    constructor(chatDebugService) {
+        this.chatDebugService = chatDebugService;
+    }
+    async prepareToolInvocation(context, _token) {
+        const eventId = context.parameters?.eventId;
+        let eventLabel;
+        if (typeof eventId === "string" && context.chatSessionResource) {
+            const events = this.chatDebugService.getEvents(context.chatSessionResource);
+            const event = events.find(e => e.id === eventId);
+            if (event) {
+                eventLabel = getEventLabel(event);
+            }
+        }
+        if (eventLabel) {
+            return {
+                invocationMessage: ( localize(7370, "Resolving details for \"{0}\"", eventLabel)),
+                pastTenseMessage: ( localize(7371, "Resolved details for \"{0}\"", eventLabel))
+            };
+        }
+        return {
+            invocationMessage: ( localize(7372, "Resolving debug event details")),
+            pastTenseMessage: ( localize(7373, "Resolved debug event details"))
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const eventId = invocation.parameters["eventId"];
+        if (typeof eventId !== "string" || !eventId) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: eventId parameter is required."
+                }]
+            };
+        }
+        const sessionResource = invocation.context?.sessionResource;
+        if (!sessionResource) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: "Error: no chat session context available."
+                }]
+            };
+        }
+        const sessionEvents = this.chatDebugService.getEvents(sessionResource);
+        if (!( sessionEvents.some(e => e.id === eventId))) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: `No event with ID "${eventId}" found in the current session.`
+                }]
+            };
+        }
+        const resolved = await this.chatDebugService.resolveEvent(eventId);
+        if (!resolved) {
+            return {
+                content: [{
+                    kind: "text",
+                    value: `No details found for event ID: ${eventId}`
+                }]
+            };
+        }
+        return {
+            content: [{
+                kind: "text",
+                value: formatResolvedContent(resolved)
+            }]
+        };
+    }
+};
+ResolveDebugEventDetailsTool = ( __decorate([( __param(0, IChatDebugService))], ResolveDebugEventDetailsTool));
+
+export { ResolveDebugEventDetailsTool, ResolveDebugEventDetailsToolData, ResolveDebugEventDetailsToolId };

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

@@ -5,6 +5,7 @@ import { IConfigurationChangeEvent } from "../../../../../../platform/configurat
 import { IConfigurationService } from "../../../../../../platform/configuration/common/configuration.service.js";
 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 { IChatService } from "../../chatService/chatService.service.js";
 import { ILanguageModelsService } from "../../languageModels.service.js";
 import { IChatAgentService } from "../../participants/chatAgents.service.js";
@@ -26,11 +27,12 @@ export declare class RunSubagentTool extends Disposable implements IToolImpl {
     private readonly configurationService;
     private readonly promptsService;
     private readonly instantiationService;
+    private readonly productService;
     static readonly Id = "runSubagent";
     readonly onDidUpdateToolData: Event<IConfigurationChangeEvent>;
     /** Hack to port data between prepare/invoke */
     private readonly _resolvedModels;
-    constructor(chatAgentService: IChatAgentService, chatService: IChatService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, logService: ILogService, toolsService: ILanguageModelToolsService, configurationService: IConfigurationService, promptsService: IPromptsService, instantiationService: IInstantiationService);
+    constructor(chatAgentService: IChatAgentService, chatService: IChatService, languageModelToolsService: ILanguageModelToolsService, languageModelsService: ILanguageModelsService, logService: ILogService, toolsService: ILanguageModelToolsService, configurationService: IConfigurationService, promptsService: IPromptsService, instantiationService: IInstantiationService, productService: IProductService);
     getToolData(): IToolData;
     invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
     private getSubAgentByName;

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

@@ -11,13 +11,17 @@ import { localize } from '../../../../../../nls.js';
 import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.service.js';
 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 { ChatRequestVariableSet } from '../../attachments/chatVariableEntries.js';
 import { IChatService } from '../../chatService/chatService.service.js';
 import { ChatConfiguration, ChatAgentLocation, ChatModeKind } from '../../constants.js';
 import { ILanguageModelsService } from '../../languageModels.service.js';
 import { IChatAgentService } from '../../participants/chatAgents.service.js';
 import { ComputeAutomaticInstructions } from '../../promptSyntax/computeAutomaticInstructions.js';
+import { mergeHooks } from '../../promptSyntax/hookSchema.js';
+import { HookType } from '../../promptSyntax/hookTypes.js';
 import { IPromptsService } from '../../promptSyntax/service/promptsService.service.js';
+import { isBuiltinAgent } from '../../promptSyntax/utils/promptsServiceUtils.js';
 import { ToolDataSource, VSCodeToolReference, isToolSet } from '../languageModelToolsService.js';
 import { ILanguageModelToolsService } from '../languageModelToolsService.service.js';
 import { ManageTodoListToolToolId } from './manageTodoListTool.js';
@@ -47,7 +51,8 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         toolsService,
         configurationService,
         promptsService,
-        instantiationService
+        instantiationService,
+        productService
     ) {
         super();
         this.chatAgentService = chatAgentService;
@@ -59,6 +64,7 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         this.configurationService = configurationService;
         this.promptsService = promptsService;
         this.instantiationService = instantiationService;
+        this.productService = productService;
         this._resolvedModels = ( new Map());
         this.onDidUpdateToolData = Event.filter(
             this.configurationService.onDidChangeConfiguration,
@@ -92,9 +98,9 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             id: RunSubagentTool_1.Id,
             toolReferenceName: VSCodeToolReference.runSubagent,
             icon: ThemeIcon.fromId(Codicon.organization.id),
-            displayName: ( localize(7189, "Run Subagent")),
+            displayName: ( localize(7374, "Run Subagent")),
             userDescription: ( localize(
-                7190,
+                7375,
                 "Run a task within an isolated subagent context to enable efficient organization of tasks and context window management."
             )),
             modelDescription: modelDescription,
@@ -156,7 +162,8 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
                         name: subAgentName,
                         content: instructions.content,
                         toolReferences: this.toolsService.toToolReferences(instructions.toolReferences),
-                        metadata: instructions.metadata
+                        metadata: instructions.metadata,
+                        isBuiltin: isBuiltinAgent(subagent.source, subagent.uri, this.productService)
                     };
                 } else {
                     throw ( new Error(
@@ -232,6 +239,17 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
             } 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()}`,
@@ -338,6 +356,6 @@ let RunSubagentTool = class RunSubagentTool extends Disposable {
         };
     }
 };
-RunSubagentTool = RunSubagentTool_1 = ( __decorate([( __param(0, IChatAgentService)), ( __param(1, IChatService)), ( __param(2, ILanguageModelToolsService)), ( __param(3, ILanguageModelsService)), ( __param(4, ILogService)), ( __param(5, ILanguageModelToolsService)), ( __param(6, IConfigurationService)), ( __param(7, IPromptsService)), ( __param(8, IInstantiationService))], RunSubagentTool));
+RunSubagentTool = RunSubagentTool_1 = ( __decorate([( __param(0, IChatAgentService)), ( __param(1, IChatService)), ( __param(2, ILanguageModelToolsService)), ( __param(3, ILanguageModelsService)), ( __param(4, ILogService)), ( __param(5, ILanguageModelToolsService)), ( __param(6, IConfigurationService)), ( __param(7, IPromptsService)), ( __param(8, IInstantiationService)), ( __param(9, IProductService))], RunSubagentTool));
 
 export { RunSubagentTool };

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

@@ -0,0 +1,12 @@
+import { CancellationToken } from "../../../../../../base/common/cancellation.js";
+import { IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress, CountTokensCallback } from "../languageModelToolsService.js";
+export declare const TaskCompleteToolId = "task_complete";
+/**
+ * Message sent to the agent when the session goes idle without task completion.
+ */
+export declare const AUTOPILOT_CONTINUATION_MESSAGE: string;
+export declare const TaskCompleteToolData: IToolData;
+export declare class TaskCompleteTool implements IToolImpl {
+    prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
+    invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, _token: CancellationToken): Promise<IToolResult>;
+}

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

@@ -0,0 +1,53 @@
+
+import { ToolDataSource, ToolInvocationPresentation } from '../languageModelToolsService.js';
+
+const TaskCompleteToolId = 'task_complete';
+const TaskCompleteToolData = {
+    id: TaskCompleteToolId,
+    displayName: 'Task Complete',
+    modelDescription: 'Signal that the user\'s task is fully done. You MUST call this tool when your work is complete — ' +
+        'whether you made code changes, answered a question, or completed any other kind of task. ' +
+        'Provide a brief summary of what was accomplished. ' +
+        'Do not restate the summary in your message text — it is shown to the user directly.\n\n' +
+        'IMPORTANT: Before calling this tool, you MUST output a brief text message summarizing what was done. ' +
+        'The task is not complete until both your summary message AND this tool call are present.\n\n' +
+        'When to call:\n' +
+        '- After answering the user\'s question or completing a conversational request\n' +
+        '- After you have completed ALL requested changes\n' +
+        '- After verifying results: tests pass, terminal commands succeeded, tool calls returned expected output\n\n' +
+        'When NOT to call:\n' +
+        '- If a terminal command failed or produced unexpected output\n' +
+        '- If an MCP or external tool call returned an error\n' +
+        '- If you encountered errors you have not resolved\n' +
+        '- If there are remaining steps to complete\n' +
+        '- If you have not verified your changes work',
+    source: ToolDataSource.Internal,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            summary: {
+                type: 'string',
+                description: 'Brief summary of what was accomplished. Omit for trivial interactions.',
+            },
+        },
+    },
+};
+class TaskCompleteTool {
+    async prepareToolInvocation(_context, _token) {
+        return {
+            presentation: ToolInvocationPresentation.Hidden,
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const params = invocation.parameters;
+        const summary = params?.summary ?? 'All done!';
+        return {
+            content: [{
+                    kind: 'text',
+                    value: summary,
+                }],
+        };
+    }
+}
+
+export { TaskCompleteTool, TaskCompleteToolData, TaskCompleteToolId };

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

@@ -7,7 +7,9 @@ import { AskQuestionsTool, AskQuestionsToolData } from './askQuestionsTool.js';
 import { ConfirmationTool, ConfirmationToolData, ConfirmationToolWithOptionsData } from './confirmationTool.js';
 import { EditTool, EditToolData } from './editFileTool.js';
 import { createManageTodoListToolData, ManageTodoListTool } from './manageTodoListTool.js';
+import { ResolveDebugEventDetailsTool, ResolveDebugEventDetailsToolData } from './resolveDebugEventDetailsTool.js';
 import { RunSubagentTool } from './runSubagentTool.js';
+import { TaskCompleteTool, TaskCompleteToolData } from './taskCompleteTool.js';
 
 let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable {
     static {
@@ -28,6 +30,13 @@ let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable
         this._register(
             toolsService.registerTool(ConfirmationToolWithOptionsData, confirmationTool)
         );
+        const taskCompleteTool = instantiationService.createInstance(TaskCompleteTool);
+        this._register(toolsService.registerTool(TaskCompleteToolData, taskCompleteTool));
+        const resolveDebugEventDetailsTool = instantiationService.createInstance(ResolveDebugEventDetailsTool);
+        this._register(
+            toolsService.registerTool(ResolveDebugEventDetailsToolData, resolveDebugEventDetailsTool)
+        );
+        this._register(toolsService.readToolSet.addTool(ResolveDebugEventDetailsToolData));
         const runSubagentTool = this._register(instantiationService.createInstance(RunSubagentTool));
         let runSubagentRegistration;
         let toolSetRegistration;

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

@@ -30,7 +30,7 @@ export interface ILanguageModelToolConfirmationActionProducer {
 export interface ILanguageModelToolConfirmationContributionQuickTreeItem extends IQuickTreeItem {
     onDidTriggerItemButton?(button: IQuickInputButton): void;
     onDidChangeChecked?(checked: boolean): void;
-    onDidOpen?(): void;
+    onDidOpen?(): void | Promise<void>;
 }
 /**
  * Type that can be registered to provide more specific confirmation

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

@@ -19,12 +19,21 @@ export interface ILanguageModelToolsConfirmationService extends ILanguageModelTo
     /** Opens an IQuickTree to let the user manage their preferences.  */
     manageConfirmationPreferences(tools: readonly IToolData[], options?: {
         defaultScope?: "workspace" | "profile" | "session";
+        focusToolId?: string;
     }): void;
     /**
     * Registers a contribution that provides more specific confirmation logic
     * for a tool, in addition to the default confirmation handling.
     */
     registerConfirmationContribution(toolName: string, contribution: ILanguageModelToolConfirmationContribution): IDisposable;
+    /**
+    * Returns true if the tool has confirmation that can be managed, either
+    * because it has {@link IToolData.canRequestPreApproval} or
+    * {@link IToolData.canRequestPostApproval} set, because a
+    * {@link ILanguageModelToolConfirmationContribution} is registered for it,
+    * or because it has stored auto-confirmation settings.
+    */
+    toolCanManageConfirmation(tool: IToolData): boolean;
     /** Resets all tool and server confirmation preferences */
     resetToolAutoConfirmation(): void;
 }

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

@@ -30,7 +30,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
     },
     jsonSchema: {
         description: ( localize(
-            7191,
+            7376,
             "Contributes a tool that can be invoked by a language model in a chat session, or from a standalone command. Registered tools can be used by all extensions."
         )),
         type: "array",
@@ -56,7 +56,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
             properties: {
                 name: {
                     description: ( localize(
-                        7192,
+                        7377,
                         "A unique name for this tool. This name must be a globally unique identifier, and is also used as a name when presenting this tool to a language model."
                     )),
                     type: "string",
@@ -64,7 +64,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 toolReferenceName: {
                     markdownDescription: ( localize(
-                        7193,
+                        7378,
                         "If {0} is enabled for this tool, the user may use '#' with this name to invoke the tool in a query. Otherwise, the name is not required. Name must not contain whitespace.",
                         "`canBeReferencedInPrompt`"
                     )),
@@ -73,32 +73,32 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 displayName: {
                     description: ( localize(
-                        7194,
+                        7379,
                         "A human-readable name for this tool that may be used to describe it in the UI."
                     )),
                     type: "string"
                 },
                 userDescription: {
-                    description: ( localize(7195, "A description of this tool that may be shown to the user.")),
+                    description: ( localize(7380, "A description of this tool that may be shown to the user.")),
                     type: "string"
                 },
                 modelDescription: {
                     description: ( localize(
-                        7196,
+                        7381,
                         "A description of this tool that may be used by a language model to select it."
                     )),
                     type: "string"
                 },
                 inputSchema: {
                     description: ( localize(
-                        7197,
+                        7382,
                         "A JSON schema for the input this tool accepts. The input must be an object at the top level. A particular language model may not support all JSON schema features. See the documentation for the language model family you are using for more information."
                     )),
                     $ref: toolsParametersSchemaSchemaId
                 },
                 canBeReferencedInPrompt: {
                     markdownDescription: ( localize(
-                        7198,
+                        7383,
                         "If true, this tool shows up as an attachment that the user can add manually to their request. Chat participants will receive the tool in {0}.",
                         "`ChatRequest#toolReferences`"
                     )),
@@ -106,7 +106,7 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 icon: {
                     markdownDescription: ( localize(
-                        7199,
+                        7384,
                         "An icon that represents this tool. Either a file path, an object with file paths for dark and light themes, or a theme icon reference, like \"\\$(zap)\""
                     )),
                     anyOf: [{
@@ -115,11 +115,11 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                         type: "object",
                         properties: {
                             light: {
-                                description: ( localize(7200, "Icon path when a light theme is used")),
+                                description: ( localize(7385, "Icon path when a light theme is used")),
                                 type: "string"
                             },
                             dark: {
-                                description: ( localize(7201, "Icon path when a dark theme is used")),
+                                description: ( localize(7386, "Icon path when a dark theme is used")),
                                 type: "string"
                             }
                         }
@@ -127,14 +127,14 @@ const languageModelToolsExtensionPoint = ExtensionsRegistry.registerExtensionPoi
                 },
                 when: {
                     markdownDescription: ( localize(
-                        7202,
+                        7387,
                         "Condition which must be true for this tool to be enabled. Note that a tool may still be invoked by another extension even when its `when` condition is false."
                     )),
                     type: "string"
                 },
                 tags: {
                     description: ( localize(
-                        7203,
+                        7388,
                         "A set of tags that roughly describe the tool's capabilities. A tool user may use these to filter the set of tools to just ones that are relevant for the task at hand, or they may want to pick a tag that can be used to identify just the tools contributed by this extension."
                     )),
                     type: "array",
@@ -152,7 +152,7 @@ const languageModelToolSetsExtensionPoint = ExtensionsRegistry.registerExtension
     deps: [languageModelToolsExtensionPoint],
     jsonSchema: {
         description: ( localize(
-            7204,
+            7389,
             "Contributes a set of language model tools that can be used together."
         )),
         type: "array",
@@ -170,23 +170,23 @@ const languageModelToolSetsExtensionPoint = ExtensionsRegistry.registerExtension
             properties: {
                 name: {
                     description: ( localize(
-                        7205,
+                        7390,
                         "A name for this tool set. Used as reference and should not contain whitespace."
                     )),
                     type: "string",
                     pattern: "^[\\w-]+$"
                 },
                 description: {
-                    description: ( localize(7206, "A description of this tool set.")),
+                    description: ( localize(7391, "A description of this tool set.")),
                     type: "string"
                 },
                 icon: {
-                    markdownDescription: ( localize(7207, "An icon that represents this tool set, like `$(zap)`")),
+                    markdownDescription: ( localize(7392, "An icon that represents this tool set, like `$(zap)`")),
                     type: "string"
                 },
                 tools: {
                     markdownDescription: ( localize(
-                        7208,
+                        7393,
                         "A list of tools or tool sets to include in this tool set. Cannot be empty and must reference tools by their `toolReferenceName`."
                     )),
                     type: "array",
@@ -426,7 +426,7 @@ class LanguageModelToolDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(7209, "Name")), ( localize(7210, "Display Name")), ( localize(7211, "Description"))];
+        const headers = [( localize(7394, "Name")), ( localize(7395, "Display Name")), ( localize(7396, "Description"))];
         const rows = ( contribs.map(t => {
             return [( new MarkdownString(`\`${t.name}\``)), t.displayName, t.userDescription ?? t.modelDescription];
         }));
@@ -441,7 +441,7 @@ class LanguageModelToolDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelTools",
-    label: ( localize(7212, "Language Model Tools")),
+    label: ( localize(7397, "Language Model Tools")),
     access: {
         canToggle: false
     },
@@ -466,7 +466,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
                 dispose: () => {}
             };
         }
-        const headers = [( localize(7213, "Name")), ( localize(7214, "Reference Name")), ( localize(7215, "Tools")), ( localize(7216, "Description"))];
+        const headers = [( localize(7398, "Name")), ( localize(7399, "Reference Name")), ( localize(7400, "Tools")), ( localize(7401, "Description"))];
         const rows = ( contribs.map(t => {
             return [( new MarkdownString(`\`${t.name}\``)), t.referenceName ? ( new MarkdownString(`\`#${t.referenceName}\``)) : "none", t.tools.join(", "), t.description];
         }));
@@ -481,7 +481,7 @@ class LanguageModelToolSetDataRenderer extends Disposable {
 }
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: "languageModelToolSets",
-    label: ( localize(7217, "Language Model Tool Sets")),
+    label: ( localize(7402, "Language Model Tool Sets")),
     access: {
         canToggle: false
     },

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

@@ -54,7 +54,7 @@ var ToolDataSource;
         if (source.type === "internal") {
             return {
                 ordinal: 1,
-                label: ( localize(7218, "Built-In"))
+                label: ( localize(7403, "Built-In"))
             };
         } else if (source.type === "mcp") {
             return {
@@ -64,7 +64,7 @@ var ToolDataSource;
         } else if (source.type === "user") {
             return {
                 ordinal: 0,
-                label: ( localize(7219, "User Defined"))
+                label: ( localize(7404, "User Defined"))
             };
         } else {
             return {
@@ -93,7 +93,7 @@ function toolContentToA11yString(part) {
             return p.value;
         case "data":
             return localize(
-                7220,
+                7405,
                 "{0} of {1} binary data",
                 ByteSize.formatSize(p.value.data.byteLength),
                 p.value.mimeType || "unknown"

package/vscode/src/vs/workbench/contrib/chat/common/widget/chatResponseResourceFileSystemProvider.service.d.ts

@@ -0,0 +1,15 @@
+import { URI } from "../../../../../base/common/uri.js";
+import { IFileSystemProvider } from "../../../../../platform/files/common/files.js";
+export declare const IChatResponseResourceFileSystemProvider: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatResponseResourceFileSystemProvider>;
+export interface IChatResponseResourceFileSystemProvider extends IFileSystemProvider {
+    readonly _serviceBrand: undefined;
+    /**
+    * Associates arbitrary data with a URI in the chat response resource filesystem.
+    * The data is scoped to the given session and automatically cleaned up when
+    * the session is disposed.
+    * Returns a URI that can later be read via the file service.
+    */
+    associate(sessionResource: URI, data: Uint8Array | {
+        base64: string;
+    }, name?: string): URI;
+}