fix(P0): Auto-detect OpenAI provider from BYOK api_key prefix

Bug: When users entered an OpenAI key (sk-...) in Gradio without
a provider parameter, the client factory only checked settings.has_openai_key
(env var) and fell through to HuggingFace, causing V1 chat completion errors.

Fix: Add provider auto-detection from api_key prefix in get_chat_client():
- sk-ant-... → Anthropic (NotImplementedError - not yet supported)
- sk-... → OpenAI (now correctly routed)
- hf_... → Falls through to HuggingFace (default)

Order matters: "sk-ant-" must be checked before "sk-" since both share prefix.

Tests added:
- test_byok_auto_detects_openai_from_key_prefix (the critical fix test)
- test_byok_auto_detects_anthropic_from_key_prefix
- test_byok_hf_token_falls_through_to_huggingface
- test_anthropic_provider_raises_not_implemented

All 310 unit tests pass.

src/clients/factory.py

@@ -23,13 +23,14 @@ def get_chat_client(
 
     Auto-detection priority:
     1. Explicit provider parameter
-    2. OpenAI key (Best Function Calling)
-    3. Gemini key (Best Context/Cost)
-    4. HuggingFace (Free Fallback)
+    2. API key prefix detection (sk- → OpenAI, sk-ant- → Anthropic)
+    3. OpenAI key from env (Best Function Calling)
+    4. Gemini key from env (Best Context/Cost)
+    5. HuggingFace (Free Fallback)
 
     Args:
         provider: Force specific provider ("openai", "gemini", "huggingface")
-        api_key: Override API key for the provider
+        api_key: Override API key for the provider (auto-detects provider from prefix)
         model_id: Override default model ID
         **kwargs: Additional arguments for the client
 
@@ -38,13 +39,23 @@ def get_chat_client(
 
     Raises:
         ValueError: If an unsupported provider is explicitly requested
-        NotImplementedError: If Gemini is explicitly requested (not yet implemented)
+        NotImplementedError: If Gemini or Anthropic is requested (not yet implemented)
     """
     # Normalize provider to lowercase for case-insensitive matching
     normalized = provider.lower() if provider is not None else None
 
+    # FIX: Auto-detect provider from API key prefix when not explicitly set
+    # 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-"):
+            normalized = "openai"
+        # HF tokens start with "hf_" - no auto-detection needed (falls through to default)
+
     # Validate explicit provider requests early
-    valid_providers = (None, "openai", "gemini", "huggingface")
+    valid_providers = (None, "openai", "anthropic", "gemini", "huggingface")
     if normalized not in valid_providers:
         raise ValueError(f"Unsupported provider: {provider!r}")
 
@@ -57,7 +68,15 @@ def get_chat_client(
             **kwargs,
         )
 
-    # 2. Gemini (High Performance / Alternative)
+    # 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)")
@@ -66,7 +85,7 @@ def get_chat_client(
         # Implicit (has key but not explicit) - log warning and fall through
         logger.warning("Gemini key detected but client not yet implemented; falling back")
 
-    # 3. HuggingFace (Free Fallback)
+    # 4. HuggingFace (Free Fallback)
     # This is the default if no other keys are present
     logger.info("Using HuggingFace Chat Client (Free Tier)")
     return HuggingFaceChatClient(

tests/unit/clients/test_chat_client_factory.py

@@ -91,8 +91,73 @@ class TestChatClientFactory:
             from src.clients.factory import get_chat_client
 
             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.
+
+        This is the critical BYOK (Bring Your Own Key) test case:
+        - User enters 'sk-...' key in Gradio
+        - No explicit provider parameter
+        - No OPENAI_API_KEY in env (settings.has_openai_key = False)
+        - Should auto-detect OpenAI from the key prefix
+        """
+        with patch("src.clients.factory.settings") as mock_settings:
+            mock_settings.has_openai_key = False  # No env key
+            mock_settings.has_gemini_key = False
+            mock_settings.openai_api_key = None
+            mock_settings.openai_model = "gpt-5"
+
+            from src.clients.factory import get_chat_client
+
+            # BYOK: Pass api_key without explicit provider
+            client = get_chat_client(api_key="sk-user-provided-key")
+
+            # 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:
+            mock_settings.has_openai_key = False
+            mock_settings.has_gemini_key = False
+            mock_settings.huggingface_model = "Qwen/Qwen2.5-7B-Instruct"
+            mock_settings.hf_token = None
+
+            from src.clients.factory import get_chat_client
+
+            # HF tokens don't trigger auto-detection, falls through to HuggingFace
+            client = get_chat_client(api_key="hf_user_provided_token")
+
+            assert "HuggingFace" in type(client).__name__
+
     def test_provider_is_case_insensitive(self) -> None:
         """Provider matching should be case-insensitive."""
         with patch("src.clients.factory.settings") as mock_settings: