@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

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

@@ -4,7 +4,7 @@ import { renderAsPlaintext } from '@codingame/monaco-vscode-api/vscode/vs/base/b
 import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
 import { RunOnceScheduler, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { encodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
-import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { arrayEqualsC } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
 import { toErrorMessage } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errorMessage';
@@ -34,32 +34,50 @@ import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform
 import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
-import { ChatToolInvocation } from '../../common/model/chatProgressTypes/chatToolInvocation.js';
+import { toToolSetVariableEntry, toToolVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
 import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
-import { toToolSetVariableEntry, toToolVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
 import { ChatConfiguration } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatToolInvocation } from '../../common/model/chatProgressTypes/chatToolInvocation.js';
 import { ILanguageModelToolsConfirmationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsConfirmationService.service';
-import { ToolDataSource, VSCodeToolReference, SpecedToolAliases, ToolSet, createToolSchemaUri, stringifyPromptTsxPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ToolDataSource, VSCodeToolReference, SpecedToolAliases, isToolSet, createToolSchemaUri, toolMatchesModel, stringifyPromptTsxPart, ToolSetForModel, ToolSet } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { getToolConfirmationAlert } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/accessibility/chatAccessibilityProvider';
-import { observableFromEventOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { chatSessionResourceToId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import { ObservableSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/set';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { derived, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableFromEventOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+import { observableSignal } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignal';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
 
 var LanguageModelToolsService_1;
 const jsonSchemaRegistry = ( Registry.as(Extensions.JSONContribution));
 var AutoApproveStorageKeys;
-(function (AutoApproveStorageKeys) {
+(function(AutoApproveStorageKeys) {
     AutoApproveStorageKeys["GlobalAutoApproveOptIn"] = "chat.tools.global.autoApprove.optIn";
 })(AutoApproveStorageKeys || (AutoApproveStorageKeys = {}));
-const SkipAutoApproveConfirmationKey = 'vscode.chat.tools.global.autoApprove.testMode';
+const SkipAutoApproveConfirmationKey = "vscode.chat.tools.global.autoApprove.testMode";
 const globalAutoApproveDescription = ( localize2(
-    5574,
-    'Global auto approve also known as "YOLO mode" disables manual approval completely for _all tools in all workspaces_, allowing the agent to act fully autonomously. This is extremely dangerous and is *never* recommended, even containerized environments like [Codespaces](https://github.com/features/codespaces) and [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) have user keys forwarded into the container that could be compromised.\n\n**This feature disables [critical security protections](https://code.visualstudio.com/docs/copilot/security) and makes it much easier for an attacker to compromise the machine.**'
+    5792,
+    "Global auto approve also known as \"YOLO mode\" disables manual approval completely for _all tools in all workspaces_, allowing the agent to act fully autonomously. This is extremely dangerous and is *never* recommended, even containerized environments like [Codespaces](https://github.com/features/codespaces) and [Dev Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) have user keys forwarded into the container that could be compromised.\n\n**This feature disables [critical security protections](https://code.visualstudio.com/docs/copilot/security) and makes it much easier for an attacker to compromise the machine.**"
 ));
 let LanguageModelToolsService = class LanguageModelToolsService extends Disposable {
-    static { LanguageModelToolsService_1 = this; }
-    constructor(_instantiationService, _extensionService, _contextKeyService, _chatService, _dialogService, _telemetryService, _logService, _configurationService, _accessibilityService, _accessibilitySignalService, _storageService, _confirmationService) {
+    static {
+        LanguageModelToolsService_1 = this;
+    }
+    constructor(
+        _instantiationService,
+        _extensionService,
+        _contextKeyService,
+        _chatService,
+        _dialogService,
+        _telemetryService,
+        _logService,
+        _configurationService,
+        _accessibilityService,
+        _accessibilitySignalService,
+        _storageService,
+        _confirmationService
+    ) {
         super();
         this._instantiationService = _instantiationService;
         this._extensionService = _extensionService;
@@ -77,21 +95,26 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         this.onDidChangeTools = this._onDidChangeTools.event;
         this._onDidPrepareToolCallBecomeUnresponsive = this._register(( new Emitter()));
         this.onDidPrepareToolCallBecomeUnresponsive = this._onDidPrepareToolCallBecomeUnresponsive.event;
+        this._onDidInvokeTool = this._register(( new Emitter()));
+        this.onDidInvokeTool = this._onDidInvokeTool.event;
         this._onDidChangeToolsScheduler = ( new RunOnceScheduler(() => this._onDidChangeTools.fire(), 750));
         this._tools = ( new Map());
         this._toolContextKeys = ( new Set());
         this._callsByRequestId = ( new Map());
-        this.toolsObservable = observableFromEventOpts({ equalsFn: arrayEqualsC() }, this.onDidChangeTools, () => Array.from(this.getTools()));
+        this._pendingToolCalls = ( new Map());
         this._toolSets = ( new ObservableSet());
         this.toolSets = derived(this, reader => {
             const allToolSets = Array.from(this._toolSets.observable.read(reader));
             return allToolSets.filter(toolSet => this.isPermitted(toolSet, reader));
         });
+        this.allToolsIncludingDisableObs = observableFromEventOpts({
+            equalsFn: arrayEqualsC()
+        }, this.onDidChangeTools, () => Array.from(this.getAllToolsIncludingDisabled()));
         this.toolsWithFullReferenceName = derived(reader => {
             const result = [];
             const coveredByToolSets = ( new Set());
             for (const toolSet of this.toolSets.read(reader)) {
-                if (toolSet.source.type !== 'user') {
+                if (toolSet.source.type !== "user") {
                     result.push([toolSet, getToolSetFullReferenceName(toolSet)]);
                     for (const tool of toolSet.getTools()) {
                         result.push([tool, getToolFullReferenceName(tool, toolSet)]);
@@ -99,7 +122,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     }
                 }
             }
-            for (const tool of this.toolsObservable.read(reader)) {
+            for (const tool of this.allToolsIncludingDisableObs.read(reader)) {
+                if (tool.when && !this._contextKeyService.contextMatchesRules(tool.when)) {
+                    continue;
+                }
                 if (tool.canBeReferencedInPrompt && !( coveredByToolSets.has(tool)) && this.isPermitted(tool, reader)) {
                     result.push([tool, getToolFullReferenceName(tool)]);
                 }
@@ -117,26 +143,40 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 this._onDidChangeToolsScheduler.schedule();
             }
         }));
-        this._register(Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
-            if (!e || e.affectsConfiguration(ChatConfiguration.GlobalAutoApprove)) {
-                if (this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove) !== true) {
-                    this._storageService.remove(AutoApproveStorageKeys.GlobalAutoApproveOptIn, StorageScope.APPLICATION);
+        this._register(
+            Event.runAndSubscribe(this._configurationService.onDidChangeConfiguration, e => {
+                if (!e || e.affectsConfiguration(ChatConfiguration.GlobalAutoApprove)) {
+                    if (this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove) !== true) {
+                        this._storageService.remove(AutoApproveStorageKeys.GlobalAutoApproveOptIn, StorageScope.APPLICATION);
+                    }
                 }
-            }
-        }));
+            })
+        );
         this._ctxToolsCount = ChatContextKeys.Tools.toolsCount.bindTo(_contextKeyService);
-        this.vscodeToolSet = this._register(this.createToolSet(ToolDataSource.Internal, 'vscode', VSCodeToolReference.vscode, {
-            icon: ThemeIcon.fromId(Codicon.vscode.id),
-            description: ( localize(5575, 'Use VS Code features')),
-        }));
-        this.executeToolSet = this._register(this.createToolSet(ToolDataSource.Internal, 'execute', SpecedToolAliases.execute, {
-            icon: ThemeIcon.fromId(Codicon.terminal.id),
-            description: ( localize(5576, 'Execute code and applications on your machine')),
-        }));
-        this.readToolSet = this._register(this.createToolSet(ToolDataSource.Internal, 'read', SpecedToolAliases.read, {
-            icon: ThemeIcon.fromId(Codicon.eye.id),
-            description: ( localize(5577, 'Read files in your workspace')),
-        }));
+        this.vscodeToolSet = this._register(
+            this.createToolSet(ToolDataSource.Internal, "vscode", VSCodeToolReference.vscode, {
+                icon: ThemeIcon.fromId(Codicon.vscode.id),
+                description: ( localize(5793, "Use VS Code features"))
+            })
+        );
+        this.executeToolSet = this._register(
+            this.createToolSet(ToolDataSource.Internal, "execute", SpecedToolAliases.execute, {
+                icon: ThemeIcon.fromId(Codicon.terminal.id),
+                description: ( localize(5794, "Execute code and applications on your machine"))
+            })
+        );
+        this.readToolSet = this._register(
+            this.createToolSet(ToolDataSource.Internal, "read", SpecedToolAliases.read, {
+                icon: ThemeIcon.fromId(Codicon.book.id),
+                description: ( localize(5795, "Read files in your workspace"))
+            })
+        );
+        this.agentToolSet = this._register(
+            this.createToolSet(ToolDataSource.Internal, "agent", SpecedToolAliases.agent, {
+                icon: ThemeIcon.fromId(Codicon.agent.id),
+                description: ( localize(5796, "Delegate tasks to other agents"))
+            })
+        );
     }
     isPermitted(toolOrToolSet, reader) {
         const agentModeEnabled = this._isAgentModeEnabled.read(reader);
@@ -144,40 +184,71 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             return true;
         }
         const permittedInternalToolSetIds = [SpecedToolAliases.read, SpecedToolAliases.search, SpecedToolAliases.web];
-        if (toolOrToolSet instanceof ToolSet) {
-            const permitted = toolOrToolSet.source.type === 'internal' && permittedInternalToolSetIds.includes(toolOrToolSet.referenceName);
-            this._logService.trace(`LanguageModelToolsService#isPermitted: ToolSet ${toolOrToolSet.id} (${toolOrToolSet.referenceName}) permitted=${permitted}`);
+        if (isToolSet(toolOrToolSet)) {
+            const permitted = toolOrToolSet.source.type === "internal" && permittedInternalToolSetIds.includes(toolOrToolSet.referenceName);
+            this._logService.trace(
+                `LanguageModelToolsService#isPermitted: ToolSet ${toolOrToolSet.id} (${toolOrToolSet.referenceName}) permitted=${permitted}`
+            );
             return permitted;
         }
-        this._logService.trace(`LanguageModelToolsService#isPermitted: Tool ${toolOrToolSet.id} (${toolOrToolSet.toolReferenceName}) permitted=false`);
+        for (const toolSet of this._toolSets) {
+            if (toolSet.source.type === "internal" && permittedInternalToolSetIds.includes(toolSet.referenceName)) {
+                for (const memberTool of toolSet.getTools()) {
+                    if (memberTool.id === toolOrToolSet.id) {
+                        this._logService.trace(
+                            `LanguageModelToolsService#isPermitted: Tool ${toolOrToolSet.id} (${toolOrToolSet.toolReferenceName}) permitted=true (member of ${toolSet.referenceName})`
+                        );
+                        return true;
+                    }
+                }
+            }
+        }
+        if (toolOrToolSet.id === "vscode_fetchWebPage_internal" && permittedInternalToolSetIds.includes(SpecedToolAliases.web)) {
+            this._logService.trace(
+                `LanguageModelToolsService#isPermitted: Tool ${toolOrToolSet.id} (${toolOrToolSet.toolReferenceName}) permitted=true (special case)`
+            );
+            return true;
+        }
+        this._logService.trace(
+            `LanguageModelToolsService#isPermitted: Tool ${toolOrToolSet.id} (${toolOrToolSet.toolReferenceName}) permitted=false`
+        );
         return false;
     }
     dispose() {
         super.dispose();
         this._callsByRequestId.forEach(calls => calls.forEach(call => call.store.dispose()));
+        this._pendingToolCalls.clear();
         this._ctxToolsCount.reset();
     }
     registerToolData(toolData) {
         if (( this._tools.has(toolData.id))) {
             throw ( new Error(`Tool "${toolData.id}" is already registered.`));
         }
-        this._tools.set(toolData.id, { data: toolData });
+        this._tools.set(toolData.id, {
+            data: toolData
+        });
         this._ctxToolsCount.set(this._tools.size);
-        this._onDidChangeToolsScheduler.schedule();
+        if (!this._onDidChangeToolsScheduler.isScheduled()) {
+            this._onDidChangeToolsScheduler.schedule();
+        }
         toolData.when?.keys().forEach(key => this._toolContextKeys.add(key));
         let store;
         if (toolData.inputSchema) {
             store = ( new DisposableStore());
             const schemaUrl = ( createToolSchemaUri(toolData.id).toString());
             jsonSchemaRegistry.registerSchema(schemaUrl, toolData.inputSchema, store);
-            store.add(jsonSchemaRegistry.registerSchemaAssociation(schemaUrl, `/lm/tool/${toolData.id}/tool_input.json`));
+            store.add(
+                jsonSchemaRegistry.registerSchemaAssociation(schemaUrl, `/lm/tool/${toolData.id}/tool_input.json`)
+            );
         }
         return toDisposable(() => {
             store?.dispose();
             this._tools.delete(toolData.id);
             this._ctxToolsCount.set(this._tools.size);
             this._refreshAllToolContextKeys();
-            this._onDidChangeToolsScheduler.schedule();
+            if (!this._onDidChangeToolsScheduler.isScheduled()) {
+                this._onDidChangeToolsScheduler.schedule();
+            }
         });
     }
     flushToolUpdates() {
@@ -203,32 +274,50 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         });
     }
     registerTool(toolData, tool) {
-        return combinedDisposable(this.registerToolData(toolData), this.registerToolImplementation(toolData.id, tool));
+        return combinedDisposable(
+            this.registerToolData(toolData),
+            this.registerToolImplementation(toolData.id, tool)
+        );
     }
-    getTools(includeDisabled) {
+    getTools(model) {
         const toolDatas = ( Iterable.map(( this._tools.values()), i => i.data));
         const extensionToolsEnabled = this._configurationService.getValue(ChatConfiguration.ExtensionToolsEnabled);
         return Iterable.filter(toolDatas, toolData => {
-            const satisfiesWhenClause = includeDisabled || !toolData.when || this._contextKeyService.contextMatchesRules(toolData.when);
-            const satisfiesExternalToolCheck = toolData.source.type !== 'extension' || !!extensionToolsEnabled;
-            const satisfiesPermittedCheck = includeDisabled || this.isPermitted(toolData);
-            return satisfiesWhenClause && satisfiesExternalToolCheck && satisfiesPermittedCheck;
+            const satisfiesWhenClause = !toolData.when || this._contextKeyService.contextMatchesRules(toolData.when);
+            const satisfiesExternalToolCheck = toolData.source.type !== "extension" || !!extensionToolsEnabled;
+            const satisfiesPermittedCheck = this.isPermitted(toolData);
+            const satisfiesModelFilter = toolMatchesModel(toolData, model);
+            return satisfiesWhenClause && satisfiesExternalToolCheck && satisfiesPermittedCheck && satisfiesModelFilter;
         });
     }
-    getTool(id) {
-        return this._getToolEntry(id)?.data;
+    observeTools(model) {
+        const meta = derived(reader => {
+            const signal = observableSignal("observeToolsContext");
+            const trigger = () => transaction(tx => signal.trigger(tx));
+            reader.store.add(this.onDidChangeTools(trigger));
+            return signal;
+        });
+        return derivedOpts({
+            equalsFn: arrayEqualsC()
+        }, reader => {
+            meta.read(reader).read(reader);
+            return Array.from(this.getTools(model));
+        });
     }
-    _getToolEntry(id) {
-        const entry = this._tools.get(id);
-        if (entry && (!entry.data.when || this._contextKeyService.contextMatchesRules(entry.data.when))) {
-            return entry;
-        }
-        else {
-            return undefined;
-        }
+    getAllToolsIncludingDisabled() {
+        const toolDatas = ( Iterable.map(( this._tools.values()), i => i.data));
+        const extensionToolsEnabled = this._configurationService.getValue(ChatConfiguration.ExtensionToolsEnabled);
+        return Iterable.filter(toolDatas, toolData => {
+            const satisfiesExternalToolCheck = toolData.source.type !== "extension" || !!extensionToolsEnabled;
+            const satisfiesPermittedCheck = this.isPermitted(toolData);
+            return satisfiesExternalToolCheck && satisfiesPermittedCheck;
+        });
     }
-    getToolByName(name, includeDisabled) {
-        for (const tool of this.getTools(!!includeDisabled)) {
+    getTool(id) {
+        return this._tools.get(id)?.data;
+    }
+    getToolByName(name) {
+        for (const tool of this.getAllToolsIncludingDisabled()) {
             if (tool.toolReferenceName === name) {
                 return tool;
             }
@@ -236,7 +325,15 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return undefined;
     }
     async invokeTool(dto, countTokens, token) {
-        this._logService.trace(`[LanguageModelToolsService#invokeTool] Invoking tool ${dto.toolId} with parameters ${JSON.stringify(dto.parameters)}`);
+        this._logService.trace(
+            `[LanguageModelToolsService#invokeTool] Invoking tool ${dto.toolId} with parameters ${JSON.stringify(dto.parameters)}`
+        );
+        this._onDidInvokeTool.fire({
+            toolId: dto.toolId,
+            sessionResource: dto.context?.sessionResource,
+            requestId: dto.chatRequestId,
+            subagentInvocationId: dto.subAgentInvocationId
+        });
         let tool = this._tools.get(dto.toolId);
         if (!tool) {
             throw ( new Error(`Tool ${dto.toolId} was not contributed`));
@@ -248,7 +345,19 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 throw ( new Error(`Tool ${dto.toolId} does not have an implementation registered.`));
             }
         }
+        let pendingToolCallKey;
         let toolInvocation;
+        if (( this._pendingToolCalls.has(dto.callId))) {
+            pendingToolCallKey = dto.callId;
+            toolInvocation = this._pendingToolCalls.get(dto.callId);
+        } else if (dto.chatStreamToolCallId && ( this._pendingToolCalls.has(dto.chatStreamToolCallId))) {
+            pendingToolCallKey = dto.chatStreamToolCallId;
+            toolInvocation = this._pendingToolCalls.get(dto.chatStreamToolCallId);
+        }
+        const hadPendingInvocation = !!toolInvocation;
+        if (hadPendingInvocation && pendingToolCallKey) {
+            this._pendingToolCalls.delete(pendingToolCallKey);
+        }
         let requestId;
         let store;
         let toolResult;
@@ -265,40 +374,57 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 const request = model.getRequests().at(-1);
                 requestId = request.id;
                 dto.modelId = request.modelId;
-                dto.userSelectedTools = request.userSelectedTools && { ...request.userSelectedTools };
+                dto.userSelectedTools = request.userSelectedTools && {
+                    ...request.userSelectedTools
+                };
                 if (!( this._callsByRequestId.has(requestId))) {
                     this._callsByRequestId.set(requestId, []);
                 }
-                const trackedCall = { store };
+                const trackedCall = {
+                    store
+                };
                 this._callsByRequestId.get(requestId).push(trackedCall);
                 const source = ( new CancellationTokenSource());
                 store.add(toDisposable(() => {
                     source.dispose(true);
                 }));
                 store.add(token.onCancellationRequested(() => {
-                    IChatToolInvocation.confirmWith(toolInvocation, { type: ToolConfirmKind.Denied });
+                    IChatToolInvocation.confirmWith(toolInvocation, {
+                        type: ToolConfirmKind.Denied
+                    });
                     source.cancel();
                 }));
                 store.add(source.token.onCancellationRequested(() => {
-                    IChatToolInvocation.confirmWith(toolInvocation, { type: ToolConfirmKind.Denied });
+                    IChatToolInvocation.confirmWith(toolInvocation, {
+                        type: ToolConfirmKind.Denied
+                    });
                 }));
                 token = source.token;
                 prepareTimeWatch = StopWatch.create(true);
                 preparedInvocation = await this.prepareToolInvocation(tool, dto, token);
                 prepareTimeWatch.stop();
-                toolInvocation = ( new ChatToolInvocation(
-                    preparedInvocation,
-                    tool.data,
-                    dto.callId,
-                    dto.fromSubAgent,
-                    dto.parameters
-                ));
-                trackedCall.invocation = toolInvocation;
-                const autoConfirmed = await this.shouldAutoConfirm(tool.data.id, tool.data.runsInWorkspace, tool.data.source, dto.parameters);
-                if (autoConfirmed) {
-                    IChatToolInvocation.confirmWith(toolInvocation, autoConfirmed);
-                }
-                this._chatService.appendProgress(request, toolInvocation);
+                const autoConfirmed = await this.shouldAutoConfirm(
+                    tool.data.id,
+                    tool.data.runsInWorkspace,
+                    tool.data.source,
+                    dto.parameters,
+                    dto.context?.sessionResource
+                );
+                if (hadPendingInvocation && toolInvocation) {
+                    toolInvocation.transitionFromStreaming(preparedInvocation, dto.parameters, autoConfirmed);
+                } else {
+                    toolInvocation = ( new ChatToolInvocation(
+                        preparedInvocation,
+                        tool.data,
+                        dto.callId,
+                        dto.subAgentInvocationId,
+                        dto.parameters
+                    ));
+                    if (autoConfirmed) {
+                        IChatToolInvocation.confirmWith(toolInvocation, autoConfirmed);
+                    }
+                    this._chatService.appendProgress(request, toolInvocation);
+                }
                 dto.toolSpecificData = toolInvocation?.toolSpecificData;
                 if (preparedInvocation?.confirmationMessages?.title) {
                     if (!IChatToolInvocation.executionConfirmedOrDenied(toolInvocation) && !autoConfirmed) {
@@ -311,24 +437,32 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     if (userConfirmed.type === ToolConfirmKind.Skipped) {
                         toolResult = {
                             content: [{
-                                    kind: 'text',
-                                    value: 'The user chose to skip the tool call, they want to proceed without running it'
-                                }]
+                                kind: "text",
+                                value: "The user chose to skip the tool call, they want to proceed without running it"
+                            }]
                         };
                         return toolResult;
                     }
-                    if (dto.toolSpecificData?.kind === 'input') {
+                    if (dto.toolSpecificData?.kind === "input") {
                         dto.parameters = dto.toolSpecificData.rawInput;
                         dto.toolSpecificData = undefined;
                     }
                 }
-            }
-            else {
+            } else {
                 prepareTimeWatch = StopWatch.create(true);
                 preparedInvocation = await this.prepareToolInvocation(tool, dto, token);
                 prepareTimeWatch.stop();
-                if (preparedInvocation?.confirmationMessages?.title && !(await this.shouldAutoConfirm(tool.data.id, tool.data.runsInWorkspace, tool.data.source, dto.parameters))) {
-                    const result = await this._dialogService.confirm({ message: renderAsPlaintext(preparedInvocation.confirmationMessages.title), detail: renderAsPlaintext(preparedInvocation.confirmationMessages.message) });
+                if (preparedInvocation?.confirmationMessages?.title && !(await this.shouldAutoConfirm(
+                    tool.data.id,
+                    tool.data.runsInWorkspace,
+                    tool.data.source,
+                    dto.parameters,
+                    undefined
+                ))) {
+                    const result = await this._dialogService.confirm({
+                        message: renderAsPlaintext(preparedInvocation.confirmationMessages.title),
+                        detail: renderAsPlaintext(preparedInvocation.confirmationMessages.message)
+                    });
                     if (!result.confirmed) {
                         throw ( new CancellationError());
                     }
@@ -347,7 +481,13 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             invocationTimeWatch.stop();
             this.ensureToolDetails(dto, toolResult, tool.data);
             if (toolInvocation?.didExecuteTool(toolResult).type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
-                const autoConfirmedPost = await this.shouldAutoConfirmPostExecution(tool.data.id, tool.data.runsInWorkspace, tool.data.source, dto.parameters);
+                const autoConfirmedPost = await this.shouldAutoConfirmPostExecution(
+                    tool.data.id,
+                    tool.data.runsInWorkspace,
+                    tool.data.source,
+                    dto.parameters,
+                    dto.context?.sessionResource
+                );
                 if (autoConfirmedPost) {
                     IChatToolInvocation.confirmWith(toolInvocation, autoConfirmedPost);
                 }
@@ -358,43 +498,55 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 if (postConfirm.type === ToolConfirmKind.Skipped) {
                     toolResult = {
                         content: [{
-                                kind: 'text',
-                                value: 'The tool executed but the user chose not to share the results'
-                            }]
+                            kind: "text",
+                            value: "The tool executed but the user chose not to share the results"
+                        }]
                     };
                 }
             }
-            this._telemetryService.publicLog2('languageModelToolInvoked', {
-                result: 'success',
-                chatSessionId: dto.context?.sessionId,
+            this._telemetryService.publicLog2("languageModelToolInvoked", {
+                result: "success",
+                chatSessionId: dto.context?.sessionResource ? chatSessionResourceToId(dto.context.sessionResource) : undefined,
                 toolId: tool.data.id,
-                toolExtensionId: tool.data.source.type === 'extension' ? tool.data.source.extensionId.value : undefined,
+                toolExtensionId: tool.data.source.type === "extension" ? tool.data.source.extensionId.value : undefined,
                 toolSourceKind: tool.data.source.type,
                 prepareTimeMs: prepareTimeWatch?.elapsed(),
-                invocationTimeMs: invocationTimeWatch?.elapsed(),
+                invocationTimeMs: invocationTimeWatch?.elapsed()
             });
             return toolResult;
-        }
-        catch (err) {
-            const result = isCancellationError(err) ? 'userCancelled' : 'error';
-            this._telemetryService.publicLog2('languageModelToolInvoked', {
+        } catch (err) {
+            const result = isCancellationError(err) ? "userCancelled" : "error";
+            this._telemetryService.publicLog2("languageModelToolInvoked", {
                 result,
                 chatSessionId: dto.context?.sessionId,
                 toolId: tool.data.id,
-                toolExtensionId: tool.data.source.type === 'extension' ? tool.data.source.extensionId.value : undefined,
+                toolExtensionId: tool.data.source.type === "extension" ? tool.data.source.extensionId.value : undefined,
                 toolSourceKind: tool.data.source.type,
                 prepareTimeMs: prepareTimeWatch?.elapsed(),
-                invocationTimeMs: invocationTimeWatch?.elapsed(),
+                invocationTimeMs: invocationTimeWatch?.elapsed()
             });
-            this._logService.error(`[LanguageModelToolsService#invokeTool] Error from tool ${dto.toolId} with parameters ${JSON.stringify(dto.parameters)}:\n${toErrorMessage(err, true)}`);
-            toolResult ??= { content: [] };
+            if (!isCancellationError(err)) {
+                this._logService.error(
+                    `[LanguageModelToolsService#invokeTool] Error from tool ${dto.toolId} with parameters ${JSON.stringify(dto.parameters)}:\n${toErrorMessage(err, true)}`
+                );
+            }
+            toolResult ??= {
+                content: []
+            };
             toolResult.toolResultError = err instanceof Error ? err.message : String(err);
             if (tool.data.alwaysDisplayInputOutput) {
-                toolResult.toolResultDetails = { input: this.formatToolInput(dto), output: [{ type: 'embed', isText: true, value: String(err) }], isError: true };
+                toolResult.toolResultDetails = {
+                    input: this.formatToolInput(dto),
+                    output: [{
+                        type: "embed",
+                        isText: true,
+                        value: String(err)
+                    }],
+                    isError: true
+                };
             }
             throw err;
-        }
-        finally {
+        } finally {
             toolInvocation?.didExecuteTool(toolResult, true);
             if (store) {
                 this.cleanupCallDisposables(requestId, store);
@@ -408,15 +560,13 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                 parameters: dto.parameters,
                 chatRequestId: dto.chatRequestId,
                 chatSessionId: dto.context?.sessionId,
+                chatSessionResource: dto.context?.sessionResource,
                 chatInteractionId: dto.chatInteractionId
             }, token);
-            const raceResult = await Promise.race([
-                timeout(3000, token).then(() => 'timeout'),
-                preparePromise
-            ]);
-            if (raceResult === 'timeout') {
+            const raceResult = await Promise.race([timeout(3000, token).then(() => "timeout"), preparePromise]);
+            if (raceResult === "timeout" && dto.context) {
                 this._onDidPrepareToolCallBecomeUnresponsive.fire({
-                    sessionId: dto.context?.sessionId ?? '',
+                    sessionResource: dto.context.sessionResource,
                     toolData: tool.data
                 });
             }
@@ -430,38 +580,115 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             const fullReferenceName = getToolFullReferenceName(tool.data);
             prepared.confirmationMessages = {
                 ...prepared.confirmationMessages,
-                title: ( localize(5578, 'Confirm tool execution')),
-                message: ( localize(5579, 'Run the \'{0}\' tool?', fullReferenceName)),
+                title: ( localize(5797, "Confirm tool execution")),
+                message: ( localize(5798, "Run the '{0}' tool?", fullReferenceName)),
                 disclaimer: ( new MarkdownString(( localize(
-                    5580,
-                    'Auto approval for \'{0}\' is restricted via {1}.',
+                    5799,
+                    "Auto approval for '{0}' is restricted via {1}.",
                     getToolFullReferenceName(tool.data),
-                    createMarkdownCommandLink({ title: '`' + ChatConfiguration.EligibleForAutoApproval + '`', id: 'workbench.action.openSettings', arguments: [ChatConfiguration.EligibleForAutoApproval] }, false)
-                )), { isTrusted: true })),
-                allowAutoConfirm: false,
+                    createMarkdownCommandLink({
+                        title: "`" + ChatConfiguration.EligibleForAutoApproval + "`",
+                        id: "workbench.action.openSettings",
+                        arguments: [ChatConfiguration.EligibleForAutoApproval]
+                    }, false)
+                )), {
+                    isTrusted: true
+                })),
+                allowAutoConfirm: false
             };
         }
         if (!isEligibleForAutoApproval && prepared?.confirmationMessages?.title) {
             prepared.confirmationMessages.disclaimer = ( new MarkdownString(( localize(
-                5580,
-                'Auto approval for \'{0}\' is restricted via {1}.',
+                5799,
+                "Auto approval for '{0}' is restricted via {1}.",
                 getToolFullReferenceName(tool.data),
-                createMarkdownCommandLink({ title: '`' + ChatConfiguration.EligibleForAutoApproval + '`', id: 'workbench.action.openSettings', arguments: [ChatConfiguration.EligibleForAutoApproval] }, false)
-            )), { isTrusted: true }));
+                createMarkdownCommandLink({
+                    title: "`" + ChatConfiguration.EligibleForAutoApproval + "`",
+                    id: "workbench.action.openSettings",
+                    arguments: [ChatConfiguration.EligibleForAutoApproval]
+                }, false)
+            )), {
+                isTrusted: true
+            }));
         }
         if (prepared?.confirmationMessages?.title) {
-            if (prepared.toolSpecificData?.kind !== 'terminal' && prepared.confirmationMessages.allowAutoConfirm !== false) {
+            if (prepared.toolSpecificData?.kind !== "terminal" && prepared.confirmationMessages.allowAutoConfirm !== false) {
                 prepared.confirmationMessages.allowAutoConfirm = isEligibleForAutoApproval;
             }
             if (!prepared.toolSpecificData && tool.data.alwaysDisplayInputOutput) {
                 prepared.toolSpecificData = {
-                    kind: 'input',
-                    rawInput: dto.parameters,
+                    kind: "input",
+                    rawInput: dto.parameters
                 };
             }
         }
         return prepared;
     }
+    beginToolCall(options) {
+        const toolEntry = this._tools.get(options.toolId);
+        if (!toolEntry) {
+            return undefined;
+        }
+        if (!toolEntry.impl?.handleToolStream) {
+            return undefined;
+        }
+        const invocation = ChatToolInvocation.createStreaming({
+            toolCallId: options.toolCallId,
+            toolId: options.toolId,
+            toolData: toolEntry.data,
+            subagentInvocationId: options.subagentInvocationId,
+            chatRequestId: options.chatRequestId
+        });
+        this._pendingToolCalls.set(options.toolCallId, invocation);
+        if (options.sessionResource) {
+            const model = this._chatService.getSession(options.sessionResource);
+            if (model) {
+                const request = (options.chatRequestId ? model.getRequests().find(r => r.id === options.chatRequestId) : undefined) ?? model.getRequests().at(-1);
+                if (request) {
+                    this._chatService.appendProgress(request, invocation);
+                }
+            }
+        }
+        this._callHandleToolStream(
+            toolEntry,
+            invocation,
+            options.toolCallId,
+            undefined,
+            CancellationToken.None
+        );
+        return invocation;
+    }
+    async _callHandleToolStream(toolEntry, invocation, toolCallId, rawInput, token) {
+        if (!toolEntry.impl?.handleToolStream) {
+            return;
+        }
+        try {
+            const result = await toolEntry.impl.handleToolStream({
+                toolCallId,
+                rawInput,
+                chatRequestId: invocation.chatRequestId
+            }, token);
+            if (result?.invocationMessage) {
+                invocation.updateStreamingMessage(result.invocationMessage);
+            }
+        } catch (error) {
+            this._logService.error(
+                `[LanguageModelToolsService#_callHandleToolStream] Error calling handleToolStream for tool ${toolEntry.data.id}:`,
+                error
+            );
+        }
+    }
+    async updateToolStream(toolCallId, partialInput, token) {
+        const invocation = this._pendingToolCalls.get(toolCallId);
+        if (!invocation) {
+            return;
+        }
+        invocation.updatePartialInput(partialInput);
+        const toolEntry = this._tools.get(invocation.toolId);
+        if (toolEntry) {
+            await this._callHandleToolStream(toolEntry, invocation, toolCallId, partialInput, token);
+        }
+    }
     playAccessibilitySignal(toolInvocations) {
         const autoApproved = this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove);
         if (autoApproved) {
@@ -471,17 +698,21 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (!setting) {
             return;
         }
-        const soundEnabled = setting.sound === 'on' || (setting.sound === 'auto' && (this._accessibilityService.isScreenReaderOptimized()));
-        const announcementEnabled = this._accessibilityService.isScreenReaderOptimized() && setting.announcement === 'auto';
+        const soundEnabled = setting.sound === "on" || (setting.sound === "auto" && (this._accessibilityService.isScreenReaderOptimized()));
+        const announcementEnabled = this._accessibilityService.isScreenReaderOptimized() && setting.announcement === "auto";
         if (soundEnabled || announcementEnabled) {
-            this._accessibilitySignalService.playSignal(AccessibilitySignal.chatUserActionRequired, { customAlertMessage: this._instantiationService.invokeFunction(getToolConfirmationAlert, toolInvocations), userGesture: true, modality: !soundEnabled ? 'announcement' : undefined });
+            this._accessibilitySignalService.playSignal(AccessibilitySignal.chatUserActionRequired, {
+                customAlertMessage: this._instantiationService.invokeFunction(getToolConfirmationAlert, toolInvocations),
+                userGesture: true,
+                modality: !soundEnabled ? "announcement" : undefined
+            });
         }
     }
     ensureToolDetails(dto, toolResult, toolData) {
         if (!toolResult.toolResultDetails && toolData.alwaysDisplayInputOutput) {
             toolResult.toolResultDetails = {
                 input: this.formatToolInput(dto),
-                output: this.toolResultToIO(toolResult),
+                output: this.toolResultToIO(toolResult)
             };
         }
     }
@@ -490,33 +721,42 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     }
     toolResultToIO(toolResult) {
         return ( toolResult.content.map(part => {
-            if (part.kind === 'text') {
-                return { type: 'embed', isText: true, value: part.value };
-            }
-            else if (part.kind === 'promptTsx') {
-                return { type: 'embed', isText: true, value: stringifyPromptTsxPart(part) };
-            }
-            else if (part.kind === 'data') {
-                return { type: 'embed', value: encodeBase64(part.value.data), mimeType: part.value.mimeType };
-            }
-            else {
+            if (part.kind === "text") {
+                return {
+                    type: "embed",
+                    isText: true,
+                    value: part.value
+                };
+            } else if (part.kind === "promptTsx") {
+                return {
+                    type: "embed",
+                    isText: true,
+                    value: stringifyPromptTsxPart(part)
+                };
+            } else if (part.kind === "data") {
+                return {
+                    type: "embed",
+                    value: encodeBase64(part.value.data),
+                    mimeType: part.value.mimeType
+                };
+            } else {
                 assertNever();
             }
         }));
     }
     getEligibleForAutoApprovalSpecialCase(toolData) {
-        if (toolData.id === 'vscode_fetchWebPage_internal') {
-            return 'fetch';
+        if (toolData.id === "vscode_fetchWebPage_internal") {
+            return "fetch";
         }
         return undefined;
     }
     isToolEligibleForAutoApproval(toolData) {
         const fullReferenceName = this.getEligibleForAutoApprovalSpecialCase(toolData) ?? getToolFullReferenceName(toolData);
-        if (toolData.id === 'copilot_fetchWebPage') {
+        if (toolData.id === "copilot_fetchWebPage") {
             return true;
         }
         const eligibilityConfig = this._configurationService.getValue(ChatConfiguration.EligibleForAutoApproval);
-        if (eligibilityConfig && typeof eligibilityConfig === 'object' && fullReferenceName) {
+        if (eligibilityConfig && typeof eligibilityConfig === "object" && fullReferenceName) {
             if (Object.prototype.hasOwnProperty.call(eligibilityConfig, fullReferenceName)) {
                 return eligibilityConfig[fullReferenceName];
             }
@@ -525,8 +765,8 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     if (Object.prototype.hasOwnProperty.call(eligibilityConfig, legacyName)) {
                         return eligibilityConfig[legacyName];
                     }
-                    if (legacyName.includes('/')) {
-                        const trimmedLegacyName = legacyName.split('/').pop();
+                    if (legacyName.includes("/")) {
+                        const trimmedLegacyName = legacyName.split("/").pop();
                         if (trimmedLegacyName && Object.prototype.hasOwnProperty.call(eligibilityConfig, trimmedLegacyName)) {
                             return eligibilityConfig[trimmedLegacyName];
                         }
@@ -536,7 +776,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         return true;
     }
-    async shouldAutoConfirm(toolId, runsInWorkspace, source, parameters) {
+    async shouldAutoConfirm(toolId, runsInWorkspace, source, parameters, chatSessionResource) {
         const tool = this._tools.get(toolId);
         if (!tool) {
             return undefined;
@@ -544,34 +784,54 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (!this.isToolEligibleForAutoApproval(tool.data)) {
             return undefined;
         }
-        const reason = this._confirmationService.getPreConfirmAction({ toolId, source, parameters });
+        const reason = this._confirmationService.getPreConfirmAction({
+            toolId,
+            source,
+            parameters,
+            chatSessionResource
+        });
         if (reason) {
             return reason;
         }
         const config = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
         let value = config.value ?? config.defaultValue;
-        if (typeof runsInWorkspace === 'boolean') {
+        if (typeof runsInWorkspace === "boolean") {
             value = config.userLocalValue ?? config.applicationValue;
             if (runsInWorkspace) {
                 value = config.workspaceValue ?? config.workspaceFolderValue ?? config.userRemoteValue ?? value;
             }
         }
-        const autoConfirm = value === true || (typeof value === 'object' && value.hasOwnProperty(toolId) && value[toolId] === true);
+        const autoConfirm = value === true || (typeof value === "object" && value.hasOwnProperty(toolId) && value[toolId] === true);
         if (autoConfirm) {
             if (await this._checkGlobalAutoApprove()) {
-                return { type: ToolConfirmKind.Setting, id: ChatConfiguration.GlobalAutoApprove };
+                return {
+                    type: ToolConfirmKind.Setting,
+                    id: ChatConfiguration.GlobalAutoApprove
+                };
             }
         }
         return undefined;
     }
-    async shouldAutoConfirmPostExecution(toolId, runsInWorkspace, source, parameters) {
+    async shouldAutoConfirmPostExecution(toolId, runsInWorkspace, source, parameters, chatSessionResource) {
         if (this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove) && (await this._checkGlobalAutoApprove())) {
-            return { type: ToolConfirmKind.Setting, id: ChatConfiguration.GlobalAutoApprove };
+            return {
+                type: ToolConfirmKind.Setting,
+                id: ChatConfiguration.GlobalAutoApprove
+            };
         }
-        return this._confirmationService.getPostConfirmAction({ toolId, source, parameters });
+        return this._confirmationService.getPostConfirmAction({
+            toolId,
+            source,
+            parameters,
+            chatSessionResource
+        });
     }
     async _checkGlobalAutoApprove() {
-        const optedIn = this._storageService.getBoolean(AutoApproveStorageKeys.GlobalAutoApproveOptIn, StorageScope.APPLICATION, false);
+        const optedIn = this._storageService.getBoolean(
+            AutoApproveStorageKeys.GlobalAutoApproveOptIn,
+            StorageScope.APPLICATION,
+            false
+        );
         if (optedIn) {
             return true;
         }
@@ -580,30 +840,32 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         }
         const promptResult = await this._dialogService.prompt({
             type: Severity.Warning,
-            message: ( localize(5581, 'Enable global auto approve?')),
-            buttons: [
-                {
-                    label: ( localize(5582, 'Enable')),
-                    run: () => true
-                },
-                {
-                    label: ( localize(5583, 'Disable')),
-                    run: () => false
-                },
-            ],
+            message: ( localize(5800, "Enable global auto approve?")),
+            buttons: [{
+                label: ( localize(5801, "Enable")),
+                run: () => true
+            }, {
+                label: ( localize(5802, "Disable")),
+                run: () => false
+            }],
             custom: {
                 icon: Codicon.warning,
                 disableCloseAction: true,
                 markdownDetails: [{
-                        markdown: ( new MarkdownString(globalAutoApproveDescription.value)),
-                    }],
+                    markdown: ( new MarkdownString(globalAutoApproveDescription.value))
+                }]
             }
         });
         if (promptResult.result !== true) {
             await this._configurationService.updateValue(ChatConfiguration.GlobalAutoApprove, false);
             return false;
         }
-        this._storageService.store(AutoApproveStorageKeys.GlobalAutoApproveOptIn, true, StorageScope.APPLICATION, StorageTarget.USER);
+        this._storageService.store(
+            AutoApproveStorageKeys.GlobalAutoApproveOptIn,
+            true,
+            StorageScope.APPLICATION,
+            StorageTarget.USER
+        );
         return true;
     }
     cleanupCallDisposables(requestId, store) {
@@ -627,9 +889,22 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             calls.forEach(call => call.store.dispose());
             this._callsByRequestId.delete(requestId);
         }
+        for (const [toolCallId, invocation] of this._pendingToolCalls) {
+            if (invocation.chatRequestId === requestId) {
+                this._pendingToolCalls.delete(toolCallId);
+            }
+        }
+    }
+    static {
+        this.githubMCPServerAliases = [
+            "github/github-mcp-server",
+            "io.github.github/github-mcp-server",
+            "github-mcp-server"
+        ];
+    }
+    static {
+        this.playwrightMCPServerAliases = ["microsoft/playwright-mcp", "com.microsoft/playwright-mcp"];
     }
-    static { this.githubMCPServerAliases = ['github/github-mcp-server', 'io.github.github/github-mcp-server', 'github-mcp-server']; }
-    static { this.playwrightMCPServerAliases = ['microsoft/playwright-mcp', 'com.microsoft/playwright-mcp']; }
     *getToolSetAliases(toolSet, fullReferenceName) {
         if (fullReferenceName !== toolSet.referenceName) {
             yield toolSet.referenceName;
@@ -638,23 +913,25 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             yield* toolSet.legacyFullNames;
         }
         switch (toolSet.referenceName) {
-            case 'github':
-                for (const alias of LanguageModelToolsService_1.githubMCPServerAliases) {
-                    yield alias + '/*';
-                }
-                break;
-            case 'playwright':
-                for (const alias of LanguageModelToolsService_1.playwrightMCPServerAliases) {
-                    yield alias + '/*';
-                }
-                break;
-            case SpecedToolAliases.execute:
-                yield 'shell';
-                break;
-            case SpecedToolAliases.agent:
-                yield VSCodeToolReference.runSubagent;
-                yield 'custom-agent';
-                break;
+        case "github":
+            for (const alias of LanguageModelToolsService_1.githubMCPServerAliases) {
+                yield alias + "/*";
+            }
+            break;
+        case "playwright":
+            for (const alias of LanguageModelToolsService_1.playwrightMCPServerAliases) {
+                yield alias + "/*";
+            }
+            break;
+        case
+        SpecedToolAliases.execute:
+            yield "shell";
+            break;
+        case
+        SpecedToolAliases.agent:
+            yield VSCodeToolReference.runSubagent;
+            yield "custom-agent";
+            break;
         }
     }
     *getToolAliases(toolSet, fullReferenceName) {
@@ -665,55 +942,56 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         if (toolSet.legacyToolReferenceFullNames) {
             for (const legacyName of toolSet.legacyToolReferenceFullNames) {
                 yield legacyName;
-                const lastSlashIndex = legacyName.lastIndexOf('/');
+                const lastSlashIndex = legacyName.lastIndexOf("/");
                 if (lastSlashIndex !== -1) {
                     yield legacyName.substring(lastSlashIndex + 1);
                 }
             }
         }
-        const slashIndex = fullReferenceName.lastIndexOf('/');
+        const slashIndex = fullReferenceName.lastIndexOf("/");
         if (slashIndex !== -1) {
             switch (fullReferenceName.substring(0, slashIndex)) {
-                case 'github':
-                    for (const alias of LanguageModelToolsService_1.githubMCPServerAliases) {
-                        yield alias + fullReferenceName.substring(slashIndex);
-                    }
-                    break;
-                case 'playwright':
-                    for (const alias of LanguageModelToolsService_1.playwrightMCPServerAliases) {
-                        yield alias + fullReferenceName.substring(slashIndex);
-                    }
-                    break;
+            case "github":
+                for (const alias of LanguageModelToolsService_1.githubMCPServerAliases) {
+                    yield alias + fullReferenceName.substring(slashIndex);
+                }
+                break;
+            case "playwright":
+                for (const alias of LanguageModelToolsService_1.playwrightMCPServerAliases) {
+                    yield alias + fullReferenceName.substring(slashIndex);
+                }
+                break;
             }
         }
     }
-    toToolAndToolSetEnablementMap(fullReferenceNames, _target) {
+    toToolAndToolSetEnablementMap(fullReferenceNames, _target, model) {
         const toolOrToolSetNames = ( new Set(fullReferenceNames));
         const result = ( new Map());
         for (const [tool, fullReferenceName] of this.toolsWithFullReferenceName.get()) {
-            if (tool instanceof ToolSet) {
+            if (isToolSet(tool)) {
                 const enabled = ( toolOrToolSetNames.has(fullReferenceName)) || ( Iterable.some(this.getToolSetAliases(tool, fullReferenceName), name => ( toolOrToolSetNames.has(name))));
-                result.set(tool, enabled);
+                const scoped = model ? ( new ToolSetForModel(tool, model)) : tool;
+                result.set(scoped, enabled);
                 if (enabled) {
-                    for (const memberTool of tool.getTools()) {
+                    for (const memberTool of scoped.getTools()) {
                         result.set(memberTool, true);
                     }
                 }
-            }
-            else {
+            } else {
+                if (model && !toolMatchesModel(tool, model)) {
+                    continue;
+                }
                 if (!( result.has(tool))) {
-                    const enabled = ( toolOrToolSetNames.has(fullReferenceName))
-                        || ( Iterable.some(this.getToolAliases(tool, fullReferenceName), name => ( toolOrToolSetNames.has(name))))
-                        || !!tool.legacyToolReferenceFullNames?.some(toolFullName => {
-                            const index = toolFullName.lastIndexOf('/');
-                            return index !== -1 && ( toolOrToolSetNames.has(toolFullName.substring(0, index)));
-                        });
+                    const enabled = ( toolOrToolSetNames.has(fullReferenceName)) || ( Iterable.some(this.getToolAliases(tool, fullReferenceName), name => ( toolOrToolSetNames.has(name)))) || !!tool.legacyToolReferenceFullNames?.some(toolFullName => {
+                        const index = toolFullName.lastIndexOf("/");
+                        return index !== -1 && ( toolOrToolSetNames.has(toolFullName.substring(0, index)));
+                    });
                     result.set(tool, enabled);
                 }
             }
         }
         for (const toolSet of this._toolSets) {
-            if (toolSet.source.type === 'user') {
+            if (toolSet.source.type === "user") {
                 const enabled = Iterable.every(toolSet.getTools(), t => result.get(t) === true);
                 result.set(toolSet, enabled);
             }
@@ -724,15 +1002,14 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         const result = [];
         const toolsCoveredByEnabledToolSet = ( new Set());
         for (const [tool, fullReferenceName] of this.toolsWithFullReferenceName.get()) {
-            if (tool instanceof ToolSet) {
+            if (isToolSet(tool)) {
                 if (map.get(tool)) {
                     result.push(fullReferenceName);
                     for (const memberTool of tool.getTools()) {
                         toolsCoveredByEnabledToolSet.add(memberTool);
                     }
                 }
-            }
-            else {
+            } else {
                 if (map.get(tool) && !( toolsCoveredByEnabledToolSet.has(tool))) {
                     result.push(fullReferenceName);
                 }
@@ -749,16 +1026,21 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         for (const ref of variableReferences) {
             const toolOrToolSet = toolsOrToolSetByName.get(ref.name);
             if (toolOrToolSet) {
-                if (toolOrToolSet instanceof ToolSet) {
+                if (isToolSet(toolOrToolSet)) {
                     result.push(toToolSetVariableEntry(toolOrToolSet, ref.range));
-                }
-                else {
+                } else {
                     result.push(toToolVariableEntry(toolOrToolSet, ref.range));
                 }
             }
         }
         return result;
     }
+    getToolSetsForModel(model, reader) {
+        if (!model) {
+            return this.toolSets.read(reader);
+        }
+        return ( Iterable.map(this.toolSets.read(reader), ts => ( new ToolSetForModel(ts, model))));
+    }
     getToolSet(id) {
         for (const toolSet of this._toolSets) {
             if (toolSet.id === id) {
@@ -777,10 +1059,10 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
     }
     getSpecedToolSetName(referenceName) {
         if (LanguageModelToolsService_1.githubMCPServerAliases.includes(referenceName)) {
-            return 'github';
+            return "github";
         }
         if (LanguageModelToolsService_1.playwrightMCPServerAliases.includes(referenceName)) {
-            return 'playwright';
+            return "playwright";
         }
         return referenceName;
     }
@@ -794,7 +1076,15 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
                     that._toolSets.delete(result);
                 }
             }
-        })(id, referenceName, options?.icon ?? Codicon.tools, source, options?.description, options?.legacyFullNames);
+        })(
+            id,
+            referenceName,
+            options?.icon ?? Codicon.tools,
+            source,
+            options?.description,
+            options?.legacyFullNames,
+            this._contextKeyService
+        );
         this._toolSets.add(result);
         return result;
     }
@@ -815,7 +1105,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }
         };
         for (const [tool, _] of this.toolsWithFullReferenceName.get()) {
-            if (tool instanceof ToolSet) {
+            if (isToolSet(tool)) {
                 knownToolSetNames.add(tool.referenceName);
                 if (tool.legacyFullNames) {
                     for (const legacyName of tool.legacyFullNames) {
@@ -825,19 +1115,18 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             }
         }
         for (const [tool, fullReferenceName] of this.toolsWithFullReferenceName.get()) {
-            if (tool instanceof ToolSet) {
+            if (isToolSet(tool)) {
                 for (const alias of this.getToolSetAliases(tool, fullReferenceName)) {
                     add(alias, fullReferenceName);
                 }
-            }
-            else {
+            } else {
                 for (const alias of this.getToolAliases(tool, fullReferenceName)) {
                     add(alias, fullReferenceName);
                 }
                 if (tool.legacyToolReferenceFullNames) {
                     for (const legacyName of tool.legacyToolReferenceFullNames) {
-                        if (legacyName.includes('/')) {
-                            const toolSetFullName = legacyName.substring(0, legacyName.lastIndexOf('/'));
+                        if (legacyName.includes("/")) {
+                            const toolSetFullName = legacyName.substring(0, legacyName.lastIndexOf("/"));
                             if (!( knownToolSetNames.has(toolSetFullName))) {
                                 add(toolSetFullName, fullReferenceName);
                             }
@@ -853,7 +1142,7 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
             if (fullReferenceName === toolFullReferenceName) {
                 return tool;
             }
-            const aliases = tool instanceof ToolSet ? this.getToolSetAliases(tool, toolFullReferenceName) : this.getToolAliases(tool, toolFullReferenceName);
+            const aliases = isToolSet(tool) ? this.getToolSetAliases(tool, toolFullReferenceName) : this.getToolAliases(tool, toolFullReferenceName);
             if (( Iterable.some(aliases, alias => fullReferenceName === alias))) {
                 return tool;
             }
@@ -861,38 +1150,24 @@ let LanguageModelToolsService = class LanguageModelToolsService extends Disposab
         return undefined;
     }
     getFullReferenceName(tool, toolSet) {
-        if (tool instanceof ToolSet) {
+        if (isToolSet(tool)) {
             return getToolSetFullReferenceName(tool);
         }
         return getToolFullReferenceName(tool, toolSet);
     }
 };
-LanguageModelToolsService = LanguageModelToolsService_1 = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IExtensionService)),
-    ( __param(2, IContextKeyService)),
-    ( __param(3, IChatService)),
-    ( __param(4, IDialogService)),
-    ( __param(5, ITelemetryService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, IAccessibilityService)),
-    ( __param(9, IAccessibilitySignalService)),
-    ( __param(10, IStorageService)),
-    ( __param(11, ILanguageModelToolsConfirmationService))
-], LanguageModelToolsService));
+LanguageModelToolsService = LanguageModelToolsService_1 = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IExtensionService)), ( __param(2, IContextKeyService)), ( __param(3, IChatService)), ( __param(4, IDialogService)), ( __param(5, ITelemetryService)), ( __param(6, ILogService)), ( __param(7, IConfigurationService)), ( __param(8, IAccessibilityService)), ( __param(9, IAccessibilitySignalService)), ( __param(10, IStorageService)), ( __param(11, ILanguageModelToolsConfirmationService))], LanguageModelToolsService));
 function getToolFullReferenceName(tool, toolSet) {
     const toolName = tool.toolReferenceName ?? tool.displayName;
     if (toolSet) {
         return `${toolSet.referenceName}/${toolName}`;
-    }
-    else if (tool.source.type === 'extension') {
+    } else if (tool.source.type === "extension") {
         return `${tool.source.extensionId.value.toLowerCase()}/${toolName}`;
     }
     return toolName;
 }
 function getToolSetFullReferenceName(toolSet) {
-    if (toolSet.source.type === 'mcp') {
+    if (toolSet.source.type === "mcp") {
         return `${toolSet.referenceName}/*`;
     }
     return toolSet.referenceName;