The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
feat: dynamic tool registration via middleware (#34842)
Sydney Runklebc8620189c9d
diff --git a/libs/langchain_v1/langchain/agents/factory.py b/libs/langchain_v1/langchain/agents/factory.pyindex 3c4cef0524..a7106fbb78 100644--- a/libs/langchain_v1/langchain/agents/factory.py+++ b/libs/langchain_v1/langchain/agents/factory.py@@ -63,6 +63,32 @@ if TYPE_CHECKING:STRUCTURED_OUTPUT_ERROR_TEMPLATE = "Error: {error}\n Please fix your mistakes."+DYNAMIC_TOOL_ERROR_TEMPLATE = """+Middleware added tools that the agent doesn't know how to execute.++Unknown tools: {unknown_tool_names}+Registered tools: {available_tool_names}++This happens when middleware modifies `request.tools` in `wrap_model_call` to include+tools that weren't passed to `create_agent()`.++How to fix this:++Option 1: Register tools at agent creation (recommended for most cases)+ Pass the tools to `create_agent(tools=[...])` or set them on `middleware.tools`.+ This makes tools available for every agent invocation.++Option 2: Handle dynamic tools in middleware (for tools created at runtime)+ Implement `wrap_tool_call` to execute tools that are added dynamically:++ class MyMiddleware(AgentMiddleware):+ def wrap_tool_call(self, request, handler):+ if request.tool_call["name"] == "dynamic_tool":+ # Execute the dynamic tool yourself or override with tool instance+ return handler(request.override(tool=my_dynamic_tool))+ return handler(request)+""".strip()+FALLBACK_MODELS_WITH_STRUCTURED_OUTPUT = [# if model profile data are not available, these models are assumed to support# structured output@@ -775,14 +801,15 @@ def create_agent(# Tools that require client-side execution (must be in ToolNode)available_tools = middleware_tools + regular_tools- # Only create ToolNode if we have client-side tools+ # Create ToolNode if we have client-side tools OR if middleware defines wrap_tool_call+ # (which may handle dynamically registered tools)tool_node = (ToolNode(tools=available_tools,wrap_tool_call=wrap_tool_call_wrapper,awrap_tool_call=awrap_tool_call_wrapper,)- if available_tools+ if available_tools or wrap_tool_call_wrapper or awrap_tool_call_wrapperelse None)@@ -997,6 +1024,10 @@ def create_agent(ValueError: If `ToolStrategy` specifies tools not declared upfront."""# Validate ONLY client-side tools that need to exist in tool_node+ # Skip validation when wrap_tool_call is defined, as middleware may handle+ # dynamic tools that are added at runtime via wrap_model_call+ has_wrap_tool_call = wrap_tool_call_wrapper or awrap_tool_call_wrapper+# Build map of available client-side tools from the ToolNode# (which has already converted callables)available_tools_by_name = {}@@ -1004,29 +1035,23 @@ def create_agent(available_tools_by_name = tool_node.tools_by_name.copy()# Check if any requested tools are unknown CLIENT-SIDE tools- unknown_tool_names = []- for t in request.tools:- # Only validate BaseTool instances (skip built-in dict tools)- if isinstance(t, dict):- continue- if isinstance(t, BaseTool) and t.name not in available_tools_by_name:- unknown_tool_names.append(t.name)-- if unknown_tool_names:- available_tool_names = sorted(available_tools_by_name.keys())- msg = (- f"Middleware returned unknown tool names: {unknown_tool_names}\n\n"- f"Available client-side tools: {available_tool_names}\n\n"- "To fix this issue:\n"- "1. Ensure the tools are passed to create_agent() via "- "the 'tools' parameter\n"- "2. If using custom middleware with tools, ensure "- "they're registered via middleware.tools attribute\n"- "3. Verify that tool names in ModelRequest.tools match "- "the actual tool.name values\n"- "Note: Built-in provider tools (dict format) can be added dynamically."- )- raise ValueError(msg)+ # Only validate if wrap_tool_call is NOT defined (no dynamic tool handling)+ if not has_wrap_tool_call:+ unknown_tool_names = []+ for t in request.tools:+ # Only validate BaseTool instances (skip built-in dict tools)+ if isinstance(t, dict):+ continue+ if isinstance(t, BaseTool) and t.name not in available_tools_by_name:+ unknown_tool_names.append(t.name)++ if unknown_tool_names:+ available_tool_names = sorted(available_tools_by_name.keys())+ msg = DYNAMIC_TOOL_ERROR_TEMPLATE.format(+ unknown_tool_names=unknown_tool_names,+ available_tool_names=available_tool_names,+ )+ raise ValueError(msg)# Determine effective response format (auto-detect if needed)effective_response_format: ResponseFormat[Any] | Nonediff --git a/libs/langchain_v1/pyproject.toml b/libs/langchain_v1/pyproject.tomlindex 70f8d7d01e..d40d583fb9 100644--- a/libs/langchain_v1/pyproject.toml+++ b/libs/langchain_v1/pyproject.toml@@ -13,7 +13,7 @@ version = "1.2.6"requires-python = ">=3.10.0,<4.0.0"dependencies = ["langchain-core>=1.2.7,<2.0.0",- "langgraph>=1.0.2,<1.1.0",+ "langgraph>=1.0.7,<1.1.0","pydantic>=2.7.4,<3.0.0",]diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_dynamic_tools.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_dynamic_tools.pynew file mode 100644index 0000000000..bfa4def569--- /dev/null+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_dynamic_tools.py@@ -0,0 +1,407 @@+"""Tests for dynamic tool registration via middleware.++These tests verify that middleware can dynamically register and handle tools+that are not declared upfront when creating the agent.+"""++from collections.abc import Awaitable, Callable+from typing import Any++import pytest+from langchain_core.messages import HumanMessage, ToolCall, ToolMessage+from langchain_core.tools import tool+from langgraph.checkpoint.memory import InMemorySaver+from langgraph.types import Command++from langchain.agents.factory import create_agent+from langchain.agents.middleware.types import (+ AgentMiddleware,+ ModelCallResult,+ ModelRequest,+ ModelResponse,+ ToolCallRequest,+)+from tests.unit_tests.agents.model import FakeToolCallingModel+++@tool+def static_tool(value: str) -> str:+ """A static tool that is always available."""+ return f"Static result: {value}"+++@tool+def dynamic_tool(value: str) -> str:+ """A dynamically registered tool."""+ return f"Dynamic result: {value}"+++@tool+def another_dynamic_tool(x: int, y: int) -> str:+ """Another dynamically registered tool for calculations."""+ return f"Sum: {x + y}"+++# -----------------------------------------------------------------------------+# Middleware classes+# -----------------------------------------------------------------------------+++class DynamicToolMiddleware(AgentMiddleware):+ """Middleware that dynamically adds and handles a tool (sync and async)."""++ def wrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], ModelResponse],+ ) -> ModelCallResult:+ updated = request.override(tools=[*request.tools, dynamic_tool])+ return handler(updated)++ async def awrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], Awaitable[ModelResponse]],+ ) -> ModelCallResult:+ updated = request.override(tools=[*request.tools, dynamic_tool])+ return await handler(updated)++ def wrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], ToolMessage | Command[Any]],+ ) -> ToolMessage | Command[Any]:+ if request.tool_call["name"] == "dynamic_tool":+ return handler(request.override(tool=dynamic_tool))+ return handler(request)++ async def awrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]],+ ) -> ToolMessage | Command[Any]:+ if request.tool_call["name"] == "dynamic_tool":+ return await handler(request.override(tool=dynamic_tool))+ return await handler(request)+++class MultipleDynamicToolsMiddleware(AgentMiddleware):+ """Middleware that dynamically adds multiple tools (sync and async)."""++ def wrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], ModelResponse],+ ) -> ModelCallResult:+ updated = request.override(tools=[*request.tools, dynamic_tool, another_dynamic_tool])+ return handler(updated)++ async def awrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], Awaitable[ModelResponse]],+ ) -> ModelCallResult:+ updated = request.override(tools=[*request.tools, dynamic_tool, another_dynamic_tool])+ return await handler(updated)++ def _handle_tool(self, request: ToolCallRequest) -> ToolCallRequest | None:+ """Return updated request if this is a dynamic tool, else None."""+ tool_name = request.tool_call["name"]+ if tool_name == "dynamic_tool":+ return request.override(tool=dynamic_tool)+ if tool_name == "another_dynamic_tool":+ return request.override(tool=another_dynamic_tool)+ return None++ def wrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], ToolMessage | Command[Any]],+ ) -> ToolMessage | Command[Any]:+ updated = self._handle_tool(request)+ return handler(updated if updated else request)++ async def awrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]],+ ) -> ToolMessage | Command[Any]:+ updated = self._handle_tool(request)+ return await handler(updated if updated else request)+++class DynamicToolMiddlewareWithoutHandler(AgentMiddleware):+ """Middleware that adds a dynamic tool but doesn't handle it."""++ def wrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], ModelResponse],+ ) -> ModelCallResult:+ updated = request.override(tools=[*request.tools, dynamic_tool])+ return handler(updated)++ async def awrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], Awaitable[ModelResponse]],+ ) -> ModelCallResult:+ updated = request.override(tools=[*request.tools, dynamic_tool])+ return await handler(updated)+++class ConditionalDynamicToolMiddleware(AgentMiddleware):+ """Middleware that conditionally adds a tool based on state (sync and async)."""++ def _should_add_tool(self, request: ModelRequest) -> bool:+ messages = request.state.get("messages", [])+ return messages and "calculator" in str(messages[-1].content).lower()++ def wrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], ModelResponse],+ ) -> ModelCallResult:+ if self._should_add_tool(request):+ request = request.override(tools=[*request.tools, another_dynamic_tool])+ return handler(request)++ async def awrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], Awaitable[ModelResponse]],+ ) -> ModelCallResult:+ if self._should_add_tool(request):+ request = request.override(tools=[*request.tools, another_dynamic_tool])+ return await handler(request)++ def wrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], ToolMessage | Command[Any]],+ ) -> ToolMessage | Command[Any]:+ if request.tool_call["name"] == "another_dynamic_tool":+ return handler(request.override(tool=another_dynamic_tool))+ return handler(request)++ async def awrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]],+ ) -> ToolMessage | Command[Any]:+ if request.tool_call["name"] == "another_dynamic_tool":+ return await handler(request.override(tool=another_dynamic_tool))+ return await handler(request)+++# -----------------------------------------------------------------------------+# Helper functions+# -----------------------------------------------------------------------------+++def get_tool_messages(result: dict[str, Any]) -> list[ToolMessage]:+ """Extract ToolMessage objects from agent result."""+ return [m for m in result["messages"] if isinstance(m, ToolMessage)]+++async def invoke_agent(agent: Any, message: str, *, use_async: bool) -> dict[str, Any]:+ """Invoke agent synchronously or asynchronously based on flag."""+ input_data = {"messages": [HumanMessage(message)]}+ config = {"configurable": {"thread_id": "test"}}+ if use_async:+ return await agent.ainvoke(input_data, config)+ return agent.invoke(input_data, config)+++# -----------------------------------------------------------------------------+# Tests+# -----------------------------------------------------------------------------++[email protected]("use_async", [False, True])+ "tools",+ [+ pytest.param([static_tool], id="with_static_tools"),+ pytest.param([], id="without_static_tools"),+ pytest.param(None, id="with_none_tools"),+ ],+)+async def test_dynamic_tool_basic(*, use_async: bool, tools: list[Any] | None) -> None:+ """Test dynamic tool registration with various static tool configurations."""+ model = FakeToolCallingModel(+ tool_calls=[+ [ToolCall(name="dynamic_tool", args={"value": "test"}, id="1")],+ [],+ ]+ )++ agent = create_agent(+ model=model,+ tools=tools, # type: ignore[arg-type]+ middleware=[DynamicToolMiddleware()],+ checkpointer=InMemorySaver(),+ )++ result = await invoke_agent(agent, "Use the dynamic tool", use_async=use_async)++ tool_messages = get_tool_messages(result)+ assert len(tool_messages) == 1+ assert tool_messages[0].name == "dynamic_tool"+ assert "Dynamic result: test" in tool_messages[0].content++[email protected]("use_async", [False, True])+async def test_multiple_dynamic_tools_with_static(*, use_async: bool) -> None:+ """Test multiple dynamic tools and mixing with static tool calls."""+ model = FakeToolCallingModel(+ tool_calls=[+ [+ ToolCall(name="static_tool", args={"value": "static-call"}, id="1"),+ ToolCall(name="dynamic_tool", args={"value": "first"}, id="2"),+ ToolCall(name="another_dynamic_tool", args={"x": 5, "y": 3}, id="3"),+ ],+ [],+ ]+ )++ agent = create_agent(+ model=model,+ tools=[static_tool],+ middleware=[MultipleDynamicToolsMiddleware()],+ checkpointer=InMemorySaver(),+ )++ result = await invoke_agent(agent, "Use all tools", use_async=use_async)++ tool_messages = get_tool_messages(result)+ assert len(tool_messages) == 3++ tool_results = {m.name: m.content for m in tool_messages}+ assert "Static result: static-call" in tool_results["static_tool"]+ assert "Dynamic result: first" in tool_results["dynamic_tool"]+ assert "Sum: 8" in tool_results["another_dynamic_tool"]++[email protected]("use_async", [False, True])+ "tools",+ [+ pytest.param([static_tool], id="with_static_tools"),+ pytest.param([], id="without_static_tools"),+ ],+)+async def test_dynamic_tool_without_handler_raises_error(+ *, use_async: bool, tools: list[Any]+) -> None:+ """Test that a helpful error is raised when dynamic tool is not handled."""+ model = FakeToolCallingModel(+ tool_calls=[+ [ToolCall(name="dynamic_tool", args={"value": "test"}, id="1")],+ [],+ ]+ )++ agent = create_agent(+ model=model,+ tools=tools,+ middleware=[DynamicToolMiddlewareWithoutHandler()],+ checkpointer=InMemorySaver(),+ )++ with pytest.raises(+ ValueError,+ match=r"(?s)Middleware added tools.*Unknown tools:.*dynamic_tool",+ ):+ await invoke_agent(agent, "Use the dynamic tool", use_async=use_async)++[email protected]("use_async", [False, True])+async def test_conditional_dynamic_tool(*, use_async: bool) -> None:+ """Test that dynamic tools can be conditionally added based on state."""+ model = FakeToolCallingModel(+ tool_calls=[+ [ToolCall(name="another_dynamic_tool", args={"x": 10, "y": 20}, id="1")],+ [],+ ]+ )++ agent = create_agent(+ model=model,+ tools=[static_tool],+ middleware=[ConditionalDynamicToolMiddleware()],+ checkpointer=InMemorySaver(),+ )++ result = await invoke_agent(agent, "I need a calculator to add numbers", use_async=use_async)++ tool_messages = get_tool_messages(result)+ assert len(tool_messages) == 1+ assert tool_messages[0].name == "another_dynamic_tool"+ assert "Sum: 30" in tool_messages[0].content++[email protected]("use_async", [False, True])+async def test_dynamic_tool_chained_middleware(*, use_async: bool) -> None:+ """Test dynamic tools work with multiple middleware in chain."""+ call_log: list[str] = []++ class LoggingMiddleware(AgentMiddleware):+ def __init__(self, label: str) -> None:+ self._label = label++ def wrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], ModelResponse],+ ) -> ModelCallResult:+ call_log.append(f"{self._label}_model")+ return handler(request)++ async def awrap_model_call(+ self,+ request: ModelRequest,+ handler: Callable[[ModelRequest], Awaitable[ModelResponse]],+ ) -> ModelCallResult:+ call_log.append(f"{self._label}_model")+ return await handler(request)++ def wrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], ToolMessage | Command[Any]],+ ) -> ToolMessage | Command[Any]:+ call_log.append(f"{self._label}_tool")+ return handler(request)++ async def awrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]],+ ) -> ToolMessage | Command[Any]:+ call_log.append(f"{self._label}_tool")+ return await handler(request)++ model = FakeToolCallingModel(+ tool_calls=[+ [ToolCall(name="dynamic_tool", args={"value": "chained"}, id="1")],+ [],+ ]+ )++ agent = create_agent(+ model=model,+ tools=[static_tool],+ middleware=[LoggingMiddleware("first"), DynamicToolMiddleware()],+ checkpointer=InMemorySaver(),+ )++ result = await invoke_agent(agent, "Use the dynamic tool", use_async=use_async)++ tool_messages = get_tool_messages(result)+ assert len(tool_messages) == 1+ assert tool_messages[0].name == "dynamic_tool"++ # Verify middleware chain was called+ assert "first_model" in call_log+ assert "first_tool" in call_logdiff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_tools.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_tools.pyindex d6c3bbfd20..53cf54ffeb 100644--- a/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_tools.py+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_tools.py@@ -152,7 +152,10 @@ def test_unknown_tool_raises_error() -> None:middleware=[BadMiddleware()],)- with pytest.raises(ValueError, match="Middleware returned unknown tool names"):+ with pytest.raises(+ ValueError,+ match=r"(?s)Middleware added tools.*Unknown tools:.*unknown_tool",+ ):agent.invoke({"messages": [HumanMessage("Hello")]})diff --git a/libs/langchain_v1/uv.lock b/libs/langchain_v1/uv.lockindex 3643e1d44e..69cc1624ec 100644--- a/libs/langchain_v1/uv.lock+++ b/libs/langchain_v1/uv.lock@@ -1970,7 +1970,7 @@ requires-dist = [{ name = "langchain-perplexity", marker = "extra == 'perplexity'" },{ name = "langchain-together", marker = "extra == 'together'" },{ name = "langchain-xai", marker = "extra == 'xai'" },- { name = "langgraph", specifier = ">=1.0.2,<1.1.0" },+ { name = "langgraph", specifier = ">=1.0.7,<1.1.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },]provides-extras = ["community", "anthropic", "openai", "azure-ai", "google-vertexai", "google-genai", "fireworks", "ollama", "together", "mistralai", "huggingface", "groq", "aws", "deepseek", "xai", "perplexity"]@@ -2119,7 +2119,7 @@ dependencies = [requires-dist = [{ name = "jsonpatch", specifier = ">=1.33.0,<2.0.0" },{ name = "langsmith", specifier = ">=0.3.45,<1.0.0" },- { name = "packaging", specifier = ">=23.2.0,<26.0.0" },+ { name = "packaging", specifier = ">=23.2.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },{ name = "pyyaml", specifier = ">=5.3.0,<7.0.0" },{ name = "tenacity", specifier = ">=8.1.0,!=8.4.0,<10.0.0" },@@ -2131,7 +2131,7 @@ requires-dist = [dev = [{ name = "grandalf", specifier = ">=0.8.0,<1.0.0" },{ name = "jupyter", specifier = ">=1.0.0,<2.0.0" },- { name = "setuptools", specifier = ">=67.6.1,<68.0.0" },+ { name = "setuptools", specifier = ">=67.6.1,<79.0.0" },]lint = [{ name = "ruff", specifier = ">=0.14.11,<0.15.0" }]test = [@@ -2303,7 +2303,7 @@ dev = [{ name = "langchain-core", editable = "../core" }]lint = [{ name = "ruff", specifier = ">=0.13.1,<0.14.0" }]test = [{ name = "freezegun", specifier = ">=1.2.2,<2.0.0" },- { name = "langchain", editable = "../langchain_v1" },+ { name = "langchain", editable = "." },{ name = "langchain-core", editable = "../core" },{ name = "langchain-tests", editable = "../standard-tests" },{ name = "numpy", marker = "python_full_version < '3.13'", specifier = ">=1.26.4" },@@ -2484,7 +2484,7 @@ wheels = [[[package]]name = "langgraph"-version = "1.0.4"+version = "1.0.7"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },@@ -2494,9 +2494,9 @@ dependencies = [{ name = "pydantic" },{ name = "xxhash" },]-sdist = { url = "https://files.pythonhosted.org/packages/d6/3c/af87902d300c1f467165558c8966d8b1e1f896dace271d3f35a410a5c26a/langgraph-1.0.4.tar.gz", hash = "sha256:86d08e25d7244340f59c5200fa69fdd11066aa999b3164b531e2a20036fac156", size = 484397, upload-time = "2025-11-25T20:31:48.608Z" }+sdist = { url = "https://files.pythonhosted.org/packages/72/5b/f72655717c04e33d3b62f21b166dc063d192b53980e9e3be0e2a117f1c9f/langgraph-1.0.7.tar.gz", hash = "sha256:0cfdfee51e6e8cfe503ecc7367c73933437c505b03fa10a85c710975c8182d9a", size = 497098, upload-time = "2026-01-22T16:57:47.303Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/14/52/4eb25a3f60399da34ba34adff1b3e324cf0d87eb7a08cebf1882a9b5e0d5/langgraph-1.0.4-py3-none-any.whl", hash = "sha256:b1a835ceb0a8d69b9db48075e1939e28b1ad70ee23fa3fa8f90149904778bacf", size = 157271, upload-time = "2025-11-25T20:31:47.518Z" },+ { url = "https://files.pythonhosted.org/packages/7e/0e/fe80144e3e4048e5d19ccdb91ac547c1a7dc3da8dbd1443e210048194c14/langgraph-1.0.7-py3-none-any.whl", hash = "sha256:9d68e8f8dd8f3de2fec45f9a06de05766d9b075b78fb03171779893b7a52c4d2", size = 157353, upload-time = "2026-01-22T16:57:45.997Z" },][[package]]@@ -2514,28 +2514,28 @@ wheels = [[[package]]name = "langgraph-prebuilt"-version = "1.0.5"+version = "1.0.7"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },{ name = "langgraph-checkpoint" },]-sdist = { url = "https://files.pythonhosted.org/packages/46/f9/54f8891b32159e4542236817aea2ee83de0de18bce28e9bdba08c7f93001/langgraph_prebuilt-1.0.5.tar.gz", hash = "sha256:85802675ad778cc7240fd02d47db1e0b59c0c86d8369447d77ce47623845db2d", size = 144453, upload-time = "2025-11-20T16:47:39.23Z" }+sdist = { url = "https://files.pythonhosted.org/packages/a7/59/711aecd1a50999456850dc328f3cad72b4372d8218838d8d5326f80cb76f/langgraph_prebuilt-1.0.7.tar.gz", hash = "sha256:38e097e06de810de4d0e028ffc0e432bb56d1fb417620fb1dfdc76c5e03e4bf9", size = 163692, upload-time = "2026-01-22T16:45:22.801Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/87/5e/aeba4a5b39fe6e874e0dd003a82da71c7153e671312671a8dacc5cb7c1af/langgraph_prebuilt-1.0.5-py3-none-any.whl", hash = "sha256:22369563e1848862ace53fbc11b027c28dd04a9ac39314633bb95f2a7e258496", size = 35072, upload-time = "2025-11-20T16:47:38.187Z" },+ { url = "https://files.pythonhosted.org/packages/47/49/5e37abb3f38a17a3487634abc2a5da87c208cc1d14577eb8d7184b25c886/langgraph_prebuilt-1.0.7-py3-none-any.whl", hash = "sha256:e14923516504405bb5edc3977085bc9622c35476b50c1808544490e13871fe7c", size = 35324, upload-time = "2026-01-22T16:45:21.784Z" },][[package]]name = "langgraph-sdk"-version = "0.2.9"+version = "0.3.3"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "httpx" },{ name = "orjson" },]-sdist = { url = "https://files.pythonhosted.org/packages/23/d8/40e01190a73c564a4744e29a6c902f78d34d43dad9b652a363a92a67059c/langgraph_sdk-0.2.9.tar.gz", hash = "sha256:b3bd04c6be4fa382996cd2be8fbc1e7cc94857d2bc6b6f4599a7f2a245975303", size = 99802, upload-time = "2025-09-20T18:49:14.734Z" }+sdist = { url = "https://files.pythonhosted.org/packages/c3/0f/ed0634c222eed48a31ba48eab6881f94ad690d65e44fe7ca838240a260c1/langgraph_sdk-0.3.3.tar.gz", hash = "sha256:c34c3dce3b6848755eb61f0c94369d1ba04aceeb1b76015db1ea7362c544fb26", size = 130589, upload-time = "2026-01-13T00:30:43.894Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/66/05/b2d34e16638241e6f27a6946d28160d4b8b641383787646d41a3727e0896/langgraph_sdk-0.2.9-py3-none-any.whl", hash = "sha256:fbf302edadbf0fb343596f91c597794e936ef68eebc0d3e1d358b6f9f72a1429", size = 56752, upload-time = "2025-09-20T18:49:13.346Z" },+ { url = "https://files.pythonhosted.org/packages/6e/be/4ad511bacfdd854afb12974f407cb30010dceb982dc20c55491867b34526/langgraph_sdk-0.3.3-py3-none-any.whl", hash = "sha256:a52ebaf09d91143e55378bb2d0b033ed98f57f48c9ad35c8f81493b88705fc7b", size = 67021, upload-time = "2026-01-13T00:30:42.264Z" },][[package]]