deepagents 0.0.6rc2__py3-none-any.whl → 0.0.7__py3-none-any.whl

deepagents/__init__.py

@@ -1,9 +1,5 @@
 from deepagents.graph import create_deep_agent, async_create_deep_agent
-from deepagents.interrupt import ToolInterruptConfig
+from deepagents.middleware import PlanningMiddleware, FilesystemMiddleware, SubAgentMiddleware
 from deepagents.state import DeepAgentState
-from deepagents.sub_agent import SubAgent
+from deepagents.types import SubAgent, CustomSubAgent
 from deepagents.model import get_default_model
-from deepagents.builder import (
-    create_configurable_agent,
-    async_create_configurable_agent,
-)

deepagents/graph.py

@@ -1,130 +1,81 @@
-from deepagents.sub_agent import (
-    _create_task_tool,
-    _create_sync_task_tool,
-    SubAgent,
-    CustomSubAgent,
-)
-from deepagents.model import get_default_model
-from deepagents.tools import write_todos, write_file, read_file, ls, edit_file
-from deepagents.state import DeepAgentState
-from typing import Sequence, Union, Callable, Any, TypeVar, Type, Optional
-from langchain_core.tools import BaseTool, tool
+from typing import Sequence, Union, Callable, Any, Type, Optional
+from langchain_core.tools import BaseTool
 from langchain_core.language_models import LanguageModelLike
-from deepagents.interrupt import create_interrupt_hook, ToolInterruptConfig
 from langgraph.types import Checkpointer
-from langgraph.prebuilt import create_react_agent
+from langchain.agents import create_agent
+from langchain.agents.middleware import AgentMiddleware, SummarizationMiddleware, HumanInTheLoopMiddleware
+from langchain.agents.middleware.human_in_the_loop import ToolConfig
+from langchain.agents.middleware.prompt_caching import AnthropicPromptCachingMiddleware
+from deepagents.middleware import PlanningMiddleware, FilesystemMiddleware, SubAgentMiddleware
 from deepagents.prompts import BASE_AGENT_PROMPT
+from deepagents.model import get_default_model
+from deepagents.types import SubAgent, CustomSubAgent
 
-StateSchema = TypeVar("StateSchema", bound=DeepAgentState)
-StateSchemaType = Type[StateSchema]
-
-
-def _agent_builder(
+def agent_builder(
     tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]],
     instructions: str,
+    middleware: Optional[list[AgentMiddleware]] = None,
+    tool_configs: Optional[dict[str, bool | ToolConfig]] = None,
     model: Optional[Union[str, LanguageModelLike]] = None,
-    subagents: list[SubAgent | CustomSubAgent] = None,
-    state_schema: Optional[StateSchemaType] = None,
-    builtin_tools: Optional[list[str]] = None,
-    interrupt_config: Optional[ToolInterruptConfig] = None,
-    config_schema: Optional[Type[Any]] = None,
+    subagents: Optional[list[SubAgent | CustomSubAgent]] = None,
+    context_schema: Optional[Type[Any]] = None,
     checkpointer: Optional[Checkpointer] = None,
-    post_model_hook: Optional[Callable] = None,
-    main_agent_tools: Optional[list[str]] = None,
     is_async: bool = False,
 ):
-    prompt = instructions + BASE_AGENT_PROMPT
-
-    all_builtin_tools = [write_todos, write_file, read_file, ls, edit_file]
-
-    if builtin_tools is not None:
-        tools_by_name = {}
-        for tool_ in all_builtin_tools:
-            if not isinstance(tool_, BaseTool):
-                tool_ = tool(tool_)
-            tools_by_name[tool_.name] = tool_
-        # Only include built-in tools whose names are in the specified list
-        built_in_tools = [tools_by_name[_tool] for _tool in builtin_tools]
-    else:
-        built_in_tools = all_builtin_tools
-
     if model is None:
         model = get_default_model()
-    state_schema = state_schema or DeepAgentState
 
