feat: add toggle functionality for enabling/disabling/reloading all MCP servers

package.json

@@ -169,6 +169,16 @@
 				"command": "roo.acceptInput",
 				"title": "%command.acceptInput.title%",
 				"category": "%configuration.title%"
+			},
+			{
+				"command": "extension.reloadAllMcpServers",
+				"title": "Reload All MCP Servers",
+				"icon": "$(sync)"
+			},
+			{
+				"command": "extension.toggleAllMcpServersDisabled",
+				"title": "Toggle All MCP Servers Enabled/Disabled",
+				"icon": "$(power)"
 			}
 		],
 		"menus": {

src/activate/registerCommands.ts

@@ -176,6 +176,35 @@ const getCommandsMap = ({ context, outputChannel, provider }: RegisterCommandOpt
 
 		visibleProvider.postMessageToWebview({ type: "acceptInput" })
 	},
+	"extension.reloadAllMcpServers": async () => {
+		const visibleProvider = getVisibleProviderOrLog(outputChannel)
+		if (!visibleProvider) {
+			return
+		}
+		try {
+			await visibleProvider.getMcpHub()?.restartAllMcpServers()
+		} catch (error) {
+			outputChannel.appendLine(`Failed to reload all MCP servers: ${error}`)
+			vscode.window.showErrorMessage(`Failed to reload all MCP servers: ${error}`)
+		}
+	},
+	"extension.toggleAllMcpServersDisabled": async () => {
+		const visibleProvider = getVisibleProviderOrLog(outputChannel)
+		if (!visibleProvider) {
+			return
+		}
+		try {
+			const mcpHub = visibleProvider.getMcpHub()
+			if (mcpHub) {
+				const allServers = mcpHub.getAllServers()
+				const anyEnabled = allServers.some((server) => !server.disabled)
+				await mcpHub.toggleAllServersDisabled(anyEnabled)
+			}
+		} catch (error) {
+			outputChannel.appendLine(`Failed to toggle all MCP servers: ${error}`)
+			vscode.window.showErrorMessage(`Failed to toggle all MCP servers: ${error}`)
+		}
+	},
 })
 
 export const openClineInNewTab = async ({ context, outputChannel }: Omit<RegisterCommandOptions, "provider">) => {

src/api/providers/lmstudio.ts

@@ -25,108 +25,103 @@ export class LmStudioHandler extends BaseProvider implements SingleCompletionHan
 	}
 
 	override async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
