deepagents 0.0.6rc1__py3-none-any.whl → 0.0.6rc3__py3-none-any.whl

{deepagents-0.0.6rc1.dist-info → deepagents-0.0.6rc3.dist-info}/METADATA

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.0.6rc1
+Version: 0.0.6rc3
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: langgraph>=0.2.6
+Requires-Dist: langgraph>=1.0.0a3
 Requires-Dist: langchain-anthropic>=0.1.23
-Requires-Dist: langchain>=0.2.14
-Requires-Dist: build>=1.3.0
+Requires-Dist: langchain>=1.0.0a7
+Requires-Dist: langgraph-prebuilt>=0.7.0a2
 Dynamic: license-file
 
 # 🧠🤖Deep Agents
@@ -38,7 +38,7 @@ pip install deepagents
 ```python
 import os
 from typing import Literal
-
+from langchain_core.tools import tool
 from tavily import TavilyClient
 from deepagents import create_deep_agent
 
@@ -87,7 +87,7 @@ in the same way you would any LangGraph agent.
 
 ## Creating a custom deep agent
 
-There are three parameters you can pass to `create_deep_agent` to create your own custom deep agent.
+There are several parameters you can pass to `create_deep_agent` to create your own custom deep agent.
 
 ### `tools` (Required)
 
@@ -99,7 +99,7 @@ The agent (and any subagents) will have access to these tools.
 
 The second argument to `create_deep_agent` is `instructions`.
 This will serve as part of the prompt of the deep agent.
-Note that there is a [built in system prompt](src/deepagents/prompts.py) as well, so this is not the *entire* prompt the agent will see.
+Note that our deep agent middleware appends further instructions to the deep agent regarding to-do list, filesystem, and subagent usage, so this is not the *entire* prompt the agent will see.
 
 ### `subagents` (Optional)
 
@@ -115,7 +115,8 @@ class SubAgent(TypedDict):
     description: str
     prompt: str
     tools: NotRequired[list[str]]
-    model_settings: NotRequired[dict[str, Any]]
+    model: NotRequired[Union[LanguageModelLike, dict[str, Any]]]
+    middleware: NotRequired[list[AgentMiddleware]]
 
 class CustomSubAgent(TypedDict):
     name: str
@@ -128,7 +129,8 @@ class CustomSubAgent(TypedDict):
 - **description**: This is the description of the subagent that is shown to the main agent
 - **prompt**: This is the prompt used for the subagent
 - **tools**: This is the list of tools that the subagent has access to. By default will have access to all tools passed in, as well as all built-in tools.
-- **model_settings**: Optional dictionary for per-subagent model configuration (inherits the main model when omitted).
+- **model**: Optional model instance OR dictionary for per-subagent model configuration (inherits the main model when omitted).
+- **middleware** Additional middleware to attach to the subagent. See [here](https://docs.langchain.com/oss/python/langchain/middleware) for an introduction into middleware and how it works with create_agent.
 
 **CustomSubAgent fields:**
 - **name**: This is the name of the subagent, and how the main agent will call the subagent
@@ -142,6 +144,7 @@ research_subagent = {
     "name": "research-agent",
     "description": "Used to research more in depth questions",
     "prompt": sub_research_prompt,
+    "tools": [internet_search]
 }
 subagents = [research_subagent]
 agent = create_deep_agent(
@@ -184,18 +187,6 @@ agent = create_deep_agent(
 
 By default, `deepagents` uses `"claude-sonnet-4-20250514"`. You can customize this by passing any [LangChain model object](https://python.langchain.com/docs/integrations/chat/).
 
-### `builtin_tools` (Optional)
-
-By default, a deep agent will have access to a number of [built-in tools](#builtintools--optional-).
-You can change this by specifying the tools (by name) that the agent should have access to with this parameter.
-
-Example:
-```python
-# Only give agent access to todo tool, none of the filesystem tools
-builtin_tools = ["write_todos"]
-agent = create_deep_agent(..., builtin_tools=builtin_tools, ...)
-```
-
 #### Example: Using a Custom Model
 
 Here's how to use a custom model (like OpenAI's `gpt-oss` model via Ollama):
@@ -244,6 +235,15 @@ agent = create_deep_agent(
 )
 ```
 
