fix: various mcp fixes and error/warnings

Author: RomneyDa

extensions/cli/src/configLoader.ts

@@ -194,6 +194,8 @@ async function loadFromSource(
           injectBlocks,
         );
 
+      // TODO this is currently skipped because we are forcing default config
+      // Because models add on won't work for injected blocks e.g. default model, (only default config)
       case "no-config":
         return await unrollPackageIdentifiersAsConfigYaml(
           injectBlocks,

extensions/cli/src/services/MCPService.ts

@@ -50,7 +50,6 @@ export class MCPService
   private connections: Map<string, ServerConnection> = new Map();
   private assistant: AssistantConfig | null = null;
   private isShuttingDown = false;
-  private isHeadless = false;
 
   getDependencies(): string[] {
     return [SERVICE_NAMES.CONFIG];
@@ -71,16 +70,14 @@ export class MCPService
    */
   async doInitialize(
     assistant: AssistantConfig,
-    waitForConnections = false,
+    hasAgentFile: boolean,
+    isHeadless: boolean | undefined,
   ): Promise<MCPServiceState> {
     logger.debug("Initializing MCPService", {
       configName: assistant.name,
       serverCount: assistant.mcpServers?.length || 0,
     });
 
-    // Store headless mode flag
-    this.isHeadless = waitForConnections;
-
     await this.shutdownConnections();
 
     this.assistant = assistant;
@@ -102,23 +99,24 @@ export class MCPService
         logger.debug("MCP connections established", {
           connectionCount: connections.length,
         });
-        this.updateState();
       },
     );
-    if (waitForConnections) {
+    if (isHeadless || hasAgentFile) {
       await connectionInit;
 
-      // In headless mode, throw error if any MCP server failed to connect
-      const failedConnections = Array.from(this.connections.values()).filter(
-        (c) => c.status === "error",
-      );
-      if (failedConnections.length > 0) {
-        const errorMessages = failedConnections.map(
-          (c) => `${c.config?.name}: ${c.error}`,
-        );
-        throw new Error(
-          `MCP server(s) failed to load in headless mode:\n${errorMessages.join("\n")}`,
+      if (isHeadless) {
+        // With headless or agent, throw error if any MCP server failed to connect
+        const failedConnections = Array.from(this.connections.values()).filter(
+          (c) => c.status === "error",
         );
+        if (failedConnections.length > 0) {
+          const errorMessages = failedConnections.map(
+            (c) => `${c.config?.name}: ${c.error}`,
+          );
+          throw new Error(
+            `MCP server(s) failed to load:\n${errorMessages.join("\n")}`,
+          );
+        }
       }
     } else {
       this.updateState();
@@ -249,7 +247,7 @@ export class MCPService
     this.updateState();
 
     try {
-      const client = await this.getConnectedClient(serverConfig);
+      const client = await this.getConnectedClient(serverConfig, connection);
 
       connection.client = client;
       connection.status = "connected";
@@ -276,13 +274,6 @@ export class MCPService
             name: serverName,
             error: errorMessage,
           });
-
-          // In headless mode, throw error on capability failures
-          if (this.isHeadless) {
-            throw new Error(
-              `Failed to load prompts from MCP server ${serverName}: ${errorMessage}`,
-            );
-          }
         }
       }
 
@@ -300,30 +291,27 @@ export class MCPService
             name: serverName,
             error: errorMessage,
           });
-
-          // In headless mode, throw error on capability failures
-          if (this.isHeadless) {
-            throw new Error(
-              `Failed to load tools from MCP server ${serverName}: ${errorMessage}`,
-            );
-          }
         }
       }
 
       logger.debug("MCP server connected successfully", { name: serverName });
     } catch (error) {
       const errorMessage = getErrorString(error);
       connection.status = "error";
-      connection.error = errorMessage;
+
+      // Convert any warnings to error at time of connection failure
+      if (connection.warnings.length > 0) {
+        const stderrContent = connection.warnings.join("\n");
+        connection.error = `${errorMessage}\n\nServer stderr:\n${stderrContent}`;
+        connection.warnings = [];
+      } else {
+        connection.error = errorMessage;
+      }
+
       logger.error("Failed to connect to MCP server", {
         name: serverName,
-        error: errorMessage,
+        error: connection.error,
       });
-
-      // In headless mode, re-throw the error to fail fast
-      if (this.isHeadless) {
-        throw error;
-      }
     }
 
     this.updateState();
@@ -392,6 +380,7 @@ export class MCPService
    */
   private async getConnectedClient(
     serverConfig: MCPServerConfig,
+    connection: ServerConnection,
   ): Promise<Client> {
     const client = new Client(
       { name: "continue-cli-client", version: "1.0.0" },
@@ -404,7 +393,7 @@ export class MCPService
         name: serverConfig.name,
         command: serverConfig.command,
       });
