langgraph-prebuilt 0.2.1__tar.gz → 0.2.3__tar.gz

{langgraph_prebuilt-0.2.1 → langgraph_prebuilt-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-prebuilt
-Version: 0.2.1
+Version: 0.2.3
 Summary: Library with high-level APIs for creating and executing LangGraph agents and tools.
 Project-URL: Repository, https://www.github.com/langchain-ai/langgraph
 License-Expression: MIT

{langgraph_prebuilt-0.2.1 → langgraph_prebuilt-0.2.3}/langgraph/prebuilt/chat_agent_executor.py

@@ -140,7 +140,9 @@ def _get_prompt_runnable(prompt: Optional[Prompt]) -> Runnable:
     return prompt_runnable
 
 
-def _should_bind_tools(model: LanguageModelLike, tools: Sequence[BaseTool]) -> bool:
+def _should_bind_tools(
+    model: LanguageModelLike, tools: Sequence[BaseTool], num_builtin: int = 0
+) -> bool:
     if isinstance(model, RunnableSequence):
         model = next(
             (
@@ -158,9 +160,10 @@ def _should_bind_tools(model: LanguageModelLike, tools: Sequence[BaseTool]) -> b
         return True
 
     bound_tools = model.kwargs["tools"]
-    if len(tools) != len(bound_tools):
+    if len(tools) != len(bound_tools) - num_builtin:
         raise ValueError(
             "Number of tools in the model.bind_tools() and tools passed to create_react_agent must match"
+            f" Got {len(tools)} tools, expected {len(bound_tools) - num_builtin}"
         )
 
     tool_names = set(tool.name for tool in tools)
@@ -444,9 +447,8 @@ def create_react_agent(
     tool_calling_enabled = len(tool_classes) > 0
 
     if (
-        _should_bind_tools(model, tool_classes)
+        _should_bind_tools(model, tool_classes, num_builtin=len(llm_builtin_tools))
         and len(tool_classes) > 0
-        or (len(llm_builtin_tools) > 0)
     ):
         model = cast(BaseChatModel, model).bind_tools(tool_classes + llm_builtin_tools)  # type: ignore[operator]
 
@@ -727,6 +729,10 @@ def create_react_agent(
             ]
 
             if pending_tool_calls:
+                pending_tool_calls = [
+                    tool_node.inject_tool_args(call, state, store)  # type: ignore[arg-type]
+                    for call in pending_tool_calls
+                ]
                 return [Send("tools", [tool_call]) for tool_call in pending_tool_calls]
             elif isinstance(messages[-1], ToolMessage):
                 return entrypoint

{langgraph_prebuilt-0.2.1 → langgraph_prebuilt-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-prebuilt"
-version = "0.2.1"
+version = "0.2.3"
 description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
 authors = []
 requires-python = ">=3.9"

{langgraph_prebuilt-0.2.1 → langgraph_prebuilt-0.2.3}/tests/model.py

@@ -73,9 +73,12 @@ class FakeToolCallingModel(BaseChatModel):
 
         tool_dicts = []
         for tool in tools:
+            if isinstance(tool, dict):
+                tool_dicts.append(tool)
+                continue
             if not isinstance(tool, BaseTool):
                 raise TypeError(
-                    "Only BaseTool is supported by FakeToolCallingModel.bind_tools"
+                    "Only BaseTool and dict is supported by FakeToolCallingModel.bind_tools"
                 )
 
             # NOTE: this is a simplified tool spec for testing purposes only

{langgraph_prebuilt-0.2.1 → langgraph_prebuilt-0.2.3}/tests/test_react_agent.py

@@ -275,7 +275,8 @@ async def test_prompt_with_store_async():
 
 @pytest.mark.parametrize("tool_style", ["openai", "anthropic"])
 @pytest.mark.parametrize("version", REACT_TOOL_CALL_VERSIONS)
-def test_model_with_tools(tool_style: str, version: str):
+@pytest.mark.parametrize("include_builtin", [True, False])
+def test_model_with_tools(tool_style: str, version: str, include_builtin: bool):
     model = FakeToolCallingModel(tool_style=tool_style)
 
     @dec_tool
@@ -288,10 +289,27 @@ def test_model_with_tools(tool_style: str, version: str):
         """Tool 2 docstring."""
         return f"Tool 2: {some_val}"
 
+    tools = [tool1, tool2]
+    if include_builtin:
+        tools.append(
+            {
+                "type": "mcp",
+                "server_label": "atest_sever",
+                "server_url": "https://some.mcp.somewhere.com/sse",
+                "headers": {"foo": "bar"},
+                "allowed_tools": [
+                    "mcp_tool_1",
+                    "set_active_account",
+                    "get_url_markdown",
+                    "get_url_screenshot",
+                ],
+                "require_approval": "never",
+            }
+        )
     # check valid agent constructor
     agent = create_react_agent(
-        model.bind_tools([tool1, tool2]),
-        [tool1, tool2],
+        model.bind_tools(tools),
+        tools,
         version=version,
     )
     result = agent.nodes["tools"].invoke(
@@ -1540,3 +1558,63 @@ def test_post_model_hook_with_structured_output() -> None:
             }
         },
     ]
+
+
+@pytest.mark.parametrize(
+    "state_schema", [AgentStateExtraKey, AgentStateExtraKeyPydantic]
+)
+def test_create_react_agent_inject_vars_with_post_model_hook(
+    state_schema: StateSchemaType,
+) -> None:
+    store = InMemoryStore()
+    namespace = ("test",)
+    store.put(namespace, "test_key", {"bar": 3})
+
+    if issubclass(state_schema, AgentStatePydantic):
+
+        def tool1(
+            some_val: int,
+            state: Annotated[AgentStateExtraKeyPydantic, InjectedState],
+            store: Annotated[BaseStore, InjectedStore()],
+        ) -> str:
+            """Tool 1 docstring."""
+            store_val = store.get(namespace, "test_key").value["bar"]
+            return some_val + state.foo + store_val
+    else:
+
+        def tool1(
+            some_val: int,
+            state: Annotated[dict, InjectedState],
+            store: Annotated[BaseStore, InjectedStore()],
+        ) -> str:
+            """Tool 1 docstring."""
+            store_val = store.get(namespace, "test_key").value["bar"]
+            return some_val + state["foo"] + store_val
+
+    tool_call = {
+        "name": "tool1",
+        "args": {"some_val": 1},
+        "id": "some 0",
+        "type": "tool_call",
+    }
+
+    def post_model_hook(state: dict) -> None:
+        return
+
+    model = FakeToolCallingModel(tool_calls=[[tool_call], []])
+    agent = create_react_agent(
+        model,
+        [tool1],
+        state_schema=state_schema,
+        store=store,
+        post_model_hook=post_model_hook,
+    )
+    input_message = HumanMessage("hi")
+    result = agent.invoke({"messages": [input_message], "foo": 2})
+    assert result["messages"] == [
+        input_message,
+        AIMessage(content="hi", tool_calls=[tool_call], id="0"),
+        _AnyIdToolMessage(content="6", name="tool1", tool_call_id="some 0"),
+        AIMessage("hi-hi-6", id="1"),
+    ]
+    assert result["foo"] == 2