+
+### `middleware` (Optional)
+Both the main agent and sub-agents can take additional custom AgentMiddleware. Middleware is the best supported approach for extending the state_schema, adding additional tools, and adding pre / post model hooks. See this [doc](https://docs.langchain.com/oss/python/langchain/middleware) to learn more about Middleware and how you can use it!
+
+### `tool_configs` (Optional)
+Tool configs are used to specify how to handle Human In The Loop interactions on certain tools that require additional human oversight. 
+
+These tool_configs are passed to our prebuilt [HITL middleware](https://docs.langchain.com/oss/python/langchain/middleware#human-in-the-loop) so that the agent pauses execution and waits for feedback from the user before executing configured tools.
+
 ## Deep Agent Details
 
 The below components are built into `deepagents` and helps make it work for deep tasks off-the-shelf.
@@ -305,25 +305,20 @@ By default, deep agents come with five built-in tools:
 - `ls`: Tool for listing files in the virtual filesystem
 - `edit_file`: Tool for editing a file in the virtual filesystem
 
-These can be disabled via the [`builtin_tools`](#builtintools--optional-) parameter.
+If you want to omit some deepagents functionality, use specific middleware components directly!
 
 ### Human-in-the-Loop
 
-`deepagents` supports human-in-the-loop approval for tool execution. You can configure specific tools to require human approval before execution using the `interrupt_config` parameter, which maps tool names to `HumanInterruptConfig`.
+`deepagents` supports human-in-the-loop approval for tool execution. You can configure specific tools to require human approval before execution using the `tool_configs` parameter, which maps tool names to a `HumanInTheLoopConfig`.
 
-`HumanInterruptConfig` is how you specify what type of human in the loop patterns are supported. 
+`HumanInTheLoopConfig` is how you specify what type of human in the loop patterns are supported. 
 It is a dictionary with four specific keys:
 
-- `allow_ignore`: Whether the user can skip the tool call
-- `allow_respond`: Whether the user can add a text response
-- `allow_edit`: Whether the user can edit the tool arguments
-- `allow_accept`: Whether the user can accept the tool call
-
-Currently, `deepagents` does NOT support `allow_ignore`
+- `allow_accept`: Whether the human can approve the current action without changes
+- `allow_respond`: Whether the human can reject the current action with feedback
+- `allow_edit`: Whether the human can approve the current action with edited content
 
-Currently, `deepagents` only support interrupting one tool at a time. If multiple tools are called in parallel, each requiring interrupts, then the agent will error.
-
-Instead of specifying a `HumanInterruptConfig` for a tool, you can also just set `True`. This will set `allow_ignore`, `allow_respond`, `allow_edit`, and `allow_accept` to be `True`.
+Instead of specifying a `HumanInTheLoopConfig` for a tool, you can also just set `True`. This will set `allow_ignore`, `allow_respond`, `allow_edit`, and `allow_accept` to be `True`.
 
 In order to use human in the loop, you need to have a checkpointer attached.
 Note: if you are using LangGraph Platform, this is automatically attached.
@@ -338,10 +333,9 @@ from langgraph.checkpoint.memory import InMemorySaver
 agent = create_deep_agent(
     tools=[your_tools],
     instructions="Your instructions here",
-    interrupt_config={
+    tool_configs={
         # You can specify a dictionary for fine grained control over what interrupt options exist
         "tool_1": {
-            "allow_ignore": False,
             "allow_respond": True,
             "allow_edit": True,
             "allow_accept":True,
@@ -414,12 +408,12 @@ for s in agent.stream(Command(resume=[{"type": "response", "args": "..."}]), con
 ```
 ## Async
 
-If you are passing async tools to your agent, you will want to `from deepagents import async_create_deep_agent`
+If you are passing async tools to your agent, you will want to use `from deepagents import async_create_deep_agent`
 ## MCP
 
 The `deepagents` library can be ran with MCP tools. This can be achieved by using the [Langchain MCP Adapter library](https://github.com/langchain-ai/langchain-mcp-adapters).
 
-**NOTE:** will want to use `from deepagents import async_create_deep_agent` to use the async version of `deepagents`, since MCP tools are async
+**NOTE:** You will want to use `from deepagents import async_create_deep_agent` to use the async version of `deepagents`, since MCP tools are async
 
 (To run the example below, will need to `pip install langchain-mcp-adapters`)
 
@@ -447,27 +441,6 @@ async def main():
 asyncio.run(main())
 ```
 
-## Configurable Agent
-
-Configurable agents allow you to control the agent via a config passed in.
-
-```python
-from deepagents import create_configurable_agent
-
-agent_config = {"instructions": "foo", "subagents": []}
-
-build_agent = create_configurable_agent(
-    agent_config['instructions'],
-    agent_config['subagents'],
-    [],
-    agent_config={"recursion_limit": 1000}
-)
-```
-You can now use `build_agent` in your `langgraph.json` and deploy it with `langgraph dev`
-
-For async tools, you can use `from deepagents import async_create_configurable_agent`
-
-
 ## Roadmap
 - [ ] Allow users to customize full system prompt
 - [ ] Code cleanliness (type hinting, docstrings, formating)

deepagents-0.0.6rc3.dist-info/RECORD

@@ -0,0 +1,17 @@
+deepagents/__init__.py,sha256=fA_91ByxPb3e8aPfci43zOXrWz8ylh_CFQALo7EUKi8,312
+deepagents/graph.py,sha256=LciBn8Q2wbi-vlEbqPS0udQvXDnMTP0WKQHNcOyrQsc,6419
+deepagents/middleware.py,sha256=WyK1bf3u1QmMxVcM5KD2tsYMoIKBFQivi6bWYa_cFfA,7242
+deepagents/model.py,sha256=VyRIkdeXJH8HqLrudTKucHpBTtrwMFTQGRlXBj0kUyo,155
+deepagents/prompts.py,sha256=mCnNGTRljfDUMXEfVRiBNGvhoc_wQjt0epiGMJkktgo,25150
+deepagents/state.py,sha256=8so3MgL-zRPYP8Ci_OuVg4wHrs5uAXCErKF1AjjCSt8,726
+deepagents/tools.py,sha256=NpjO2ZEAnL8ZKsYBfxK36AYaayOxC7hWYOvEBCL_5tA,4777
+deepagents/types.py,sha256=5KBSUPlWOnv9It3SnJCMHrOtp9Y4_NQGtGCp69JsEjE,694
+deepagents-0.0.6rc3.dist-info/licenses/LICENSE,sha256=c__BaxUCK69leo2yEKynf8lWndu8iwYwge1CbyqAe-E,1071
+tests/test_deepagents.py,sha256=SwtOiJF4c1O3r_Q3AiM7XZu6tVq4uMIcZlnsfRjx8Ig,7648
+tests/test_hitl.py,sha256=B16ZFiyaVSOcDLz7mh1RTaQZ93EMTKOPUY-IEslkcfM,2460
+tests/test_middleware.py,sha256=3HYmTx0Jw4XTNJjqLYeyGS_QZzcqkFuKfShtajIDhF4,2146
+tests/utils.py,sha256=Ln_DYaMkwAVBo4XQ-QKwlCWP8zZYMenWTcFhsneoL0g,2913
+deepagents-0.0.6rc3.dist-info/METADATA,sha256=i1wrfqlpyi9Dej8vlvuct10xOzljw887Q1BW3i8xJ08,17171
+deepagents-0.0.6rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deepagents-0.0.6rc3.dist-info/top_level.txt,sha256=_w9VMQtG4YDNg5A5eAeUre7dF7x7hk9zRpT9zsFaukY,17
+deepagents-0.0.6rc3.dist-info/RECORD,,

{deepagents-0.0.6rc1.dist-info → deepagents-0.0.6rc3.dist-info}/top_level.txt

@@ -1 +1,2 @@
 deepagents
+tests

tests/test_deepagents.py

@@ -0,0 +1,136 @@
+from deepagents.graph import create_deep_agent
+from langchain.agents import create_agent
+from tests.utils import assert_all_deepagent_qualities, SAMPLE_MODEL, sample_tool, get_weather, get_soccer_scores, SampleMiddlewareWithTools, SampleMiddlewareWithToolsAndState, WeatherToolMiddleware, ResearchMiddleware, ResearchMiddlewareWithTools, TOY_BASKETBALL_RESEARCH
+
+class TestDeepAgents:
+    def test_base_deep_agent(self):
+        agent = create_deep_agent()
+        assert_all_deepagent_qualities(agent)
+
+    def test_deep_agent_with_tool(self):
+        agent = create_deep_agent(tools=[sample_tool])
+        assert_all_deepagent_qualities(agent)
+        assert "sample_tool" in agent.nodes["tools"].bound._tools_by_name.keys()
+
+    def test_deep_agent_with_middleware_with_tool(self):
+        agent = create_deep_agent(middleware=[SampleMiddlewareWithTools()])
+        assert_all_deepagent_qualities(agent)
+        assert "sample_tool" in agent.nodes["tools"].bound._tools_by_name.keys()
+
+    def test_deep_agent_with_middleware_with_tool_and_state(self):
+        agent = create_deep_agent(middleware=[SampleMiddlewareWithToolsAndState()])
+        assert_all_deepagent_qualities(agent)
+        assert "sample_tool" in agent.nodes["tools"].bound._tools_by_name.keys()
+        assert "sample_input" in agent.stream_channels
+
+    def test_deep_agent_with_subagents(self):
+        subagents = [
+            {
+                "name": "weather_agent",
+                "description": "Use this agent to get the weather",
+                "prompt": "You are a weather agent.",
+                "tools": [get_weather],
+                "model": SAMPLE_MODEL,
+            }
+        ]
+        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
+        assert_all_deepagent_qualities(agent)
+        result = agent.invoke({"messages": [{"role": "user", "content": "What is the weather in Tokyo?"}]})
+        agent_messages = [msg for msg in result.get("messages", []) if msg.type == "ai"]
+        tool_calls = [tool_call for msg in agent_messages for tool_call in msg.tool_calls]
+        assert any([tool_call["name"] == "task" and tool_call["args"].get("subagent_type") == "weather_agent" for tool_call in tool_calls])
+
+    def test_deep_agent_with_subagents_gen_purpose(self):
+        subagents = [
+            {
+                "name": "weather_agent",
+                "description": "Use this agent to get the weather",
+                "prompt": "You are a weather agent.",
+                "tools": [get_weather],
+                "model": SAMPLE_MODEL,
+            }
+        ]
+        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
+        assert_all_deepagent_qualities(agent)
+        result = agent.invoke({"messages": [{"role": "user", "content": "Use the general purpose subagent to call the sample tool"}]})
+        agent_messages = [msg for msg in result.get("messages", []) if msg.type == "ai"]
+        tool_calls = [tool_call for msg in agent_messages for tool_call in msg.tool_calls]
+        assert any([tool_call["name"] == "task" and tool_call["args"].get("subagent_type") == "general-purpose" for tool_call in tool_calls])
+
+    def test_deep_agent_with_subagents_with_middleware(self):
+        subagents = [
+            {
+                "name": "weather_agent",
+                "description": "Use this agent to get the weather",
+                "prompt": "You are a weather agent.",
+                "tools": [],
+                "model": SAMPLE_MODEL,
+                "middleware": [WeatherToolMiddleware()],
+            }
+        ]
+        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
+        assert_all_deepagent_qualities(agent)
+        result = agent.invoke({"messages": [{"role": "user", "content": "What is the weather in Tokyo?"}]})
+        agent_messages = [msg for msg in result.get("messages", []) if msg.type == "ai"]
+        tool_calls = [tool_call for msg in agent_messages for tool_call in msg.tool_calls]
+        assert any([tool_call["name"] == "task" and tool_call["args"].get("subagent_type") == "weather_agent" for tool_call in tool_calls])
+
+    def test_deep_agent_with_custom_subagents(self):
+        subagents = [
+            {
+                "name": "weather_agent",
+                "description": "Use this agent to get the weather",
+                "prompt": "You are a weather agent.",
+                "tools": [get_weather],
+                "model": SAMPLE_MODEL,
+            },
+            {
+                "name": "soccer_agent",
+                "description": "Use this agent to get the latest soccer scores",
+                "graph": create_agent(
+                    model=SAMPLE_MODEL,
+                    tools=[get_soccer_scores],
+                    prompt="You are a soccer agent.",
+                )
+            }
+        ]
+        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
+        assert_all_deepagent_qualities(agent)
+        result = agent.invoke({"messages": [{"role": "user", "content": "Look up the weather in Tokyo, and the latest scores for Manchester City!"}]})
+        agent_messages = [msg for msg in result.get("messages", []) if msg.type == "ai"]
+        tool_calls = [tool_call for msg in agent_messages for tool_call in msg.tool_calls]
+        assert any([tool_call["name"] == "task" and tool_call["args"].get("subagent_type") == "weather_agent" for tool_call in tool_calls])
+        assert any([tool_call["name"] == "task" and tool_call["args"].get("subagent_type") == "soccer_agent" for tool_call in tool_calls])
+
+    def test_deep_agent_with_extended_state_and_subagents(self):
+        subagents = [
+            {
+                "name": "basketball_info_agent",
+                "description": "Use this agent to get surface level info on any basketball topic",
+                "prompt": "You are a basketball info agent.",
+                "middleware": [ResearchMiddlewareWithTools()],
+            }
+        ]
+        agent = create_deep_agent(tools=[sample_tool], subagents=subagents, middleware=[ResearchMiddleware()])
+        assert_all_deepagent_qualities(agent)
+        assert "research" in agent.stream_channels
+        result = agent.invoke({"messages": [{"role": "user", "content": "Get surface level info on lebron james"}]}, config={"recursion_limit": 100})
+        agent_messages = [msg for msg in result.get("messages", []) if msg.type == "ai"]
+        tool_calls = [tool_call for msg in agent_messages for tool_call in msg.tool_calls]
+        assert any([tool_call["name"] == "task" and tool_call["args"].get("subagent_type") == "basketball_info_agent" for tool_call in tool_calls])
+        assert TOY_BASKETBALL_RESEARCH in result["research"]
+
+    def test_deep_agent_with_subagents_no_tools(self):
+        subagents = [
+            {
+                "name": "basketball_info_agent",
+                "description": "Use this agent to get surface level info on any basketball topic",
+                "prompt": "You are a basketball info agent.",
+            }
+        ]
+        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
+        assert_all_deepagent_qualities(agent)
+        result = agent.invoke({"messages": [{"role": "user", "content": "Use the basketball info subagent to call the sample tool"}]}, config={"recursion_limit": 100})
+        agent_messages = [msg for msg in result.get("messages", []) if msg.type == "ai"]
+        tool_calls = [tool_call for msg in agent_messages for tool_call in msg.tool_calls]
+        assert any([tool_call["name"] == "task" and tool_call["args"].get("subagent_type") == "basketball_info_agent" for tool_call in tool_calls])

tests/test_hitl.py

@@ -0,0 +1,51 @@
+from deepagents.graph import create_deep_agent
+from tests.utils import assert_all_deepagent_qualities, get_weather, sample_tool, get_soccer_scores
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.types import Command
+import uuid
+
+SAMPLE_TOOL_CONFIG = {
+    "sample_tool": True,
+    "get_weather": False,
+    "get_soccer_scores": {
+        "allow_accept": True,
+        "allow_reject": True,
+        "allow_respond": False,
+        "description": "Ohohohooooo"
+    },
+}
+
+class TestHITL:
+    def test_hitl_agent(self):
+        checkpointer = MemorySaver()
+        agent = create_deep_agent(tools=[sample_tool, get_weather, get_soccer_scores], tool_configs=SAMPLE_TOOL_CONFIG, checkpointer=checkpointer)
+        config = {
+            "configurable": {
+                "thread_id": uuid.uuid4()
+            }
+        }
+        assert_all_deepagent_qualities(agent)
+        result = agent.invoke({"messages": [{"role": "user", "content": "Call the sample tool, get the weather in New York and get scores for the latest soccer games in parallel"}]}, config=config)
+        agent_messages = [msg for msg in result.get("messages", []) if msg.type == "ai"]
+        tool_calls = [tool_call for msg in agent_messages for tool_call in msg.tool_calls]
+        assert any([tool_call["name"] == "sample_tool" for tool_call in tool_calls])
+        assert any([tool_call["name"] == "get_weather" for tool_call in tool_calls])
+        assert any([tool_call["name"] == "get_soccer_scores" for tool_call in tool_calls])
+        
+        assert result["__interrupt__"] is not None
+        interrupts = result["__interrupt__"][0].value
+        assert len(interrupts) == 2
+        assert any([interrupt["action_request"]["action"] == "sample_tool" for interrupt in interrupts])
+        assert any([interrupt["action_request"]["action"] == "get_soccer_scores" for interrupt in interrupts])
+
+        result2 = agent.invoke(
+            Command(
+                resume=[{"type": "accept"}, {"type": "accept"}]
+            ),
+            config=config
+        )
+        tool_results = [msg for msg in result2.get("messages", []) if msg.type == "tool"]
+        assert any([tool_result.name == "sample_tool" for tool_result in tool_results])
+        assert any([tool_result.name == "get_weather" for tool_result in tool_results])
+        assert any([tool_result.name == "get_soccer_scores" for tool_result in tool_results])
+        assert "__interrupt__" not in result2

tests/test_middleware.py

@@ -0,0 +1,57 @@
+from langchain.agents import create_agent
+from deepagents.middleware import (
+    PlanningMiddleware,
+    FilesystemMiddleware,
+    SubAgentMiddleware,
+)
+
+SAMPLE_MODEL = "claude-3-5-sonnet-20240620"
+
+class TestAddMiddleware:
+    def test_planning_middleware(self):
+        middleware = [PlanningMiddleware()]
+        agent = create_agent(model=SAMPLE_MODEL, middleware=middleware, tools=[])
+        assert "todos" in agent.stream_channels
+        assert "write_todos" in agent.nodes["tools"].bound._tools_by_name.keys()
+
+    def test_filesystem_middleware(self):
+        middleware = [FilesystemMiddleware()]
+        agent = create_agent(model=SAMPLE_MODEL, middleware=middleware, tools=[])
+        assert "files" in agent.stream_channels
+        agent_tools = agent.nodes["tools"].bound._tools_by_name.keys()
+        assert "ls" in agent_tools
+        assert "read_file" in agent_tools
+        assert "write_file" in agent_tools
+        assert "edit_file" in agent_tools
+
+    def test_subagent_middleware(self):
+        middleware = [
+            SubAgentMiddleware(
+                default_subagent_tools=[],
+                subagents=[],
+                model=SAMPLE_MODEL
+            )
+        ]
+        agent = create_agent(model=SAMPLE_MODEL, middleware=middleware, tools=[])
+        assert "task" in agent.nodes["tools"].bound._tools_by_name.keys()
+
+    def test_multiple_middleware(self):
+        middleware = [
+            PlanningMiddleware(),
+            FilesystemMiddleware(),
+            SubAgentMiddleware(
+                default_subagent_tools=[],
+                subagents=[],
+                model=SAMPLE_MODEL
+            )
+        ]
+        agent = create_agent(model=SAMPLE_MODEL, middleware=middleware, tools=[])
+        assert "todos" in agent.stream_channels
+        assert "files" in agent.stream_channels
+        agent_tools = agent.nodes["tools"].bound._tools_by_name.keys()
+        assert "write_todos" in agent_tools
+        assert "ls" in agent_tools
+        assert "read_file" in agent_tools
+        assert "write_file" in agent_tools
+        assert "edit_file" in agent_tools
+        assert "task" in agent_tools

tests/utils.py

@@ -0,0 +1,81 @@
+from langchain_core.tools import tool, InjectedToolCallId
+from langchain.agents.middleware import AgentMiddleware
+from typing import Annotated
+from langchain.agents.tool_node import InjectedState
+from langchain.agents.middleware import AgentMiddleware, AgentState
+from langgraph.types import Command
+from langchain_core.messages import ToolMessage
+
+def assert_all_deepagent_qualities(agent):
+    assert "todos" in agent.stream_channels
+    assert "files" in agent.stream_channels
+    assert "write_todos" in agent.nodes["tools"].bound._tools_by_name.keys()
+    assert "ls" in agent.nodes["tools"].bound._tools_by_name.keys()
+    assert "read_file" in agent.nodes["tools"].bound._tools_by_name.keys()
+    assert "write_file" in agent.nodes["tools"].bound._tools_by_name.keys()
+    assert "edit_file" in agent.nodes["tools"].bound._tools_by_name.keys()
+    assert "task" in agent.nodes["tools"].bound._tools_by_name.keys()
+
+###########################
+# Mock tools and middleware
+###########################
+
+SAMPLE_MODEL = "claude-3-5-sonnet-20240620"
+
+@tool(description="Use this tool to get the weather")
+def get_weather(location: str):
+    return f"The weather in {location} is sunny."
+
+@tool(description="Use this tool to get the latest soccer scores")
+def get_soccer_scores(team: str):
+    return f"The latest soccer scores for {team} are 2-1."
+
+@tool(description="Sample tool")
+def sample_tool(sample_input: str):
+    return sample_input
+
+@tool(description="Sample tool with injected state")
+def sample_tool_with_injected_state(sample_input: str, state: Annotated[dict, InjectedState]):
+    return sample_input + state["sample_input"]
+
+TOY_BASKETBALL_RESEARCH = "Lebron James is the best basketball player of all time with over 40k points and 21 seasons in the NBA."
+
+@tool(description="Use this tool to conduct research into basketball and save it to state")
+def research_basketball(
+    topic: str,
+    state: Annotated[dict, InjectedState],
+    tool_call_id: Annotated[str, InjectedToolCallId]
+):
+    current_research = state.get("research", "")
+    research = f"{current_research}\n\nResearching on {topic}... Done! {TOY_BASKETBALL_RESEARCH}"
+    return Command(
+        update={
+            "research": research,
+            "messages": [
+                ToolMessage(research, tool_call_id=tool_call_id)
+            ]
+        }
+    )
+
+class ResearchState(AgentState):
+    research: str
+
+class ResearchMiddlewareWithTools(AgentMiddleware):
+    state_schema = ResearchState
+    tools = [research_basketball]
+
+class ResearchMiddleware(AgentMiddleware):
+    state_schema = ResearchState
+
+class SampleMiddlewareWithTools(AgentMiddleware):
+    tools = [sample_tool]
+
+class SampleState(AgentState):
+    sample_input: str
+
+class SampleMiddlewareWithToolsAndState(AgentMiddleware):
+    state_schema = SampleState
+    tools = [sample_tool]
+
+class WeatherToolMiddleware(AgentMiddleware):
+    tools = [get_weather]

deepagents/builder.py

@@ -1,84 +0,0 @@
-from deepagents import create_deep_agent, async_create_deep_agent, SubAgent
-from langchain_core.tools import BaseTool, tool
-from pydantic import BaseModel
-from typing import Any, Optional
-from typing_extensions import TypedDict, NotRequired
-
-
-class SerializableSubAgent(TypedDict):
-    name: str
-    description: str
-    prompt: str
-    tools: NotRequired[list[str]]
-    # Optional per-subagent model: can be either a model instance OR dict settings
-    model: NotRequired[dict[str, Any]]
-
-
-def create_configurable_agent(
-    default_instructions: str,
-    default_sub_agents: list[SerializableSubAgent],
-    tools,
-    agent_config: Optional[dict] = None,
-    **kwargs,
-):
-    tools = [t if isinstance(t, BaseTool) else tool(t) for t in tools]
-    tool_names = [t.name for t in tools]
-
-    class AgentConfig(BaseModel):
-        instructions: str = default_instructions
-        subagents: list[SerializableSubAgent] = default_sub_agents
-        tools: list[str] = tool_names
-
-    def build_agent(config: Optional[dict] = None):
-        if config is not None:
-            config = config.get("configurable", {})
-        else:
-            config = {}
-        config_fields = {
-            k: v for k, v in config.items() if k in ["instructions", "subagents"]
-        }
-        config = AgentConfig(**config_fields)
-        return create_deep_agent(
-            instructions=config.instructions,
-            tools=[t for t in tools if t.name in config.tools],
-            subagents=config.subagents,
-            config_schema=AgentConfig,
-            **kwargs,
-        ).with_config(agent_config or {})
-
-    return build_agent
-
-
-def async_create_configurable_agent(
-    default_instructions: str,
-    default_sub_agents: list[SerializableSubAgent],
-    tools,
-    agent_config: Optional[dict] = None,
-    **kwargs,
-):
-    tools = [t if isinstance(t, BaseTool) else tool(t) for t in tools]
-    tool_names = [t.name for t in tools]
-
-    class AgentConfig(BaseModel):
-        instructions: str = default_instructions
-        subagents: list[SerializableSubAgent] = default_sub_agents
-        tools: list[str] = tool_names
-
-    def build_agent(config: Optional[dict] = None):
-        if config is not None:
-            config = config.get("configurable", {})
-        else:
-            config = {}
-        config_fields = {
-            k: v for k, v in config.items() if k in ["instructions", "subagents"]
-        }
-        config = AgentConfig(**config_fields)
-        return async_create_deep_agent(
-            instructions=config.instructions,
-            tools=[t for t in tools if t.name in config.tools],
-            subagents=config.subagents,
-            config_schema=AgentConfig,
-            **kwargs,
-        ).with_config(agent_config or {"recursion_limit": 1000})
-
-    return build_agent