✨ feat: implement SiliconFlow integration for v0.2

- Add SiliconFlow model provider with regional endpoint support
- Create modular model architecture (qwen, siliconflow modules)
- Implement ChatOpenAI workaround for function calling limitations
- Add comprehensive E2E test suite for SiliconFlow models
- Update tests to use context parameter and shared TEST_MODEL constant
- Add regional endpoint support with cn/prc and en/international aliases
- Include region normalization utilities for consistent handling
- Update all imports and dependencies for modular structure

SiliconFlow integration uses OpenAI-compatible API with proper regional
routing to avoid API quota issues in testing while maintaining full
compatibility with the ReAct agent pattern.

Author: webup

.env.example

@@ -8,6 +8,9 @@ OPENAI_API_KEY=sk-...
 # DashScope (Qwen models)
 DASHSCOPE_API_KEY=sk-...
 
+# SiliconFlow
+SILICONFLOW_API_KEY=sk-...
+
 # LangSmith (tracing)
 LANGCHAIN_TRACING_V2=true
 LANGCHAIN_PROJECT=langgraph-up-react

src/common/__init__.py

@@ -2,14 +2,14 @@
 
 from . import prompts
 from .context import Context
-from .models import create_qwen_model, get_supported_qwen_models
+from .models import create_qwen_model, create_siliconflow_model
 from .tools import web_search
 from .utils import load_chat_model
 
 __all__ = [
     "Context",
     "create_qwen_model",
-    "get_supported_qwen_models",
+    "create_siliconflow_model",
     "web_search",
     "load_chat_model",
     "prompts",

src/common/models/__init__.py

@@ -0,0 +1,9 @@
+"""Model integrations for the ReAct agent."""
+
+from .qwen import create_qwen_model
+from .siliconflow import create_siliconflow_model
+
+__all__ = [
+    "create_qwen_model",
+    "create_siliconflow_model",
+]

src/common/models.py renamed to src/common/models/qwen.py

@@ -1,10 +1,12 @@
-"""Custom model integrations for ReAct agent."""
+"""Qwen model integrations for ReAct agent."""
 
 import os
-from typing import Any, List, Optional, Union
+from typing import Any, Optional, Union
 
 from langchain_qwq import ChatQwen, ChatQwQ
 
+from ..utils import normalize_region
+
 
 def create_qwen_model(
     model_name: str,
@@ -19,7 +21,7 @@ def create_qwen_model(
         model_name: The model name (e.g., 'qwq-32b-preview', 'qwen-plus')
         api_key: DashScope API key (defaults to env var DASHSCOPE_API_KEY)
         base_url: Custom base URL for API (optional)
-        region: Region setting ('prc' for China, 'international' for global)
+        region: Region setting ('prc'/'cn' for China, 'international'/'en' for global)
                 Defaults to env var REGION
         **kwargs: Additional model parameters
 
@@ -36,10 +38,12 @@ def create_qwen_model(
 
     # Set base URL based on region if not explicitly provided
     if base_url is None and region:
-        if region.lower() == "prc":
+        # Normalize region aliases
+        normalized_region = normalize_region(region)
+        if normalized_region == "prc":
             # China mainland endpoint
             base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
-        elif region.lower() == "international":
+        elif normalized_region == "international":
             # International endpoint
             base_url = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
 
@@ -55,15 +59,3 @@ def create_qwen_model(
         return ChatQwQ(**config)
     else:
         return ChatQwen(**config)
-
-
-def get_supported_qwen_models() -> List[str]:
-    """Get list of supported Qwen models."""
-    return [
-        "qwen-plus",
-        "qwen-turbo",
-        "qwen-max",
-        "qwq-32b-preview",
-        "qvq-72b-preview",
-        # Add more Qwen models as they become available
-    ]

src/common/models/siliconflow.py

@@ -0,0 +1,67 @@
+"""SiliconFlow model integrations for ReAct agent."""
+
+import os
+from typing import Any, Optional
+
+# NOTE: Using ChatOpenAI instead of ChatSiliconFlow because langchain-siliconflow v0.1.1
+# does not support function calling (bind_tools raises NotImplementedError).
+# We'll switch back to ChatSiliconFlow once they add function calling support.
+from langchain_openai import ChatOpenAI
+
+from ..utils import normalize_region
+
+
+def create_siliconflow_model(
+    model_name: str,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    region: Optional[str] = None,
+    **kwargs: Any,
+) -> ChatOpenAI:
+    """Create a SiliconFlow model using ChatOpenAI (OpenAI-compatible API).
+
+    NOTE: Using ChatOpenAI instead of ChatSiliconFlow because langchain-siliconflow v0.1.1
+    does not support function calling (bind_tools raises NotImplementedError).
+    SiliconFlow provides OpenAI-compatible API endpoints, so we use ChatOpenAI directly.
+
+    Args:
+        model_name: The model name (e.g., 'Qwen/Qwen3-8B', 'THUDM/GLM-4.1V-9B-Thinking')
+        api_key: SiliconFlow API key (defaults to env var SILICONFLOW_API_KEY)
+        base_url: Custom base URL for API (optional)
+        region: Region setting ('prc'/'cn' for China, 'international'/'en' for global)
+                Defaults to env var REGION
+        **kwargs: Additional model parameters
+
+    Returns:
+        Configured ChatOpenAI instance pointing to SiliconFlow API
+    """
+    # Get API key from env if not provided
+    if api_key is None:
+        api_key = os.getenv("SILICONFLOW_API_KEY")
+
+    # Get region from env if not provided
+    if region is None:
+        region = os.getenv("REGION")
+
+    # Set base URL based on region if not explicitly provided
+    if base_url is None and region:
+        # Normalize region aliases
+        normalized_region = normalize_region(region)
+        if normalized_region == "prc":
+            base_url = "https://api.siliconflow.cn/v1"
+        elif normalized_region == "international":
+            base_url = "https://api.siliconflow.com/v1"
+
+    # Default to PRC endpoint if no region specified
+    if base_url is None:
+        base_url = "https://api.siliconflow.cn/v1"
+
+    # Create ChatOpenAI configuration for SiliconFlow
+    config = {
+        "model": model_name,
+        "api_key": api_key,
+        "base_url": base_url,
+        **kwargs
+    }
+
+    return ChatOpenAI(**config)

src/common/utils.py

@@ -1,13 +1,31 @@
 """Utility & helper functions."""
 
-from typing import Union
+from typing import Optional, Union
 
 from langchain.chat_models import init_chat_model
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import BaseMessage
 from langchain_qwq import ChatQwen, ChatQwQ
 
-from .models import create_qwen_model
+
+def normalize_region(region: str) -> Optional[str]:
+    """Normalize region aliases to standard values.
+    
+    Args:
+        region: Region string to normalize
+        
+    Returns:
+        Normalized region ('prc' or 'international') or None if invalid
+    """
+    if not region:
+        return None
+
+    region_lower = region.lower()
+    if region_lower in ("prc", "cn"):
+        return "prc"
+    elif region_lower in ("international", "en"):
+        return "international"
+    return None
 
 
 def get_message_text(msg: BaseMessage) -> str:
@@ -31,10 +49,17 @@ def load_chat_model(
         fully_specified_name (str): String in the format 'provider:model'.
     """
     provider, model = fully_specified_name.split(":", maxsplit=1)
+    provider_lower = provider.lower()
 
     # Handle Qwen models specially with dashscope integration
-    if provider.lower() == "qwen":
+    if provider_lower == "qwen":
+        from .models import create_qwen_model
         return create_qwen_model(model)
 
+    # Handle SiliconFlow models
+    if provider_lower == "siliconflow":
+        from .models import create_siliconflow_model
+        return create_siliconflow_model(model)
+
     # Use standard langchain initialization for other providers
     return init_chat_model(model, model_provider=provider)

tests/conftest.py

@@ -8,6 +8,9 @@
 from langchain_core.messages import HumanMessage
 from langgraph_sdk import get_client
 
+# Default test model - use SiliconFlow to avoid API quota issues
+TEST_MODEL = "siliconflow:Qwen/Qwen3-8B"
+
 
 @pytest.fixture(scope="session", autouse=True)
 def load_env():
@@ -21,7 +24,7 @@ def load_env():
 
     # Ensure required environment variables are available for tests
     # You can add fallback values or skip tests if keys are missing
-    required_keys = ["DASHSCOPE_API_KEY", "TAVILY_API_KEY"]
+    required_keys = ["DASHSCOPE_API_KEY", "TAVILY_API_KEY", "SILICONFLOW_API_KEY"]
     missing_keys = [key for key in required_keys if not os.getenv(key)]
 
     if missing_keys:
@@ -36,11 +39,22 @@ async def langgraph_client():
 
 @pytest.fixture
 async def assistant_id(langgraph_client):
-    """Get the first available assistant ID for testing."""
-    assistants = await langgraph_client.assistants.search()
-    if not assistants:
-        pytest.skip("No assistants found for e2e testing")
-    return assistants[0]["assistant_id"]
+    """Create an assistant with SiliconFlow Qwen3-8B model for testing."""
+    assistant = await langgraph_client.assistants.create(
+        graph_id="agent",
+        context={
+            "model": TEST_MODEL,
+        },
+    )
+    assistant_id = assistant["assistant_id"]
+    
+    yield assistant_id
+    
+    # Cleanup
+    try:
+        await langgraph_client.assistants.delete(assistant_id)
+    except Exception:
+        pass  # Ignore cleanup errors
 
 
 class TestHelpers:

tests/e2e_tests/test_deepwiki.py

@@ -2,35 +2,33 @@
 
 import pytest
 
+from ..conftest import TEST_MODEL
+
 
 @pytest.fixture
 async def assistant_deepwiki_disabled(langgraph_client):
     """Create an assistant with deepwiki explicitly disabled."""
-    config = {
-        "configurable": {
-            "enable_deepwiki": False,
-            "system_prompt": "You are a helpful AI assistant.",
-        }
-    }
     assistant = await langgraph_client.assistants.create(
         graph_id="agent",
-        config=config,
+        context={
+            "model": TEST_MODEL,
+            "enable_deepwiki": False,
+            "system_prompt": "You are a helpful AI assistant.",
+        },
     )
     return assistant["assistant_id"]
 
 
 @pytest.fixture
 async def assistant_deepwiki_enabled(langgraph_client):
     """Create an assistant with deepwiki explicitly enabled."""
-    config = {
-        "configurable": {
-            "enable_deepwiki": True,
-            "system_prompt": "You are a helpful AI assistant with access to deepwiki tools. When asked to use deepwiki tools, you must use them to get current documentation.",
-        }
-    }
     assistant = await langgraph_client.assistants.create(
         graph_id="agent",
-        config=config,
+        context={
+            "model": TEST_MODEL,
+            "enable_deepwiki": True,
+            "system_prompt": "You are a helpful AI assistant with access to deepwiki tools. When asked to use deepwiki tools, you must use them to get current documentation.",
+        },
     )
     return assistant["assistant_id"]
 
@@ -312,11 +310,6 @@ async def test_deepwiki_configuration_persistence_e2e(
         # Test with deepwiki enabled configuration
         input_data = {
             "messages": [{"role": "human", "content": "Hello, please keep it brief"}],
-            "configurable": {
-                "enable_deepwiki": True,
-                "max_search_results": 3,
-                "system_prompt": "You are a helpful AI assistant with deepwiki access.",
-            },
         }
 
         # This should execute without errors even if deepwiki tools aren't used