♻️ refactor: upgrade to langchain 1.0.0a12 and migrate to v1alpha ecosystem

**Breaking Changes:**
- Upgraded langchain to 1.0.0a12 which forces langchain-core to v1alpha
- Migrated from langchain-qwq and langchain-siliconflow to langchain-openai
  - langchain-qwq and langchain-siliconflow are not yet v1alpha compatible
  - Consolidated all OpenAI-compatible providers to use langchain-openai
- Standardized InjectedState imports to `langchain.tools.tool_node.InjectedState`
  - Removed fallback import logic from search.py
  - Updated handoff.py to use canonical import location

**API Changes:**
- Fixed AgentStatePydantic deprecation warnings in tests
- Updated import paths for v1alpha compatibility
- Removed redundant provider registration for deprecated packages

**Test Updates:**
- Updated all unit and integration tests for langchain v1alpha
- Fixed API key fixture handling in test suites
- All 171 unit tests passing across libs and apps

**Dependencies:**
- libs/langgraph-up-devkits/pyproject.toml: Updated to langchain-openai
- apps/sample-deep-agent/pyproject.toml: Aligned with v1alpha ecosystem
- uv.lock: Regenerated with new dependency tree

Author: webup

.github/workflows/unit-tests.yml

@@ -41,5 +41,9 @@ jobs:
           ignore_words_file: .codespellignore
           path: "**/README.md"
       - name: Run tests with make
+        env:
+          SILICONFLOW_API_KEY: sk-test-fake-key-for-ci
+          OPENROUTER_API_KEY: sk-test-fake-key-for-ci
+          OPENAI_API_KEY: sk-test-fake-key-for-ci
         run: |
           make test

apps/sample-agent/src/sample_agent/subagents/math.py

