refactor: replace litellm with native openai + anthropic SDKs

- Remove litellm dependency entirely (supply chain risk mitigation)
- Add AnthropicProvider (native SDK) and OpenAICompatProvider (unified)
- Merge CustomProvider into OpenAICompatProvider, delete custom_provider.py
- Add ProviderSpec.backend field for declarative provider routing
- Remove _resolve_model, find_gateway, find_by_model (dead heuristics)
- Pass resolved spec directly into provider — zero internal lookups
- Stub out litellm-dependent model database (cli/models.py)
- Add anthropic>=0.45.0 to dependencies, remove litellm
- 593 tests passed, net -1034 lines

tests/agent/test_gemini_thought_signature.py

@@ -1,40 +1,6 @@
 from types import SimpleNamespace
 
 from nanobot.providers.base import ToolCallRequest
-from nanobot.providers.litellm_provider import LiteLLMProvider
-
-
-def test_litellm_parse_response_preserves_tool_call_provider_fields() -> None:
-    provider = LiteLLMProvider(default_model="gemini/gemini-3-flash")
-
-    response = SimpleNamespace(
-        choices=[
-            SimpleNamespace(
-                finish_reason="tool_calls",
-                message=SimpleNamespace(
-                    content=None,
-                    tool_calls=[
-                        SimpleNamespace(
-                            id="call_123",
-                            function=SimpleNamespace(
-                                name="read_file",
-                                arguments='{"path":"todo.md"}',
-                                provider_specific_fields={"inner": "value"},
-                            ),
-                            provider_specific_fields={"thought_signature": "signed-token"},
-                        )
-                    ],
-                ),
-            )
-        ],
-        usage=None,
-    )
-
-    parsed = provider._parse_response(response)
-
-    assert len(parsed.tool_calls) == 1
-    assert parsed.tool_calls[0].provider_specific_fields == {"thought_signature": "signed-token"}
-    assert parsed.tool_calls[0].function_provider_specific_fields == {"inner": "value"}
 
 
 def test_tool_call_request_serializes_provider_fields() -> None:

tests/agent/test_memory_consolidation_types.py

@@ -380,7 +380,7 @@ class TestMemoryConsolidationTypeHandling:
         """Forced tool_choice rejected by provider -> retry with auto and succeed."""
         store = MemoryStore(tmp_path)
         error_resp = LLMResponse(
-            content="Error calling LLM: litellm.BadRequestError: "
+            content="Error calling LLM: BadRequestError: "
             "The tool_choice parameter does not support being set to required or object",
             finish_reason="error",
             tool_calls=[],

tests/cli/test_commands.py

@@ -9,9 +9,8 @@ from typer.testing import CliRunner
 from nanobot.bus.events import OutboundMessage
 from nanobot.cli.commands import _make_provider, app
 from nanobot.config.schema import Config
-from nanobot.providers.litellm_provider import LiteLLMProvider
 from nanobot.providers.openai_codex_provider import _strip_model_prefix
-from nanobot.providers.registry import find_by_model, find_by_name
+from nanobot.providers.registry import find_by_name
 
 runner = CliRunner()
 
@@ -228,7 +227,7 @@ def test_config_matches_explicit_ollama_prefix_without_api_key():
     config.agents.defaults.model = "ollama/llama3.2"
 
     assert config.get_provider_name() == "ollama"
-    assert config.get_api_base() == "http://localhost:11434"
+    assert config.get_api_base() == "http://localhost:11434/v1"
 
 
 def test_config_explicit_ollama_provider_uses_default_localhost_api_base():
@@ -237,7 +236,7 @@ def test_config_explicit_ollama_provider_uses_default_localhost_api_base():
     config.agents.defaults.model = "llama3.2"
 
     assert config.get_provider_name() == "ollama"
-    assert config.get_api_base() == "http://localhost:11434"
+    assert config.get_api_base() == "http://localhost:11434/v1"
 
 
 def test_config_accepts_camel_case_explicit_provider_name_for_coding_plan():
@@ -272,12 +271,12 @@ def test_config_auto_detects_ollama_from_local_api_base():
     config = Config.model_validate(
         {
             "agents": {"defaults": {"provider": "auto", "model": "llama3.2"}},
-            "providers": {"ollama": {"apiBase": "http://localhost:11434"}},
+            "providers": {"ollama": {"apiBase": "http://localhost:11434/v1"}},
         }
     )
 
     assert config.get_provider_name() == "ollama"
-    assert config.get_api_base() == "http://localhost:11434"
+    assert config.get_api_base() == "http://localhost:11434/v1"
 
 
 def test_config_prefers_ollama_over_vllm_when_both_local_providers_configured():
@@ -286,13 +285,13 @@ def test_config_prefers_ollama_over_vllm_when_both_local_providers_configured():
             "agents": {"defaults": {"provider": "auto", "model": "llama3.2"}},
             "providers": {
                 "vllm": {"apiBase": "http://localhost:8000"},
-                "ollama": {"apiBase": "http://localhost:11434"},
+                "ollama": {"apiBase": "http://localhost:11434/v1"},
             },
         }
     )
 
     assert config.get_provider_name() == "ollama"