-    # Should never be the case that both are specified
-    if post_model_hook and interrupt_config:
-        raise ValueError(
-            "Cannot specify both post_model_hook and interrupt_config together. "
-            "Use either interrupt_config for tool interrupts or post_model_hook for custom post-processing."
+    deepagent_middleware = [
+        PlanningMiddleware(),
+        FilesystemMiddleware(),
+        SubAgentMiddleware(
+            default_subagent_tools=tools,   # NOTE: These tools are piped to the general-purpose subagent.
+            subagents=subagents if subagents is not None else [],
+            model=model,
+            is_async=is_async,
+        ),
+        SummarizationMiddleware(
+            model=model,
+            max_tokens_before_summary=150000,
+            messages_to_keep=20,
         )
-    elif post_model_hook is not None:
-        selected_post_model_hook = post_model_hook
-    elif interrupt_config is not None:
-        selected_post_model_hook = create_interrupt_hook(interrupt_config)
-    else:
-        selected_post_model_hook = None
+    ]
+    # Add tool interrupt config if provided
+    if tool_configs is not None:
+        deepagent_middleware.append(HumanInTheLoopMiddleware(tool_configs=tool_configs))
 
-    if not is_async:
-        task_tool = _create_sync_task_tool(
-            list(tools) + built_in_tools,
-            instructions,
-            subagents or [],
-            model,
-            state_schema,
-            selected_post_model_hook,
-        )
-    else:
-        task_tool = _create_task_tool(
-            list(tools) + built_in_tools,
-            instructions,
-            subagents or [],
-            model,
-            state_schema,
-            selected_post_model_hook,
-        )
-    if main_agent_tools is not None:
-        passed_in_tools = []
-        for tool_ in tools:
-            if not isinstance(tool_, BaseTool):
-                tool_ = tool(tool_)
-            if tool_.name in main_agent_tools:
-                passed_in_tools.append(tool_)
-    else:
-        passed_in_tools = list(tools)
-    all_tools = built_in_tools + passed_in_tools + [task_tool]
+    # Add Anthropic prompt caching is model is Anthropic
+    # TODO: Add this back when fixed
+    # if isinstance(model, ChatAnthropic):
+    #     deepagent_middleware.append(AnthropicPromptCachingMiddleware(ttl="5m"))
 
-    return create_react_agent(
+    if middleware is not None:
+        deepagent_middleware.extend(middleware)
+
+    return create_agent(
         model,
-        prompt=prompt,
-        tools=all_tools,
-        state_schema=state_schema,
-        post_model_hook=selected_post_model_hook,
-        config_schema=config_schema,
+        prompt=instructions + "\n\n" + BASE_AGENT_PROMPT,
+        tools=tools,
+        middleware=deepagent_middleware,
+        context_schema=context_schema,
         checkpointer=checkpointer,
     )
 
-
 def create_deep_agent(
-    tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]],
-    instructions: str,
+    tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]] = [],
+    instructions: str = "",
+    middleware: Optional[list[AgentMiddleware]] = None,
     model: Optional[Union[str, LanguageModelLike]] = None,
-    subagents: list[SubAgent | CustomSubAgent] = None,
-    state_schema: Optional[StateSchemaType] = None,
-    builtin_tools: Optional[list[str]] = None,
-    interrupt_config: Optional[ToolInterruptConfig] = None,
-    config_schema: Optional[Type[Any]] = None,
+    subagents: Optional[list[SubAgent | CustomSubAgent]] = None,
+    context_schema: Optional[Type[Any]] = None,
     checkpointer: Optional[Checkpointer] = None,
