@codingame/monaco-vscode-chat-service-override 34.1.2 → 35.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostLocalCustomizations.js

@@ -1,15 +1,23 @@
 
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
 import { isEqualOrParent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
 import { CustomizationType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
 import { customizationId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { McpServerType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes';
 import { BUILTIN_STORAGE, AICustomizationSources } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
 import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
 import { PromptsStorage, matchesSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { isContributionEnabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
+import { MCP_PLUGIN_COLLECTION_ID_PREFIX } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/discovery/pluginMcpDiscovery';
+import { McpServerTransportType, McpCollectionDefinition } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes';
+import { ConfigurationResolverExpression } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolverExpression';
+import { isDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
 
 const SYNCABLE_PROMPT_TYPES = [
     PromptsType.agent,
@@ -56,15 +64,123 @@ async function enumerateLocalCustomizationsForHarness(promptsService, syncProvid
     }
     return result;
 }
-async function resolveCustomizationRefs(promptsService, syncProvider, agentPluginService, bundler, sessionType) {
+function launchToMcpServerConfiguration(launch) {
+    switch (launch.type) {
+    case McpServerTransportType.Stdio:
+        if (!launch.command) {
+            return undefined;
+        }
+        return {
+            type: McpServerType.LOCAL,
+            command: launch.command,
+            args: launch.args.length > 0 ? [...launch.args] : undefined,
+            env: ( Object.keys(launch.env)).length > 0 ? {
+                ...launch.env
+            } : undefined,
+            envFile: launch.envFile,
+            cwd: launch.cwd
+        };
+    case McpServerTransportType.HTTP:
+        return {
+            type: McpServerType.REMOTE,
+            url: ( launch.uri.toString()),
+            headers: launch.headers.length > 0 ? Object.fromEntries(launch.headers) : undefined
+        };
+    }
+}
+async function resolveConfigurationForSync(configurationResolverService, folder, configuration) {
+    const expr = ConfigurationResolverExpression.parse(configuration);
+    for (const replacement of expr.unresolved()) {
+        if (replacement.name === "input" || replacement.name === "command") {
+            return undefined;
+        }
+    }
+    try {
+        await configurationResolverService.resolveAsync(folder, expr);
+    } catch {
+        return undefined;
+    }
+    if (!Iterable.isEmpty(expr.unresolved())) {
+        return undefined;
+    }
+    return expr.toObject();
+}
+async function collectNonPluginMcpServers(mcpService, configurationResolverService) {
+    const result = [];
+    for (const server of mcpService.servers.get()) {
+        if (server.collection.id.startsWith(MCP_PLUGIN_COLLECTION_ID_PREFIX)) {
+            continue;
+        }
+        if (!isContributionEnabled(server.enablement.get())) {
+            continue;
+        }
+        const definitions = server.readDefinitions().get();
+        const definition = definitions.server;
+        const launch = definition?.launch;
+        if (!launch) {
+            continue;
+        }
+        let configuration = launchToMcpServerConfiguration(launch);
+        if (!configuration) {
+            continue;
+        }
+        const collection = definitions.collection;
+        if (collection && McpCollectionDefinition.isWorkspaceDiscovered(collection)) {
+            if (!McpCollectionDefinition.isVscodeMcpJson(collection)) {
+                continue;
+            }
+            const resolved = await resolveConfigurationForSync(
+                configurationResolverService,
+                definition.variableReplacement?.folder,
+                configuration
+            );
+            if (!resolved) {
+                continue;
+            }
+            configuration = resolved;
+        }
+        result.push({
+            name: server.definition.label,
+            configuration
+        });
+    }
+    return result;
+}
+async function resolveCustomizationRefs(
+    fileService,
+    promptsService,
+    syncProvider,
+    agentPluginService,
+    mcpService,
+    configurationResolverService,
+    bundler,
+    sessionType
+) {
     const enumerated = await enumerateLocalCustomizationsForHarness(promptsService, syncProvider, sessionType, CancellationToken.None);
     const enabled = enumerated.filter(e => !e.disabled);
-    if (enabled.length === 0) {
-        return [];
-    }
     const plugins = agentPluginService.plugins.get();
     const pluginRefs = ( new Map());
     const looseFiles = [];
+    const addPluginRef = plugin => {
+        const key = ( plugin.uri.toString());
+        if (!( pluginRefs.has(key))) {
+            const promise = (async () => {
+                let nonce;
+                try {
+                    nonce = (await fileService.stat(plugin.uri)).mtime;
+                } catch {}
+                return {
+                    type: CustomizationType.Plugin,
+                    id: customizationId(key),
+                    uri: key,
+                    name: plugin.label,
+                    nonce: nonce?.toString(16),
+                    enabled: true
+                };
+            })();
+            pluginRefs.set(key, promise);
+        }
+    };
     for (const entry of enabled) {
         if (entry.source === AICustomizationSources.plugin) {
             const plugin = plugins.find(p => isEqualOrParent(entry.uri, p.uri));
@@ -74,16 +190,10 @@ async function resolveCustomizationRefs(promptsService, syncProvider, agentPlugi
             if (syncProvider.isDisabled(plugin.uri)) {
                 continue;
             }
-            const key = ( plugin.uri.toString());
-            if (!( pluginRefs.has(key))) {
-                pluginRefs.set(key, {
-                    type: CustomizationType.Plugin,
-                    id: customizationId(key),
-                    uri: key,
-                    name: plugin.label,
-                    enabled: true
-                });
+            if (!isContributionEnabled(plugin.enablement.get())) {
+                continue;
             }
+            addPluginRef(plugin);
         } else {
             looseFiles.push({
                 uri: entry.uri,
@@ -91,14 +201,27 @@ async function resolveCustomizationRefs(promptsService, syncProvider, agentPlugi
             });
         }
     }
-    const refs = [...( pluginRefs.values())];
-    if (looseFiles.length > 0) {
-        const result = await bundler.bundle(looseFiles);
-        if (result) {
-            refs.push(result.ref);
+    for (const plugin of plugins) {
+        if (( pluginRefs.has(( plugin.uri.toString())))) {
+            continue;
         }
+        if (syncProvider.isDisabled(plugin.uri)) {
+            continue;
+        }
+        if (!isContributionEnabled(plugin.enablement.get())) {
+            continue;
+        }
+        if (plugin.mcpServerDefinitions.get().length === 0) {
+            continue;
+        }
+        addPluginRef(plugin);
+    }
+    const refs = [...( pluginRefs.values())];
+    const mcpServers = await collectNonPluginMcpServers(mcpService, configurationResolverService);
+    if (looseFiles.length > 0 || mcpServers.length > 0) {
+        refs.push(bundler.bundle(looseFiles, mcpServers).then(r => r?.ref));
     }
-    return refs;
+    return await Promise.all(refs).then(r => r.filter(isDefined));
 }
 
-export { SYNCABLE_PROMPT_TYPES, SYNCABLE_STORAGE_SOURCES, enumerateLocalCustomizationsForHarness, resolveCustomizationRefs };
+export { SYNCABLE_PROMPT_TYPES, SYNCABLE_STORAGE_SOURCES, collectNonPluginMcpServers, enumerateLocalCustomizationsForHarness, resolveCustomizationRefs };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostModeSynchronizer.js

@@ -3,11 +3,8 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { Disposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { AgentSession } from '../../../../../../platform/agentHost/common/agentService.js';
-import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
 import { fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
 import { agentHostAgentPickerStorageKey } from '../../../../../../platform/agentHost/common/customAgents.js';
-import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
-import { StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
 import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
@@ -24,14 +21,12 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
     }
     constructor(
         _chatWidgetService,
-        _agentHostService,
         _provisionalSessionService,
         _storageService,
         environmentService
     ) {
         super();
         this._chatWidgetService = _chatWidgetService;
-        this._agentHostService = _agentHostService;
         this._provisionalSessionService = _provisionalSessionService;
         this._storageService = _storageService;
         this._widgetListeners = this._register(( new DisposableMap()));
@@ -57,11 +52,6 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
                 this._syncWidgetFromBackend(widget);
             }
         }));
-        this._register(this._agentHostService.onDidAction(envelope => {
-            if (envelope.action.type === ActionType.SessionAgentChanged) {
-                this._syncWidgetsFromBackend();
-            }
-        }));
     }
     _attachWidget(widget) {
         if (( this._widgetListeners.has(widget))) {
@@ -75,11 +65,6 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
         this._widgetListeners.set(widget, store);
         this._syncWidgetFromBackend(widget);
     }
-    _syncWidgetsFromBackend() {
-        for (const widget of this._chatWidgetService.getAllWidgets()) {
-            this._syncWidgetFromBackend(widget);
-        }
-    }
     _onWidgetModeChanged(widget) {
         if (( this._updatingWidgets.has(widget))) {
             return;
@@ -91,19 +76,10 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
         }
         const mode = widget.input.currentModeObs.get();
         const agentUri = this._agentUriFromMode(mode);
-        this._storeSelectedAgent(sessionResource, agentUri);
-        const currentAgentUri = this._readSessionState(backendSession)?.summary.agent?.uri;
-        if (currentAgentUri === agentUri) {
+        if (this._readSelectedAgent(sessionResource) === agentUri) {
             return;
         }
-        this._agentHostService.dispatch(( backendSession.toString()), {
-            type: ActionType.SessionAgentChanged,
-            ...(agentUri ? {
-                agent: {
-                    uri: agentUri
-                }
-            } : {})
-        });
+        this._storeSelectedAgent(sessionResource, agentUri);
     }
     _syncWidgetFromBackend(widget) {
         const sessionResource = widget.viewModel?.sessionResource;
@@ -111,7 +87,7 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
         if (!sessionResource || !backendSession) {
             return;
         }
-        const agentUri = this._readSessionState(backendSession)?.summary.agent?.uri;
+        const agentUri = this._readSelectedAgent(sessionResource);
         void this._applyMode(widget, sessionResource, agentUri);
     }
     async _applyMode(widget, sessionResource, agentUri) {
@@ -153,9 +129,9 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
             this._storageService.remove(key, StorageScope.PROFILE);
         }
     }
-    _readSessionState(backendSession) {
-        const value = this._agentHostService.getSubscriptionUnmanaged(StateComponents.Session, backendSession)?.value;
-        return value && !(value instanceof Error) ? value : undefined;
+    _readSelectedAgent(sessionResource) {
+        const key = agentHostAgentPickerStorageKey(sessionResource.scheme);
+        return this._storageService.get(key, StorageScope.PROFILE);
     }
     _resolveBackendSession(sessionResource) {
         const provisionalSession = this._provisionalSessionService.get(sessionResource);
@@ -169,7 +145,7 @@ let AgentHostModeSynchronizer = class AgentHostModeSynchronizer extends Disposab
         return provider ? AgentSession.uri(provider, sessionResource.path.substring(1)) : undefined;
     }
 };
-AgentHostModeSynchronizer = ( __decorate([( __param(0, IChatWidgetService)), ( __param(1, IAgentHostService)), ( __param(2, IAgentHostUntitledProvisionalSessionService)), ( __param(3, IStorageService)), ( __param(4, IWorkbenchEnvironmentService))], AgentHostModeSynchronizer));
+AgentHostModeSynchronizer = ( __decorate([( __param(0, IChatWidgetService)), ( __param(1, IAgentHostUntitledProvisionalSessionService)), ( __param(2, IStorageService)), ( __param(3, IWorkbenchEnvironmentService))], AgentHostModeSynchronizer));
 registerWorkbenchContribution2(
     AgentHostModeSynchronizer.ID,
     AgentHostModeSynchronizer,

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService.d.ts

@@ -0,0 +1,23 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IAgentHostNewSessionFolderService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService.service";
+export declare class AgentHostNewSessionFolderService extends Disposable implements IAgentHostNewSessionFolderService {
+    private readonly _workspaceContextService;
+    readonly _serviceBrand: undefined;
+    private readonly _folders;
+    /**
+     * The most recently chosen folder in this window. Window-level "sticky"
+     * default that, unlike {@link _folders}, is not cleared on session
+     * disposal so a new chat can default to the user's last folder choice.
+     */
+    private _defaultFolder;
+    private readonly _onDidChangeFolder;
+    readonly onDidChangeFolder: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<URI>;
+    constructor(chatService: IChatService, _workspaceContextService: IWorkspaceContextService);
+    getFolder(sessionResource: URI): URI | undefined;
+    setFolder(sessionResource: URI, folder: URI): void;
+    clear(sessionResource: URI): void;
+    getDefaultFolder(): URI | undefined;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService.js

@@ -0,0 +1,52 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { extUriBiasedIgnorePathCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+let AgentHostNewSessionFolderService = class AgentHostNewSessionFolderService extends Disposable {
+    constructor(chatService, _workspaceContextService) {
+        super();
+        this._workspaceContextService = _workspaceContextService;
+        this._folders = ( new ResourceMap());
+        this._onDidChangeFolder = this._register(( new Emitter()));
+        this.onDidChangeFolder = this._onDidChangeFolder.event;
+        this._register(chatService.onDidDisposeSession(e => {
+            for (const sessionResource of e.sessionResources) {
+                this.clear(sessionResource);
+            }
+        }));
+    }
+    getFolder(sessionResource) {
+        return this._folders.get(sessionResource);
+    }
+    setFolder(sessionResource, folder) {
+        this._defaultFolder = folder;
+        const existing = this._folders.get(sessionResource);
+        if (existing?.toString() === ( folder.toString())) {
+            return;
+        }
+        this._folders.set(sessionResource, folder);
+        this._onDidChangeFolder.fire(sessionResource);
+    }
+    clear(sessionResource) {
+        if (this._folders.delete(sessionResource)) {
+            this._onDidChangeFolder.fire(sessionResource);
+        }
+    }
+    getDefaultFolder() {
+        const stored = this._defaultFolder;
+        if (stored && ( this._workspaceContextService.getWorkspace().folders.some(folder => extUriBiasedIgnorePathCase.isEqual(folder.uri, stored)))) {
+            return stored;
+        }
+        return undefined;
+    }
+};
+AgentHostNewSessionFolderService = ( __decorate([( __param(0, IChatService)), ( __param(1, IWorkspaceContextService))], AgentHostNewSessionFolderService));
+
+export { AgentHostNewSessionFolderService };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostPermissionUiContribution.js

@@ -64,23 +64,23 @@ let AgentHostPermissionUiContribution = class AgentHostPermissionUiContribution
         const path = request.uri.scheme === Schemas.file ? request.uri.fsPath : ( request.uri.toString());
         const fence = "`".repeat((path.match(/`+/g)?.reduce((m, s) => Math.max(m, s.length), 0) ?? 0) + 1);
         const codePath = `${fence}${path}${fence}`;
-        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(5279, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(5280, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
-        const description = totalPending > 1 ? totalPending === 2 ? ( localize(5281, "+1 more request waiting")) : ( localize(5282, "+{0} more requests waiting", totalPending - 1)) : undefined;
+        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(5507, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(5508, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
+        const description = totalPending > 1 ? totalPending === 2 ? ( localize(5509, "+1 more request waiting")) : ( localize(5510, "+{0} more requests waiting", totalPending - 1)) : undefined;
         return {
             id: AgentHostPermissionUiContribution_1.NOTIFICATION_ID,
             severity: ChatInputNotificationSeverity.Warning,
             message,
             description,
             actions: [{
-                label: ( localize(5283, "Deny")),
+                label: ( localize(5511, "Deny")),
                 commandId: DENY_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5284, "Allow")),
+                label: ( localize(5512, "Allow")),
                 commandId: ALLOW_COMMAND,
                 commandArgs: [request.id]
             }, {
-                label: ( localize(5285, "Always Allow")),
+                label: ( localize(5513, "Always Allow")),
                 commandId: ALLOW_ALWAYS_COMMAND,
                 commandArgs: [request.id]
             }],

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService.d.ts

@@ -0,0 +1,47 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable, IReader } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IAgentHostToolSetEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService.service";
+/**
+ * The Copilot CLI agent-host session type. Tool enablement is scoped per session type; this is the
+ * only target for the Chat Customizations → Tools section today.
+ */
+export declare const AGENT_HOST_COPILOT_CLI_SESSION_TYPE = "agent-host-copilotcli";
+/**
+ * Tool / tool-set enablement state. Both maps are keyed by id and store only deviations from the
+ * default ("enabled"). A tool's effective state resolves child → parent → default:
+ * `tools[toolId] ?? toolSets[setId] ?? true`. Storing the tool-set default (rather than every
+ * member) lets a disabled group also cover member tools that register later.
+ */
+export interface IToolEnablementState {
+    readonly toolSets: ReadonlyMap<string, boolean>;
+    readonly tools: ReadonlyMap<string, boolean>;
+}
+export type TriState = boolean | "mixed";
+/** Whether `toolId`, as a member of `toolSetId`, is effectively enabled. */
+export declare function isToolEnabledInSet(state: IToolEnablementState, toolSetId: string, toolId: string): boolean;
+/** Aggregate tri-state of a tool set, derived from its member tools' effective states. */
+export declare function getToolSetTriState(state: IToolEnablementState, toolSetId: string, toolIds: readonly string[]): TriState;
+/** The subset of a tool set needed to count its enabled tools. {@link IToolSet} satisfies this shape. */
+export interface ICountableToolSet {
+    readonly id: string;
+    readonly deprecated?: boolean;
+    getTools(reader?: IReader): Iterable<{
+        readonly id: string;
+    }>;
+}
+/** Counts the enabled tools across the non-deprecated tool sets surfaced in Chat Customizations → Tools. */
+export declare function countEnabledCustomizationTools(toolSets: Iterable<ICountableToolSet>, state: IToolEnablementState, reader?: IReader): number;
+export declare class AgentHostToolSetEnablementService extends Disposable implements IAgentHostToolSetEnablementService {
+    private readonly _storageService;
+    readonly _serviceBrand: undefined;
+    private readonly _state;
+    constructor(_storageService: IStorageService);
+    observe(sessionType: string): IObservable<IToolEnablementState>;
+    getState(sessionType: string): IToolEnablementState;
+    setToolSetEnabled(sessionType: string, toolSetId: string, toolIds: readonly string[], enabled: boolean): void;
+    setToolEnabled(sessionType: string, toolSetId: string, toolId: string, enabled: boolean): void;
+    private _setState;
+    private _load;
+    private _save;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService.js

@@ -0,0 +1,163 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+
+const AGENT_HOST_COPILOT_CLI_SESSION_TYPE = "agent-host-copilotcli";
+function isToolEnabledInSet(state, toolSetId, toolId) {
+    return state.tools.get(toolId) ?? state.toolSets.get(toolSetId) ?? true;
+}
+function getToolSetTriState(state, toolSetId, toolIds) {
+    let anyOn = false;
+    let anyOff = false;
+    for (const toolId of toolIds) {
+        if (isToolEnabledInSet(state, toolSetId, toolId)) {
+            anyOn = true;
+        } else {
+            anyOff = true;
+        }
+        if (anyOn && anyOff) {
+            return "mixed";
+        }
+    }
+    return anyOn;
+}
+function countEnabledCustomizationTools(toolSets, state, reader) {
+    const enabled = ( new Set());
+    for (const ts of toolSets) {
+        if (ts.deprecated) {
+            continue;
+        }
+        for (const tool of ts.getTools(reader)) {
+            if (isToolEnabledInSet(state, ts.id, tool.id)) {
+                enabled.add(tool.id);
+            }
+        }
+    }
+    return enabled.size;
+}
+const STORAGE_KEY = "chat.agentHost.toolSetEnablement";
+const EMPTY_STATE = {
+    toolSets: ( new Map()),
+    tools: ( new Map())
+};
+let AgentHostToolSetEnablementService = class AgentHostToolSetEnablementService extends Disposable {
+    constructor(_storageService) {
+        super();
+        this._storageService = _storageService;
+        this._state = observableValue("agentHostToolSetEnablement", this._load());
+        const storeForListener = this._register(( new DisposableStore()));
+        this._register(
+            this._storageService.onDidChangeValue(StorageScope.PROFILE, STORAGE_KEY, storeForListener)(() => {
+                this._state.set(this._load(), undefined);
+            })
+        );
+    }
+    observe(sessionType) {
+        return derived(reader => this._state.read(reader).get(sessionType) ?? EMPTY_STATE);
+    }
+    getState(sessionType) {
+        return this._state.get().get(sessionType) ?? EMPTY_STATE;
+    }
+    setToolSetEnabled(sessionType, toolSetId, toolIds, enabled) {
+        const state = this.getState(sessionType);
+        const toolSets = ( new Map(state.toolSets));
+        const tools = ( new Map(state.tools));
+        if (enabled) {
+            toolSets.delete(toolSetId);
+        } else {
+            toolSets.set(toolSetId, false);
+        }
+        for (const toolId of toolIds) {
+            tools.delete(toolId);
+        }
+        this._setState(sessionType, {
+            toolSets,
+            tools
+        });
+    }
+    setToolEnabled(sessionType, toolSetId, toolId, enabled) {
+        const state = this.getState(sessionType);
+        const tools = ( new Map(state.tools));
+        const setDefault = state.toolSets.get(toolSetId) ?? true;
+        if (enabled === setDefault) {
+            tools.delete(toolId);
+        } else {
+            tools.set(toolId, enabled);
+        }
+        this._setState(sessionType, {
+            toolSets: state.toolSets,
+            tools
+        });
+    }
+    _setState(sessionType, next) {
+        const current = ( new Map(this._state.get()));
+        if (next.toolSets.size === 0 && next.tools.size === 0) {
+            current.delete(sessionType);
+        } else {
+            current.set(sessionType, {
+                toolSets: ( new Map(next.toolSets)),
+                tools: ( new Map(next.tools))
+            });
+        }
+        this._state.set(current, undefined);
+        this._save(current);
+    }
+    _load() {
+        const raw = this._storageService.get(STORAGE_KEY, StorageScope.PROFILE);
+        if (!raw) {
+            return ( new Map());
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            const out = ( new Map());
+            for (const [sessionType, entry] of Object.entries(parsed)) {
+                const toolSets = ( new Map());
+                const tools = ( new Map());
+                for (const [id, value] of Object.entries(entry.toolSets ?? {})) {
+                    toolSets.set(id, value);
+                }
+                for (const [id, value] of Object.entries(entry.tools ?? {})) {
+                    tools.set(id, value);
+                }
+                if (toolSets.size > 0 || tools.size > 0) {
+                    out.set(sessionType, {
+                        toolSets,
+                        tools
+                    });
+                }
+            }
+            return out;
+        } catch {
+            return ( new Map());
+        }
+    }
+    _save(state) {
+        if (state.size === 0) {
+            this._storageService.remove(STORAGE_KEY, StorageScope.PROFILE);
+            return;
+        }
+        const out = {};
+        for (const [sessionType, entry] of state) {
+            out[sessionType] = {
+                toolSets: Object.fromEntries(entry.toolSets),
+                tools: Object.fromEntries(entry.tools)
+            };
+        }
+        this._storageService.store(
+            STORAGE_KEY,
+            JSON.stringify(out),
+            StorageScope.PROFILE,
+            StorageTarget.MACHINE
+        );
+    }
+};
+AgentHostToolSetEnablementService = ( __decorate([( __param(0, IStorageService))], AgentHostToolSetEnablementService));
+
+export { AGENT_HOST_COPILOT_CLI_SESSION_TYPE, AgentHostToolSetEnablementService, countEnabledCustomizationTools, getToolSetTriState, isToolEnabledInSet };