@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.0.0

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

@@ -0,0 +1,638 @@
+
+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 { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { ExtensionIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/platform/extensions/common/extensions';
+import { McpServerType } from '@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes';
+import { AICustomizationSources } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { ContributionEnablementState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
+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';
+
+const COPILOT_CHAT_EXTENSION_ID = "github.copilot-chat";
+const LOCAL_AGENT_HOST_SESSION_TYPE_PREFIX = "agent-host-";
+const AGENT_HOST_PROVIDERS_WITH_GITHUB_MCP = ( new Set(["copilotcli", "claude", "codex"]));
+const COPILOT_CHAT_GITHUB_MCP_COLLECTION_ID = extensionPrefixedIdentifier(( new ExtensionIdentifier(COPILOT_CHAT_EXTENSION_ID)), "github");
+var AgentHostMcpServerDelivery;
+(function(AgentHostMcpServerDelivery) {
+    AgentHostMcpServerDelivery["ClientForwarded"] = "clientForwarded";
+    AgentHostMcpServerDelivery["RuntimeDiscovered"] = "runtimeDiscovered";
+    AgentHostMcpServerDelivery["AgentPlugin"] = "agentPlugin";
+    AgentHostMcpServerDelivery["ProviderBuiltIn"] = "providerBuiltIn";
+    AgentHostMcpServerDelivery["NotDelivered"] = "notDelivered";
+    AgentHostMcpServerDelivery["Unknown"] = "unknown";
+})(AgentHostMcpServerDelivery || (AgentHostMcpServerDelivery = {}));
+var AgentHostMcpServerApplicability;
+(function(AgentHostMcpServerApplicability) {
+    AgentHostMcpServerApplicability["Applicable"] = "applicable";
+    AgentHostMcpServerApplicability["OutsideCurrentScope"] = "outsideCurrentScope";
+    AgentHostMcpServerApplicability["Unknown"] = "unknown";
+})(AgentHostMcpServerApplicability || (AgentHostMcpServerApplicability = {}));
+var AgentHostMcpServerEnablementState;
+(function(AgentHostMcpServerEnablementState) {
+    AgentHostMcpServerEnablementState["EnabledProfile"] = "enabledProfile";
+    AgentHostMcpServerEnablementState["EnabledWorkspace"] = "enabledWorkspace";
+    AgentHostMcpServerEnablementState["DisabledProfile"] = "disabledProfile";
+    AgentHostMcpServerEnablementState["DisabledWorkspace"] = "disabledWorkspace";
+    AgentHostMcpServerEnablementState["DisabledByAccess"] = "disabledByAccess";
+    AgentHostMcpServerEnablementState["DisabledNotRegistered"] = "disabledNotRegistered";
+})(
+    AgentHostMcpServerEnablementState || (AgentHostMcpServerEnablementState = {})
+);
+var AgentHostMcpServerSourceKind;
+(function(AgentHostMcpServerSourceKind) {
+    AgentHostMcpServerSourceKind["UserProfile"] = "userProfile";
+    AgentHostMcpServerSourceKind["RemoteUser"] = "remoteUser";
+    AgentHostMcpServerSourceKind["VscodeWorkspaceFolder"] = "vscodeWorkspaceFolder";
+    AgentHostMcpServerSourceKind["WorkspaceConfiguration"] = "workspaceConfiguration";
+    AgentHostMcpServerSourceKind["WorkspaceDotMcp"] = "workspaceDotMcp";
+    AgentHostMcpServerSourceKind["ClaudeDesktop"] = "claudeDesktop";
+    AgentHostMcpServerSourceKind["Windsurf"] = "windsurf";
+    AgentHostMcpServerSourceKind["CursorUser"] = "cursorUser";
+    AgentHostMcpServerSourceKind["CursorWorkspace"] = "cursorWorkspace";
+    AgentHostMcpServerSourceKind["Extension"] = "extension";
+    AgentHostMcpServerSourceKind["AgentPlugin"] = "agentPlugin";
+    AgentHostMcpServerSourceKind["Unknown"] = "unknown";
+})(AgentHostMcpServerSourceKind || (AgentHostMcpServerSourceKind = {}));
+var AgentHostMcpSupportReason;
+(function(AgentHostMcpSupportReason) {
+    AgentHostMcpSupportReason["UnsupportedSourceLocation"] = "unsupportedSourceLocation";
+    AgentHostMcpSupportReason["RequiresUserInteraction"] = "requiresUserInteraction";
+    AgentHostMcpSupportReason["UnresolvedConfiguration"] = "unresolvedConfiguration";
+    AgentHostMcpSupportReason["LaunchNotRepresentable"] = "launchNotRepresentable";
+    AgentHostMcpSupportReason["EnvironmentFileIgnored"] = "environmentFileIgnored";
+    AgentHostMcpSupportReason["SandboxConfigurationIgnored"] = "sandboxConfigurationIgnored";
+    AgentHostMcpSupportReason["DevelopmentModeIgnored"] = "developmentModeIgnored";
+    AgentHostMcpSupportReason["OAuthClientConfigurationIgnored"] = "oauthClientConfigurationIgnored";
+    AgentHostMcpSupportReason["DefinitionNotLoaded"] = "definitionNotLoaded";
+    AgentHostMcpSupportReason["SourceUnknown"] = "sourceUnknown";
+})(AgentHostMcpSupportReason || (AgentHostMcpSupportReason = {}));
+function agentHostProviderHasBuiltInGitHubMcpServer(provider) {
+    return ( AGENT_HOST_PROVIDERS_WITH_GITHUB_MCP.has(provider));
+}
+async function assessMcpServersForCopilotAgentHost(
+    servers,
+    configurationResolverService,
+    sessionType,
+    workingDirectories,
+    lazyCollectionState
+) {
+    if (!isCopilotCliSessionType(sessionType)) {
+        return undefined;
+    }
+    const resolved = await resolveMcpServersForAgentHostDelivery(servers, configurationResolverService, sessionType, workingDirectories);
+    return {
+        servers: ( resolved.map((
+            {
+                server,
+                source,
+                applicability,
+                delivery,
+                compatibility,
+                projectedConfiguration
+            }
+        ) => ({
+            id: server.definition.id,
+            name: server.definition.label,
+            collectionId: server.collection.id,
+            source,
+            enablement: getMcpServerEnablement(server),
+            applicability,
+            delivery,
+            compatibility,
+            projectedConfiguration
+        }))),
+        discoveryComplete: lazyCollectionState === LazyCollectionState.AllKnown
+    };
+}
+async function mergeInstalledMcpServersIntoAgentHostSupportAssessment(
+    assessment,
+    installedServers,
+    configurationResolverService,
+    workingDirectories
+) {
+    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);
+        return enablement ? {
+            ...server,
+            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(
+        server => assessDisabledInstalledMcpServer(server, configurationResolverService, workingDirectories)
+    )));
+    return {
+        ...assessment,
+        servers: [...servers, ...missingDisabledServers]
+    };
+}
+function resolveMcpServersForAgentHostDelivery(servers, configurationResolverService, sessionType, workingDirectories) {
+    return Promise.all(( servers.map(
+        server => resolveMcpServerForAgentHostDelivery(server, configurationResolverService, sessionType, workingDirectories)
+    )));
+}
+async function resolveMcpServerForAgentHostDelivery(server, configurationResolverService, sessionType, workingDirectories) {
+    const definitions = server.readDefinitions().get();
+    const definition = definitions.server;
+    const collection = definitions.collection;
+    const source = getMcpServerSource(server, collection, definition);
+    const applicability = getMcpServerApplicability(collection, source.kind, workingDirectories);
+    if (isPluginCollection(server, collection)) {
+        return createResolution(
+            server,
+            definition,
+            source,
+            applicability,
+            AgentHostMcpServerDelivery.AgentPlugin,
+            supported()
+        );
+    }
+    if (isProviderBuiltInReplacement(server, collection, sessionType)) {
+        return createResolution(
+            server,
+            definition,
+            source,
+            applicability,
+            AgentHostMcpServerDelivery.ProviderBuiltIn,
+            supported()
+        );
+    }
+    if (!definition?.launch) {
+        return createResolution(
+            server,
+            definition,
+            source,
+            applicability,
+            AgentHostMcpServerDelivery.Unknown,
+            unknown([AgentHostMcpSupportReason.DefinitionNotLoaded])
+        );
+    }
+    if (source.kind === AgentHostMcpServerSourceKind.WorkspaceDotMcp) {
+        return createResolution(
+            server,
+            definition,
+            source,
+            applicability,
+            applicability === AgentHostMcpServerApplicability.Applicable ? AgentHostMcpServerDelivery.RuntimeDiscovered : deliveryForInapplicable(applicability),
+            supported()
+        );
+    }
+    if (collection && McpCollectionDefinition.isWorkspaceDiscovered(collection) && !McpCollectionDefinition.isVscodeMcpJson(collection)) {
+        return createResolution(
+            server,
+            definition,
+            source,
+            applicability,
+            AgentHostMcpServerDelivery.NotDelivered,
+            unsupported([AgentHostMcpSupportReason.UnsupportedSourceLocation])
+        );
+    }
+    let projectedConfiguration = projectMcpServerConfiguration(definition.launch);
+    if (!projectedConfiguration) {
+        return createResolution(
+            server,
+            definition,
+            source,
+            applicability,
+            AgentHostMcpServerDelivery.NotDelivered,
+            unsupported([AgentHostMcpSupportReason.LaunchNotRepresentable])
+        );
+    }
+    const unsupportedReasons = [];
+    if (collection && McpCollectionDefinition.isVscodeMcpJson(collection)) {
+        const resolved = await resolveMcpConfigurationForSync(
+            configurationResolverService,
+            definition.variableReplacement?.folder,
+            projectedConfiguration
+        );
+        if (resolved.kind === "error") {
+            unsupportedReasons.push(resolved.reason);
+        } else {
+            projectedConfiguration = resolved.configuration;
+        }
+    } else {
+        const unresolvedReason = getUnresolvedConfigurationReason(projectedConfiguration);
+        if (unresolvedReason) {
+            unsupportedReasons.push(unresolvedReason);
+        }
+    }
+    const partialReasons = getPartialSupportReasons(definition.launch, definition.sandboxEnabled, definition.devMode);
+    const unknownReasons = source.kind === AgentHostMcpServerSourceKind.Unknown ? [AgentHostMcpSupportReason.SourceUnknown] : [];
+    const delivery = applicability === AgentHostMcpServerApplicability.Applicable ? AgentHostMcpServerDelivery.ClientForwarded : deliveryForInapplicable(applicability);
+    return {
+        server,
+        definition,
+        source,
+        applicability,
+        delivery: unsupportedReasons.length > 0 && collection && McpCollectionDefinition.isVscodeMcpJson(collection) ? AgentHostMcpServerDelivery.NotDelivered : delivery,
+        compatibility: getCompatibility(unsupportedReasons, partialReasons, unknownReasons),
+        projectedConfiguration
+    };
+}
+function createResolution(server, definition, source, applicability, delivery, compatibility) {
+    return {
+        server,
+        definition,
+        source,
+        applicability,
+        delivery,
+        compatibility,
+        projectedConfiguration: undefined
+    };
+}
+function getMcpServerSource(server, collection, definition) {
+    const kind = getMcpServerSourceKind(server, collection);
+    return {
+        group: getMcpServerSourceGroup(kind),
+        kind,
+        label: collection?.label ?? server.collection.label,
+        collectionUri: collection?.presentation?.origin,
+        definitionLocation: definition?.presentation?.origin,
+        remoteAuthority: collection?.remoteAuthority ?? null,
+        extensionId: collection?.source instanceof ExtensionIdentifier ? collection.source.value : undefined,
+        pluginUri: getPluginUri(server, collection)
+    };
+}
+function getMcpServerSourceKind(server, collection) {
+    const provenanceKind = getMcpCollectionSourceKind(collection?.provenance, collection?.discoverySource);
+    if (provenanceKind !== undefined) {
+        return provenanceKind;
+    }
+    const collectionId = collection?.id ?? server.collection.id;
+    if (collectionId.startsWith(MCP_PLUGIN_COLLECTION_ID_PREFIX)) {
+        return AgentHostMcpServerSourceKind.AgentPlugin;
+    }
+    if (collectionId.startsWith(WORKSPACE_DOT_MCP_COLLECTION_ID_PREFIX)) {
+        return AgentHostMcpServerSourceKind.WorkspaceDotMcp;
+    }
+    if (collectionId.startsWith(CURSOR_WORKSPACE_MCP_COLLECTION_ID_PREFIX)) {
+        return AgentHostMcpServerSourceKind.CursorWorkspace;
+    }
+    if (collectionId.startsWith(`${MCP_CONFIGURATION_COLLECTION_ID_PREFIX}ws`)) {
+        return AgentHostMcpServerSourceKind.VscodeWorkspaceFolder;
+    }
+    if (collectionId === `${MCP_CONFIGURATION_COLLECTION_ID_PREFIX}workspace`) {
+        return AgentHostMcpServerSourceKind.WorkspaceConfiguration;
+    }
+    if (collectionId === `${MCP_CONFIGURATION_COLLECTION_ID_PREFIX}usrlocal`) {
+        return AgentHostMcpServerSourceKind.UserProfile;
+    }
+    if (collectionId === `${MCP_CONFIGURATION_COLLECTION_ID_PREFIX}usrremote`) {
+        return AgentHostMcpServerSourceKind.RemoteUser;
+    }
+    if (collectionId.startsWith(extensionMcpCollectionPrefix) || collection?.source instanceof ExtensionIdentifier) {
+        return AgentHostMcpServerSourceKind.Extension;
+    }
+    return AgentHostMcpServerSourceKind.Unknown;
+}
+function getMcpCollectionSourceKind(provenance, discoverySource) {
+    switch (provenance) {
+    case McpCollectionProvenance.UserProfile:
+        return AgentHostMcpServerSourceKind.UserProfile;
+    case McpCollectionProvenance.RemoteUser:
+        return AgentHostMcpServerSourceKind.RemoteUser;
+    case McpCollectionProvenance.WorkspaceConfiguration:
+        return AgentHostMcpServerSourceKind.WorkspaceConfiguration;
+    case McpCollectionProvenance.WorkspaceFolderConfiguration:
+        return AgentHostMcpServerSourceKind.VscodeWorkspaceFolder;
+    case McpCollectionProvenance.WorkspaceDotMcp:
+        return AgentHostMcpServerSourceKind.WorkspaceDotMcp;
+    case McpCollectionProvenance.ExternalConfiguration:
+        return getExternalConfigurationSourceKind(discoverySource);
+    case McpCollectionProvenance.Extension:
+        return AgentHostMcpServerSourceKind.Extension;
+    case McpCollectionProvenance.Plugin:
+        return AgentHostMcpServerSourceKind.AgentPlugin;
+    default:
+        return undefined;
+    }
+}
+function getExternalConfigurationSourceKind(discoverySource) {
+    switch (discoverySource) {
+    case ExternalDiscoverySource.ClaudeDesktop:
+        return AgentHostMcpServerSourceKind.ClaudeDesktop;
+    case ExternalDiscoverySource.Windsurf:
+        return AgentHostMcpServerSourceKind.Windsurf;
+    case ExternalDiscoverySource.CursorGlobal:
+        return AgentHostMcpServerSourceKind.CursorUser;
+    case ExternalDiscoverySource.CursorWorkspace:
+        return AgentHostMcpServerSourceKind.CursorWorkspace;
+    default:
+        return AgentHostMcpServerSourceKind.Unknown;
+    }
+}
+function getMcpServerSourceGroup(kind) {
+    switch (kind) {
+    case AgentHostMcpServerSourceKind.UserProfile:
+    case AgentHostMcpServerSourceKind.RemoteUser:
+    case AgentHostMcpServerSourceKind.ClaudeDesktop:
+    case AgentHostMcpServerSourceKind.Windsurf:
+    case AgentHostMcpServerSourceKind.CursorUser:
+        return AICustomizationSources.user;
+    case AgentHostMcpServerSourceKind.VscodeWorkspaceFolder:
+    case AgentHostMcpServerSourceKind.WorkspaceConfiguration:
+    case AgentHostMcpServerSourceKind.WorkspaceDotMcp:
+    case AgentHostMcpServerSourceKind.CursorWorkspace:
+        return AICustomizationSources.local;
+    case AgentHostMcpServerSourceKind.Extension:
+        return AICustomizationSources.extension;
+    case AgentHostMcpServerSourceKind.AgentPlugin:
+        return AICustomizationSources.plugin;
+    case AgentHostMcpServerSourceKind.Unknown:
+        return undefined;
+    }
+}
+function getMcpServerApplicability(collection, sourceKind, workingDirectories) {
+    return getMcpConfigurationApplicability(
+        collection?.configTarget,
+        collection?.presentation?.origin,
+        sourceKind,
+        workingDirectories
+    );
+}
+function getMcpConfigurationApplicability(configTarget, origin, sourceKind, workingDirectories) {
+    if (configTarget !== ConfigurationTarget.WORKSPACE && configTarget !== ConfigurationTarget.WORKSPACE_FOLDER) {
+        return AgentHostMcpServerApplicability.Applicable;
+    }
+    if (workingDirectories === undefined) {
+        return AgentHostMcpServerApplicability.Unknown;
+    }
+    if (workingDirectories.length === 0) {
+        return AgentHostMcpServerApplicability.OutsideCurrentScope;
+    }
+    if (sourceKind === AgentHostMcpServerSourceKind.WorkspaceConfiguration) {
+        return AgentHostMcpServerApplicability.Applicable;
+    }
+    return origin && ( workingDirectories.some(workingDirectory => isEqualOrParent(origin, workingDirectory))) ? AgentHostMcpServerApplicability.Applicable : AgentHostMcpServerApplicability.OutsideCurrentScope;
+}
+function getMcpServerEnablement(server) {
+    switch (server.enablement.get()) {
+    case ContributionEnablementState.EnabledProfile:
+        return {
+            enabled: true,
+            state: AgentHostMcpServerEnablementState.EnabledProfile
+        };
+    case ContributionEnablementState.EnabledWorkspace:
+        return {
+            enabled: true,
+            state: AgentHostMcpServerEnablementState.EnabledWorkspace
+        };
+    case ContributionEnablementState.DisabledProfile:
+        return {
+            enabled: false,
+            state: AgentHostMcpServerEnablementState.DisabledProfile
+        };
+    case ContributionEnablementState.DisabledWorkspace:
+        return {
+            enabled: false,
+            state: AgentHostMcpServerEnablementState.DisabledWorkspace
+        };
+    }
+}
+function getInstalledMcpServerEnablementOverride(runtimeState) {
+    switch (runtimeState) {
+    case McpServerEnablementState.Disabled:
+        return {
+            enabled: false,
+            state: AgentHostMcpServerEnablementState.DisabledNotRegistered
+        };
+    case McpServerEnablementState.DisabledByAccess:
+        return {
+            enabled: false,
+            state: AgentHostMcpServerEnablementState.DisabledByAccess
+        };
+    case McpServerEnablementState.DisabledProfile:
+        return {
+            enabled: false,
+            state: AgentHostMcpServerEnablementState.DisabledProfile
+        };
+    case McpServerEnablementState.DisabledWorkspace:
+        return {
+            enabled: false,
+            state: AgentHostMcpServerEnablementState.DisabledWorkspace
+        };
+    case McpServerEnablementState.Enabled:
+    case undefined:
+        return undefined;
+    }
+}
+async function assessDisabledInstalledMcpServer(server, configurationResolverService, workingDirectories) {
+    const sourceKind = getMcpConfigurationSourceKind(server.configPath?.target);
+    const compatibility = await getInstalledMcpServerCompatibility(server, sourceKind, configurationResolverService);
+    const collectionId = server.configPath ? `${MCP_CONFIGURATION_COLLECTION_ID_PREFIX}${server.configPath.id}` : getCollectionIdFromInstalledServer(server);
+    return {
+        id: server.id,
+        name: server.name,
+        collectionId,
+        source: {
+            group: getMcpServerSourceGroup(sourceKind),
+            kind: sourceKind,
+            label: server.configPath?.label ?? server.label,
+            collectionUri: server.configPath?.uri,
+            definitionLocation: undefined,
+            remoteAuthority: server.configPath?.remoteAuthority ?? null,
+            extensionId: undefined,
+            pluginUri: undefined
+        },
+        enablement: getInstalledMcpServerEnablementOverride(server.runtimeState) ?? {
+            enabled: false,
+            state: AgentHostMcpServerEnablementState.DisabledNotRegistered
+        },
+        applicability: getMcpConfigurationApplicability(
+            server.configPath?.target,
+            server.configPath?.uri,
+            sourceKind,
+            workingDirectories
+        ),
+        delivery: AgentHostMcpServerDelivery.NotDelivered,
+        compatibility
+    };
+}
+function getCollectionIdFromInstalledServer(server) {
+    const nameSuffix = `.${server.name}`;
+    return server.id.endsWith(nameSuffix) ? server.id.slice(0, -nameSuffix.length) : `${MCP_CONFIGURATION_COLLECTION_ID_PREFIX}unknown`;
+}
+function getMcpConfigurationSourceKind(configTarget) {
+    return getMcpCollectionSourceKind(getMcpCollectionProvenance(configTarget), undefined) ?? AgentHostMcpServerSourceKind.Unknown;
+}
+async function getInstalledMcpServerCompatibility(server, sourceKind, configurationResolverService) {
+    if (sourceKind === AgentHostMcpServerSourceKind.WorkspaceConfiguration) {
+        return unsupported([AgentHostMcpSupportReason.UnsupportedSourceLocation]);
+    }
+    const launch = McpServerLaunch.fromServerConfiguration(server.configuration, server.sandbox);
+    if (!launch) {
+        return unsupported([AgentHostMcpSupportReason.LaunchNotRepresentable]);
+    }
+    const projectedConfiguration = projectMcpServerConfiguration(launch);
+    if (!projectedConfiguration) {
+        return unsupported([AgentHostMcpSupportReason.LaunchNotRepresentable]);
+    }
+    const unsupportedReasons = [];
+    if (server.configPath?.target === ConfigurationTarget.WORKSPACE_FOLDER) {
+        const resolved = await resolveMcpConfigurationForSync(
+            configurationResolverService,
+            server.configPath.workspaceFolder,
+            projectedConfiguration
+        );
+        if (resolved.kind === "error") {
+            unsupportedReasons.push(resolved.reason);
+        }
+    } else {
+        const unresolvedReason = getUnresolvedConfigurationReason(projectedConfiguration);
+        if (unresolvedReason) {
+            unsupportedReasons.push(unresolvedReason);
+        }
+    }
+    const partialReasons = getPartialSupportReasons(
+        launch,
+        server.configuration.type === McpServerType.LOCAL ? server.configuration.sandboxEnabled : undefined,
+        server.configuration.dev
+    );
+    const unknownReasons = sourceKind === AgentHostMcpServerSourceKind.Unknown ? [AgentHostMcpSupportReason.SourceUnknown] : [];
+    return getCompatibility(unsupportedReasons, partialReasons, unknownReasons);
+}
+function isPluginCollection(server, collection) {
+    return collection?.provenance === McpCollectionProvenance.Plugin || server.collection.id.startsWith(MCP_PLUGIN_COLLECTION_ID_PREFIX);
+}
+function getPluginUri(server, collection) {
+    if (!isPluginCollection(server, collection)) {
+        return undefined;
+    }
+    const collectionId = collection?.id ?? server.collection.id;
+    return collectionId.startsWith(MCP_PLUGIN_COLLECTION_ID_PREFIX) ? ( URI.parse(collectionId.slice(MCP_PLUGIN_COLLECTION_ID_PREFIX.length))) : undefined;
+}
+function isProviderBuiltInReplacement(server, collection, sessionType) {
+    return hasBuiltInGitHubMcpServer(sessionType) && server.collection.id === COPILOT_CHAT_GITHUB_MCP_COLLECTION_ID && collection?.source instanceof ExtensionIdentifier && ExtensionIdentifier.equals(collection.source, COPILOT_CHAT_EXTENSION_ID);
+}
+function hasBuiltInGitHubMcpServer(sessionType) {
+    const localProvider = sessionType.startsWith(LOCAL_AGENT_HOST_SESSION_TYPE_PREFIX) ? sessionType.slice(LOCAL_AGENT_HOST_SESSION_TYPE_PREFIX.length) : undefined;
+    return agentHostProviderHasBuiltInGitHubMcpServer(localProvider ?? "");
+}
+function deliveryForInapplicable(applicability) {
+    return applicability === AgentHostMcpServerApplicability.Unknown ? AgentHostMcpServerDelivery.Unknown : AgentHostMcpServerDelivery.NotDelivered;
+}
+function projectMcpServerConfiguration(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,
+            transport: launch.transport === "sse" ? "sse" : "http",
+            url: ( launch.uri.toString()),
+            headers: launch.headers.length > 0 ? Object.fromEntries(launch.headers) : undefined
+        };
+    }
+}
+async function resolveMcpConfigurationForSync(configurationResolverService, folder, configuration) {
+    const expression = ConfigurationResolverExpression.parse(configuration);
+    const unresolvedReason = getExpressionUnresolvedReason(expression);
+    if (unresolvedReason === AgentHostMcpSupportReason.RequiresUserInteraction) {
+        return {
+            kind: "error",
+            reason: unresolvedReason
+        };
+    }
+    try {
+        await configurationResolverService.resolveAsync(folder, expression);
+    } catch {
+        return {
+            kind: "error",
+            reason: AgentHostMcpSupportReason.UnresolvedConfiguration
+        };
+    }
+    if (!Iterable.isEmpty(expression.unresolved())) {
+        return {
+            kind: "error",
+            reason: AgentHostMcpSupportReason.UnresolvedConfiguration
+        };
+    }
+    return {
+        kind: "success",
+        configuration: expression.toObject()
+    };
+}
+function getUnresolvedConfigurationReason(configuration) {
+    return getExpressionUnresolvedReason(ConfigurationResolverExpression.parse(configuration));
+}
+function getExpressionUnresolvedReason(expression) {
+    let hasUnresolved = false;
+    for (const replacement of expression.unresolved()) {
+        if (replacement.name === "input" || replacement.name === "command") {
+            return AgentHostMcpSupportReason.RequiresUserInteraction;
+        }
+        hasUnresolved = true;
+    }
+    return hasUnresolved ? AgentHostMcpSupportReason.UnresolvedConfiguration : undefined;
+}
+function getPartialSupportReasons(launch, sandboxEnabled, devMode) {
+    const reasons = [];
+    if (launch.type === McpServerTransportType.Stdio) {
+        if (launch.envFile) {
+            reasons.push(AgentHostMcpSupportReason.EnvironmentFileIgnored);
+        }
+        if (launch.sandbox || sandboxEnabled) {
+            reasons.push(AgentHostMcpSupportReason.SandboxConfigurationIgnored);
+        }
+    } else if (launch.oauth) {
+        reasons.push(AgentHostMcpSupportReason.OAuthClientConfigurationIgnored);
+    }
+    if (devMode) {
+        reasons.push(AgentHostMcpSupportReason.DevelopmentModeIgnored);
+    }
+    return reasons;
+}
+function getCompatibility(unsupportedReasons, partialReasons, unknownReasons) {
+    if (unsupportedReasons.length > 0) {
+        return unsupported(unsupportedReasons);
+    }
+    if (unknownReasons.length > 0) {
+        return unknown(unknownReasons);
+    }
+    if (partialReasons.length > 0) {
+        return {
+            kind: "partiallySupported",
+            reasons: partialReasons
+        };
+    }
+    return supported();
+}
+function supported() {
+    return {
+        kind: "supported"
+    };
+}
+function unsupported(reasons) {
+    return {
+        kind: "unsupported",
+        reasons
+    };
+}
+function unknown(reasons) {
+    return {
+        kind: "unknown",
+        reasons
+    };
+}
+
+export { AgentHostMcpServerApplicability, AgentHostMcpServerDelivery, AgentHostMcpServerEnablementState, AgentHostMcpServerSourceKind, AgentHostMcpSupportReason, COPILOT_CHAT_GITHUB_MCP_COLLECTION_ID, agentHostProviderHasBuiltInGitHubMcpServer, assessMcpServersForCopilotAgentHost, mergeInstalledMcpServersIntoAgentHostSupportAssessment, resolveMcpServersForAgentHostDelivery };

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

