π OpenHands: AI-Driven Development
fix(backend): unable to use custom mcp servers (v1 conversations) (#12038)
Hiep Leeb9a22ef7e13
diff --git a/openhands/app_server/app_conversation/live_status_app_conversation_service.py b/openhands/app_server/app_conversation/live_status_app_conversation_service.pyindex dd4b2dd499..e7641ad487 100644--- a/openhands/app_server/app_conversation/live_status_app_conversation_service.py+++ b/openhands/app_server/app_conversation/live_status_app_conversation_service.py@@ -585,69 +585,231 @@ class LiveStatusAppConversationService(AppConversationServiceBase):return secrets- async def _configure_llm_and_mcp(- self, user: UserInfo, llm_model: str | None- ) -> tuple[LLM, dict]:- """Configure LLM and MCP (Model Context Protocol) settings.+ def _configure_llm(self, user: UserInfo, llm_model: str | None) -> LLM:+ """Configure LLM settings.Args:user: User information containing LLM preferencesllm_model: Optional specific model to use, falls back to user defaultReturns:- Tuple of (configured LLM instance, MCP config dictionary)+ Configured LLM instance"""- # Configure LLMmodel = llm_model or user.llm_modelbase_url = user.llm_base_urlif model and model.startswith('openhands/'):base_url = user.llm_base_url or self.openhands_provider_base_url- llm = LLM(++ return LLM(model=model,base_url=base_url,api_key=user.llm_api_key,usage_id='agent',)- # Configure MCP- mcp_config: dict[str, Any] = {}- if self.web_url:- mcp_url = f'{self.web_url}/mcp/mcp'- mcp_config = {- 'default': {- 'url': mcp_url,- }+ async def _get_tavily_api_key(self, user: UserInfo) -> str | None:+ """Get Tavily search API key, prioritizing user's key over service key.++ Args:+ user: User information++ Returns:+ Tavily API key if available, None otherwise+ """+ # Get the actual API key values, prioritizing user's key over service key+ user_search_key = None+ if user.search_api_key:+ key_value = user.search_api_key.get_secret_value()+ if key_value and key_value.strip():+ user_search_key = key_value++ service_tavily_key = None+ if self.tavily_api_key:+ # tavily_api_key is already a string (extracted in the factory method)+ if self.tavily_api_key.strip():+ service_tavily_key = self.tavily_api_key++ return user_search_key or service_tavily_key++ async def _add_system_mcp_servers(+ self, mcp_servers: dict[str, Any], user: UserInfo+ ) -> None:+ """Add system-generated MCP servers (default OpenHands server and Tavily).++ Args:+ mcp_servers: Dictionary to add servers to+ user: User information for API keys+ """+ if not self.web_url:+ return++ # Add default OpenHands MCP server+ mcp_url = f'{self.web_url}/mcp/mcp'+ mcp_servers['default'] = {'url': mcp_url}++ # Add API key if available+ mcp_api_key = await self.user_context.get_mcp_api_key()+ if mcp_api_key:+ mcp_servers['default']['headers'] = {+ 'X-Session-API-Key': mcp_api_key,}- # Add API key if available- mcp_api_key = await self.user_context.get_mcp_api_key()- if mcp_api_key:- mcp_config['default']['headers'] = {- 'X-Session-API-Key': mcp_api_key,+ # Add Tavily search if API key is available+ tavily_api_key = await self._get_tavily_api_key(user)+ if tavily_api_key:+ _logger.info('Adding search engine to MCP config')+ mcp_servers['tavily'] = {+ 'url': f'https://mcp.tavily.com/mcp/?tavilyApiKey={tavily_api_key}'+ }+ else:+ _logger.info('No search engine API key found, skipping search engine')++ def _add_custom_sse_servers(+ self, mcp_servers: dict[str, Any], sse_servers: list+ ) -> None:+ """Add custom SSE MCP servers from user configuration.++ Args:+ mcp_servers: Dictionary to add servers to+ sse_servers: List of SSE server configurations+ """+ for sse_server in sse_servers:+ server_config = {+ 'url': sse_server.url,+ 'transport': 'sse',+ }+ if sse_server.api_key:+ server_config['headers'] = {+ 'Authorization': f'Bearer {sse_server.api_key}'}- # Get the actual API key values, prioritizing user's key over service key- user_search_key = None- if user.search_api_key:- key_value = user.search_api_key.get_secret_value()- if key_value and key_value.strip():- user_search_key = key_value-- service_tavily_key = None- if self.tavily_api_key:- # tavily_api_key is already a string (extracted in the factory method)- if self.tavily_api_key.strip():- service_tavily_key = self.tavily_api_key-- tavily_api_key = user_search_key or service_tavily_key-- if tavily_api_key:- _logger.info('Adding search engine to MCP config')- mcp_config['tavily'] = {- 'url': f'https://mcp.tavily.com/mcp/?tavilyApiKey={tavily_api_key}'+ # Generate unique server name using UUID+ # TODO: Let the users specify the server name+ server_name = f'sse_{uuid4().hex[:8]}'+ mcp_servers[server_name] = server_config+ _logger.debug(+ f'Added custom SSE server: {server_name} for {sse_server.url}'+ )++ def _add_custom_shttp_servers(+ self, mcp_servers: dict[str, Any], shttp_servers: list+ ) -> None:+ """Add custom SHTTP MCP servers from user configuration.++ Args:+ mcp_servers: Dictionary to add servers to+ shttp_servers: List of SHTTP server configurations+ """+ for shttp_server in shttp_servers:+ server_config = {+ 'url': shttp_server.url,+ 'transport': 'streamable-http',+ }+ if shttp_server.api_key:+ server_config['headers'] = {+ 'Authorization': f'Bearer {shttp_server.api_key}'}- else:- _logger.info('No search engine API key found, skipping search engine')+ if shttp_server.timeout:+ server_config['timeout'] = shttp_server.timeout++ # Generate unique server name using UUID+ # TODO: Let the users specify the server name+ server_name = f'shttp_{uuid4().hex[:8]}'+ mcp_servers[server_name] = server_config+ _logger.debug(+ f'Added custom SHTTP server: {server_name} for {shttp_server.url}'+ )++ def _add_custom_stdio_servers(+ self, mcp_servers: dict[str, Any], stdio_servers: list+ ) -> None:+ """Add custom STDIO MCP servers from user configuration.++ Args:+ mcp_servers: Dictionary to add servers to+ stdio_servers: List of STDIO server configurations+ """+ for stdio_server in stdio_servers:+ server_config = {+ 'command': stdio_server.command,+ 'args': stdio_server.args,+ }+ if stdio_server.env:+ server_config['env'] = stdio_server.env++ # STDIO servers have an explicit name field+ mcp_servers[stdio_server.name] = server_config+ _logger.debug(f'Added custom STDIO server: {stdio_server.name}')++ def _merge_custom_mcp_config(+ self, mcp_servers: dict[str, Any], user: UserInfo+ ) -> None:+ """Merge custom MCP configuration from user settings.++ Args:+ mcp_servers: Dictionary to add servers to+ user: User information containing custom MCP config+ """+ if not user.mcp_config:+ return++ try:+ sse_count = len(user.mcp_config.sse_servers)+ shttp_count = len(user.mcp_config.shttp_servers)+ stdio_count = len(user.mcp_config.stdio_servers)++ _logger.info(+ f'Loading custom MCP config from user settings: '+ f'{sse_count} SSE, {shttp_count} SHTTP, {stdio_count} STDIO servers'+ )++ # Add each type of custom server+ self._add_custom_sse_servers(mcp_servers, user.mcp_config.sse_servers)+ self._add_custom_shttp_servers(mcp_servers, user.mcp_config.shttp_servers)+ self._add_custom_stdio_servers(mcp_servers, user.mcp_config.stdio_servers)++ _logger.info(+ f'Successfully merged custom MCP config: added {sse_count} SSE, '+ f'{shttp_count} SHTTP, and {stdio_count} STDIO servers'+ )++ except Exception as e:+ _logger.error(+ f'Error loading custom MCP config from user settings: {e}',+ exc_info=True,+ )+ # Continue with system config only, don't fail conversation startup+ _logger.warning(+ 'Continuing with system-generated MCP config only due to custom config error'+ )++ async def _configure_llm_and_mcp(+ self, user: UserInfo, llm_model: str | None+ ) -> tuple[LLM, dict]:+ """Configure LLM and MCP (Model Context Protocol) settings.++ Args:+ user: User information containing LLM preferences+ llm_model: Optional specific model to use, falls back to user default++ Returns:+ Tuple of (configured LLM instance, MCP config dictionary)+ """+ # Configure LLM+ llm = self._configure_llm(user, llm_model)++ # Configure MCP - SDK expects format: {'mcpServers': {'server_name': {...}}}+ mcp_servers: dict[str, Any] = {}++ # Add system-generated servers (default + tavily)+ await self._add_system_mcp_servers(mcp_servers, user)++ # Merge custom servers from user settings+ self._merge_custom_mcp_config(mcp_servers, user)++ # Wrap in the mcpServers structure required by the SDK+ mcp_config = {'mcpServers': mcp_servers} if mcp_servers else {}+ _logger.info(f'Final MCP configuration: {mcp_config}')return llm, mcp_configdiff --git a/tests/unit/app_server/test_live_status_app_conversation_service.py b/tests/unit/app_server/test_live_status_app_conversation_service.pyindex 273d79ca25..6a9821b9f3 100644--- a/tests/unit/app_server/test_live_status_app_conversation_service.py+++ b/tests/unit/app_server/test_live_status_app_conversation_service.py@@ -68,6 +68,7 @@ class TestLiveStatusAppConversationService:self.mock_user.search_api_key = None # Default to Noneself.mock_user.condenser_max_size = None # Default to Noneself.mock_user.llm_base_url = 'https://api.openai.com/v1'+ self.mock_user.mcp_config = None # Default to None to avoid error handling path# Mock sandboxself.mock_sandbox = Mock(spec=SandboxInfo)@@ -239,9 +240,16 @@ class TestLiveStatusAppConversationService:assert llm.api_key.get_secret_value() == self.mock_user.llm_api_keyassert llm.usage_id == 'agent'- assert 'default' in mcp_config- assert mcp_config['default']['url'] == 'https://test.example.com/mcp/mcp'- assert mcp_config['default']['headers']['X-Session-API-Key'] == 'mcp_api_key'+ assert 'mcpServers' in mcp_config+ assert 'default' in mcp_config['mcpServers']+ assert (+ mcp_config['mcpServers']['default']['url']+ == 'https://test.example.com/mcp/mcp'+ )+ assert (+ mcp_config['mcpServers']['default']['headers']['X-Session-API-Key']+ == 'mcp_api_key'+ )@pytest.mark.asyncioasync def test_configure_llm_and_mcp_openhands_model_prefers_user_base_url(self):@@ -320,8 +328,9 @@ class TestLiveStatusAppConversationService:# Assertassert llm.model == self.mock_user.llm_model- assert 'default' in mcp_config- assert 'headers' not in mcp_config['default']+ assert 'mcpServers' in mcp_config+ assert 'default' in mcp_config['mcpServers']+ assert 'headers' not in mcp_config['mcpServers']['default']@pytest.mark.asyncioasync def test_configure_llm_and_mcp_without_web_url(self):@@ -354,10 +363,11 @@ class TestLiveStatusAppConversationService:# Assertassert isinstance(llm, LLM)- assert 'default' in mcp_config- assert 'tavily' in mcp_config+ assert 'mcpServers' in mcp_config+ assert 'default' in mcp_config['mcpServers']+ assert 'tavily' in mcp_config['mcpServers']assert (- mcp_config['tavily']['url']+ mcp_config['mcpServers']['tavily']['url']== 'https://mcp.tavily.com/mcp/?tavilyApiKey=user_search_key')@@ -375,10 +385,11 @@ class TestLiveStatusAppConversationService:# Assertassert isinstance(llm, LLM)- assert 'default' in mcp_config- assert 'tavily' in mcp_config+ assert 'mcpServers' in mcp_config+ assert 'default' in mcp_config['mcpServers']+ assert 'tavily' in mcp_config['mcpServers']assert (- mcp_config['tavily']['url']+ mcp_config['mcpServers']['tavily']['url']== 'https://mcp.tavily.com/mcp/?tavilyApiKey=env_tavily_key')@@ -399,9 +410,10 @@ class TestLiveStatusAppConversationService:# Assertassert isinstance(llm, LLM)- assert 'tavily' in mcp_config+ assert 'mcpServers' in mcp_config+ assert 'tavily' in mcp_config['mcpServers']assert (- mcp_config['tavily']['url']+ mcp_config['mcpServers']['tavily']['url']== 'https://mcp.tavily.com/mcp/?tavilyApiKey=user_search_key')@@ -420,8 +432,9 @@ class TestLiveStatusAppConversationService:# Assertassert isinstance(llm, LLM)- assert 'default' in mcp_config- assert 'tavily' not in mcp_config+ assert 'mcpServers' in mcp_config+ assert 'default' in mcp_config['mcpServers']+ assert 'tavily' not in mcp_config['mcpServers']@pytest.mark.asyncioasync def test_configure_llm_and_mcp_saas_mode_no_tavily_without_user_key(self):@@ -443,8 +456,9 @@ class TestLiveStatusAppConversationService:# Assertassert isinstance(llm, LLM)- assert 'default' in mcp_config- assert 'tavily' not in mcp_config+ assert 'mcpServers' in mcp_config+ assert 'default' in mcp_config['mcpServers']+ assert 'tavily' not in mcp_config['mcpServers']@pytest.mark.asyncioasync def test_configure_llm_and_mcp_saas_mode_with_user_search_key(self):@@ -467,10 +481,11 @@ class TestLiveStatusAppConversationService:# Assertassert isinstance(llm, LLM)- assert 'default' in mcp_config- assert 'tavily' in mcp_config+ assert 'mcpServers' in mcp_config+ assert 'default' in mcp_config['mcpServers']+ assert 'tavily' in mcp_config['mcpServers']assert (- mcp_config['tavily']['url']+ mcp_config['mcpServers']['tavily']['url']== 'https://mcp.tavily.com/mcp/?tavilyApiKey=user_search_key')@@ -491,10 +506,11 @@ class TestLiveStatusAppConversationService:# Assertassert isinstance(llm, LLM)- assert 'tavily' in mcp_config+ assert 'mcpServers' in mcp_config+ assert 'tavily' in mcp_config['mcpServers']# Should fall back to env key since user key is emptyassert (- mcp_config['tavily']['url']+ mcp_config['mcpServers']['tavily']['url']== 'https://mcp.tavily.com/mcp/?tavilyApiKey=env_tavily_key')@@ -515,10 +531,11 @@ class TestLiveStatusAppConversationService:# Assertassert isinstance(llm, LLM)- assert 'tavily' in mcp_config+ assert 'mcpServers' in mcp_config+ assert 'tavily' in mcp_config['mcpServers']# Should fall back to env key since user key is whitespace onlyassert (- mcp_config['tavily']['url']+ mcp_config['mcpServers']['tavily']['url']== 'https://mcp.tavily.com/mcp/?tavilyApiKey=env_tavily_key')@@ -824,3 +841,404 @@ class TestLiveStatusAppConversationService:secrets=mock_secrets,)self.service._finalize_conversation_request.assert_called_once()++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_with_custom_sse_servers(self):+ """Test _configure_llm_and_mcp merges custom SSE servers with UUID-based names."""+ # Arrange++ from openhands.core.config.mcp_config import MCPConfig, MCPSSEServerConfig++ self.mock_user.mcp_config = MCPConfig(+ sse_servers=[+ MCPSSEServerConfig(url='https://linear.app/sse', api_key='linear_key'),+ MCPSSEServerConfig(url='https://notion.com/sse'),+ ]+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ assert isinstance(llm, LLM)+ assert 'mcpServers' in mcp_config++ # Should have default server + 2 custom SSE servers+ mcp_servers = mcp_config['mcpServers']+ assert 'default' in mcp_servers++ # Find SSE servers (they have sse_ prefix)+ sse_servers = {k: v for k, v in mcp_servers.items() if k.startswith('sse_')}+ assert len(sse_servers) == 2++ # Verify SSE server configurations+ for server_name, server_config in sse_servers.items():+ assert server_name.startswith('sse_')+ assert len(server_name) > 4 # Has UUID suffix+ assert 'url' in server_config+ assert 'transport' in server_config+ assert server_config['transport'] == 'sse'++ # Check if this is the Linear server (has headers)+ if 'headers' in server_config:+ assert server_config['headers']['Authorization'] == 'Bearer linear_key'++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_with_custom_shttp_servers(self):+ """Test _configure_llm_and_mcp merges custom SHTTP servers with timeout."""+ # Arrange+ from openhands.core.config.mcp_config import MCPConfig, MCPSHTTPServerConfig++ self.mock_user.mcp_config = MCPConfig(+ shttp_servers=[+ MCPSHTTPServerConfig(+ url='https://example.com/mcp',+ api_key='test_key',+ timeout=120,+ )+ ]+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ assert isinstance(llm, LLM)+ mcp_servers = mcp_config['mcpServers']++ # Find SHTTP servers+ shttp_servers = {k: v for k, v in mcp_servers.items() if k.startswith('shttp_')}+ assert len(shttp_servers) == 1++ server_config = list(shttp_servers.values())[0]+ assert server_config['url'] == 'https://example.com/mcp'+ assert server_config['transport'] == 'streamable-http'+ assert server_config['headers']['Authorization'] == 'Bearer test_key'+ assert server_config['timeout'] == 120++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_with_custom_stdio_servers(self):+ """Test _configure_llm_and_mcp merges custom STDIO servers with explicit names."""+ # Arrange+ from openhands.core.config.mcp_config import MCPConfig, MCPStdioServerConfig++ self.mock_user.mcp_config = MCPConfig(+ stdio_servers=[+ MCPStdioServerConfig(+ name='my-custom-server',+ command='npx',+ args=['-y', 'my-package'],+ env={'API_KEY': 'secret'},+ )+ ]+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ assert isinstance(llm, LLM)+ mcp_servers = mcp_config['mcpServers']++ # STDIO server should use its explicit name+ assert 'my-custom-server' in mcp_servers+ server_config = mcp_servers['my-custom-server']+ assert server_config['command'] == 'npx'+ assert server_config['args'] == ['-y', 'my-package']+ assert server_config['env'] == {'API_KEY': 'secret'}++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_merges_system_and_custom_servers(self):+ """Test _configure_llm_and_mcp merges both system and custom MCP servers."""+ # Arrange+ from pydantic import SecretStr++ from openhands.core.config.mcp_config import (+ MCPConfig,+ MCPSSEServerConfig,+ MCPStdioServerConfig,+ )++ self.mock_user.search_api_key = SecretStr('tavily_key')+ self.mock_user.mcp_config = MCPConfig(+ sse_servers=[MCPSSEServerConfig(url='https://custom.com/sse')],+ stdio_servers=[+ MCPStdioServerConfig(+ name='custom-stdio', command='node', args=['app.js']+ )+ ],+ )+ self.mock_user_context.get_mcp_api_key.return_value = 'mcp_api_key'++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ mcp_servers = mcp_config['mcpServers']++ # Should have system servers+ assert 'default' in mcp_servers+ assert 'tavily' in mcp_servers++ # Should have custom SSE server with UUID name+ sse_servers = [k for k in mcp_servers if k.startswith('sse_')]+ assert len(sse_servers) == 1++ # Should have custom STDIO server with explicit name+ assert 'custom-stdio' in mcp_servers++ # Total: default + tavily + 1 SSE + 1 STDIO = 4 servers+ assert len(mcp_servers) == 4++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_custom_config_error_handling(self):+ """Test _configure_llm_and_mcp handles errors in custom MCP config gracefully."""+ # Arrange+ self.mock_user.mcp_config = Mock()+ # Simulate error when accessing sse_servers+ self.mock_user.mcp_config.sse_servers = property(+ lambda self: (_ for _ in ()).throw(Exception('Config error'))+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert - should still return valid config with system servers only+ assert isinstance(llm, LLM)+ mcp_servers = mcp_config['mcpServers']+ assert 'default' in mcp_servers+ # Custom servers should not be added due to error++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_sdk_format_with_mcpservers_wrapper(self):+ """Test _configure_llm_and_mcp returns SDK-required format with mcpServers key."""+ # Arrange+ self.mock_user_context.get_mcp_api_key.return_value = 'mcp_key'++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert - SDK expects {'mcpServers': {...}} format+ assert 'mcpServers' in mcp_config+ assert isinstance(mcp_config['mcpServers'], dict)++ # Verify structure matches SDK expectations+ for server_name, server_config in mcp_config['mcpServers'].items():+ assert isinstance(server_name, str)+ assert isinstance(server_config, dict)++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_empty_custom_config(self):+ """Test _configure_llm_and_mcp handles empty custom MCP config."""+ # Arrange+ from openhands.core.config.mcp_config import MCPConfig++ self.mock_user.mcp_config = MCPConfig(+ sse_servers=[], stdio_servers=[], shttp_servers=[]+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ mcp_servers = mcp_config['mcpServers']+ # Should only have system default server+ assert 'default' in mcp_servers+ assert len(mcp_servers) == 1++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_sse_server_without_api_key(self):+ """Test _configure_llm_and_mcp handles SSE servers without API keys."""+ # Arrange+ from openhands.core.config.mcp_config import MCPConfig, MCPSSEServerConfig++ self.mock_user.mcp_config = MCPConfig(+ sse_servers=[MCPSSEServerConfig(url='https://public.com/sse')]+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ mcp_servers = mcp_config['mcpServers']+ sse_servers = {k: v for k, v in mcp_servers.items() if k.startswith('sse_')}++ # Server should exist but without headers+ assert len(sse_servers) == 1+ server_config = list(sse_servers.values())[0]+ assert 'headers' not in server_config+ assert server_config['url'] == 'https://public.com/sse'+ assert server_config['transport'] == 'sse'++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_shttp_server_without_timeout(self):+ """Test _configure_llm_and_mcp handles SHTTP servers without timeout."""+ # Arrange+ from openhands.core.config.mcp_config import MCPConfig, MCPSHTTPServerConfig++ self.mock_user.mcp_config = MCPConfig(+ shttp_servers=[MCPSHTTPServerConfig(url='https://example.com/mcp')]+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ mcp_servers = mcp_config['mcpServers']+ shttp_servers = {k: v for k, v in mcp_servers.items() if k.startswith('shttp_')}++ assert len(shttp_servers) == 1+ server_config = list(shttp_servers.values())[0]+ # Timeout should be included even if None (defaults to 60)+ assert 'timeout' in server_config++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_stdio_server_without_env(self):+ """Test _configure_llm_and_mcp handles STDIO servers without environment variables."""+ # Arrange+ from openhands.core.config.mcp_config import MCPConfig, MCPStdioServerConfig++ self.mock_user.mcp_config = MCPConfig(+ stdio_servers=[+ MCPStdioServerConfig(+ name='simple-server', command='node', args=['app.js']+ )+ ]+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ mcp_servers = mcp_config['mcpServers']+ assert 'simple-server' in mcp_servers+ server_config = mcp_servers['simple-server']++ # Should not have env key if not provided+ assert 'env' not in server_config+ assert server_config['command'] == 'node'+ assert server_config['args'] == ['app.js']++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_multiple_servers_same_type(self):+ """Test _configure_llm_and_mcp handles multiple custom servers of the same type."""+ # Arrange+ from openhands.core.config.mcp_config import MCPConfig, MCPSSEServerConfig++ self.mock_user.mcp_config = MCPConfig(+ sse_servers=[+ MCPSSEServerConfig(url='https://server1.com/sse'),+ MCPSSEServerConfig(url='https://server2.com/sse'),+ MCPSSEServerConfig(url='https://server3.com/sse'),+ ]+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ mcp_servers = mcp_config['mcpServers']+ sse_servers = {k: v for k, v in mcp_servers.items() if k.startswith('sse_')}++ # All 3 servers should be present with unique UUID-based names+ assert len(sse_servers) == 3++ # Verify all have unique names+ server_names = list(sse_servers.keys())+ assert len(set(server_names)) == 3 # All names are unique++ # Verify all URLs are preserved+ urls = [v['url'] for v in sse_servers.values()]+ assert 'https://server1.com/sse' in urls+ assert 'https://server2.com/sse' in urls+ assert 'https://server3.com/sse' in urls++ @pytest.mark.asyncio+ async def test_configure_llm_and_mcp_mixed_server_types(self):+ """Test _configure_llm_and_mcp handles all three server types together."""+ # Arrange+ from openhands.core.config.mcp_config import (+ MCPConfig,+ MCPSHTTPServerConfig,+ MCPSSEServerConfig,+ MCPStdioServerConfig,+ )++ self.mock_user.mcp_config = MCPConfig(+ sse_servers=[+ MCPSSEServerConfig(url='https://sse.example.com/sse', api_key='sse_key')+ ],+ shttp_servers=[+ MCPSHTTPServerConfig(url='https://shttp.example.com/mcp', timeout=90)+ ],+ stdio_servers=[+ MCPStdioServerConfig(+ name='stdio-server',+ command='npx',+ args=['mcp-server'],+ env={'TOKEN': 'value'},+ )+ ],+ )+ self.mock_user_context.get_mcp_api_key.return_value = None++ # Act+ llm, mcp_config = await self.service._configure_llm_and_mcp(+ self.mock_user, None+ )++ # Assert+ mcp_servers = mcp_config['mcpServers']++ # Check all server types are present+ sse_count = len([k for k in mcp_servers if k.startswith('sse_')])+ shttp_count = len([k for k in mcp_servers if k.startswith('shttp_')])+ stdio_count = 1 if 'stdio-server' in mcp_servers else 0++ assert sse_count == 1+ assert shttp_count == 1+ assert stdio_count == 1++ # Verify each type has correct configuration+ sse_server = next(v for k, v in mcp_servers.items() if k.startswith('sse_'))+ assert sse_server['transport'] == 'sse'+ assert sse_server['headers']['Authorization'] == 'Bearer sse_key'++ shttp_server = next(v for k, v in mcp_servers.items() if k.startswith('shttp_'))+ assert shttp_server['transport'] == 'streamable-http'+ assert shttp_server['timeout'] == 90++ stdio_server = mcp_servers['stdio-server']+ assert stdio_server['command'] == 'npx'+ assert stdio_server['env'] == {'TOKEN': 'value'}