π OpenHands: AI-Driven Development
Refactor: Add LLM provider utilities and improve API base URL detection (#12766)
Tim O'Farrell545257f870cb
diff --git a/enterprise/storage/saas_settings_store.py b/enterprise/storage/saas_settings_store.pyindex 2853c16d71..dea7eb0942 100644--- a/enterprise/storage/saas_settings_store.py+++ b/enterprise/storage/saas_settings_store.py@@ -24,6 +24,7 @@ from openhands.core.config.openhands_config import OpenHandsConfigfrom openhands.server.settings import Settingsfrom openhands.storage.settings.settings_store import SettingsStorefrom openhands.utils.async_utils import call_sync_from_async+from openhands.utils.llm import is_openhands_model@dataclass@@ -163,7 +164,7 @@ class SaasSettingsStore(SettingsStore):# Check if we need to generate an LLM key.if item.llm_base_url == LITE_LLM_API_URL:await self._ensure_api_key(- item, str(org_id), openhands_type=self._is_openhands_provider(item)+ item, str(org_id), openhands_type=is_openhands_model(item.llm_model))kwargs = item.model_dump(context={'expose_secrets': True})@@ -229,10 +230,6 @@ class SaasSettingsStore(SettingsStore):fernet_key = b64encode(hashlib.sha256(jwt_secret.encode()).digest())return Fernet(fernet_key)- def _is_openhands_provider(self, item: Settings) -> bool:- """Check if the settings use the OpenHands provider."""- return bool(item.llm_model and item.llm_model.startswith('openhands/'))-async def _ensure_api_key(self, item: Settings, org_id: str, openhands_type: bool = False) -> None:diff --git a/openhands/server/routes/settings.py b/openhands/server/routes/settings.pyindex 2a5d27f83d..eda0cb938f 100644--- a/openhands/server/routes/settings.py+++ b/openhands/server/routes/settings.py@@ -31,6 +31,7 @@ from openhands.server.user_auth import (from openhands.storage.data_models.settings import Settingsfrom openhands.storage.secrets.secrets_store import SecretsStorefrom openhands.storage.settings.settings_store import SettingsStore+from openhands.utils.llm import get_provider_api_base, is_openhands_modelLITE_LLM_API_URL = os.environ.get('LITE_LLM_API_URL', 'https://llm-proxy.app.all-hands.dev'@@ -84,6 +85,17 @@ async def load_settings(and bool(settings.search_api_key),provider_tokens_set=provider_tokens_set,)++ # If the base url matches the default for the provider, we don't send it+ # So that the frontend can display basic mode+ if is_openhands_model(settings.llm_model):+ if settings.llm_base_url == LITE_LLM_API_URL:+ settings_with_token_data.llm_base_url = None+ elif settings.llm_model and settings.llm_base_url == get_provider_api_base(+ settings.llm_model+ ):+ settings_with_token_data.llm_base_url = None+settings_with_token_data.llm_api_key = Nonesettings_with_token_data.search_api_key = Nonesettings_with_token_data.sandbox_api_key = None@@ -129,9 +141,25 @@ async def store_llm_settings(settings.llm_api_key = existing_settings.llm_api_keyif settings.llm_model is None:settings.llm_model = existing_settings.llm_model- # if llm_base_url is missing or empty, set to default as this only happens for "basic" settings+ # if llm_base_url is missing or empty, try to determine appropriate URLif not settings.llm_base_url:- settings.llm_base_url = LITE_LLM_API_URL+ if is_openhands_model(settings.llm_model):+ # OpenHands models use the LiteLLM proxy+ settings.llm_base_url = LITE_LLM_API_URL+ elif settings.llm_model:+ # For non-openhands models, try to get URL from litellm+ try:+ api_base = get_provider_api_base(settings.llm_model)+ if api_base:+ settings.llm_base_url = api_base+ else:+ logger.debug(+ f'No api_base found in litellm for model: {settings.llm_model}'+ )+ except Exception as e:+ logger.error(+ f'Failed to get api_base from litellm for model {settings.llm_model}: {e}'+ )# Keep search API key if missing or emptyif not settings.search_api_key:settings.search_api_key = existing_settings.search_api_keydiff --git a/openhands/utils/llm.py b/openhands/utils/llm.pyindex 876a890001..d84e3e31e1 100644--- a/openhands/utils/llm.py+++ b/openhands/utils/llm.py@@ -5,12 +5,68 @@ import httpxwith warnings.catch_warnings():warnings.simplefilter('ignore')import litellm+ from litellm import LlmProviders, ProviderConfigManager, get_llm_providerfrom openhands.core.config import LLMConfig, OpenHandsConfigfrom openhands.core.logger import openhands_logger as loggerfrom openhands.llm import bedrock+def is_openhands_model(model: str | None) -> bool:+ """Check if the model uses the OpenHands provider.++ Args:+ model: The model name to check.++ Returns:+ True if the model starts with 'openhands/', False otherwise.+ """+ return bool(model and model.startswith('openhands/'))+++def get_provider_api_base(model: str) -> str | None:+ """Get the API base URL for a model using litellm.++ This function tries multiple approaches to determine the API base URL:+ 1. First tries litellm.get_api_base() which handles OpenAI, Gemini, Mistral+ 2. Falls back to ProviderConfigManager.get_provider_model_info() for providers+ like Anthropic that have ModelInfo classes with get_api_base() methods++ Args:+ model: The model name (e.g., 'gpt-4', 'anthropic/claude-sonnet-4-5-20250929')++ Returns:+ The API base URL if found, None otherwise.+ """+ # First try get_api_base (handles OpenAI, Gemini with specific URL patterns)+ try:+ api_base = litellm.get_api_base(model, {})+ if api_base:+ return api_base+ except Exception:+ pass++ # Fall back to ProviderConfigManager for providers like Anthropic+ try:+ # Get the provider from the model+ _, provider_name, _, _ = get_llm_provider(model)+ if provider_name:+ # Convert provider name to LlmProviders enum+ try:+ provider_enum = LlmProviders(provider_name)+ model_info = ProviderConfigManager.get_provider_model_info(+ model, provider_enum+ )+ if model_info and hasattr(model_info, 'get_api_base'):+ return model_info.get_api_base()+ except ValueError:+ pass # Provider not in enum+ except Exception:+ pass++ return None++def get_supported_llm_models(config: OpenHandsConfig) -> list[str]:"""Get all models supported by LiteLLM.diff --git a/tests/unit/server/routes/test_settings_store_functions.py b/tests/unit/server/routes/test_settings_store_functions.pyindex 78dd3f92f7..366f9e145f 100644--- a/tests/unit/server/routes/test_settings_store_functions.py+++ b/tests/unit/server/routes/test_settings_store_functions.py@@ -188,12 +188,12 @@ async def test_store_llm_settings_update_existing():async def test_store_llm_settings_partial_update():"""Test store_llm_settings with partial update.- Note: When llm_base_url is not provided in the update, it gets set to the default- LiteLLM proxy URL. This is intentional behavior for "basic" settings where users- don't specify a custom base URL.+ Note: When llm_base_url is not provided in the update and the model is NOT an+ openhands model, we attempt to get the URL from litellm.get_api_base().+ For OpenAI models, this returns https://api.openai.com."""settings = Settings(- llm_model='gpt-4' # Only updating model+ llm_model='gpt-4' # Only updating model (not an openhands model))# Create existing settings@@ -209,9 +209,84 @@ async def test_store_llm_settings_partial_update():assert result.llm_model == 'gpt-4'# For SecretStr objects, we need to compare the secret valueassert result.llm_api_key.get_secret_value() == 'existing-api-key'- # When llm_base_url is not provided, it defaults to the LiteLLM proxy URL+ # OpenAI models: litellm.get_api_base() returns https://api.openai.com+ assert result.llm_base_url == 'https://api.openai.com'+++async def test_store_llm_settings_anthropic_model_gets_api_base():+ """Test store_llm_settings with an Anthropic model.++ For Anthropic models, get_provider_api_base() returns the Anthropic API base URL+ via ProviderConfigManager.get_provider_model_info().+ """+ settings = Settings(+ llm_model='anthropic/claude-sonnet-4-5-20250929' # Anthropic model+ )++ existing_settings = Settings(+ llm_model='gpt-3.5',+ llm_api_key=SecretStr('existing-api-key'),+ )++ result = await store_llm_settings(settings, existing_settings)++ assert result.llm_model == 'anthropic/claude-sonnet-4-5-20250929'+ assert result.llm_api_key.get_secret_value() == 'existing-api-key'+ # Anthropic models get https://api.anthropic.com via ProviderConfigManager+ assert result.llm_base_url == 'https://api.anthropic.com'+++async def test_store_llm_settings_litellm_error_logged():+ """Test that litellm errors are logged when getting api_base fails."""+ from unittest.mock import patch++ settings = Settings(+ llm_model='unknown-model-xyz' # A model that litellm won't recognize+ )++ existing_settings = Settings(+ llm_model='gpt-3.5',+ llm_api_key=SecretStr('existing-api-key'),+ )++ # The function should not raise even if litellm fails+ with patch('openhands.server.routes.settings.logger') as mock_logger:+ result = await store_llm_settings(settings, existing_settings)++ # llm_base_url should remain None since litellm couldn't find the model+ assert result.llm_base_url is None+ # Either error or debug should have been logged+ assert mock_logger.error.called or mock_logger.debug.called+++async def test_store_llm_settings_openhands_model_gets_default_url():+ """Test store_llm_settings with openhands model gets LiteLLM proxy URL.++ When llm_base_url is not provided and the model is an openhands model,+ it gets set to the default LiteLLM proxy URL.+ """import os+ settings = Settings(+ llm_model='openhands/claude-sonnet-4-5-20250929' # openhands model+ )++ # Create existing settings+ existing_settings = Settings(+ llm_model='gpt-3.5',+ llm_api_key=SecretStr('existing-api-key'),+ )++ result = await store_llm_settings(settings, existing_settings)++ # Should return settings with updated model+ assert result.llm_model == 'openhands/claude-sonnet-4-5-20250929'+ # For SecretStr objects, we need to compare the secret value+ assert result.llm_api_key.get_secret_value() == 'existing-api-key'+ # openhands models get the LiteLLM proxy URLexpected_base_url = os.environ.get('LITE_LLM_API_URL', 'https://llm-proxy.app.all-hands.dev')diff --git a/tests/unit/utils/test_llm_utils.py b/tests/unit/utils/test_llm_utils.pynew file mode 100644index 0000000000..67a8a0696b--- /dev/null+++ b/tests/unit/utils/test_llm_utils.py@@ -0,0 +1,74 @@+"""Tests for openhands.utils.llm module."""++from openhands.utils.llm import get_provider_api_base, is_openhands_model+++class TestIsOpenhandsModel:+ """Tests for the is_openhands_model function."""++ def test_openhands_model_returns_true(self):+ """Test that models with 'openhands/' prefix return True."""+ assert is_openhands_model('openhands/claude-sonnet-4-5-20250929') is True+ assert is_openhands_model('openhands/gpt-5-2025-08-07') is True+ assert is_openhands_model('openhands/gemini-2.5-pro') is True++ def test_non_openhands_model_returns_false(self):+ """Test that models without 'openhands/' prefix return False."""+ assert is_openhands_model('gpt-4') is False+ assert is_openhands_model('claude-3-opus-20240229') is False+ assert is_openhands_model('anthropic/claude-3-opus-20240229') is False+ assert is_openhands_model('openai/gpt-4') is False++ def test_none_model_returns_false(self):+ """Test that None model returns False."""+ assert is_openhands_model(None) is False++ def test_empty_string_returns_false(self):+ """Test that empty string returns False."""+ assert is_openhands_model('') is False++ def test_similar_prefix_not_matched(self):+ """Test that similar prefixes don't incorrectly match."""+ assert is_openhands_model('openhands') is False # Missing slash+ assert is_openhands_model('openhandsx/model') is False # Extra char+ assert is_openhands_model('OPENHANDS/model') is False # Wrong case+++class TestGetProviderApiBase:+ """Tests for the get_provider_api_base function."""++ def test_openai_model_returns_openai_api_base(self):+ """Test that OpenAI models return the OpenAI API base URL."""+ assert get_provider_api_base('gpt-4') == 'https://api.openai.com'+ assert get_provider_api_base('openai/gpt-4') == 'https://api.openai.com'++ def test_anthropic_model_returns_anthropic_api_base(self):+ """Test that Anthropic models return the Anthropic API base URL."""+ assert (+ get_provider_api_base('anthropic/claude-sonnet-4-5-20250929')+ == 'https://api.anthropic.com'+ )+ assert (+ get_provider_api_base('claude-sonnet-4-5-20250929')+ == 'https://api.anthropic.com'+ )++ def test_gemini_model_returns_google_api_base(self):+ """Test that Gemini models return a Google API base URL."""+ api_base = get_provider_api_base('gemini/gemini-pro')+ assert api_base is not None+ assert 'generativelanguage.googleapis.com' in api_base++ def test_mistral_model_returns_mistral_api_base(self):+ """Test that Mistral models return the Mistral API base URL."""+ assert (+ get_provider_api_base('mistral/mistral-large-latest')+ == 'https://api.mistral.ai/v1'+ )++ def test_unknown_model_returns_none(self):+ """Test that unknown models return None."""+ result = get_provider_api_base('unknown-provider/unknown-model')+ # May return None or an API base depending on litellm behavior+ # The function should not raise an exception+ assert result is None or isinstance(result, str)