@@ -0,0 +1,41 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IMcpWorkbenchService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
+import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
+import { IConfigurationResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/configurationResolver/common/configurationResolver.service";
+import { IAgentHostMcpServerSupportSnapshot } from "./agentHostMcpServerSupport.js";
+/** A refcounted reactive view of MCP support for one Agent Host working-directory scope. */
+export interface IAgentHostMcpServerSupportScope extends IDisposable {
+    /** The latest settled support snapshot. */
+    readonly support: IObservable<IAgentHostMcpServerSupportSnapshot>;
+    /** Whether the latest scheduled support assessment has settled. */
+    readonly isResolved: IObservable<boolean>;
+    /** Resolves after the latest scheduled support assessment settles or the scope is disposed. */
+    whenResolved(): Promise<void>;
+}
+/** Owns MCP support assessment and refreshes it while at least one consumer holds a reference. */
+export declare class AgentHostMcpServerSupportScope extends Disposable {
+    private readonly _sessionType;
+    private readonly _roots;
+    private readonly _onDispose;
+    private readonly _mcpService;
+    private readonly _mcpWorkbenchService;
+    private readonly _configurationResolverService;
+    private readonly _configurationService;
+    private readonly _updateDelayer;
+    private readonly _support;
+    private readonly _isResolved;
+    private _latestResolution;
+    private _refCount;
+    private _updateSequence;
+    private _isDisposed;
+    constructor(_sessionType: string, _roots: readonly URI[] | undefined, _onDispose: () => void, _mcpService: IMcpService, _mcpWorkbenchService: IMcpWorkbenchService, _configurationResolverService: IConfigurationResolverService, _configurationService: IConfigurationService);
+    acquire(): IAgentHostMcpServerSupportScope;
+    dispose(): void;
+    private _whenResolved;
+    private _completeUpdate;
+    private _getCoverage;
+    private _release;
+}