-    assert config.get_api_base() == "http://localhost:11434"
+    assert config.get_api_base() == "http://localhost:11434/v1"
 
 
 def test_config_falls_back_to_vllm_when_ollama_not_configured():
@@ -309,19 +308,13 @@ def test_config_falls_back_to_vllm_when_ollama_not_configured():
     assert config.get_api_base() == "http://localhost:8000"
 
 
-def test_find_by_model_prefers_explicit_prefix_over_generic_codex_keyword():
-    spec = find_by_model("github-copilot/gpt-5.3-codex")
+def test_openai_compat_provider_passes_model_through():
+    from nanobot.providers.openai_compat_provider import OpenAICompatProvider
 
-    assert spec is not None
-    assert spec.name == "github_copilot"
+    with patch("nanobot.providers.openai_compat_provider.AsyncOpenAI"):
+        provider = OpenAICompatProvider(default_model="github-copilot/gpt-5.3-codex")
 
-
-def test_litellm_provider_canonicalizes_github_copilot_hyphen_prefix():
-    provider = LiteLLMProvider(default_model="github-copilot/gpt-5.3-codex")
-
-    resolved = provider._resolve_model("github-copilot/gpt-5.3-codex")
-
-    assert resolved == "github_copilot/gpt-5.3-codex"
+    assert provider.get_default_model() == "github-copilot/gpt-5.3-codex"
 
 
 def test_openai_codex_strip_prefix_supports_hyphen_and_underscore():
@@ -346,7 +339,7 @@ def test_make_provider_passes_extra_headers_to_custom_provider():
         }
     )
 
-    with patch("nanobot.providers.custom_provider.AsyncOpenAI") as mock_async_openai:
+    with patch("nanobot.providers.openai_compat_provider.AsyncOpenAI") as mock_async_openai:
         _make_provider(config)
 
     kwargs = mock_async_openai.call_args.kwargs

tests/providers/test_custom_provider.py

@@ -1,10 +1,14 @@
-from types import SimpleNamespace
+"""Tests for OpenAICompatProvider handling custom/direct endpoints."""
 
-from nanobot.providers.custom_provider import CustomProvider
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from nanobot.providers.openai_compat_provider import OpenAICompatProvider
 
 
 def test_custom_provider_parse_handles_empty_choices() -> None:
-    provider = CustomProvider()
+    with patch("nanobot.providers.openai_compat_provider.AsyncOpenAI"):
+        provider = OpenAICompatProvider()
     response = SimpleNamespace(choices=[])
 
     result = provider._parse(response)

tests/providers/test_litellm_kwargs.py

@@ -1,161 +1,122 @@
-"""Regression tests for PR #2026 — litellm_kwargs injection from ProviderSpec.
+"""Tests for OpenAICompatProvider spec-driven behavior.
 
 Validates that:
