Add Cerebras and Silicon Flow provider support

- Cerebras: qwen/qwen-3-235b-a22b-instruct-2507 (Qwen 3 235B)
- Silicon Flow: Qwen3.6-35B/27B, Qwen3.5-35B/27B (VLM multimodal),
Gemma-4-26B/31B reasoning models
- Both use OpenAI-compatible /chat/completions via OpenAIChatTransport
- API keys: CEREBRAS_API_KEY, SILICON_API_KEY

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

api/services.py

@@ -38,7 +38,7 @@ TokenCounter = Callable[[list[Any], str | list[Any] | None, list[Any] | None], i
 ProviderGetter = Callable[[str], BaseProvider]
 
 # Providers that use ``/chat/completions`` + Anthropic-to-OpenAI conversion (not native Messages).
-_OPENAI_CHAT_UPSTREAM_IDS = frozenset({"nvidia_nim", "groq", "cerebras"})
+_OPENAI_CHAT_UPSTREAM_IDS = frozenset({"nvidia_nim", "groq", "cerebras", "silicon"})
 
 
 def anthropic_sse_streaming_response(

config/provider_catalog.py

@@ -14,6 +14,8 @@ TransportType = Literal["openai_chat", "anthropic_messages"]
 # Default upstream base URLs (also re-exported via :mod:`providers.defaults`)
 NVIDIA_NIM_DEFAULT_BASE = "https://integrate.api.nvidia.com/v1"
 ZEN_DEFAULT_BASE = "https://opencode.ai/zen"
+CEREBRAS_DEFAULT_BASE = "https://api.cerebras.ai/v1"
+SILICON_DEFAULT_BASE = "https://api.siliconflow.cn/v1"
 
 
 @dataclass(frozen=True, slots=True)
@@ -53,10 +55,28 @@ PROVIDER_CATALOG: dict[str, ProviderDescriptor] = {
         base_url_attr="zen_base_url",
         capabilities=("chat", "streaming", "tools", "thinking"),
     ),
+    "cerebras": ProviderDescriptor(
+        provider_id="cerebras",
+        transport_type="openai_chat",
+        credential_env="CEREBRAS_API_KEY",
+        credential_url="https://cerebras.ai/labs",
+        credential_attr="cerebras_api_key",
+        default_base_url=CEREBRAS_DEFAULT_BASE,
+        capabilities=("chat", "streaming", "tools", "thinking"),
+    ),
+    "silicon": ProviderDescriptor(
+        provider_id="silicon",
+        transport_type="openai_chat",
+        credential_env="SILICON_API_KEY",
+        credential_url="https://siliconflow.cn",
+        credential_attr="silicon_api_key",
+        default_base_url=SILICON_DEFAULT_BASE,
+        capabilities=("chat", "streaming", "tools", "thinking"),
+    ),
 }
 
 # Order matches docs; must match PROVIDER_CATALOG keys.
-SUPPORTED_PROVIDER_IDS: tuple[str, ...] = ("nvidia_nim", "zen")
+SUPPORTED_PROVIDER_IDS: tuple[str, ...] = ("nvidia_nim", "zen", "cerebras", "silicon")
 
 if len(set(SUPPORTED_PROVIDER_IDS)) != len(SUPPORTED_PROVIDER_IDS):
     raise AssertionError("Duplicate provider ids in PROVIDER_CATALOG key order")

config/settings.py

@@ -145,6 +145,10 @@ class Settings(BaseSettings):
     session_retention_minutes: int = Field(
         default=30, validation_alias="SESSION_RETENTION_MINUTES"
     )
+    # ==================== Cerebras Config ====================
+    cerebras_api_key: str = Field(default="", validation_alias="CEREBRAS_API_KEY")
+    # ==================== Silicon Flow Config ====================
+    silicon_api_key: str = Field(default="", validation_alias="SILICON_API_KEY")
     zen_base_url: str = Field(
         default="https://opencode.ai/zen", validation_alias="ZEN_BASE_URL"
     )
@@ -535,6 +539,10 @@ class Settings(BaseSettings):
             )
         if provider_id == "zen":
             return bool(self.zen_api_key.strip())
+        if provider_id == "cerebras":
+            return bool(self.cerebras_api_key.strip())
+        if provider_id == "silicon":
+            return bool(self.silicon_api_key.strip())
         # conservative default: assume not configured
         return False
 