-	const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
-		{ role: "system", content: systemPrompt },
-		...convertToOpenAiMessages(messages),
-	]
-
-	// -------------------------
-	// Track token usage
-	// -------------------------
-	const toContentBlocks = (
-		blocks: Anthropic.Messages.MessageParam[] | string,
-	): Anthropic.Messages.ContentBlockParam[] => {
-		if (typeof blocks === "string") {
-			return [{ type: "text", text: blocks }]
-		}
+		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
+			{ role: "system", content: systemPrompt },
+			...convertToOpenAiMessages(messages),
+		]
+
+		// -------------------------
+		// Track token usage
+		// -------------------------
+		const toContentBlocks = (
+			blocks: Anthropic.Messages.MessageParam[] | string,
+		): Anthropic.Messages.ContentBlockParam[] => {
+			if (typeof blocks === "string") {
+				return [{ type: "text", text: blocks }]
+			}
 
-		const result: Anthropic.Messages.ContentBlockParam[] = []
-		for (const msg of blocks) {
-			if (typeof msg.content === "string") {
-				result.push({ type: "text", text: msg.content })
-			} else if (Array.isArray(msg.content)) {
-				for (const part of msg.content) {
-					if (part.type === "text") {
-						result.push({ type: "text", text: part.text })
+			const result: Anthropic.Messages.ContentBlockParam[] = []
+			for (const msg of blocks) {
+				if (typeof msg.content === "string") {
+					result.push({ type: "text", text: msg.content })
+				} else if (Array.isArray(msg.content)) {
+					for (const part of msg.content) {
+						if (part.type === "text") {
+							result.push({ type: "text", text: part.text })
+						}
 					}
 				}
 			}
+			return result
 		}
-		return result
-	}
 
-	let inputTokens = 0
-	try {
-		inputTokens = await this.countTokens([
-			{ type: "text", text: systemPrompt },
-			...toContentBlocks(messages),
-		])
-	} catch (err) {
-		console.error("[LmStudio] Failed to count input tokens:", err)
-		inputTokens = 0
-	}
+		let inputTokens = 0
+		try {
+			inputTokens = await this.countTokens([{ type: "text", text: systemPrompt }, ...toContentBlocks(messages)])
+		} catch (err) {
+			console.error("[LmStudio] Failed to count input tokens:", err)
+			inputTokens = 0
+		}
 
-	let assistantText = ""
+		let assistantText = ""
 
-	try {
-		const params: OpenAI.Chat.ChatCompletionCreateParamsStreaming & { draft_model?: string } = {
-			model: this.getModel().id,
-			messages: openAiMessages,
-			temperature: this.options.modelTemperature ?? LMSTUDIO_DEFAULT_TEMPERATURE,
-			stream: true,
-		}
+		try {
+			const params: OpenAI.Chat.ChatCompletionCreateParamsStreaming & { draft_model?: string } = {
+				model: this.getModel().id,
+				messages: openAiMessages,
+				temperature: this.options.modelTemperature ?? LMSTUDIO_DEFAULT_TEMPERATURE,
+				stream: true,
+			}
 
-		if (this.options.lmStudioSpeculativeDecodingEnabled && this.options.lmStudioDraftModelId) {
-			params.draft_model = this.options.lmStudioDraftModelId
-		}
+			if (this.options.lmStudioSpeculativeDecodingEnabled && this.options.lmStudioDraftModelId) {
+				params.draft_model = this.options.lmStudioDraftModelId
+			}
 
-		const results = await this.client.chat.completions.create(params)
+			const results = await this.client.chat.completions.create(params)
 
-		const matcher = new XmlMatcher(
-			"think",
-			(chunk) =>
-				({
-					type: chunk.matched ? "reasoning" : "text",
-					text: chunk.data,
-				}) as const,
-		)
+			const matcher = new XmlMatcher(
+				"think",
+				(chunk) =>
+					({
+						type: chunk.matched ? "reasoning" : "text",
+						text: chunk.data,
+					}) as const,
+			)
 
-		for await (const chunk of results) {
-			const delta = chunk.choices[0]?.delta
+			for await (const chunk of results) {
+				const delta = chunk.choices[0]?.delta
 
-			if (delta?.content) {
-				assistantText += delta.content
-				for (const processedChunk of matcher.update(delta.content)) {
-					yield processedChunk
+				if (delta?.content) {
+					assistantText += delta.content
+					for (const processedChunk of matcher.update(delta.content)) {
+						yield processedChunk
+					}
 				}
 			}
-		}
 
-		for (const processedChunk of matcher.final()) {
-			yield processedChunk
-		}
+			for (const processedChunk of matcher.final()) {
+				yield processedChunk
+			}
 
-
-		let outputTokens = 0
-		try {
-			outputTokens = await this.countTokens([{ type: "text", text: assistantText }])
-		} catch (err) {
-			console.error("[LmStudio] Failed to count output tokens:", err)
-			outputTokens = 0
-		}
+			let outputTokens = 0
+			try {
+				outputTokens = await this.countTokens([{ type: "text", text: assistantText }])
+			} catch (err) {
+				console.error("[LmStudio] Failed to count output tokens:", err)
+				outputTokens = 0
+			}
 
-		yield {
-			type: "usage",
-			inputTokens,
-			outputTokens,
-		} as const
-	} catch (error) {
-		throw new Error(
-			"Please check the LM Studio developer logs to debug what went wrong. You may need to load the model with a larger context length to work with Roo Code's prompts.",
-		)
+			yield {
+				type: "usage",
+				inputTokens,
+				outputTokens,
+			} as const
+		} catch (error) {
+			throw new Error(
+				"Please check the LM Studio developer logs to debug what went wrong. You may need to load the model with a larger context length to work with Roo Code's prompts.",
+			)
+		}
 	}
-}
-
 
 	override getModel(): { id: string; info: ModelInfo } {
 		return {

src/core/webview/webviewMessageHandler.ts

@@ -1255,5 +1255,16 @@ export const webviewMessageHandler = async (provider: ClineProvider, message: We
 			await provider.postStateToWebview()
 			break
 		}
+		case "executeVSCodeCommand": {
+			if (message.command) {
+				try {
+					await vscode.commands.executeCommand(message.command)
+				} catch (error) {
+					provider.log(`Failed to execute VS Code command ${message.command}: ${error}`)
+					vscode.window.showErrorMessage(`Failed to execute command: ${message.command}`)
+				}
+			}
+			break
+		}
 	}
 }

src/schemas/index.ts

@@ -57,6 +57,8 @@ const commandIds = [
 	"setCustomStoragePath",
 	"focusInput",
 	"acceptInput",
+	"extension.reloadAllMcpServers",
+	"extension.toggleAllMcpServersDisabled",
 ] as const
 
 export type CommandId = (typeof commandIds)[number]

src/services/mcp/McpHub.ts

@@ -1306,4 +1306,52 @@ export class McpHub {
 		}
 		this.disposables.forEach((d) => d.dispose())
 	}
+
+	/**
+	 * Enables or disables all global MCP servers at once.
+	 * When activated, the configuration is reloaded.
+	 * @param disabled true = disable all, false = enable all
+	 */
+	public async toggleAllServersDisabled(disabled: boolean): Promise<void> {
+		// Collect all global server names
+		const allServers = this.getAllServers()
+
+		// Set the Disabled flag for all servers
+		for (const server of allServers) {
+			await this.updateServerConfig(server.name, { disabled }, server.source)
+			const conn = this.findConnection(server.name, server.source)
+			if (conn) {
+				conn.server.disabled = disabled
+			}
+		}
+
+		// If activated, reload configuration
+		if (!disabled) {
+			// Re-initialize all servers, both global and project
+			await this.initializeMcpServers("global")
+			await this.initializeMcpServers("project")
+		}
+
+		await this.notifyWebviewOfServerChanges()
+	}
+
+	/**
+	 * Restarts all currently active MCP servers.
+	 * This will trigger a popup for each server being restarted.
+	 */
+	public async restartAllMcpServers(): Promise<void> {
+		const allServers = this.getAllServers() // Get all servers, regardless of disabled state
+		const restartPromises = allServers.map(async (server) => {
+			// Only restart if not disabled
+			if (!server.disabled) {
+				try {
+					await this.restartConnection(server.name, server.source)
+				} catch (error) {
+					this.showErrorMessage(`Failed to restart MCP server ${server.name}`, error)
+				}
+			}
+		})
+		await Promise.all(restartPromises)
+		await this.notifyWebviewOfServerChanges()
+	}
 }