-    post_model_hook: Optional[Callable] = None,
-    main_agent_tools: Optional[list[str]] = None,
+    tool_configs: Optional[dict[str, bool | ToolConfig]] = None,
 ):
     """Create a deep agent.
-
     This agent will by default have access to a tool to write todos (write_todos),
-    and then four file editing tools: write_file, ls, read_file, edit_file.
-
+    four file editing tools: write_file, ls, read_file, edit_file, and a tool to call subagents.
     Args:
-        tools: The additional tools the agent should have access to.
+        tools: The tools the agent should have access to.
         instructions: The additional instructions the agent should have. Will go in
             the system prompt.
         model: The model to use.
@@ -135,53 +86,38 @@ def create_deep_agent(
                 - `prompt` (used as the system prompt in the subagent)
                 - (optional) `tools`
                 - (optional) `model` (either a LanguageModelLike instance or dict settings)
-        state_schema: The schema of the deep agent. Should subclass from DeepAgentState
-        builtin_tools: If not provided, all built-in tools are included. If provided,
-            only the specified built-in tools are included.
-        interrupt_config: Optional Dict[str, HumanInterruptConfig] mapping tool names to interrupt configs.
-        config_schema: The schema of the deep agent.
-        post_model_hook: Custom post model hook
+                - (optional) `middleware` (list of AgentMiddleware)
+        context_schema: The schema of the deep agent.
         checkpointer: Optional checkpointer for persisting agent state between runs.
-        main_agent_tools: Optional list of tool names that the main agent should have. If not provided,
-            will have access to all tools. Note that built-in tools (for filesystem and todo and subagents) are
-            always included - this filtering only applies to passed in tools.
+        tool_configs: Optional Dict[str, HumanInTheLoopConfig] mapping tool names to interrupt configs.
     """
-    return _agent_builder(
+    return agent_builder(
         tools=tools,
         instructions=instructions,
+        middleware=middleware,
         model=model,
         subagents=subagents,
-        state_schema=state_schema,
-        builtin_tools=builtin_tools,
-        interrupt_config=interrupt_config,
-        config_schema=config_schema,
+        context_schema=context_schema,
         checkpointer=checkpointer,
-        post_model_hook=post_model_hook,
-        main_agent_tools=main_agent_tools,
+        tool_configs=tool_configs,
         is_async=False,
     )
 
-
 def async_create_deep_agent(
-    tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]],
-    instructions: str,
+    tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]] = [],
+    instructions: str = "",
+    middleware: Optional[list[AgentMiddleware]] = None,
     model: Optional[Union[str, LanguageModelLike]] = None,
-    subagents: list[SubAgent | CustomSubAgent] = None,
-    state_schema: Optional[StateSchemaType] = None,
-    builtin_tools: Optional[list[str]] = None,
-    interrupt_config: Optional[ToolInterruptConfig] = None,
-    config_schema: Optional[Type[Any]] = None,
+    subagents: Optional[list[SubAgent | CustomSubAgent]] = None,
+    context_schema: Optional[Type[Any]] = None,
     checkpointer: Optional[Checkpointer] = None,
-    post_model_hook: Optional[Callable] = None,
-    main_agent_tools: Optional[list[str]] = None,
+    tool_configs: Optional[dict[str, bool | ToolConfig]] = None,
 ):
     """Create a deep agent.
-
     This agent will by default have access to a tool to write todos (write_todos),
-    and then four file editing tools: write_file, ls, read_file, edit_file.
-
+    four file editing tools: write_file, ls, read_file, edit_file, and a tool to call subagents.
     Args:
-        tools: The additional tools the agent should have access to.
+        tools: The tools the agent should have access to.
         instructions: The additional instructions the agent should have. Will go in
             the system prompt.
         model: The model to use.
@@ -192,28 +128,19 @@ def async_create_deep_agent(
                 - `prompt` (used as the system prompt in the subagent)
                 - (optional) `tools`
                 - (optional) `model` (either a LanguageModelLike instance or dict settings)
-        state_schema: The schema of the deep agent. Should subclass from DeepAgentState
-        builtin_tools: If not provided, all built-in tools are included. If provided,
-            only the specified built-in tools are included.
-        interrupt_config: Optional Dict[str, HumanInterruptConfig] mapping tool names to interrupt configs.
-        config_schema: The schema of the deep agent.
-        post_model_hook: Custom post model hook
+                - (optional) `middleware` (list of AgentMiddleware)
+        context_schema: The schema of the deep agent.
         checkpointer: Optional checkpointer for persisting agent state between runs.
-        main_agent_tools: Optional list of tool names that the main agent should have. If not provided,
-            will have access to all tools. Note that built-in tools (for filesystem and todo and subagents) are
-            always included - this filtering only applies to passed in tools.
+        tool_configs: Optional Dict[str, HumanInTheLoopConfig] mapping tool names to interrupt configs.
     """