-      const transport = this.constructStdioTransport(serverConfig);
+      const transport = this.constructStdioTransport(serverConfig, connection);
       await client.connect(transport, {});
     } else {
       // SSE/HTTP: if type isn't explicit: try http and fall back to sse
@@ -424,11 +413,14 @@ export class MCPService
       } catch (error: unknown) {
         // on authorization error, use "mcp-remote" with stdio transport to connect
         if (is401Error(error)) {
-          const transport = this.constructStdioTransport({
-            name: serverConfig.name,
-            command: "npx",
-            args: ["-y", "mcp-remote", serverConfig.url],
-          });
+          const transport = this.constructStdioTransport(
+            {
+              name: serverConfig.name,
+              command: "npx",
+              args: ["-y", "mcp-remote", serverConfig.url],
+            },
+            connection,
+          );
           await client.connect(transport, {});
         } else {
           throw error;
@@ -507,6 +499,7 @@ export class MCPService
   }
   private constructStdioTransport(
     serverConfig: StdioMcpServer,
+    connection: ServerConnection,
   ): StdioClientTransport {
     const env: Record<string, string> = serverConfig.env || {};
     if (process.env) {
@@ -517,12 +510,24 @@ export class MCPService
       }
     }
 
-    return new StdioClientTransport({
+    const transport = new StdioClientTransport({
       command: serverConfig.command,
       args: serverConfig.args || [],
       env,
       cwd: serverConfig.cwd,
-      stderr: "ignore",
+      stderr: "pipe",
     });
+
+    const stderrStream = transport.stderr;
+    if (stderrStream) {
+      stderrStream.on("data", (data: Buffer) => {
+        const stderrOutput = data.toString().trim();
+        if (stderrOutput) {
+          connection.warnings.push(stderrOutput);
+        }
+      });
+    }
+
+    return transport;
   }
 }

extensions/cli/src/services/index.ts

@@ -23,6 +23,7 @@ import {
   ApiClientServiceState,
   AuthServiceState,
   ConfigServiceState,
+  MCPServiceState,
   SERVICE_NAMES,
   ServiceInitOptions,
 } from "./types.js";
@@ -114,7 +115,7 @@ export async function initializeServices(initOptions: ServiceInitOptions = {}) {
     SERVICE_NAMES.TOOL_PERMISSIONS,
     async () => {
       const [mcpState, agentFileState] = await Promise.all([
-        serviceContainer.get<AuthServiceState>(SERVICE_NAMES.MCP),
+        serviceContainer.get<MCPServiceState>(SERVICE_NAMES.MCP),
         serviceContainer.get<AgentFileServiceState>(SERVICE_NAMES.AGENT_FILE),
       ]);
 
@@ -264,7 +265,8 @@ export async function initializeServices(initOptions: ServiceInitOptions = {}) {
       }
       return mcpService.initialize(
         configState.config,
-        initOptions.headless || initOptions.options?.agent,
+        !!initOptions.options?.agent,
+        initOptions.headless,
       );
     },
     [SERVICE_NAMES.CONFIG], // Depends on config

extensions/cli/src/ui/MCPSelector.tsx

@@ -267,8 +267,6 @@ export const MCPSelector: React.FC<MCPSelectorProps> = ({ onCancel }) => {
   });
 
   const handleMainMenuSelect = async (value: string) => {
-    if (!mcpService) return;
-
     if (value.startsWith("server:")) {
       // Handle server selection
       const serverName = value.replace("server:", "");
@@ -280,11 +278,11 @@ export const MCPSelector: React.FC<MCPSelectorProps> = ({ onCancel }) => {
 
     switch (value) {
       case "restart-all":
-        await mcpService.restartAllServers();
+        await mcpService?.restartAllServers();
         setMessage("All servers restarted");
         break;
       case "stop-all":
-        await mcpService.shutdownConnections();
+        await mcpService?.shutdownConnections();
         setMessage("All servers stopped");
         break;
       case "explore-mcp-servers":
@@ -300,15 +298,20 @@ export const MCPSelector: React.FC<MCPSelectorProps> = ({ onCancel }) => {
   };
 
   const handleServerAction = async (action: string) => {
-    if (!mcpService || !selectedServer) return;
     try {
       switch (action) {
         case "restart":
-          await mcpService.restartServer(selectedServer);
+          if (!selectedServer) {
+            return;
+          }
+          await mcpService?.restartServer(selectedServer);
           setMessage(`Server "${selectedServer}" restarted`);
           break;
         case "stop":
-          await mcpService.stopServer(selectedServer);
+          if (!selectedServer) {
+            return;
+          }
+          await mcpService?.stopServer(selectedServer);
           setMessage(`Server "${selectedServer}" stopped`);
           break;
         case "back":

packages/config-yaml/src/load/unroll.ts

@@ -44,7 +44,6 @@ export function parseConfigYaml(configYaml: string): ConfigYaml {
       cause: "result.success was false",
     });
   } catch (e) {
-    console.error("Failed to parse rolled assistant:", configYaml);
     if (
       e instanceof Error &&
       "cause" in e &&