feat: add OpenRouter support as alternative LLM provider

LLM_PROVIDER env var switches between anthropic and openrouter.
OpenRouter gives access to DeepSeek, GPT-4o, Gemini and other models.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

.env.example

@@ -2,8 +2,14 @@
 TELEGRAM_BOT_TOKEN=your-bot-token-here
 ALLOWED_USER_IDS=[123456789]
 
-# Anthropic API
+# LLM Provider: "anthropic" or "openrouter"
+LLM_PROVIDER=anthropic
+
+# Anthropic API (required if LLM_PROVIDER=anthropic)
 ANTHROPIC_API_KEY=sk-ant-xxx
 
+# OpenRouter API (required if LLM_PROVIDER=openrouter)
+OPENROUTER_API_KEY=sk-or-xxx
+
 # Debug mode
 DEBUG=false

src/agent.py

@@ -125,16 +125,46 @@ def __init__(
             ssh_manager: Manager for SSH connections.
             client: Optional AsyncAnthropic client for dependency injection.
         """
-        self._client = client or AsyncAnthropic(
-            api_key=settings.anthropic_api_key.get_secret_value()
-        )
+        self._client = client or self._create_client()
         self._tools = tool_registry
         self._state = state_manager
         self._security = security_guard
         self._ssh = ssh_manager
         self._max_iterations = settings.max_iterations
         self._system_prompt = self._build_system_prompt()
 
+    @staticmethod
+    def _create_client() -> AsyncAnthropic:
+        """Create LLM client based on configured provider.
+
+        Returns:
+            AsyncAnthropic client (direct or via OpenRouter).
+
+        Raises:
+            ValueError: If provider is unknown or API key is missing.
+        """
+        provider = settings.llm_provider.lower()
+
+        if provider == "openrouter":
+            api_key = settings.openrouter_api_key.get_secret_value()
+            if not api_key:
+                msg = "OPENROUTER_API_KEY is required when LLM_PROVIDER=openrouter"
+                raise ValueError(msg)
+            return AsyncAnthropic(
+                api_key=api_key,
+                base_url=settings.openrouter_base_url,
+            )
+
+        if provider == "anthropic":
+            api_key = settings.anthropic_api_key.get_secret_value()
+            if not api_key:
+                msg = "ANTHROPIC_API_KEY is required when LLM_PROVIDER=anthropic"
+                raise ValueError(msg)
+            return AsyncAnthropic(api_key=api_key)
+
+        msg = f"Unknown LLM_PROVIDER: {provider}. Use 'anthropic' or 'openrouter'."
+        raise ValueError(msg)
+
     def _build_system_prompt(self) -> str:
         """Build system prompt with SSH hosts information.
 

src/bot.py

@@ -29,13 +29,29 @@
 
 logger = logging.getLogger(__name__)
 
-# Available Claude models
-MODELS = {
+# Available models per provider
+ANTHROPIC_MODELS = {
     "sonnet": ("claude-sonnet-4-20250514", "Sonnet 4"),
     "opus": ("claude-opus-4-20250514", "Opus 4"),
     "haiku": ("claude-3-5-haiku-20241022", "Haiku 3.5"),
 }
 
+OPENROUTER_MODELS = {
+    "sonnet": ("anthropic/claude-sonnet-4-20250514", "Sonnet 4"),
+    "opus": ("anthropic/claude-opus-4-20250514", "Opus 4"),
+    "haiku": ("anthropic/claude-3.5-haiku", "Haiku 3.5"),
+    "deepseek": ("deepseek/deepseek-chat-v3-0324", "DeepSeek V3"),
+    "gpt4o": ("openai/gpt-4o", "GPT-4o"),
+    "gemini": ("google/gemini-2.5-flash-preview", "Gemini 2.5 Flash"),
+}
+
+
+def get_models() -> dict[str, tuple[str, str]]:
+    """Get available models based on configured provider."""
+    if settings.llm_provider.lower() == "openrouter":
+        return OPENROUTER_MODELS
+    return ANTHROPIC_MODELS
+
 
 class RateLimiter:
     """Simple in-memory rate limiter.
@@ -308,7 +324,7 @@ async def _handle_health(self, message: Message) -> None:
 
         # Get user's selected model from database
         model_key = await self._state.get_user_model(user_id)
-        model_id = MODELS.get(model_key, MODELS["sonnet"])[0]
+        model_id = get_models().get(model_key, get_models()["sonnet"])[0]
 
         # Use agent to check health via SSH
         result = await self._agent.run(
@@ -350,7 +366,7 @@ async def _handle_logs(self, message: Message) -> None:
 
         # Get user's selected model from database
         model_key = await self._state.get_user_model(user_id)
-        model_id = MODELS.get(model_key, MODELS["sonnet"])[0]
+        model_id = get_models().get(model_key, get_models()["sonnet"])[0]
 
         # Use agent to read logs via SSH
         result = await self._agent.run(
@@ -452,11 +468,11 @@ async def _handle_model(self, message: Message) -> None:
 
         user_id = message.from_user.id if message.from_user else 0
         current_key = await self._state.get_user_model(user_id)
-        current_name = MODELS.get(current_key, MODELS["sonnet"])[1]
+        current_name = get_models().get(current_key, get_models()["sonnet"])[1]
 
         # Build inline keyboard
         buttons = []
-        for key, (_model_id, name) in MODELS.items():
+        for key, (_model_id, name) in get_models().items():
             marker = " ✓" if key == current_key else ""
             buttons.append(
                 InlineKeyboardButton(
@@ -490,17 +506,17 @@ async def _handle_model_callback(self, callback: CallbackQuery) -> None:
         # Extract model key from callback data
         model_key = callback.data.split(":")[1] if callback.data else "sonnet"
 
-        if model_key not in MODELS:
+        if model_key not in get_models():
             await callback.answer("Неизвестная модель", show_alert=True)
             return
 
         # Save user preference to database
         await self._state.set_user_model(user_id, model_key)
-        model_name = MODELS[model_key][1]
+        model_name = get_models()[model_key][1]
 
         # Update keyboard with new selection
         buttons = []
-        for key, (_model_id, name) in MODELS.items():
+        for key, (_model_id, name) in get_models().items():
             marker = " ✓" if key == model_key else ""
             buttons.append(
                 InlineKeyboardButton(
@@ -542,7 +558,7 @@ async def _handle_message(self, message: Message) -> None:
 
         # Get user's selected model from database
         model_key = await self._state.get_user_model(user_id)
-        model_id = MODELS.get(model_key, MODELS["sonnet"])[0]
+        model_id = get_models().get(model_key, get_models()["sonnet"])[0]
 
         # Run agent
         result = await self._agent.run(user_id=user_id, query=text, model=model_id)

src/config.py

@@ -19,11 +19,22 @@ class Settings(BaseSettings):
     telegram_bot_token: SecretStr = Field(alias="TELEGRAM_BOT_TOKEN")
     allowed_user_ids: list[int] = Field(default_factory=list, alias="ALLOWED_USER_IDS")
 
+    # LLM Provider
+    llm_provider: str = Field(default="anthropic", alias="LLM_PROVIDER")
+
     # Anthropic
-    anthropic_api_key: SecretStr = Field(alias="ANTHROPIC_API_KEY")
+    anthropic_api_key: SecretStr = Field(
+        default=SecretStr(""), alias="ANTHROPIC_API_KEY"
+    )
     model: str = "claude-sonnet-4-20250514"
     max_tokens: int = 4096
 
+    # OpenRouter
+    openrouter_api_key: SecretStr = Field(
+        default=SecretStr(""), alias="OPENROUTER_API_KEY"
+    )
+    openrouter_base_url: str = "https://openrouter.ai/api/v1"
+
     # Paths
     base_dir: Path = Path(__file__).parent.parent
 

tests/conftest.py

@@ -5,3 +5,4 @@
 # Set test environment variables before any src imports
 os.environ.setdefault("TELEGRAM_BOT_TOKEN", "test-token-for-ci")
 os.environ.setdefault("ANTHROPIC_API_KEY", "sk-ant-test-key")
+os.environ.setdefault("LLM_PROVIDER", "anthropic")