-    return _agent_builder(
+    return agent_builder(
         tools=tools,
         instructions=instructions,
+        middleware=middleware,
         model=model,
         subagents=subagents,
-        state_schema=state_schema,
-        builtin_tools=builtin_tools,
-        interrupt_config=interrupt_config,
-        config_schema=config_schema,
+        context_schema=context_schema,
         checkpointer=checkpointer,
-        post_model_hook=post_model_hook,
-        main_agent_tools=main_agent_tools,
+        tool_configs=tool_configs,
         is_async=True,
-    )
+    )

deepagents/middleware.py

@@ -0,0 +1,198 @@
+"""DeepAgents implemented as Middleware"""
+
+from langchain.agents import create_agent
+from langchain.agents.middleware import AgentMiddleware, AgentState, ModelRequest, SummarizationMiddleware
+from langchain.agents.middleware.prompt_caching import AnthropicPromptCachingMiddleware
+from langchain_core.tools import BaseTool, tool, InjectedToolCallId
+from langchain_core.messages import ToolMessage
+from langchain.chat_models import init_chat_model
+from langgraph.types import Command
+from langchain.agents.tool_node import InjectedState
+from typing import Annotated, Optional
+from deepagents.state import PlanningState, FilesystemState
+from deepagents.tools import write_todos, ls, read_file, write_file, edit_file
+from deepagents.prompts import WRITE_TODOS_SYSTEM_PROMPT, TASK_SYSTEM_PROMPT, FILESYSTEM_SYSTEM_PROMPT, TASK_TOOL_DESCRIPTION, BASE_AGENT_PROMPT
+from deepagents.types import SubAgent, CustomSubAgent
+
+###########################
+# Planning Middleware
+###########################
+
+class PlanningMiddleware(AgentMiddleware):
+    state_schema = PlanningState
+    tools = [write_todos]
+
+    def modify_model_request(self, request: ModelRequest, agent_state: PlanningState) -> ModelRequest:
+        request.system_prompt = request.system_prompt + "\n\n" + WRITE_TODOS_SYSTEM_PROMPT
+        return request
+
+###########################
+# Filesystem Middleware
+###########################
+
+class FilesystemMiddleware(AgentMiddleware):
+    state_schema = FilesystemState
+    tools = [ls, read_file, write_file, edit_file]
+
+    def modify_model_request(self, request: ModelRequest, agent_state: FilesystemState) -> ModelRequest:
+        request.system_prompt = request.system_prompt + "\n\n" + FILESYSTEM_SYSTEM_PROMPT
+        return request
+
+###########################
+# SubAgent Middleware
+###########################
+
+class SubAgentMiddleware(AgentMiddleware):
+    def __init__(
+        self,
+        default_subagent_tools: list[BaseTool] = [],
+        subagents: list[SubAgent | CustomSubAgent] = [],
+        model=None,
+        is_async=False,
+    ) -> None:
+        super().__init__()
+        task_tool = create_task_tool(
+            default_subagent_tools=default_subagent_tools,
+            subagents=subagents,
+            model=model,
+            is_async=is_async,
+        )
+        self.tools = [task_tool]
+
+    def modify_model_request(self, request: ModelRequest, agent_state: AgentState) -> ModelRequest:
+        request.system_prompt = request.system_prompt + "\n\n" + TASK_SYSTEM_PROMPT
+        return request
+
+def _get_agents(
+    default_subagent_tools: list[BaseTool],
+    subagents: list[SubAgent | CustomSubAgent],
+    model
+):
+    default_subagent_middleware = [
+        PlanningMiddleware(),
+        FilesystemMiddleware(),
+        # TODO: Add this back when fixed
+        # AnthropicPromptCachingMiddleware(ttl="5m"),
+        SummarizationMiddleware(
+            model=model,
+            max_tokens_before_summary=150000,
+            messages_to_keep=20,
+        ),
+    ]
+    agents = {
+        "general-purpose": create_agent(
+            model,
+            prompt=BASE_AGENT_PROMPT,
+            tools=default_subagent_tools,
+            checkpointer=False,
+            middleware=default_subagent_middleware
+        )
+    }
+    for _agent in subagents:
+        if "graph" in _agent:
+            agents[_agent["name"]] = _agent["graph"]
+            continue
+        if "tools" in _agent:
+            _tools = _agent["tools"]
+        else:
+            _tools = default_subagent_tools.copy()
+        # Resolve per-subagent model: can be instance or dict
+        if "model" in _agent:
+            agent_model = _agent["model"]
+            if isinstance(agent_model, dict):
+                # Dictionary settings - create model from config
+                sub_model = init_chat_model(**agent_model)
+            else:
+                # Model instance - use directly
+                sub_model = agent_model
+        else:
+            # Fallback to main model
+            sub_model = model
+        if "middleware" in _agent:
+            _middleware = [*default_subagent_middleware, *_agent["middleware"]]
+        else:
+            _middleware = default_subagent_middleware
+        agents[_agent["name"]] = create_agent(
+            sub_model,
+            prompt=_agent["prompt"],
+            tools=_tools,
+            middleware=_middleware,
+            checkpointer=False,
+        )
+    return agents
+
+
+def _get_subagent_description(subagents: list[SubAgent | CustomSubAgent]):
+    return [f"- {_agent['name']}: {_agent['description']}" for _agent in subagents]
+
+
+def create_task_tool(
+    default_subagent_tools: list[BaseTool],
+    subagents: list[SubAgent | CustomSubAgent],
+    model,
+    is_async: bool = False,
+):
+    agents = _get_agents(
+        default_subagent_tools, subagents, model
+    )
+    other_agents_string = _get_subagent_description(subagents)
+
+    if is_async:
+        @tool(
+            description=TASK_TOOL_DESCRIPTION.format(other_agents=other_agents_string)
+        )
+        async def task(
+            description: str,
+            subagent_type: str,
+            state: Annotated[AgentState, InjectedState],
+            tool_call_id: Annotated[str, InjectedToolCallId],
+        ):
+            if subagent_type not in agents:
+                return f"Error: invoked agent of type {subagent_type}, the only allowed types are {[f'`{k}`' for k in agents]}"
+            sub_agent = agents[subagent_type]
+            state["messages"] = [{"role": "user", "content": description}]
+            result = await sub_agent.ainvoke(state)
+            state_update = {}
+            for k, v in result.items():
+                if k not in ["todos", "messages"]:
+                    state_update[k] = v
+            return Command(
+                update={
+                    **state_update,
+                    "messages": [
+                        ToolMessage(
+                            result["messages"][-1].content, tool_call_id=tool_call_id
+                        )
+                    ],
+                }
+            )
+    else: 
+        @tool(
+            description=TASK_TOOL_DESCRIPTION.format(other_agents=other_agents_string)
+        )
+        def task(
+            description: str,
+            subagent_type: str,
+            state: Annotated[AgentState, InjectedState],
+            tool_call_id: Annotated[str, InjectedToolCallId],
+        ):
+            if subagent_type not in agents:
+                return f"Error: invoked agent of type {subagent_type}, the only allowed types are {[f'`{k}`' for k in agents]}"
+            sub_agent = agents[subagent_type]
+            state["messages"] = [{"role": "user", "content": description}]
+            result = sub_agent.invoke(state)
+            state_update = {}
+            for k, v in result.items():
+                if k not in ["todos", "messages"]:
+                    state_update[k] = v
+            return Command(
+                update={
+                    **state_update,
+                    "messages": [
+                        ToolMessage(
+                            result["messages"][-1].content, tool_call_id=tool_call_id
+                        )
+                    ],
+                }
+            )
+    return task