core/model_capabilities.py

@@ -131,6 +131,101 @@ MODEL_CAPABILITIES: dict[str, ModelCapabilities] = {
         speed="medium",
         priority=60,
     ),
+    # Cerebras models
+    "cerebras/qwen/qwen-3-235b-a22b-instruct-2507": ModelCapabilities(
+        provider_id="cerebras",
+        model_id="qwen/qwen-3-235b-a22b-instruct-2507",
+        model_ref="cerebras/qwen/qwen-3-235b-a22b-instruct-2507",
+        coding=True,
+        reasoning=True,
+        general_text=True,
+        max_tokens=32000,
+        speed="slow",
+        priority=85,
+    ),
+    # Silicon Flow models
+    "silicon/Qwen/Qwen3.6-35B-A3B": ModelCapabilities(
+        provider_id="silicon",
+        model_id="Qwen/Qwen3.6-35B-A3B",
+        model_ref="silicon/Qwen/Qwen3.6-35B-A3B",
+        vision=True,
+        supports_base64_images=True,
+        max_images=1,
+        multimodal_input=True,
+        coding=True,
+        reasoning=True,
+        general_text=True,
+        max_tokens=262144,
+        speed="medium",
+        priority=85,
+    ),
+    "silicon/Qwen/Qwen3.6-27B": ModelCapabilities(
+        provider_id="silicon",
+        model_id="Qwen/Qwen3.6-27B",
+        model_ref="silicon/Qwen/Qwen3.6-27B",
+        vision=True,
+        supports_base64_images=True,
+        max_images=1,
+        multimodal_input=True,
+        coding=True,
+        reasoning=True,
+        general_text=True,
+        max_tokens=262144,
+        speed="medium",
+        priority=82,
+    ),
+    "silicon/Qwen/Qwen3.5-35B-A3B": ModelCapabilities(
+        provider_id="silicon",
+        model_id="Qwen/Qwen3.5-35B-A3B",
+        model_ref="silicon/Qwen/Qwen3.5-35B-A3B",
+        vision=True,
+        supports_base64_images=True,
+        max_images=1,
+        multimodal_input=True,
+        coding=True,
+        reasoning=True,
+        general_text=True,
+        max_tokens=262144,
+        speed="medium",
+        priority=80,
+    ),
+    "silicon/Qwen/Qwen3.5-27B": ModelCapabilities(
+        provider_id="silicon",
+        model_id="Qwen/Qwen3.5-27B",
+        model_ref="silicon/Qwen/Qwen3.5-27B",
+        vision=True,
+        supports_base64_images=True,
+        max_images=1,
+        multimodal_input=True,
+        coding=True,
+        reasoning=True,
+        general_text=True,
+        max_tokens=262144,
+        speed="medium",
+        priority=78,
+    ),
+    "silicon/google/gemma-4-26B-A4B-it": ModelCapabilities(
+        provider_id="silicon",
+        model_id="google/gemma-4-26B-A4B-it",
+        model_ref="silicon/google/gemma-4-26B-A4B-it",
+        coding=True,
+        reasoning=True,
+        general_text=True,
+        max_tokens=262144,
+        speed="fast",
+        priority=75,
+    ),
+    "silicon/google/gemma-4-31B-it": ModelCapabilities(
+        provider_id="silicon",
+        model_id="google/gemma-4-31B-it",
+        model_ref="silicon/google/gemma-4-31B-it",
+        coding=True,
+        reasoning=True,
+        general_text=True,
+        max_tokens=262144,
+        speed="fast",
+        priority=76,
+    ),
 }
 
 

providers/cerebras/__init__.py

@@ -0,0 +1,5 @@
+"""Cerebras provider (OpenAI-compatible /chat/completions)."""
+
+from .client import CerebrasProvider
+
+__all__ = ["CerebrasProvider"]

providers/cerebras/client.py

