Merge pull request #126 from The-Obstacle-Is-The-Way/refactor/dead-config

refactor(config): Remove dead config and Anthropic references (Priority 4)

src/app.py

@@ -78,22 +78,15 @@ def configure_orchestrator(
 
     # 2. Paid API Key (User provided or Env)
     elif user_api_key and user_api_key.strip():
-        if user_api_key.startswith("sk-ant-"):
-            backend_info = "Paid API (Anthropic)"
-        elif user_api_key.startswith("sk-"):
+        if user_api_key.startswith("sk-"):
             backend_info = "Paid API (OpenAI)"
         else:
-            raise ConfigurationError(
-                "Invalid API key format. Expected sk-... (OpenAI) or sk-ant-... (Anthropic)"
-            )
+            raise ConfigurationError("Invalid API key format. Expected sk-... (OpenAI)")
 
     # 3. Environment API Keys (fallback)
     elif settings.has_openai_key:
         backend_info = "Paid API (OpenAI from env)"
 
-    elif settings.has_anthropic_key:
-        backend_info = "Paid API (Anthropic from env)"
-
     # 4. Free Tier (HuggingFace Inference)
     else:
         backend_info = "Free Tier (Llama 3.1 / Mistral)"
@@ -125,8 +118,7 @@ def _validate_inputs(
 
     # Check available keys
     has_openai = settings.has_openai_key
-    has_anthropic = settings.has_anthropic_key
-    has_paid_key = has_openai or has_anthropic or bool(user_api_key)
+    has_paid_key = has_openai or bool(user_api_key)
 
     return user_api_key, has_paid_key
 
@@ -320,7 +312,7 @@ def create_demo() -> tuple[gr.ChatInterface, gr.Accordion]:
             ),
             gr.Textbox(
                 label="🔑 API Key (Optional)",
-                placeholder="sk-... (OpenAI) or sk-ant-... (Anthropic)",
+                placeholder="sk-... (OpenAI)",
                 type="password",
                 info="Leave empty for free tier. Auto-detects provider from key prefix.",
                 elem_classes=["api-key-input"],

src/clients/factory.py

@@ -48,14 +48,12 @@ def get_chat_client(
     # This enables BYOK (Bring Your Own Key) from Gradio without explicit provider
     # Order matters: "sk-ant-" must be checked before "sk-" (both start with "sk-")
     if normalized is None and api_key:
-        if api_key.startswith("sk-ant-"):
-            normalized = "anthropic"
-        elif api_key.startswith("sk-"):
+        if api_key.startswith("sk-"):
             normalized = "openai"
         # HF tokens start with "hf_" - no auto-detection needed (falls through to default)
 
     # Validate explicit provider requests early
-    valid_providers = (None, "openai", "anthropic", "gemini", "huggingface")
+    valid_providers = (None, "openai", "huggingface")
     if normalized not in valid_providers:
         raise ValueError(f"Unsupported provider: {provider!r}")
 
@@ -68,23 +66,6 @@ def get_chat_client(
             **kwargs,
         )
 
-    # 2. Anthropic (Detected from sk-ant- prefix or explicit)
-    if normalized == "anthropic":
-        # Anthropic key was detected or explicitly requested - fail loudly
-        raise NotImplementedError(
-            "Anthropic client not yet implemented. "
-            "Use OpenAI key (sk-...) or leave empty for free HuggingFace tier."
-        )
-
-    # 3. Gemini (High Performance / Alternative)
-    if normalized == "gemini":
-        # Explicit request for Gemini - fail loudly
-        raise NotImplementedError("Gemini client not yet implemented (Planned Phase 4)")
-
-    if normalized is None and settings.has_gemini_key:
-        # Implicit (has key but not explicit) - log warning and fall through
-        logger.warning("Gemini key detected but client not yet implemented; falling back")
-
     # 4. HuggingFace (Free Fallback)
     # This is the default if no other keys are present
     logger.info("Using HuggingFace Chat Client (Free Tier)")

src/utils/config.py

@@ -26,15 +26,10 @@ class Settings(BaseSettings):
 
     # LLM Configuration
     openai_api_key: str | None = Field(default=None, description="OpenAI API key")
-    anthropic_api_key: str | None = Field(default=None, description="Anthropic API key")
-    gemini_api_key: str | None = Field(default=None, description="Google Gemini API key")
-    llm_provider: Literal["openai", "anthropic", "huggingface", "gemini"] = Field(
+    llm_provider: Literal["openai", "huggingface"] = Field(
         default="openai", description="Which LLM provider to use"
     )
     openai_model: str = Field(default="gpt-5", description="OpenAI model name")
-    anthropic_model: str = Field(
-        default="claude-sonnet-4-5-20250929", description="Anthropic model"
-    )
     # HuggingFace (free tier)
     # NOTE: Large models (70B+) are routed to third-party providers (Novita, Hyperbolic) which are
     # unreliable (500/401 errors). We use Qwen2.5-7B-Instruct as it is small enough to run on
@@ -77,10 +72,6 @@ class Settings(BaseSettings):
         description="Timeout for Advanced mode in seconds (default 10 min)",
     )
     search_timeout: int = Field(default=30, description="Seconds to wait for search")
-    magentic_timeout: int = Field(
-        default=600,
-        description="Timeout for Magentic mode in seconds (deprecated, use advanced_timeout)",
-    )
 
     # Logging
     log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "INFO"
@@ -105,11 +96,6 @@ class Settings(BaseSettings):
                 raise ConfigurationError("OPENAI_API_KEY not set")
             return self.openai_api_key
 
-        if provider_lower == "anthropic":
-            if not self.anthropic_api_key:
-                raise ConfigurationError("ANTHROPIC_API_KEY not set")
-            return self.anthropic_api_key
-
         raise ConfigurationError(f"Unknown LLM provider: {self.llm_provider}")
 
     def get_openai_api_key(self) -> str:
@@ -126,16 +112,6 @@ class Settings(BaseSettings):
         """Check if OpenAI API key is available."""
         return bool(self.openai_api_key)
 
-    @property
-    def has_anthropic_key(self) -> bool:
-        """Check if Anthropic API key is available."""
-        return bool(self.anthropic_api_key)
-
-    @property
-    def has_gemini_key(self) -> bool:
-        """Check if Gemini API key is available."""
-        return bool(self.gemini_api_key)
-
     @property
     def has_huggingface_key(self) -> bool:
         """Check if HuggingFace token is available."""
@@ -144,12 +120,7 @@ class Settings(BaseSettings):
     @property
     def has_any_llm_key(self) -> bool:
         """Check if any LLM API key is available."""
-        return (
-            self.has_openai_key
-            or self.has_anthropic_key
-            or self.has_huggingface_key
-            or self.has_gemini_key
-        )
+        return self.has_openai_key or self.has_huggingface_key
 
 
 def get_settings() -> Settings:

tests/unit/clients/test_chat_client_factory.py

@@ -71,17 +71,6 @@ class TestChatClientFactory:
 
             assert "HuggingFace" in type(client).__name__
 
-    def test_gemini_provider_raises_not_implemented(self) -> None:
-        """Explicit provider='gemini' should raise NotImplementedError (Phase 4)."""
-        with patch("src.clients.factory.settings") as mock_settings:
-            mock_settings.has_openai_key = False
-            mock_settings.has_gemini_key = False
-
-            from src.clients.factory import get_chat_client
-
-            with pytest.raises(NotImplementedError, match="Gemini client not yet implemented"):
-                get_chat_client(provider="gemini")
-
     def test_unsupported_provider_raises_value_error(self) -> None:
         """Unsupported provider should raise ValueError, not silently fallback."""
         with patch("src.clients.factory.settings") as mock_settings:
@@ -93,17 +82,6 @@ class TestChatClientFactory:
             with pytest.raises(ValueError, match="Unsupported provider"):
                 get_chat_client(provider="invalid_provider")
 
-    def test_anthropic_provider_raises_not_implemented(self) -> None:
-        """Anthropic provider should raise NotImplementedError (not yet implemented)."""
-        with patch("src.clients.factory.settings") as mock_settings:
-            mock_settings.has_openai_key = False
-            mock_settings.has_gemini_key = False
-
-            from src.clients.factory import get_chat_client
-
-            with pytest.raises(NotImplementedError, match="Anthropic client not yet implemented"):
-                get_chat_client(provider="anthropic")
-
     def test_byok_auto_detects_openai_from_key_prefix(self) -> None:
         """BYOK: api_key starting with 'sk-' should auto-select OpenAI without explicit provider.
 
@@ -127,22 +105,6 @@ class TestChatClientFactory:
             # Should auto-detect OpenAI from 'sk-' prefix
             assert "OpenAI" in type(client).__name__
 
-    def test_byok_auto_detects_anthropic_from_key_prefix(self) -> None:
-        """BYOK: api_key starting with 'sk-ant-' should auto-detect Anthropic.
-
-        Anthropic keys start with 'sk-ant-' which is a superset of 'sk-'.
-        Detection must check 'sk-ant-' first to avoid misdetecting as OpenAI.
-        """
-        with patch("src.clients.factory.settings") as mock_settings:
-            mock_settings.has_openai_key = False
-            mock_settings.has_gemini_key = False
-
-            from src.clients.factory import get_chat_client
-
-            # BYOK: Anthropic key should raise NotImplementedError (not fall to HuggingFace!)
-            with pytest.raises(NotImplementedError, match="Anthropic client not yet implemented"):
-                get_chat_client(api_key="sk-ant-user-anthropic-key")
-
     def test_byok_hf_token_falls_through_to_huggingface(self) -> None:
         """BYOK: HuggingFace tokens (hf_...) should use HuggingFace client."""
         with patch("src.clients.factory.settings") as mock_settings:

tests/unit/test_app_timeout.py

@@ -1,6 +1,5 @@
 """Tests for app timeout and history preservation."""
 
-import os
 from unittest.mock import MagicMock, patch
 
 import pytest
@@ -48,13 +47,3 @@ async def test_complete_event_preserves_history():
         assert "Step 1: Thinking..." in final_output
         assert "Step 2: Found data" in final_output
         assert "Timeout: Synthesizing..." in final_output
-
-
-@pytest.mark.asyncio
-async def test_timeout_configurable():
-    """Verify MAGENTIC_TIMEOUT env var is respected."""
-    from src.utils.config import Settings
-
-    with patch.dict(os.environ, {"MAGENTIC_TIMEOUT": "120"}):
-        settings = Settings()
-        assert settings.magentic_timeout == 120

tests/unit/utils/test_config.py

@@ -52,20 +52,3 @@ class TestSettings:
             settings = Settings(_env_file=None)
             with pytest.raises(ConfigurationError, match="OPENAI_API_KEY not set"):
                 settings.get_api_key()
-
-    def test_get_api_key_anthropic(self) -> None:
-        """get_api_key should return Anthropic key when provider is anthropic."""
-        with patch.dict(
-            os.environ,
-            {"LLM_PROVIDER": "anthropic", "ANTHROPIC_API_KEY": "sk-ant-test-key"},
-            clear=True,
-        ):
-            settings = Settings(_env_file=None)
-            assert settings.get_api_key() == "sk-ant-test-key"
-
-    def test_get_api_key_anthropic_missing_raises(self) -> None:
-        """get_api_key should raise ConfigurationError when Anthropic key is not set."""
-        with patch.dict(os.environ, {"LLM_PROVIDER": "anthropic"}, clear=True):
-            settings = Settings(_env_file=None)
-            with pytest.raises(ConfigurationError, match="ANTHROPIC_API_KEY not set"):
-                settings.get_api_key()