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

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

@@ -1,35 +1,32 @@
 
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
+import { Event, Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { AgentHostMcpServersConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { getEffectiveAgents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customAgents';
+import { withCustomizationEnablement, getCustomizationDisabledReason, isCustomizationEnabled } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customizationEnablement';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import { CustomizationEnablementKind, McpServerStatus, 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 '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
-import '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/oauth';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
-import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { agentHostMcpServerId, resolveMcpServerAuthentication } from './agentHostAuth.js';
+import { IOutputService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/output/common/output.service';
 
 class NullAgentHostCustomizationService {
     constructor() {
@@ -69,5 +66,420 @@ class NullAgentHostCustomizationService {
         await beforeShow?.();
     }
 }
+class AbstractAgentHostCustomizationService extends Disposable {
+    constructor(_instantiationService, _logService) {
+        super();
+        this._instantiationService = _instantiationService;
+        this._logService = _logService;
+        this._onDidChangeCustomAgents = this._register(( new Emitter()));
+        this._onDidChangeCustomizations = this._register(( new Emitter()));
+        this.onDidChangeCustomAgents = this._onDidChangeCustomAgents.event;
+        this.onDidChangeCustomizations = this._onDidChangeCustomizations.event;
+        this._mcpDiagnosticSessions = ( new ResourceSet());
+        this._mcpLogRegistry = this._register(this._instantiationService.createInstance(AgentHostMcpServerLogRegistry));
+        this._register(this.onDidChangeCustomizations(() => this._recordMcpDiagnostics()));
+    }
+    getCustomAgents(sessionResource) {
+        return getEffectiveAgents(this._resolveTarget(sessionResource)?.customizations);
+    }
+    getCustomizations(sessionResource) {
+        return this._resolveTarget(sessionResource)?.customizations ?? [];
+    }
+    whenCustomizationsReady(_sessionResource, _token) {
+        return Promise.resolve();
+    }
+    getFolderPickerDecision(sessionResource) {
+        return this._resolveTarget(sessionResource)?.folderPickerDecision;
+    }
+    getWorkingDirectory(sessionResource) {
+        return this._resolveTarget(sessionResource)?.workingDirectory;
+    }
+    getWorkingDirectories(sessionResource) {
+        return this._resolveTarget(sessionResource)?.workingDirectories ?? [];
+    }
+    getClientWorkingDirectoryUris(sessionResource) {
+        const target = this._resolveTarget(sessionResource);
+        if (!target) {
+            return [];
+        }
+        return target.workingDirectories?.map(root => target.resourceUris.fromAgentHost(( URI.parse(root)))) ?? [];
+    }
+    getMcpServers(sessionResource) {
+        const target = this._resolveTarget(sessionResource);
+        if (!target) {
+            return [];
+        }
+        return getPresentableMcpServerCustomizations(target.customizations).map((
+            {
+                server,
+                plugin
+            }
+        ) => {
+            const source = ( URI.parse(server.uri));
+            return {
+                id: this._scopedMcpServerId(sessionResource, server.id),
+                name: server.name,
+                enabled: isCustomizationEnabled(server) && (!plugin || isCustomizationEnabled(plugin)),
+                enablement: server.enablement,
+                isPluginProvided: plugin !== undefined,
+                isClientBundled: plugin !== undefined && target.isBundledMcpServer(plugin.uri, server.name),
+                owningPluginClientId: plugin?.clientId,
+                disabledReason: getCustomizationDisabledReason(server, plugin),
+                status: server.state.kind,
+                state: server.state,
+                sourceUri: source.scheme === "mcp-top-level" ? undefined : target.resourceUris.fromAgentHost(source),
+                sourceRange: server.range,
+                logOutputChannelId: channelIdForMcpServer(( sessionResource.toString()), server.id),
+                setEnabled: enabled => target.setCustomizationEnablement(
+                    server.id,
+                    withCustomizationEnablement(server.enablement, CustomizationEnablementKind.Session, {
+                        kind: CustomizationEnablementKind.Session,
+                        enabled
+                    })
+                ),
+                start: () => target.startMcpServer(server.id),
+                stop: () => target.stopMcpServer(server.id)
+            };
+        });
+    }
+    showMcpServerLog(sessionResource, serverId, beforeShow) {
+        const target = this._resolveTarget(sessionResource);
+        if (!target) {
+            return Promise.resolve();
+        }
+        const entry = flattenMcpServerCustomizations(target.customizations).find((
+            {
+                server
+            }
+        ) => this._scopedMcpServerId(sessionResource, server.id) === serverId);
+        if (!entry) {
+            return Promise.resolve();
+        }
+        const {
+            server,
+            plugin
+        } = entry;
+        this._trackMcpDiagnostics(sessionResource, target);
+        const channelId = this._mcpLogRegistry.record({
+            sessionResource,
+            rawId: server.id,
+            name: server.name,
+            enabled: isCustomizationEnabled(server) && (!plugin || isCustomizationEnabled(plugin)),
+            state: server.state
+        });
+        return this._mcpLogRegistry.show(channelId, beforeShow);
+    }
+    _trackMcpDiagnostics(sessionResource, target) {
+        this._mcpDiagnosticSessions.add(sessionResource);
+        for (const {
+            server,
+            plugin
+        } of flattenMcpServerCustomizations(target.customizations)) {
+            this._mcpLogRegistry.record({
+                sessionResource,
+                rawId: server.id,
+                name: server.name,
+                enabled: isCustomizationEnabled(server) && (!plugin || isCustomizationEnabled(plugin)),
+                state: server.state
+            });
+        }
+    }
+    _recordMcpDiagnostics() {
+        for (const sessionResource of this._mcpDiagnosticSessions) {
+            const target = this._resolveTarget(sessionResource);
+            if (!target) {
+                continue;
+            }
+            for (const {
+                server,
+                plugin
+            } of flattenMcpServerCustomizations(target.customizations)) {
+                this._mcpLogRegistry.record({
+                    sessionResource,
+                    rawId: server.id,
+                    name: server.name,
+                    enabled: isCustomizationEnabled(server) && (!plugin || isCustomizationEnabled(plugin)),
+                    state: server.state
+                });
+            }
+        }
+    }
+    _disposeMcpDiagnostics(sessionResource) {
+        this._mcpDiagnosticSessions.delete(sessionResource);
+        this._mcpLogRegistry.disposeForSession(sessionResource);
+    }
+    addMcpServer(sessionResource, name, config) {
+        const target = this._resolveTarget(sessionResource);
+        const existingServers = target?.rootConfig?.values?.[AgentHostMcpServersConfigKey];
+        if (!target || !target.rootConfig) {
+            return;
+        }
+        const servers = existingServers && typeof existingServers === "object" && !Array.isArray(existingServers) ? existingServers : {};
+        target.setRootConfigValue(AgentHostMcpServersConfigKey, {
+            ...servers,
+            [name]: config
+        });
+    }
+    async authenticateMcpServer(sessionResource, serverId) {
+        const target = this._resolveTarget(sessionResource);
+        if (!target) {
+            return false;
+        }
+        const server = this._findMcpServer(target.customizations, serverId);
+        if (!server || server.state.kind !== McpServerStatus.AuthRequired) {
+            return false;
+        }
+        const scopedServerId = agentHostMcpServerId(sessionResource.authority, server.name, server.state.resource.resource);
+        try {
+            return await this._instantiationService.invokeFunction(resolveMcpServerAuthentication, server.state.resource, {
+                allowInteraction: true,
+                logPrefix: "[AgentHost]",
+                mcpServerId: scopedServerId,
+                mcpServerName: server.name,
+                mcpServerUrl: server.state.resource.resource,
+                oauthClient: server.state.oauthClient,
+                scopes: server.state.requiredScopes ?? [],
+                agentHost: {
+                    scheme: sessionResource.scheme,
+                    authority: sessionResource.authority
+                },
+                authenticate: request => target.authenticate(request)
+            });
+        } catch (err) {
+            this._logService.error(`[AgentHost] Failed to authenticate MCP server '${server.name}'`, err);
+            return false;
+        }
+    }
+    setCustomizationEnablement(sessionResource, customizationId, currentEnablement, kind, enabled) {
+        const target = this._resolveTarget(sessionResource);
+        if (!target) {
+            this._logService.warn(
+                `[AgentHostCustomizationService] Cannot change enablement for '${customizationId}' because its session is unavailable.`
+            );
+            return;
+        }
+        const customization = this._findCustomization(target.customizations, customizationId);
+        if (!customization) {
+            this._logService.warn(
+                `[AgentHostCustomizationService] Cannot change enablement for unavailable customization '${customizationId}'.`
+            );
+            return;
+        }
+        const entry = kind === CustomizationEnablementKind.Workspace ? this._workspaceEnablementEntry(target, enabled) : {
+            kind,
+            enabled
+        };
+        if (!entry) {
+            this._logService.warn(
+                `[AgentHostCustomizationService] Cannot set workspace enablement for '${customizationId}' without a working directory.`
+            );
+            return;
+        }
+        target.setCustomizationEnablement(
+            customization.id,
+            withCustomizationEnablement(currentEnablement, kind, entry)
+        );
+    }
+    _workspaceEnablementEntry(target, enabled) {
+        const workingDirectory = target.workingDirectories?.[0] ?? target.workingDirectory;
+        return workingDirectory ? {
+            kind: CustomizationEnablementKind.Workspace,
+            uri: workingDirectory,
+            enabled
+        } : undefined;
+    }
+    _fireCustomAgentsChanged() {
+        this._onDidChangeCustomAgents.fire();
+    }
+    _fireCustomizationsChanged() {
+        this._onDidChangeCustomizations.fire();
+    }
+    _findMcpServer(customizations, serverId) {
+        for (const {
+            server
+        } of flattenMcpServerCustomizations(customizations)) {
+            if (server.id === serverId || this._isScopedMcpServerIdForRawId(serverId, server.id)) {
+                return server;
+            }
+        }
+        return undefined;
+    }
+    _findCustomization(customizations, customizationId) {
+        for (const customization of customizations) {
+            if (customization.id === customizationId || this._isScopedMcpServerIdForRawId(customizationId, customization.id)) {
+                return customization;
+            }
+            const child = (customization.type !== CustomizationType.McpServer ? customization.children : undefined)?.find(
+                child => child.id === customizationId || this._isScopedMcpServerIdForRawId(customizationId, child.id)
+            );
+            if (child) {
+                return child;
+            }
+        }
+        return undefined;
+    }
+    _scopedMcpServerId(sessionResource, rawId) {
+        return `${sessionResource.authority}/${rawId}`;
+    }
+    _isScopedMcpServerIdForRawId(serverId, rawId) {
+        const separator = serverId.indexOf("/");
+        return separator >= 0 && serverId.slice(separator + 1) === rawId;
+    }
+}
+function flattenMcpServerCustomizations(customizations) {
+    return customizations.flatMap(customization => customization.type === CustomizationType.McpServer ? [{
+        server: customization,
+        isTopLevel: true
+    }] : customization.children?.filter(child => child.type === CustomizationType.McpServer).map(server => ({
+        server,
+        plugin: customization.type === CustomizationType.Plugin ? customization : undefined,
+        isTopLevel: false
+    })) ?? []);
+}
+function getPresentableMcpServerCustomizations(customizations) {
+    const entries = flattenMcpServerCustomizations(customizations);
+    const topLevelNames = ( new Set());
+    for (const entry of entries) {
+        if (entry.isTopLevel) {
+            topLevelNames.add(entry.server.name);
+        }
+    }
+    if (topLevelNames.size === 0) {
+        return entries;
+    }
+    return entries.filter(entry => entry.isTopLevel || !( topLevelNames.has(entry.server.name)));
+}
+let AgentHostMcpServerLogRegistry = class AgentHostMcpServerLogRegistry extends Disposable {
+    constructor(_loggerService, _outputService) {
+        super();
+        this._loggerService = _loggerService;
+        this._outputService = _outputService;
+        this._entries = ( new Map());
+        this._bySession = ( new Map());
+        this._register(toDisposable(() => {
+            for (const key of [...( this._bySession.keys())]) {
+                this._disposeSessionKey(key);
+            }
+        }));
+    }
+    record(server) {
+        const sessionKey = ( server.sessionResource.toString());
+        const channelId = channelIdForMcpServer(sessionKey, server.rawId);
+        let entry = this._entries.get(channelId);
+        if (!entry) {
+            const logger = this._loggerService.createLogger(channelId, {
+                hidden: true,
+                name: ( localize(7986, "MCP: {0}", server.name))
+            });
+            const dispose = () => {
+                logger.dispose();
+                this._loggerService.deregisterLogger(channelId);
+            };
+            entry = {
+                logger,
+                dispose,
+                lastSignature: undefined
+            };
+            this._entries.set(channelId, entry);
+            let group = this._bySession.get(sessionKey);
+            if (!group) {
+                group = ( new Set());
+                this._bySession.set(sessionKey, group);
+            }
+            group.add(channelId);
+        }
+        const {
+            signature,
+            message,
+            isError
+        } = describeMcpServerState(server.name, server.enabled, server.state);
+        if (entry.lastSignature !== signature) {
+            entry.lastSignature = signature;
+            if (isError) {
+                entry.logger.error(message);
+            } else {
+                entry.logger.info(message);
+            }
+        }
+        return channelId;
+    }
+    async show(channelId, beforeShow) {
+        if (!( this._entries.has(channelId))) {
+            return;
+        }
+        this._loggerService.setVisibility(channelId, true);
+        await beforeShow?.();
+        await this._outputService.showChannel(channelId);
+    }
+    disposeForSession(sessionResource) {
+        this._disposeSessionKey(( sessionResource.toString()));
+    }
+    _disposeSessionKey(sessionKey) {
+        const group = this._bySession.get(sessionKey);
+        if (!group) {
+            return;
+        }
+        this._bySession.delete(sessionKey);
+        for (const channelId of group) {
+            this._entries.get(channelId)?.dispose();
+            this._entries.delete(channelId);
+        }
+    }
+};
+AgentHostMcpServerLogRegistry = ( __decorate([( __param(0, ILoggerService)), ( __param(1, IOutputService))], AgentHostMcpServerLogRegistry));
+function channelIdForMcpServer(sessionKey, rawId) {
+    const sha = ( new StringSHA1());
+    sha.update(sessionKey);
+    sha.update("\u0000");
+    sha.update(rawId);
+    return `agentHostMcpServer.${sha.digest()}`;
+}
+function describeMcpServerState(name, enabled, state) {
+    if (!enabled) {
+        return {
+            signature: "disabled",
+            message: ( localize(7987, "Server '{0}' is disabled", name)),
+            isError: false
+        };
+    }
+    switch (state.kind) {
+    case McpServerStatus.Ready:
+        return {
+            signature: "ready",
+            message: ( localize(7988, "Server '{0}' is running", name)),
+            isError: false
+        };
+    case McpServerStatus.Starting:
+        return {
+            signature: "starting",
+            message: ( localize(7989, "Server '{0}' is starting", name)),
+            isError: false
+        };
+    case McpServerStatus.AuthRequired:
+        return {
+            signature: `authRequired:${state.resource.resource}`,
+            message: ( localize(
+                7990,
+                "Server '{0}' requires authentication ({1})",
+                name,
+                state.resource.resource
+            )),
+            isError: false
+        };
+    case McpServerStatus.Error:
+        return {
+            signature: `error:${state.error.errorType}:${state.error.message}`,
+            message: ( localize(7991, "Server '{0}' failed: {1}", name, state.error.message)),
+            isError: true
+        };
+    case McpServerStatus.Stopped:
+    default:
+        return {
+            signature: "stopped",
+            message: ( localize(7992, "Server '{0}' is stopped", name)),
+            isError: false
+        };
+    }
+}
 
-export { NullAgentHostCustomizationService };
+export { AbstractAgentHostCustomizationService, NullAgentHostCustomizationService, flattenMcpServerCustomizations, getPresentableMcpServerCustomizations };

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

@@ -6,8 +6,8 @@ import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { readAgentModelNoticesMeta } from '../../../../../../platform/agentHost/common/agentModelNotices.js';
 import { readAgentModelPricingMeta } from '../../../../../../platform/agentHost/common/agentModelPricing.js';
 import { readAgentModelByokIdentifier } from '../../../../../../platform/agentHost/common/agentModelByokMeta.js';
-import { readAgentModelGroupId, readAgentModelSourceId } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/agentModelSource';
-import { getReasoningEffortDescription, getReasoningEffortLabel } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/reasoningEffort';
+import { readAgentModelGroupId, readAgentModelSourceId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentModelSource';
+import { getReasoningEffortDescription, getReasoningEffortLabel } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/reasoningEffort';
 import { nullExtensionDescription } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
 import { COPILOT_VENDOR_ID, AUTO_RAW_MODEL_ID, ILanguageModelChatMetadata } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
 
@@ -36,14 +36,14 @@ class AgentHostLanguageModelProvider extends Disposable {
         this._onDidChange.fire();
     }
     async provideLanguageModelChatInfo(_options, _token) {
-        return (this._models.filter(m => m.policyState !== "disabled").map(m => {
+        return this._models.filter(m => m.policyState !== "disabled").map(m => {
             const pricing = readAgentModelPricingMeta(m);
             const multiplierNumeric = pricing.multiplierNumeric;
             const isAuto = m.id === AUTO_RAW_MODEL_ID;
             const notices = isAuto ? undefined : readAgentModelNoticesMeta(m);
             const discountPercent = pricing.discountPercent;
             const hasDiscount = typeof discountPercent === "number" && discountPercent > 0 && discountPercent <= 100;
-            const detail = isAuto && hasDiscount ? ( localize(6019, "{0}% discount", discountPercent)) : undefined;
+            const detail = isAuto && hasDiscount ? ( localize(7999, "{0}% discount", discountPercent)) : undefined;
             const tooltip = notices?.rowWarning ?? (isAuto ? ILanguageModelChatMetadata.getAutoModelDescription(hasDiscount ? discountPercent : undefined) : undefined);
             const modelGroup = this._modelGroupFor(m);
             const byokModelIdentifier = readAgentModelByokIdentifier(m);
@@ -98,7 +98,7 @@ class AgentHostLanguageModelProvider extends Disposable {
                     configurationSchema: this._toLanguageModelConfigurationSchema(m.configSchema)
                 }
             };
-        }));
+        });
     }
     _catalogueEntryFor(model, group) {
         if (!this._catalogue || group?.id !== COPILOT_VENDOR_ID) {
@@ -149,8 +149,8 @@ class AgentHostLanguageModelProvider extends Disposable {
             return undefined;
         }
         return {
-            labels: ( levels.map(getReasoningEffortLabel)),
-            descriptions: ( levels.map(level => getReasoningEffortDescription(level) ?? ""))
+            labels: levels.map(getReasoningEffortLabel),
+            descriptions: levels.map(level => getReasoningEffortDescription(level) ?? "")
         };
     }
     static _groupForConfigKey(key) {

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

@@ -32,7 +32,9 @@ async function enumerateLocalCustomizationsForHarness(promptsService, syncProvid
     const storageSources = options?.includeUserStorage ? [PromptsStorage.user, ...SYNCABLE_STORAGE_SOURCES] : SYNCABLE_STORAGE_SOURCES;
     for (const type of SYNCABLE_PROMPT_TYPES) {
         const userDisabled = promptsService.getDisabledPromptFiles(type);
-        const lists = await Promise.all(( storageSources.map(storage => promptsService.listPromptFilesForStorage(type, storage, token))));
+        const lists = await Promise.all(
+            storageSources.map(storage => promptsService.listPromptFilesForStorage(type, storage, token))
+        );
         for (let i = 0; i < lists.length; i++) {
             const source = storageSources[i];
             const userToggleable = isUserToggleableCustomization(type, source);

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

@@ -2,7 +2,7 @@ import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { Location } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
 import { IMcpSandboxConfiguration, IMcpServerConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
 import { AICustomizationSource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService";
-import { IAgentHostMcpServerSupportCoverage } from "../../../common/promptSyntax/service/customizationMigrationService.js";
+import { IAgentHostMcpServerSupportCoverage } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/customizationMigrationService";
 import { IMcpConfigPath, IMcpServer, LazyCollectionState, McpServerDefinition, McpServerEnablementState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes";
 import { IConfigurationResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service";
 export declare const COPILOT_CHAT_GITHUB_MCP_COLLECTION_ID: string;

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

@@ -10,7 +10,7 @@ import { ContributionEnablementState } from '@codingame/monaco-vscode-api/vscode
 import { ExternalDiscoverySource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpConfiguration';
 import { extensionPrefixedIdentifier, LazyCollectionState, McpServerEnablementState, McpCollectionDefinition, MCP_PLUGIN_COLLECTION_ID_PREFIX, WORKSPACE_DOT_MCP_COLLECTION_ID_PREFIX, CURSOR_WORKSPACE_MCP_COLLECTION_ID_PREFIX, MCP_CONFIGURATION_COLLECTION_ID_PREFIX, extensionMcpCollectionPrefix, McpCollectionProvenance, getMcpCollectionProvenance, McpServerLaunch, McpServerTransportType } 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 { isCopilotCliSessionType } from './agentHostToolSetEnablementService.js';
+import { isCopilotCliSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostToolSetEnablementService';
 
 const COPILOT_CHAT_EXTENSION_ID = "github.copilot-chat";
 const LOCAL_AGENT_HOST_SESSION_TYPE_PREFIX = "agent-host-";
@@ -85,7 +85,7 @@ async function assessMcpServersForCopilotAgentHost(
     }
     const resolved = await resolveMcpServersForAgentHostDelivery(servers, configurationResolverService, sessionType, workingDirectories);
     return {
-        servers: ( resolved.map((
+        servers: resolved.map((
             {
                 server,
                 source,
@@ -104,7 +104,7 @@ async function assessMcpServersForCopilotAgentHost(
             delivery,
             compatibility,
             projectedConfiguration
-        }))),
+        })),
         discoveryComplete: lazyCollectionState === LazyCollectionState.AllKnown
     };
 }
@@ -114,8 +114,8 @@ async function mergeInstalledMcpServersIntoAgentHostSupportAssessment(
     configurationResolverService,
     workingDirectories
 ) {
-    const installedById = ( new Map(( installedServers.map(server => [server.id, server]))));
-    const servers = ( assessment.servers.map(server => {
+    const installedById = ( new Map(installedServers.map(server => [server.id, server])));
+    const servers = assessment.servers.map(server => {
         const installed = installedById.get(server.id);
         const runtimeState = installed?.runtimeState;
         const enablement = getInstalledMcpServerEnablementOverride(runtimeState);
@@ -124,20 +124,20 @@ async function mergeInstalledMcpServersIntoAgentHostSupportAssessment(
             enablement,
             delivery: runtimeState === McpServerEnablementState.DisabledByAccess ? AgentHostMcpServerDelivery.NotDelivered : server.delivery
         } : server;
-    }));
-    const assessedIds = ( new Set(( servers.map(server => server.id))));
-    const missingDisabledServers = await Promise.all(( installedServers.filter(server => !( assessedIds.has(server.id)) && server.runtimeState !== McpServerEnablementState.Enabled).map(
+    });
+    const assessedIds = ( new Set(servers.map(server => server.id)));
+    const missingDisabledServers = await Promise.all(installedServers.filter(server => !( assessedIds.has(server.id)) && server.runtimeState !== McpServerEnablementState.Enabled).map(
         server => assessDisabledInstalledMcpServer(server, configurationResolverService, workingDirectories)
-    )));
+    ));
     return {
         ...assessment,
         servers: [...servers, ...missingDisabledServers]
     };
 }
 function resolveMcpServersForAgentHostDelivery(servers, configurationResolverService, sessionType, workingDirectories) {
-    return Promise.all(( servers.map(
+    return Promise.all(servers.map(
         server => resolveMcpServerForAgentHostDelivery(server, configurationResolverService, sessionType, workingDirectories)
-    )));
+    ));
 }
 async function resolveMcpServerForAgentHostDelivery(server, configurationResolverService, sessionType, workingDirectories) {
     const definitions = server.readDefinitions().get();

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

@@ -5,7 +5,7 @@ import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/in
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
 import { fromAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
-import { agentHostAgentPickerStorageKey } from '../../../../../../platform/agentHost/common/customAgents.js';
+import { agentHostAgentPickerStorageKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customAgents';
 import { isUntitledChatSession } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 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';

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

@@ -64,8 +64,8 @@ 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(6034, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(6035, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
-        const description = totalPending > 1 ? totalPending === 2 ? ( localize(6036, "+1 more request waiting")) : ( localize(6037, "+{0} more requests waiting", totalPending - 1)) : undefined;
+        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(8014, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(8015, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
+        const description = totalPending > 1 ? totalPending === 2 ? ( localize(8016, "+1 more request waiting")) : ( localize(8017, "+{0} more requests waiting", totalPending - 1)) : undefined;
         return {
             id: AgentHostPermissionUiContribution_1.NOTIFICATION_ID,
             severity: ChatInputNotificationSeverity.Warning,
@@ -73,17 +73,17 @@ let AgentHostPermissionUiContribution = class AgentHostPermissionUiContribution
             description,
             actions: [{
                 kind: ChatInputNotificationActionKind.Command,
-                label: ( localize(6038, "Deny")),
+                label: ( localize(8018, "Deny")),
                 commandId: DENY_COMMAND,
                 commandArgs: [request.id]
             }, {
                 kind: ChatInputNotificationActionKind.Command,
-                label: ( localize(6039, "Allow")),
+                label: ( localize(8019, "Allow")),
                 commandId: ALLOW_COMMAND,
                 commandArgs: [request.id]
             }, {
                 kind: ChatInputNotificationActionKind.Command,
-                label: ( localize(6040, "Always Allow")),
+                label: ( localize(8020, "Always Allow")),
                 commandId: ALLOW_ALWAYS_COMMAND,
                 commandArgs: [request.id]
             }],