deepagents/prompts.py

@@ -361,10 +361,7 @@ Usage:
 - The write_file tool will create the a new file.
 - Prefer to edit existing files over creating new ones when possible."""
 
-
-BASE_AGENT_PROMPT = """In order to complete the objective that the user asks ofyou, you have access to a number of standard tools.
-
-## `write_todos`
+WRITE_TODOS_SYSTEM_PROMPT = """## `write_todos`
 
 You have access to the `write_todos` tool to help you manage and plan complex objectives. 
 Use this tool for complex objectives to ensure that you are tracking each necessary step and giving the user visibility into your progress.
@@ -374,9 +371,11 @@ It is critical that you mark todos as completed as soon as you are done with a s
 For simple objectives that only require a few steps, it is better to just complete the objective directly and NOT use this tool.
 Writing todos takes time and tokens, use it when it is helpful for managing complex many-step problems! But not for simple few-step requests.
 
-IMPORTANT: The `write_todos` tool should never be called multiple times in parallel.
+## Important To-Do List Usage Notes to Remember
+- The `write_todos` tool should never be called multiple times in parallel.
+- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant."""
 
-## `task` (subagent spawner)
+TASK_SYSTEM_PROMPT = """## `task` (subagent spawner)
 
 You have access to a `task` tool to launch short-lived subagents that handle isolated tasks. These agents are ephemeral — they live only for the duration of the task and return a single result.
 
@@ -399,17 +398,19 @@ When NOT to use the task tool:
 - If delegating does not reduce token usage, complexity, or context switching
 - If splitting would add latency without benefit
 
-## Filesystem Tools `ls`, `read_file`, `write_file`, `edit_file`
+## Important Task Tool Usage Notes to Remember
+- Whenever possible, parallelize the work that you do. This is true for both tool_calls, and for tasks. Whenever you have independent steps to complete - make tool_calls, or kick off tasks (subagents) in parallel to accomplish them faster. This saves time for the user, which is incredibly important.
+- Remember to use the `task` tool to silo independent tasks within a multi-part objective.
+- You should use the `task` tool whenever you have a complex task that will take multiple steps, and is independent from other tasks that the agent needs to complete. These agents are highly competent and efficient."""
+
+FILESYSTEM_SYSTEM_PROMPT = """## Filesystem Tools `ls`, `read_file`, `write_file`, `edit_file`
 
 You have access to a local, private filesystem which you can interact with using these tools.
 - ls: list all files in the local filesystem
 - read_file: read a file from the local filesystem
 - write_file: write to a file in the local filesystem
-- edit_file: edit a file in the local filesystem
+- edit_file: edit a file in the local filesystem"""
 
