langchain-dev-utils 1.3.2__tar.gz → 1.3.3__tar.gz

{langchain_dev_utils-1.3.2 → langchain_dev_utils-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-dev-utils
-Version: 1.3.2
+Version: 1.3.3
 Summary: A practical utility library for LangChain and LangGraph development
 Project-URL: Source Code, https://github.com/TBice123123/langchain-dev-utils
 Project-URL: repository, https://github.com/TBice123123/langchain-dev-utils

{langchain_dev_utils-1.3.2 → langchain_dev_utils-1.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langchain-dev-utils"
-version = "1.3.2"
+version = "1.3.3"
 description = "A practical utility library for LangChain and LangGraph development"
 readme = "README.md"
 authors = [{ name = "tiebingice", email = "tiebingice123@outlook.com" }]

langchain_dev_utils-1.3.3/src/langchain_dev_utils/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.3.3"

langchain_dev_utils-1.3.3/src/langchain_dev_utils/agents/__init__.py

@@ -0,0 +1,4 @@
+from .factory import create_agent
+from .wrap import wrap_agent_as_tool, wrap_all_agents_as_tool
+
+__all__ = ["create_agent", "wrap_agent_as_tool", "wrap_all_agents_as_tool"]

{langchain_dev_utils-1.3.2 → langchain_dev_utils-1.3.3}/src/langchain_dev_utils/agents/middleware/handoffs.py

@@ -78,7 +78,19 @@ def _transform_agent_config(
         dict[str, AgentConfig]: The transformed agent config.
     """
 
+    new_config = {}
     for agent_name, _cfg in config.items():
+        new_config[agent_name] = {}
+
+        if "model" in _cfg:
+            new_config[agent_name]["model"] = _cfg["model"]
+        if "prompt" in _cfg:
+            new_config[agent_name]["prompt"] = _cfg["prompt"]
+        if "default" in _cfg:
+            new_config[agent_name]["default"] = _cfg["default"]
+        if "tools" in _cfg:
+            new_config[agent_name]["tools"] = _cfg["tools"]
+
         handoffs = _cfg.get("handoffs", [])
         if handoffs == "all":
             handoff_tools = [
@@ -102,8 +114,11 @@ def _transform_agent_config(
                 ]
             ]
 
-        _cfg["tools"] = [*_cfg.get("tools", []), *handoff_tools]
-    return config
+        new_config[agent_name]["tools"] = [
+            *new_config[agent_name].get("tools", []),
+            *handoff_tools,
+        ]
+    return new_config
 
 
 class HandoffAgentMiddleware(AgentMiddleware):

langchain_dev_utils-1.3.3/src/langchain_dev_utils/agents/wrap.py

@@ -0,0 +1,274 @@
+import asyncio
+from typing import Any, Awaitable, Callable, Optional, cast
+
+from langchain.tools import ToolRuntime
+from langchain_core.messages import AnyMessage, HumanMessage
+from langchain_core.tools import BaseTool, StructuredTool
+from langgraph.graph.state import CompiledStateGraph
+
+from langchain_dev_utils.message_convert import format_sequence
+
+
+def _process_input(request: str, runtime: ToolRuntime) -> str:
+    return request
+
+
+def _process_output(
+    request: str, response: list[AnyMessage], runtime: ToolRuntime
+) -> Any:
+    return response[-1].content
+
+
+def wrap_agent_as_tool(
+    agent: CompiledStateGraph,
+    tool_name: Optional[str] = None,
+    tool_description: Optional[str] = None,
+    pre_input_hooks: Optional[
+        tuple[
+            Callable[[str, ToolRuntime], str],
+            Callable[[str, ToolRuntime], Awaitable[str]],
+        ]
+        | Callable[[str, ToolRuntime], str]
+    ] = None,
+    post_output_hooks: Optional[
+        tuple[
+            Callable[[str, list[AnyMessage], ToolRuntime], Any],
+            Callable[[str, list[AnyMessage], ToolRuntime], Awaitable[Any]],
+        ]
+        | Callable[[str, list[AnyMessage], ToolRuntime], Any]
+    ] = None,
+) -> BaseTool:
+    """Wraps an agent as a tool
+
+    Args:
+        agent: The agent to wrap
+        tool_name: The name of the tool
+        tool_description: The description of the tool
+        pre_input_hooks: Hooks to run before the input is processed
+        post_output_hooks: Hooks to run after the output is processed
+
+    Returns:
+        BaseTool: The wrapped agent as a tool
+
+    Example:
+        >>> from langchain_dev_utils.agents import wrap_agent_as_tool, create_agent
+        >>>
+        >>> call_time_agent_tool = wrap_agent_as_tool(
+        ...     time_agent,
+        ...     tool_name="call_time_agent",
+        ...     tool_description="Used to invoke the time sub-agent to perform time-related tasks"
+        ... )
+        >>>
+        >>> agent = create_agent("vllm:qwen3-4b", tools=[call_time_agent_tool], name="agent")
+
+        >>> response = agent.invoke({"messages": [HumanMessage(content="What time is it now?")]})
+        >>> response
+    """
+    if agent.name is None:
+        raise ValueError("Agent name must not be None")
+
+    process_input = _process_input
+    process_input_async = _process_input
+    process_output = _process_output
+    process_output_async = _process_output
+
+    if pre_input_hooks:
+        if isinstance(pre_input_hooks, tuple):
+            process_input = pre_input_hooks[0]
+            process_input_async = pre_input_hooks[1]
+        else:
+            process_input = pre_input_hooks
+            process_input_async = pre_input_hooks
+
+    if post_output_hooks:
+        if isinstance(post_output_hooks, tuple):
+            process_output = post_output_hooks[0]
+            process_output_async = post_output_hooks[1]
+        else:
+            process_output = post_output_hooks
+            process_output_async = post_output_hooks
+
+    def call_agent(
+        request: str,
+        runtime: ToolRuntime,
+    ) -> str:
+        request = process_input(request, runtime) if process_input else request
+
+        messages = [HumanMessage(content=request)]
+        response = agent.invoke({"messages": messages})
+
+        response = process_output(request, response["messages"], runtime)
+        return response
+
+    async def acall_agent(
+        request: str,
+        runtime: ToolRuntime,
+    ) -> str:
+        if asyncio.iscoroutinefunction(process_input_async):
+            request = await process_input_async(request, runtime)
+        else:
+            request = cast(str, process_input_async(request, runtime))
+
+        messages = [HumanMessage(content=request)]
+        response = await agent.ainvoke({"messages": messages})
+
+        if asyncio.iscoroutinefunction(process_output_async):
+            response = await process_output_async(
+                request, response["messages"], runtime
+            )
+        else:
+            response = process_output(request, response["messages"], runtime)
+
+        return response
+
+    if tool_name is None:
+        tool_name = f"transfor_to_{agent.name}"
+        if not tool_name.endswith("_agent"):
+            tool_name += "_agent"
+
+    if tool_description is None:
+        tool_description = f"This tool transforms input to {agent.name}"
+
+    return StructuredTool.from_function(
+        func=call_agent,
+        coroutine=acall_agent,
+        name=tool_name,
+        description=tool_description,
+    )
+
+
+def wrap_all_agents_as_tool(
+    agents: list[CompiledStateGraph],
+    tool_name: Optional[str] = None,
+    tool_description: Optional[str] = None,
+    pre_input_hooks: Optional[
+        tuple[
+            Callable[[str, ToolRuntime], str],
+            Callable[[str, ToolRuntime], Awaitable[str]],
+        ]
+        | Callable[[str, ToolRuntime], str]
+    ] = None,
+    post_output_hooks: Optional[
+        tuple[
+            Callable[[str, list[AnyMessage], ToolRuntime], Any],
+            Callable[[str, list[AnyMessage], ToolRuntime], Awaitable[Any]],
+        ]
+        | Callable[[str, list[AnyMessage], ToolRuntime], Any]
+    ] = None,
+) -> BaseTool:
+    """Wraps all agents as single tool
+
+    Args:
+        agents: The agents to wrap
+        tool_name: The name of the tool, default to "task"
+        tool_description: The description of the tool
+        pre_input_hooks: Hooks to run before the input is processed
+        post_output_hooks: Hooks to run after the output is processed
+
+    Returns:
+        BaseTool: The wrapped agents as single tool
+
+    Example:
+        >>> from langchain_dev_utils.agents import wrap_all_agents_as_tool, create_agent
+        >>>
+        >>> call_time_agent_tool = wrap_all_agents_as_tool(
+        ...     [time_agent,weather_agent],
+        ...     tool_name="call_sub_agents",
+        ...     tool_description="Used to invoke the sub-agents to perform tasks"
+        ... )
+        >>>
+        >>> agent = create_agent("vllm:qwen3-4b", tools=[call_sub_agents_tool], name="agent")
+
+        >>> response = agent.invoke({"messages": [HumanMessage(content="What time is it now?")]})
+        >>> response
+    """
+    if len(agents) <= 1:
+        raise ValueError("At least more than one agent must be provided")
+
+    agents_map = {}
+
+    for agent in agents:
+        if agent.name is None:
+            raise ValueError("Agent name must not be provided")
+        if agent.name in agents_map:
+            raise ValueError("Agent name must be unique")
+        agents_map[agent.name] = agent
+
+    process_input = _process_input
+    process_input_async = _process_input
+    process_output = _process_output
+    process_output_async = _process_output
+
+    if pre_input_hooks:
+        if isinstance(pre_input_hooks, tuple):
+            process_input = pre_input_hooks[0]
+            process_input_async = pre_input_hooks[1]
+        else:
+            process_input = pre_input_hooks
+            process_input_async = pre_input_hooks
+
+    if post_output_hooks:
+        if isinstance(post_output_hooks, tuple):
+            process_output = post_output_hooks[0]
+            process_output_async = post_output_hooks[1]
+        else:
+            process_output = post_output_hooks
+            process_output_async = post_output_hooks
+
+    def call_agent(
+        agent_name: str,
+        description: str,
+        runtime: ToolRuntime,
+    ) -> str:
+        task_description = (
+            process_input(description, runtime) if process_input else description
+        )
+
+        if agent_name not in agents_map:
+            raise ValueError(f"Agent {agent_name} not found")
+
+        messages = [HumanMessage(content=task_description)]
+        response = agents_map[agent_name].invoke({"messages": messages})
+
+        response = process_output(task_description, response["messages"], runtime)
+        return response
+
+    async def acall_agent(
+        agent_name: str,
+        description: str,
+        runtime: ToolRuntime,
+    ) -> str:
+        if asyncio.iscoroutinefunction(process_input_async):
+            task_description = await process_input_async(description, runtime)
+        else:
+            task_description = cast(str, process_input_async(description, runtime))
+
+        if agent_name not in agents_map:
+            raise ValueError(f"Agent {agent_name} not found")
+
+        messages = [HumanMessage(content=task_description)]
+        response = await agents_map[agent_name].ainvoke({"messages": messages})
+
+        if asyncio.iscoroutinefunction(process_output_async):
+            response = await process_output_async(
+                task_description, response["messages"], runtime
+            )
+        else:
+            response = process_output(task_description, response["messages"], runtime)
+
+        return response
+
+    if tool_name is None:
+        tool_name = "task"
+
+    if tool_description is None:
+        tool_description = (
+            "Launch an ephemeral subagent for a task.\nAvailable agents:\n "
+            + format_sequence(list(agents_map.keys()), with_num=True)
+        )
+    return StructuredTool.from_function(
+        func=call_agent,
+        coroutine=acall_agent,
+        name=tool_name,
+        description=tool_description,
+    )

{langchain_dev_utils-1.3.2 → langchain_dev_utils-1.3.3}/tests/test_handoffs_middleware.py

@@ -25,46 +25,43 @@ def run_code(code: str) -> str:
     return "Running code successfully"
 
 
-def get_config() -> tuple[dict[str, AgentConfig], dict[str, str]]:
-    agents_config: dict[str, AgentConfig] = {
-        "time_agent": {
-            "model": "zai:glm-4.5",
-            "prompt": (
-                "You are a time assistant. You can answer users' time-related questions. "
-                "If the current question is not time-related, please transfer to another assistant."
-            ),
-            "tools": [get_current_time],
-            "handoffs": ["talk_agent"],
-        },
-        "talk_agent": {
-            "prompt": (
-                "You are a conversational assistant. You can answer users' questions. "
-                "If the current question is a time query, please transfer to the time assistant; "
-                "if it's a code-related question, please transfer to the code assistant."
-            ),
-            "default": True,
-            "handoffs": "all",
-        },
-        "code_agent": {
-            "model": load_chat_model("dashscope:qwen3-coder-plus"),
-            "prompt": (
-                "You are a code assistant. You can answer users' code-related questions. "
-                "If the current question is not code-related, please transfer to another assistant."
-            ),
-            "tools": [run_code],
-            "handoffs": ["talk_agent"],
-        },
-    }
-    custom_tool_descriptions: dict[str, str] = {
-        "time_agent": "transfer to the time agent to answer time-related questions",
-        "talk_agent": "transfer to the talk agent to answer user questions",
-        "code_agent": "transfer to the code agent to answer code-related questions",
-    }
-    return agents_config, custom_tool_descriptions
+agents_config: dict[str, AgentConfig] = {
+    "time_agent": {
+        "model": "zai:glm-4.5",
+        "prompt": (
+            "You are a time assistant. You can answer users' time-related questions. "
+            "If the current question is not time-related, please transfer to another assistant."
+        ),
+        "tools": [get_current_time],
+        "handoffs": ["talk_agent"],
+    },
+    "talk_agent": {
+        "prompt": (
+            "You are a conversational assistant. You can answer users' questions. "
+            "If the current question is a time query, please transfer to the time assistant; "
+            "if it's a code-related question, please transfer to the code assistant."
+        ),
+        "default": True,
+        "handoffs": "all",
+    },
+    "code_agent": {
+        "model": load_chat_model("dashscope:qwen3-coder-plus"),
+        "prompt": (
+            "You are a code assistant. You can answer users' code-related questions. "
+            "If the current question is not code-related, please transfer to another assistant."
+        ),
+        "tools": [run_code],
+        "handoffs": ["talk_agent"],
+    },
+}
+custom_tool_descriptions: dict[str, str] = {
+    "time_agent": "transfer to the time agent to answer time-related questions",
+    "talk_agent": "transfer to the talk agent to answer user questions",
+    "code_agent": "transfer to the code agent to answer code-related questions",
+}
 
 
 def test_handoffs_middleware():
-    agents_config, custom_tool_descriptions = get_config()
     agent = create_agent(
         model="dashscope:qwen3-max",
         middleware=[HandoffAgentMiddleware(agents_config, custom_tool_descriptions)],
@@ -103,7 +100,6 @@ def test_handoffs_middleware():
 
 
 async def test_handoffs_middleware_async():
-    agents_config, custom_tool_descriptions = get_config()
     agent = create_agent(
         model="dashscope:qwen3-max",
         middleware=[HandoffAgentMiddleware(agents_config, custom_tool_descriptions)],

{langchain_dev_utils-1.3.2 → langchain_dev_utils-1.3.3}/tests/test_wrap_agent.py

@@ -5,7 +5,7 @@ from langchain.agents import create_agent
 from langchain.tools import ToolRuntime, tool
 from langchain_core.messages import HumanMessage, ToolMessage
 
-from langchain_dev_utils.agents.wrap import wrap_agent_as_tool
+from langchain_dev_utils.agents import wrap_agent_as_tool, wrap_all_agents_as_tool
 
 
 @tool
@@ -14,6 +14,12 @@ def get_time() -> str:
     return "The current time is 10:00 AM"
 
 
+@tool
+def get_weather(city: str) -> str:
+    """Get the current weather."""
+    return f"The current weather in {city} is sunny"
+
+
 def process_input(request: str, runtime: ToolRuntime) -> str:
     return "<task_description>" + request + "</task_description>"
 
@@ -37,7 +43,9 @@ async def process_output_async(
 
 
 def test_wrap_agent():
-    agent = create_agent(model="deepseek:deepseek-chat", tools=[get_time])
+    agent = create_agent(
+        model="deepseek:deepseek-chat", tools=[get_time], name="time_agent"
+    )
     call_agent_tool = wrap_agent_as_tool(
         agent, "call_time_agent", "call the agent to query the time"
     )
@@ -100,3 +108,76 @@ async def test_wrap_agent_async(
 
     assert cast(str, msg.content).startswith("<task_response>")
     assert cast(str, msg.content).endswith("</task_response>")
+
+
+def test_wrap_all_agents():
+    time_agent = create_agent(
+        model="deepseek:deepseek-chat", tools=[get_time], name="time_agent"
+    )
+    weather_agent = create_agent(
+        model="deepseek:deepseek-chat", tools=[get_weather], name="weather_agent"
+    )
+    call_agent_tool = wrap_all_agents_as_tool(
+        [time_agent, weather_agent], "call_sub_agents"
+    )
+    assert call_agent_tool.name == "call_sub_agents"
+
+    main_agent = create_agent(model="deepseek:deepseek-chat", tools=[call_agent_tool])
+    response = main_agent.invoke(
+        {"messages": [HumanMessage(content="What time is it now?")]}
+    )
+
+    msg = None
+    for message in response["messages"]:
+        if isinstance(message, ToolMessage) and message.name == "call_sub_agents":
+            msg = message
+            break
+    assert msg is not None
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "pre_input_hooks,post_output_hooks",
+    [
+        (
+            process_input,
+            process_output,
+        ),
+        (
+            (process_input, process_input_async),
+            (process_output, process_output_async),
+        ),
+    ],
+)
+async def test_wrap_all_agents_async(
+    pre_input_hooks: Any,
+    post_output_hooks: Any,
+):
+    time_agent = create_agent(
+        model="deepseek:deepseek-chat", tools=[get_time], name="time_agent"
+    )
+    weather_agent = create_agent(
+        model="deepseek:deepseek-chat", tools=[get_weather], name="weather_agent"
+    )
+    call_agent_tool = wrap_all_agents_as_tool(
+        [time_agent, weather_agent],
+        "call_sub_agents",
+        pre_input_hooks=pre_input_hooks,
+        post_output_hooks=post_output_hooks,
+    )
+    assert call_agent_tool.name == "call_sub_agents"
+
+    main_agent = create_agent(model="deepseek:deepseek-chat", tools=[call_agent_tool])
+    response = await main_agent.ainvoke(
+        {"messages": [HumanMessage(content="What time is it now?")]}
+    )
+
+    msg = None
+    for message in response["messages"]:
+        if isinstance(message, ToolMessage) and message.name == "call_sub_agents":
+            msg = message
+            break
+    assert msg is not None
+
+    assert cast(str, msg.content).startswith("<task_response>")
+    assert cast(str, msg.content).endswith("</task_response>")

langchain_dev_utils-1.3.2/src/langchain_dev_utils/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.3.2"

langchain_dev_utils-1.3.2/src/langchain_dev_utils/agents/__init__.py

@@ -1,4 +0,0 @@
-from .factory import create_agent
-from .wrap import wrap_agent_as_tool
-
-__all__ = ["create_agent", "wrap_agent_as_tool"]

langchain_dev_utils-1.3.2/src/langchain_dev_utils/agents/wrap.py

@@ -1,140 +0,0 @@
-import asyncio
-from typing import Any, Awaitable, Callable, Optional, cast
-
-from langchain.tools import ToolRuntime
-from langchain_core.messages import AnyMessage, HumanMessage
-from langchain_core.tools import BaseTool, StructuredTool
-from langgraph.graph.state import CompiledStateGraph
-from pydantic import BaseModel, Field
-
-
-class AgentToolInput(BaseModel):
-    request: str = Field(description="The input to the agent")
-
-
-def _process_input(request: str, runtime: ToolRuntime) -> str:
-    return request
-
-
-def _process_output(
-    request: str, response: list[AnyMessage], runtime: ToolRuntime
-) -> Any:
-    return response[-1].content
-
-
-def wrap_agent_as_tool(
-    agent: CompiledStateGraph,
-    tool_name: Optional[str] = None,
-    tool_description: Optional[str] = None,
-    pre_input_hooks: Optional[
-        tuple[
-            Callable[[str, ToolRuntime], str],
-            Callable[[str, ToolRuntime], Awaitable[str]],
-        ]
-        | Callable[[str, ToolRuntime], str]
-    ] = None,
-    post_output_hooks: Optional[
-        tuple[
-            Callable[[str, list[AnyMessage], ToolRuntime], Any],
-            Callable[[str, list[AnyMessage], ToolRuntime], Awaitable[Any]],
-        ]
-        | Callable[[str, list[AnyMessage], ToolRuntime], Any]
-    ] = None,
-) -> BaseTool:
-    """Wraps an agent as a tool
-
-    Args:
-        agent: The agent to wrap
-        tool_name: The name of the tool
-        tool_description: The description of the tool
-        pre_input_hooks: Hooks to run before the input is processed
-        post_output_hooks: Hooks to run after the output is processed
-
-    Returns:
-        BaseTool: The wrapped agent as a tool
-
-    Example:
-        >>> from langchain_dev_utils.agents import wrap_agent_as_tool, create_agent
-        >>>
-        >>> call_time_agent_tool = wrap_agent_as_tool(
-        ...     time_agent,
-        ...     tool_name="call_time_agent",
-        ...     tool_description="Used to invoke the time sub-agent to perform time-related tasks"
-        ... )
-        >>>
-        >>> agent = create_agent("vllm:qwen3-4b", tools=[call_time_agent_tool], name="agent")
-
-        >>> response = agent.invoke({"messages": [HumanMessage(content="What time is it now?")]})
-        >>> response
-    """
-    if agent.name is None:
-        raise ValueError("Agent name must not be None")
-
-    process_input = _process_input
-    process_input_async = _process_input
-    process_output = _process_output
-    process_output_async = _process_output
-
-    if pre_input_hooks:
-        if isinstance(pre_input_hooks, tuple):
-            process_input = pre_input_hooks[0]
-            process_input_async = pre_input_hooks[1]
-        else:
-            process_input = pre_input_hooks
-            process_input_async = pre_input_hooks
-
-    if post_output_hooks:
-        if isinstance(post_output_hooks, tuple):
-            process_output = post_output_hooks[0]
-            process_output_async = post_output_hooks[1]
-        else:
-            process_output = post_output_hooks
-            process_output_async = post_output_hooks
-
-    def call_agent(
-        request: str,
-        runtime: ToolRuntime,
-    ) -> str:
-        request = process_input(request, runtime) if process_input else request
-
-        messages = [HumanMessage(content=request)]
-        response = agent.invoke({"messages": messages})
-
-        response = process_output(request, response["messages"], runtime)
-        return response
-
-    async def acall_agent(
-        request: str,
-        runtime: ToolRuntime,
-    ) -> str:
-        if asyncio.iscoroutinefunction(process_input_async):
-            request = await process_input_async(request, runtime)
-        else:
-            request = cast(str, process_input_async(request, runtime))
-
-        messages = [HumanMessage(content=request)]
-        response = await agent.ainvoke({"messages": messages})
-
-        if asyncio.iscoroutinefunction(process_output_async):
-            response = await process_output_async(
-                request, response["messages"], runtime
-            )
-        else:
-            response = process_output(request, response["messages"], runtime)
-
-        return response
-
-    if tool_name is None:
-        tool_name = f"transfor_to_{agent.name}"
-        if not tool_name.endswith("_agent"):
-            tool_name += "_agent"
-
-    if tool_description is None:
-        tool_description = f"This tool transforms input to {agent.name}"
-
-    return StructuredTool.from_function(
-        func=call_agent,
-        coroutine=acall_agent,
-        name=tool_name,
-        description=tool_description,
-    )