-- OpenRouter uses litellm_prefix (NOT custom_llm_provider) to avoid LiteLLM double-prefixing.
-- The litellm_kwargs mechanism works correctly for providers that declare it.
-- Non-gateway providers are unaffected.
+- OpenRouter (no strip) keeps model names intact.
+- AiHubMix (strip_model_prefix=True) strips provider prefixes.
+- Standard providers pass model names through as-is.
 """
 
 from __future__ import annotations
 
 from types import SimpleNamespace
-from typing import Any
 from unittest.mock import AsyncMock, patch
 
 import pytest
 
-from nanobot.providers.litellm_provider import LiteLLMProvider
+from nanobot.providers.openai_compat_provider import OpenAICompatProvider
 from nanobot.providers.registry import find_by_name
 
 
-def _fake_response(content: str = "ok") -> SimpleNamespace:
-    """Build a minimal acompletion-shaped response object."""
+def _fake_chat_response(content: str = "ok") -> SimpleNamespace:
+    """Build a minimal OpenAI chat completion response."""
     message = SimpleNamespace(
         content=content,
         tool_calls=None,
         reasoning_content=None,
-        thinking_blocks=None,
     )
     choice = SimpleNamespace(message=message, finish_reason="stop")
     usage = SimpleNamespace(prompt_tokens=10, completion_tokens=5, total_tokens=15)
     return SimpleNamespace(choices=[choice], usage=usage)
 
 
-def test_openrouter_spec_uses_prefix_not_custom_llm_provider() -> None:
-    """OpenRouter must rely on litellm_prefix, not custom_llm_provider kwarg.
-
-    LiteLLM internally adds a provider/ prefix when custom_llm_provider is set,
-    which double-prefixes models (openrouter/anthropic/model) and breaks the API.
-    """
+def test_openrouter_spec_is_gateway() -> None:
     spec = find_by_name("openrouter")
     assert spec is not None
-    assert spec.litellm_prefix == "openrouter"
-    assert "custom_llm_provider" not in spec.litellm_kwargs, (
-        "custom_llm_provider causes LiteLLM to double-prefix the model name"
-    )
+    assert spec.is_gateway is True
+    assert spec.default_api_base == "https://openrouter.ai/api/v1"
 
 
 @pytest.mark.asyncio
-async def test_openrouter_prefixes_model_correctly() -> None:
-    """OpenRouter should prefix model as openrouter/vendor/model for LiteLLM routing."""
-    mock_acompletion = AsyncMock(return_value=_fake_response())
+async def test_openrouter_keeps_model_name_intact() -> None:
+    """OpenRouter gateway keeps the full model name (gateway does its own routing)."""
+    mock_create = AsyncMock(return_value=_fake_chat_response())
+    spec = find_by_name("openrouter")
 
-    with patch("nanobot.providers.litellm_provider.acompletion", mock_acompletion):
-        provider = LiteLLMProvider(
+    with patch("nanobot.providers.openai_compat_provider.AsyncOpenAI") as MockClient:
+        client_instance = MockClient.return_value
+        client_instance.chat.completions.create = mock_create
+
+        provider = OpenAICompatProvider(
             api_key="sk-or-test-key",
             api_base="https://openrouter.ai/api/v1",
             default_model="anthropic/claude-sonnet-4-5",
-            provider_name="openrouter",
+            spec=spec,
         )
         await provider.chat(
             messages=[{"role": "user", "content": "hello"}],
             model="anthropic/claude-sonnet-4-5",
         )
 
-    call_kwargs = mock_acompletion.call_args.kwargs
-    assert call_kwargs["model"] == "openrouter/anthropic/claude-sonnet-4-5", (
-        "LiteLLM needs openrouter/ prefix to detect the provider and strip it before API call"
-    )
-    assert "custom_llm_provider" not in call_kwargs
+    call_kwargs = mock_create.call_args.kwargs
+    assert call_kwargs["model"] == "anthropic/claude-sonnet-4-5"
 
 
 @pytest.mark.asyncio
-async def test_non_gateway_provider_no_extra_kwargs() -> None:
-    """Standard (non-gateway) providers must NOT inject any litellm_kwargs."""
-    mock_acompletion = AsyncMock(return_value=_fake_response())
+async def test_aihubmix_strips_model_prefix() -> None:
+    """AiHubMix strips the provider prefix (strip_model_prefix=True)."""
+    mock_create = AsyncMock(return_value=_fake_chat_response())
+    spec = find_by_name("aihubmix")
 
-    with patch("nanobot.providers.litellm_provider.acompletion", mock_acompletion):
-        provider = LiteLLMProvider(
-            api_key="sk-ant-test-key",
-            default_model="claude-sonnet-4-5",
-        )
-        await provider.chat(
-            messages=[{"role": "user", "content": "hello"}],
-            model="claude-sonnet-4-5",
-        )
+    with patch("nanobot.providers.openai_compat_provider.AsyncOpenAI") as MockClient:
+        client_instance = MockClient.return_value
+        client_instance.chat.completions.create = mock_create
 
-    call_kwargs = mock_acompletion.call_args.kwargs
-    assert "custom_llm_provider" not in call_kwargs, (
-        "Standard Anthropic provider should NOT inject custom_llm_provider"
-    )
-
-
-@pytest.mark.asyncio
-async def test_gateway_without_litellm_kwargs_injects_nothing_extra() -> None:
-    """Gateways without litellm_kwargs (e.g. AiHubMix) must not add extra keys."""
-    mock_acompletion = AsyncMock(return_value=_fake_response())
-
-    with patch("nanobot.providers.litellm_provider.acompletion", mock_acompletion):
-        provider = LiteLLMProvider(
+        provider = OpenAICompatProvider(
             api_key="sk-aihub-test-key",
             api_base="https://aihubmix.com/v1",
             default_model="claude-sonnet-4-5",
-            provider_name="aihubmix",
-        )
-        await provider.chat(
-            messages=[{"role": "user", "content": "hello"}],
-            model="claude-sonnet-4-5",
-        )
-
-    call_kwargs = mock_acompletion.call_args.kwargs
-    assert "custom_llm_provider" not in call_kwargs
-
-
-@pytest.mark.asyncio
-async def test_openrouter_autodetect_by_key_prefix() -> None:
-    """OpenRouter should be auto-detected by sk-or- key prefix even without explicit provider_name."""
-    mock_acompletion = AsyncMock(return_value=_fake_response())
-
-    with patch("nanobot.providers.litellm_provider.acompletion", mock_acompletion):
-        provider = LiteLLMProvider(
-            api_key="sk-or-auto-detect-key",
-            default_model="anthropic/claude-sonnet-4-5",
+            spec=spec,
         )
         await provider.chat(
             messages=[{"role": "user", "content": "hello"}],
             model="anthropic/claude-sonnet-4-5",
         )
 
-    call_kwargs = mock_acompletion.call_args.kwargs
-    assert call_kwargs["model"] == "openrouter/anthropic/claude-sonnet-4-5", (
-        "Auto-detected OpenRouter should prefix model for LiteLLM routing"
-    )
+    call_kwargs = mock_create.call_args.kwargs
+    assert call_kwargs["model"] == "claude-sonnet-4-5"
 
 
 @pytest.mark.asyncio
-async def test_openrouter_native_model_id_gets_double_prefixed() -> None:
-    """Models like openrouter/free must be double-prefixed so LiteLLM strips one layer.
+async def test_standard_provider_passes_model_through() -> None:
+    """Standard provider (e.g. deepseek) passes model name through as-is."""
+    mock_create = AsyncMock(return_value=_fake_chat_response())
+    spec = find_by_name("deepseek")
 