-# Important Usage Notes to Remember
-- Don't be afraid to revise the To-Do list as you go. New information may reveal new tasks that need to be done, or old tasks that are irrelevant.
-- Whenever possible, parallelize the work that you do. This is true for both tool_calls, and for tasks. Whenever you have independent steps to complete - make tool_calls, or kick off tasks (subagents) in parallel to accomplish them faster. This saves time for the user, which is incredibly important.
-- Remember to use the `task` tool to silo independent tasks within a multi-part objective.
-- You should use the `task` tool whenever you have a complex task that will take multiple steps, and is independent from other tasks that the agent needs to complete. These agents are highly competent and efficient.
+BASE_AGENT_PROMPT = """
+In order to complete the objective that the user asks of you, you have access to a number of standard tools.
 """

deepagents/state.py

@@ -1,4 +1,4 @@
-from langgraph.prebuilt.chat_agent_executor import AgentState
+from langchain.agents.middleware import AgentState
 from typing import NotRequired, Annotated
 from typing import Literal
 from typing_extensions import TypedDict
@@ -23,3 +23,11 @@ def file_reducer(l, r):
 class DeepAgentState(AgentState):
     todos: NotRequired[list[Todo]]
     files: Annotated[NotRequired[dict[str, str]], file_reducer]
+
+
+class PlanningState(AgentState):
+    todos: NotRequired[list[Todo]]
+
+
+class FilesystemState(AgentState):
+    files: Annotated[NotRequired[dict[str, str]], file_reducer]

deepagents/tools.py

@@ -1,9 +1,9 @@
 from langchain_core.tools import tool, InjectedToolCallId
-from langgraph.types import Command
 from langchain_core.messages import ToolMessage
+from langgraph.types import Command
+from langchain.agents.tool_node import InjectedState
 from typing import Annotated, Union
-from langgraph.prebuilt import InjectedState
-
+from deepagents.state import Todo, FilesystemState
 from deepagents.prompts import (
     WRITE_TODOS_TOOL_DESCRIPTION,
     LIST_FILES_TOOL_DESCRIPTION,
@@ -11,7 +11,6 @@ from deepagents.prompts import (
     WRITE_FILE_TOOL_DESCRIPTION,
     EDIT_FILE_TOOL_DESCRIPTION,
 )
-from deepagents.state import Todo, DeepAgentState
 
 
 @tool(description=WRITE_TODOS_TOOL_DESCRIPTION)
@@ -29,7 +28,7 @@ def write_todos(
 
 
 @tool(description=LIST_FILES_TOOL_DESCRIPTION)
-def ls(state: Annotated[DeepAgentState, InjectedState]) -> list[str]:
+def ls(state: Annotated[FilesystemState, InjectedState]) -> list[str]:
     """List all files"""
     return list(state.get("files", {}).keys())
 
@@ -37,7 +36,7 @@ def ls(state: Annotated[DeepAgentState, InjectedState]) -> list[str]:
 @tool(description=READ_FILE_TOOL_DESCRIPTION)
 def read_file(
     file_path: str,
-    state: Annotated[DeepAgentState, InjectedState],
+    state: Annotated[FilesystemState, InjectedState],
     offset: int = 0,
     limit: int = 2000,
 ) -> str:
@@ -83,7 +82,7 @@ def read_file(
 def write_file(
     file_path: str,
     content: str,
-    state: Annotated[DeepAgentState, InjectedState],
+    state: Annotated[FilesystemState, InjectedState],
     tool_call_id: Annotated[str, InjectedToolCallId],
 ) -> Command:
     files = state.get("files", {})
@@ -103,7 +102,7 @@ def edit_file(
     file_path: str,
     old_string: str,
     new_string: str,
-    state: Annotated[DeepAgentState, InjectedState],
+    state: Annotated[FilesystemState, InjectedState],
     tool_call_id: Annotated[str, InjectedToolCallId],
     replace_all: bool = False,
 ) -> Union[Command, str]:

deepagents/types.py

@@ -0,0 +1,21 @@
+from typing import NotRequired, Union, Any
+from typing_extensions import TypedDict
+from langchain_core.language_models import LanguageModelLike
+from langchain.agents.middleware import AgentMiddleware
+from langchain_core.runnables import Runnable
+from langchain_core.tools import BaseTool
+
+class SubAgent(TypedDict):
+    name: str
+    description: str
+    prompt: str
+    tools: NotRequired[list[BaseTool]]
+    # Optional per-subagent model: can be either a model instance OR dict settings
+    model: NotRequired[Union[LanguageModelLike, dict[str, Any]]]
+    middleware: NotRequired[list[AgentMiddleware]]
+
+
+class CustomSubAgent(TypedDict):
+    name: str
+    description: str
+    graph: Runnable