Merge branch 'main' into pe/conversation-starters

Author: sestinj

core/config/load.ts

@@ -28,7 +28,6 @@ import {
   IdeType,
   ILLM,
   LLMOptions,
-  MCPOptions,
   ModelDescription,
   RerankerDescription,
   SerializedContinueConfig,
@@ -518,6 +517,8 @@ async function intermediateToFinalConfig(
     contextProviders,
     models,
     tools: allTools,
+    mcpServerStatuses: [],
+    slashCommands: config.slashCommands ?? [],
     modelsByRole: {
       chat: models,
       edit: models,
@@ -538,53 +539,18 @@ async function intermediateToFinalConfig(
     },
   };
 
-  // Apply MCP if specified
+  // Trigger MCP server refreshes (Config is reloaded again once connected!)
   const mcpManager = MCPManagerSingleton.getInstance();
-  function getMcpId(options: MCPOptions) {
-    return JSON.stringify(options);
-  }
-  if (config.experimental?.modelContextProtocolServers) {
-    await mcpManager.removeUnusedConnections(
-      config.experimental.modelContextProtocolServers.map(getMcpId),
-    );
-  }
-
-  if (config.experimental?.modelContextProtocolServers) {
-    const abortController = new AbortController();
-    const mcpConnectionTimeout = setTimeout(
-      () => abortController.abort(),
-      5000,
-    );
-
-    await Promise.allSettled(
-      config.experimental.modelContextProtocolServers?.map(
-        async (server, index) => {
-          try {
-            const mcpId = getMcpId(server);
-            const mcpConnection = mcpManager.createConnection(mcpId, server);
-            await mcpConnection.modifyConfig(
-              continueConfig,
-              mcpId,
-              abortController.signal,
-              "MCP Server",
-              server.faviconUrl,
-            );
-          } catch (e) {
-            let errorMessage = "Failed to load MCP server";
-            if (e instanceof Error) {
-              errorMessage += ": " + e.message;
-            }
-            errors.push({
-              fatal: false,
-              message: errorMessage,
-            });
-          } finally {
-            clearTimeout(mcpConnectionTimeout);
-          }
-        },
-      ) || [],
-    );
-  }
+  mcpManager.setConnections(
+    (config.experimental?.modelContextProtocolServers ?? []).map(
+      (server, index) => ({
+        id: `continue-mcp-server-${index + 1}`,
+        name: `MCP Server ${index + 1}`,
+        ...server,
+      }),
+    ),
+    false,
+  );
 
   // Handle experimental modelRole config values for apply and edit
   const inlineEditModel = getModelByRole(continueConfig, "inlineEdit")?.title;
@@ -676,6 +642,7 @@ async function finalToBrowserConfig(
     rules: final.rules,
     docs: final.docs,
     tools: final.tools,
+    mcpServerStatuses: final.mcpServerStatuses,
     tabAutocompleteOptions: final.tabAutocompleteOptions,
     usePlatform: await useHub(ide.getIdeSettings()),
     modelsByRole: Object.fromEntries(

core/config/profile/doLoadConfig.ts

@@ -13,12 +13,17 @@ import {
   IDE,
   IdeSettings,
   SerializedContinueConfig,
+  Tool,
 } from "../../";
+import { constructMcpSlashCommand } from "../../commands/slash/mcp";
+import { MCPManagerSingleton } from "../../context/mcp";
+import MCPContextProvider from "../../context/providers/MCPContextProvider";
 import { ControlPlaneProxyInfo } from "../../control-plane/analytics/IAnalyticsProvider.js";
 import { ControlPlaneClient } from "../../control-plane/client.js";
 import { getControlPlaneEnv } from "../../control-plane/env.js";
 import { TeamAnalytics } from "../../control-plane/TeamAnalytics.js";
 import ContinueProxy from "../../llm/llms/stubs/ContinueProxy";
+import { encodeMCPToolUri } from "../../tools/callTool";
 import { getConfigJsonPath, getConfigYamlPath } from "../../util/paths";
 import { localPathOrUriToPath } from "../../util/pathToUri";
 import { Telemetry } from "../../util/posthog";
@@ -95,15 +100,90 @@ export default async function doLoadConfig(
     configLoadInterrupted = result.configLoadInterrupted;
   }
 
-  // Rectify model selections for each role
-  if (newConfig) {
-    newConfig = rectifySelectedModelsFromGlobalContext(newConfig, profileId);
-  }
-
   if (configLoadInterrupted || !newConfig) {
     return { errors, config: newConfig, configLoadInterrupted: true };
   }
 
+  // TODO using config result but result with non-fatal errors is an antipattern?
+  // Remove ability have undefined errors, just have an array
+  errors = [...(errors ?? [])];
+
+  // Rectify model selections for each role
+  newConfig = rectifySelectedModelsFromGlobalContext(newConfig, profileId);
+
+  // Add things from MCP servers
+  const mcpManager = MCPManagerSingleton.getInstance();
+  const mcpServerStatuses = mcpManager.getStatuses();
+
+  // Slightly hacky just need connection's client to make slash command for now
+  const serializableStatuses = mcpServerStatuses.map((server) => {
+    const { client, ...rest } = server;
+    return rest;
+  });
+  newConfig.mcpServerStatuses = serializableStatuses;
+
+  for (const server of mcpServerStatuses) {
+    if (server.status === "connected") {
+      const serverTools: Tool[] = server.tools.map((tool) => ({
+        displayTitle: server.name + " " + tool.name,
+        function: {
+          description: tool.description,
+          name: tool.name,
+          parameters: tool.inputSchema,
+        },
+        faviconUrl: server.faviconUrl,
+        readonly: false,
+        type: "function" as const,
+        wouldLikeTo: "",
+        uri: encodeMCPToolUri(server.id, tool.name),
+        group: server.name,
+      }));
+      newConfig.tools.push(...serverTools);
+
+      const serverSlashCommands = server.prompts.map((prompt) =>
+        constructMcpSlashCommand(
+          server.client,
+          prompt.name,
+          prompt.description,
+          prompt.arguments?.map((a: any) => a.name),
+        ),
+      );
+      newConfig.slashCommands.push(...serverSlashCommands);
+
+      const submenuItems = server.resources.map((resource) => ({
+        title: resource.name,
+        description: resource.description ?? resource.name,
+        id: resource.uri,
+        icon: server.faviconUrl,
+      }));
+      if (submenuItems.length > 0) {
+        const serverContextProvider = new MCPContextProvider({
+          submenuItems,
+          mcpId: server.id,
+        });
+        newConfig.contextProviders.push(serverContextProvider);
+      }
+    }
+  }
+
+  // Detect duplicate tool names
+  const counts: Record<string, number> = {};
+  newConfig.tools.forEach((tool) => {
+    if (counts[tool.function.name]) {
+      counts[tool.function.name] = counts[tool.function.name] + 1;
+    } else {
+      counts[tool.function.name] = 1;
+    }
+  });
+  Object.entries(counts).forEach(([toolName, count]) => {
+    if (count > 1) {
+      errors!.push({
+        fatal: false,
+        message: `Duplicate (${count}) tools named "${toolName}" detected. Permissions will conflict and usage may be unpredictable`,
+      });
+    }
+  });
+
   newConfig.allowAnonymousTelemetry =
     newConfig.allowAnonymousTelemetry && (await ide.isTelemetryEnabled());
 

core/config/yaml/loadYaml.ts

@@ -110,7 +110,8 @@ async function configYamlToContinueConfig(
   const continueConfig: ContinueConfig = {
     slashCommands: [],
     models: [],
-    tools: allTools,
+    tools: [...allTools],
+    mcpServerStatuses: [],
     systemMessage: config.rules?.join("\n"),
     experimental: {
       modelContextProtocolServers: config.mcpServers?.map((mcpServer) => ({
@@ -366,52 +367,19 @@ async function configYamlToContinueConfig(
     continueConfig.contextProviders.push(new DocsContextProvider({}));
   }
 
-  // Apply MCP if specified
+  // Trigger MCP server refreshes (Config is reloaded again once connected!)
   const mcpManager = MCPManagerSingleton.getInstance();
-  if (config.mcpServers) {
-    await mcpManager.removeUnusedConnections(
-      config.mcpServers.map((s) => s.name),
-    );
-  }
-
-  await Promise.allSettled(
-    config.mcpServers?.map(async (server) => {
-      const abortController = new AbortController();
-      const mcpConnectionTimeout = setTimeout(
-        () => abortController.abort(),
-        5000,
-      );
-
-      try {
-        const mcpId = server.name;
-        const mcpConnection = mcpManager.createConnection(mcpId, {
-          transport: {
-            type: "stdio",
-            args: [],
-            ...server,
-          },
-        });
-
-        await mcpConnection.modifyConfig(
-          continueConfig,
-          mcpId,
-          abortController.signal,
-          server.name,
-          server.faviconUrl,
-        );
-      } catch (e) {
-        let errorMessage = `Failed to load MCP server ${server.name}`;
-        if (e instanceof Error) {
-          errorMessage += ": " + e.message;
-        }
-        localErrors.push({
-          fatal: false,
-          message: errorMessage,
-        });
-      } finally {
-        clearTimeout(mcpConnectionTimeout);
-      }
-    }) ?? [],
+  mcpManager.setConnections(
+    (config.mcpServers ?? []).map((server) => ({
+      id: server.name,
+      name: server.name,
+      transport: {
+        type: "stdio",
+        args: [],
+        ...server,
+      },
+    })),
+    false,
   );
 
   return { config: continueConfig, errors: localErrors };