-    openrouter/free is an actual OpenRouter model ID.  LiteLLM strips the first
-    openrouter/ for routing, so we must send openrouter/openrouter/free to ensure
-    the API receives openrouter/free.
-    """
-    mock_acompletion = AsyncMock(return_value=_fake_response())
+    with patch("nanobot.providers.openai_compat_provider.AsyncOpenAI") as MockClient:
+        client_instance = MockClient.return_value
+        client_instance.chat.completions.create = mock_create
 
-    with patch("nanobot.providers.litellm_provider.acompletion", mock_acompletion):
-        provider = LiteLLMProvider(
-            api_key="sk-or-test-key",
-            api_base="https://openrouter.ai/api/v1",
-            default_model="openrouter/free",
-            provider_name="openrouter",
+        provider = OpenAICompatProvider(
+            api_key="sk-deepseek-test-key",
+            default_model="deepseek-chat",
+            spec=spec,
         )
         await provider.chat(
             messages=[{"role": "user", "content": "hello"}],
-            model="openrouter/free",
+            model="deepseek-chat",
         )
 
-    call_kwargs = mock_acompletion.call_args.kwargs
-    assert call_kwargs["model"] == "openrouter/openrouter/free", (
-        "openrouter/free must become openrouter/openrouter/free — "
-        "LiteLLM strips one layer so the API receives openrouter/free"
-    )
+    call_kwargs = mock_create.call_args.kwargs
+    assert call_kwargs["model"] == "deepseek-chat"
+
+
+def test_openai_model_passthrough() -> None:
+    """OpenAI models pass through unchanged."""
+    spec = find_by_name("openai")
+    with patch("nanobot.providers.openai_compat_provider.AsyncOpenAI"):
+        provider = OpenAICompatProvider(
+            api_key="sk-test-key",
+            default_model="gpt-4o",
+            spec=spec,
+        )
+    assert provider.get_default_model() == "gpt-4o"

tests/providers/test_mistral_provider.py

@@ -17,6 +17,4 @@ def test_mistral_provider_in_registry():
 
     mistral = specs["mistral"]
     assert mistral.env_key == "MISTRAL_API_KEY"
-    assert mistral.litellm_prefix == "mistral"
     assert mistral.default_api_base == "https://api.mistral.ai/v1"
-    assert "mistral/" in mistral.skip_prefixes

tests/providers/test_providers_init.py

@@ -8,19 +8,22 @@ import sys
 
 def test_importing_providers_package_is_lazy(monkeypatch) -> None:
     monkeypatch.delitem(sys.modules, "nanobot.providers", raising=False)
-    monkeypatch.delitem(sys.modules, "nanobot.providers.litellm_provider", raising=False)
+    monkeypatch.delitem(sys.modules, "nanobot.providers.anthropic_provider", raising=False)
+    monkeypatch.delitem(sys.modules, "nanobot.providers.openai_compat_provider", raising=False)
     monkeypatch.delitem(sys.modules, "nanobot.providers.openai_codex_provider", raising=False)
     monkeypatch.delitem(sys.modules, "nanobot.providers.azure_openai_provider", raising=False)
 
     providers = importlib.import_module("nanobot.providers")
 
-    assert "nanobot.providers.litellm_provider" not in sys.modules
+    assert "nanobot.providers.anthropic_provider" not in sys.modules
+    assert "nanobot.providers.openai_compat_provider" not in sys.modules
     assert "nanobot.providers.openai_codex_provider" not in sys.modules
     assert "nanobot.providers.azure_openai_provider" not in sys.modules
     assert providers.__all__ == [
         "LLMProvider",
         "LLMResponse",
-        "LiteLLMProvider",
+        "AnthropicProvider",
+        "OpenAICompatProvider",
         "OpenAICodexProvider",
         "AzureOpenAIProvider",
     ]
@@ -28,10 +31,10 @@ def test_importing_providers_package_is_lazy(monkeypatch) -> None:
 
 def test_explicit_provider_import_still_works(monkeypatch) -> None:
     monkeypatch.delitem(sys.modules, "nanobot.providers", raising=False)
-    monkeypatch.delitem(sys.modules, "nanobot.providers.litellm_provider", raising=False)
+    monkeypatch.delitem(sys.modules, "nanobot.providers.anthropic_provider", raising=False)
 
     namespace: dict[str, object] = {}
-    exec("from nanobot.providers import LiteLLMProvider", namespace)
+    exec("from nanobot.providers import AnthropicProvider", namespace)
 
-    assert namespace["LiteLLMProvider"].__name__ == "LiteLLMProvider"
-    assert "nanobot.providers.litellm_provider" in sys.modules
+    assert namespace["AnthropicProvider"].__name__ == "AnthropicProvider"
+    assert "nanobot.providers.anthropic_provider" in sys.modules