@@ -0,0 +1,36 @@
+"""Cerebras provider using OpenAI-compatible API."""
+
+from typing import Any
+
+from config.settings import Settings
+from core.anthropic import ReasoningReplayMode, build_base_request_body
+from providers.base import ProviderConfig
+from providers.defaults import CEREBRAS_DEFAULT_BASE
+from providers.openai_compat import OpenAIChatTransport
+
+
+class CerebrasProvider(OpenAIChatTransport):
+    """Cerebras provider using OpenAI-compatible /chat/completions."""
+
+    def __init__(self, config: ProviderConfig, *, settings: Settings):
+        base_url = (config.base_url or CEREBRAS_DEFAULT_BASE).rstrip("/")
+        if not base_url.endswith("/v1"):
+            base_url = base_url + "/v1"
+        super().__init__(
+            config,
+            provider_name="Cerebras",
+            base_url=base_url,
+            api_key=config.api_key,
+        )
+        self._settings = settings
+
+    def _build_request_body(
+        self, request: Any, thinking_enabled: bool | None = None
+    ) -> dict:
+        thinking = self._is_thinking_enabled(request, thinking_enabled)
+        reasoning_replay = (
+            ReasoningReplayMode.REASONING_CONTENT
+            if thinking
+            else ReasoningReplayMode.DISABLED
+        )
+        return build_base_request_body(request, reasoning_replay=reasoning_replay)

providers/defaults.py

@@ -1,11 +1,15 @@
 """Re-exports default upstream base URLs from the config provider catalog."""
 
 from config.provider_catalog import (
+    CEREBRAS_DEFAULT_BASE,
     NVIDIA_NIM_DEFAULT_BASE,
+    SILICON_DEFAULT_BASE,
     ZEN_DEFAULT_BASE,
 )
 
 __all__ = (
+    "CEREBRAS_DEFAULT_BASE",
     "NVIDIA_NIM_DEFAULT_BASE",
+    "SILICON_DEFAULT_BASE",
     "ZEN_DEFAULT_BASE",
 )

providers/registry.py

@@ -44,9 +44,23 @@ def _create_zen(config: ProviderConfig, settings: Settings) -> BaseProvider:
     return ZenProvider(config, settings=settings)
 
 
+def _create_cerebras(config: ProviderConfig, settings: Settings) -> BaseProvider:
+    from providers.cerebras import CerebrasProvider
+
+    return CerebrasProvider(config, settings=settings)
+
+
+def _create_silicon(config: ProviderConfig, settings: Settings) -> BaseProvider:
+    from providers.silicon import SiliconProvider
+
+    return SiliconProvider(config, settings=settings)
+
+
 PROVIDER_FACTORIES: dict[str, ProviderFactory] = {
     "nvidia_nim": _create_nvidia_nim,
     "zen": _create_zen,
+    "cerebras": _create_cerebras,
+    "silicon": _create_silicon,
 }
 
 if set(PROVIDER_DESCRIPTORS) != set(SUPPORTED_PROVIDER_IDS) or set(

providers/silicon/__init__.py

@@ -0,0 +1,5 @@
+"""Silicon Flow provider (OpenAI-compatible /chat/completions)."""
+
+from .client import SiliconProvider
+
+__all__ = ["SiliconProvider"]

providers/silicon/client.py

@@ -0,0 +1,36 @@
+"""Silicon Flow provider using OpenAI-compatible API."""
+
+from typing import Any
+
+from config.settings import Settings
+from core.anthropic import ReasoningReplayMode, build_base_request_body
+from providers.base import ProviderConfig
+from providers.defaults import SILICON_DEFAULT_BASE
+from providers.openai_compat import OpenAIChatTransport
+
+
+class SiliconProvider(OpenAIChatTransport):
+    """Silicon Flow provider using OpenAI-compatible /chat/completions."""
+
+    def __init__(self, config: ProviderConfig, *, settings: Settings):
+        base_url = (config.base_url or SILICON_DEFAULT_BASE).rstrip("/")
+        if not base_url.endswith("/v1"):
+            base_url = base_url + "/v1"
+        super().__init__(
+            config,
+            provider_name="Silicon",
+            base_url=base_url,
+            api_key=config.api_key,
+        )
+        self._settings = settings
+
+    def _build_request_body(
+        self, request: Any, thinking_enabled: bool | None = None
+    ) -> dict:
+        thinking = self._is_thinking_enabled(request, thinking_enabled)
+        reasoning_replay = (
+            ReasoningReplayMode.REASONING_CONTENT
+            if thinking
+            else ReasoningReplayMode.DISABLED
+        )
+        return build_base_request_body(request, reasoning_replay=reasoning_replay)