@@ -34,10 +34,9 @@ def make_graph(config: RunnableConfig | None = None) -> CompiledStateGraph[Any,
     model = load_chat_model(context.model_name)
 
     # Create and return the math agent directly
-    agent = create_agent(
+    return create_agent(
         model=model,
         tools=[add, multiply],
         name="math_expert",
-        prompt=MATH_EXPERT_PROMPT,
+        system_prompt=MATH_EXPERT_PROMPT,
     )
-    return agent.compile() if hasattr(agent, "compile") else agent

apps/sample-agent/src/sample_agent/subagents/research.py

@@ -34,10 +34,9 @@ def make_graph(config: RunnableConfig | None = None) -> CompiledStateGraph[Any,
     model = load_chat_model(context.model_name)
 
     # Create and return the research agent directly
-    agent = create_agent(
+    return create_agent(
         model=model,
         tools=[web_search],
         name="research_expert",
-        prompt=RESEARCH_EXPERT_PROMPT,
+        system_prompt=RESEARCH_EXPERT_PROMPT,
     )
-    return agent.compile() if hasattr(agent, "compile") else agent

apps/sample-agent/tests/unit/test_graph.py

@@ -89,9 +89,8 @@ def test_math_agent_creation(self, mock_load_model, mock_create_agent):
 
         mock_model = Mock()
         mock_load_model.return_value = mock_model
-        mock_agent = Mock()
-        mock_agent.compile.return_value = "compiled_agent"
-        mock_create_agent.return_value = mock_agent
+        mock_compiled_graph = Mock()
+        mock_create_agent.return_value = mock_compiled_graph
 
         config = {"configurable": {"model_name": "test_model"}}
         result = make_graph(config)
@@ -102,8 +101,8 @@ def test_math_agent_creation(self, mock_load_model, mock_create_agent):
         assert call_args[1]['model'] == mock_model
         assert call_args[1]['name'] == "math_expert"
         assert len(call_args[1]['tools']) == 2  # add and multiply
-        # Result should be compiled agent since agent has compile method
-        assert result == "compiled_agent"
+        # Result should be the compiled graph returned by create_agent
+        assert result == mock_compiled_graph
 
     @patch('sample_agent.subagents.research.create_agent')
     @patch('sample_agent.subagents.research.load_chat_model')
@@ -113,9 +112,8 @@ def test_research_agent_creation(self, mock_load_model, mock_create_agent):
 
         mock_model = Mock()
         mock_load_model.return_value = mock_model
-        mock_agent = Mock()
-        mock_agent.compile.return_value = "compiled_agent"
-        mock_create_agent.return_value = mock_agent
+        mock_compiled_graph = Mock()
+        mock_create_agent.return_value = mock_compiled_graph
 
         config = {"configurable": {"model_name": "test_model"}}
         result = make_graph(config)
@@ -126,8 +124,8 @@ def test_research_agent_creation(self, mock_load_model, mock_create_agent):
         assert call_args[1]['model'] == mock_model
         assert call_args[1]['name'] == "research_expert"
         assert len(call_args[1]['tools']) == 1  # web_search
-        # Result should be compiled agent since agent has compile method
-        assert result == "compiled_agent"
+        # Result should be the compiled graph returned by create_agent
+        assert result == mock_compiled_graph
 
     @patch('sample_agent.graph.load_chat_model')
     @patch('sample_agent.graph.make_math_graph')

apps/sample-deep-agent/pyproject.toml

@@ -9,7 +9,7 @@ readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.11,<4.0"
 dependencies = [
-    "deepagents>=0.0.9",
+    "deepagents>=0.0.11",
     "langgraph-up-devkits",
 ]
 

apps/sample-deep-agent/tests/conftest.py

@@ -1,16 +1,16 @@
 """Test configuration and fixtures."""
 
-import os
 from unittest.mock import Mock, patch
 
 import pytest
 
 
 @pytest.fixture(autouse=True)
 def mock_openai_key(monkeypatch):
-    """Mock OPENAI_API_KEY to prevent API key errors in unit tests."""
+    """Mock API keys to prevent API key errors in unit tests."""
     monkeypatch.setenv("OPENAI_API_KEY", "sk-test-fake-key-for-unit-tests")
     monkeypatch.setenv("OPENROUTER_API_KEY", "sk-test-fake-key-for-unit-tests")
+    monkeypatch.setenv("SILICONFLOW_API_KEY", "sk-test-fake-key-for-unit-tests")
 
 
 @pytest.fixture

apps/sample-deep-agent/tests/unit/test_graph.py

@@ -1,6 +1,5 @@
 """Unit tests for sample deep agent graph components."""
 
-import pytest
 from unittest.mock import Mock, patch
 
 from sample_deep_agent.context import DeepAgentContext
@@ -225,9 +224,9 @@ def test_tool_integration_in_graph(self):
         assert deep_web_search is not None
         assert think_tool is not None
 
-        # Should have required methods
-        assert callable(deep_web_search)
-        assert callable(think_tool)
+        # Should have required methods (StructuredTool has invoke, not directly callable)
+        assert hasattr(deep_web_search, "invoke") or callable(deep_web_search)
+        assert hasattr(think_tool, "invoke") or callable(think_tool)
 
     @patch('sample_deep_agent.graph.async_create_deep_agent')
     def test_tools_passed_to_deep_agent(self, mock_create_deep_agent):

libs/langgraph-up-devkits/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langgraph-up-devkits"
-version = "0.1.1"
+version = "0.2.0"
 description = "Development toolkit for LangGraph agents with middleware, context schemas, and provider integrations"
 authors = [
     { name = "Haili Zhang", email = "[email protected]" },
@@ -20,12 +20,11 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = [
-    "langchain>=1.0.0a10",
-    "langchain-dev-utils>=0.1.15",
+    "langchain>=1.0.0a12",
+    "langchain-dev-utils>=0.1.17",
     "tavily-python>=0.7.12",
-    "langchain-siliconflow>=0.1.3",
-    "langchain-qwq>=0.2.1",
-    "langchain-mcp-adapters>=0.1.10",
+    "langchain-mcp-adapters>=0.1.11",
+    "langchain-openai>=1.0.0a4",
 ]
 
 [project.urls]

libs/langgraph-up-devkits/src/langgraph_up_devkits/tools/search.py

@@ -7,31 +7,12 @@
 from datetime import datetime
 from typing import Annotated, Any, cast
 
+from langchain.tools.tool_node import InjectedState
 from langchain_core.messages import ToolMessage
-from langchain_core.tools import tool
+from langchain_core.tools import InjectedToolCallId, tool
 from langgraph.runtime import get_runtime
 from langgraph.types import Command
 
-try:
-    # Try new location first (LangGraph 0.2+)
-    from langgraph.prebuilt.tool_node import InjectedState
-except ImportError:
-    try:
-        # Fallback to old location for compatibility
-        from langchain.agents.tool_node import InjectedState  # type: ignore[import-not-found,no-redef]
-    except ImportError as e:
-        raise ImportError(
-            "InjectedState is required for deep_web_search tool. "
-            "Please update LangChain and LangGraph to compatible versions."
-        ) from e
-
-try:
-    from langchain_core.tools import InjectedToolCallId
-except ImportError as e:
-    raise ImportError(
-        "InjectedToolCallId is required for deep_web_search tool. Please update LangChain to a compatible version."
-    ) from e
-
 
 def _get_tavily_client() -> Any:
     """Dynamically import Tavily client to avoid hard dependency."""

libs/langgraph-up-devkits/src/langgraph_up_devkits/utils/providers.py

@@ -57,80 +57,78 @@ def normalize_region(region: str) -> str | None:
     return None
 
 
+def _get_qwen_base_url() -> str:
+    """Get Qwen base URL based on region."""
+    region = normalize_region(os.getenv("REGION", ""))
+    return (
+        "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+        if region == "international"
+        else "https://dashscope.aliyuncs.com/compatible-mode/v1"
+    )
+
+
+def _get_siliconflow_base_url() -> str:
+    """Get SiliconFlow base URL based on region."""
+    region = normalize_region(os.getenv("REGION", ""))
+    return "https://api.siliconflow.com/v1" if region == "international" else "https://api.siliconflow.cn/v1"
+
+
 def _register_qwen_provider() -> bool:
-    """Register Qwen provider using langchain-dev-utils."""
+    """Register Qwen provider using langchain-dev-utils, fallback to OpenAI."""
     if not DEV_UTILS_AVAILABLE:
         return False
 
+    base_url = _get_qwen_base_url()
+
     try:
-        # Dynamic imports to avoid hard dependencies
+        # Try to use native langchain_qwq package
         import importlib
 
         qwq_module = importlib.import_module("langchain_qwq")
         ChatQwen = getattr(qwq_module, "ChatQwen", None)
         ChatQwQ = getattr(qwq_module, "ChatQwQ", None)
 
-        if not ChatQwen or not ChatQwQ:
-            return False
-
-        # Register both ChatQwen and ChatQwQ
-        register_model_provider("qwen", ChatQwen)  # For regular Qwen models
-        register_model_provider("qwq", ChatQwQ)  # For QwQ models
-
-        # Handle region-based URLs
-        region = normalize_region(os.getenv("REGION", ""))
-        if region == "prc":
-            base_url = "https://dashscope.aliyuncs.com/compatible-mode/v1"
-        elif region == "international":
-            base_url = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-        else:
-            base_url = None
-
-        # Register with base URL if needed
-        if base_url:
+        if ChatQwen and ChatQwQ:
             register_model_provider("qwen", ChatQwen, base_url=base_url)
             register_model_provider("qwq", ChatQwQ, base_url=base_url)
-
-        return True
+            return True
     except (ImportError, AttributeError, ModuleNotFoundError):
-        return False
+        pass
+
+    # Fallback to OpenAI client
+    register_model_provider("qwen", "openai", base_url=base_url)
+    register_model_provider("qwq", "openai", base_url=base_url)
+    return True
 
 
 def _register_siliconflow_provider() -> bool:
-    """Register SiliconFlow provider using langchain-dev-utils with proper base URL."""
+    """Register SiliconFlow provider using langchain-dev-utils, fallback to OpenAI."""
     if not DEV_UTILS_AVAILABLE:
         return False
 
+    base_url = _get_siliconflow_base_url()
+
     try:
-        # Dynamic import to avoid hard dependency
+        # Try to use native langchain_siliconflow package
         import importlib
 
         siliconflow_module = importlib.import_module("langchain_siliconflow")
         ChatSiliconFlow = getattr(siliconflow_module, "ChatSiliconFlow", None)
-        if not ChatSiliconFlow:
-            return False
-
-        # Handle region-based URLs during registration
-        region = normalize_region(os.getenv("REGION", ""))
-        if region == "prc":
-            base_url = "https://api.siliconflow.cn/v1"
-        elif region == "international":
-            base_url = "https://api.siliconflow.com/v1"
-        else:
-            base_url = "https://api.siliconflow.cn/v1"  # Default to PRC
-
-        # Create a factory function that returns ChatSiliconFlow with correct base URL
-        def siliconflow_factory(**kwargs: Any) -> Any:
-            # Always use our region-specific base URL
-            kwargs["base_url"] = base_url
-            return ChatSiliconFlow(**kwargs)
-
-        # Register the factory function instead of the raw class
-        register_model_provider("siliconflow", siliconflow_factory)
-
-        return True
+
+        if ChatSiliconFlow:
+            # Create factory to inject base_url
+            def siliconflow_factory(**kwargs: Any) -> Any:
+                kwargs["base_url"] = base_url
+                return ChatSiliconFlow(**kwargs)
+
+            register_model_provider("siliconflow", siliconflow_factory)
+            return True
     except (ImportError, AttributeError, ModuleNotFoundError):
-        return False
+        pass
+
+    # Fallback to OpenAI client
+    register_model_provider("siliconflow", "openai", base_url=base_url)
+    return True
 
 
 def _register_openrouter_provider() -> bool: