deepagents 0.3.5__py3-none-any.whl → 0.3.6__py3-none-any.whl

deepagents/backends/utils.py

@@ -12,8 +12,7 @@ from typing import Any, Literal
 
 import wcmatch.glob as wcglob
 
-from deepagents.backends.protocol import FileInfo as _FileInfo
-from deepagents.backends.protocol import GrepMatch as _GrepMatch
+from deepagents.backends.protocol import FileInfo as _FileInfo, GrepMatch as _GrepMatch
 
 EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents"
 MAX_LINE_LENGTH = 10000

deepagents/graph.py

@@ -62,18 +62,28 @@ def create_deep_agent(
 ) -> CompiledStateGraph:
     """Create a deep agent.
 
+    Deep agents require a LLM that supports tool calling.
+
     This agent will by default have access to a tool to write todos (`write_todos`),
     seven file and execution tools: `ls`, `read_file`, `write_file`, `edit_file`, `glob`, `grep`, `execute`,
-    and a tool to call subagents.
+    and a tool to call subagents (`task`).
 
     The `execute` tool allows running shell commands if the backend implements `SandboxBackendProtocol`.
     For non-sandbox backends, the `execute` tool will return an error message.
 
     Args:
-        model: The model to use. Defaults to `claude-sonnet-4-5-20250929`.
+        model: The model to use.
+
+            Defaults to `claude-sonnet-4-5-20250929`.
+
+            Use the `provider:model` format (e.g., `openai:gpt-5`) to quickly switch between models.
         tools: The tools the agent should have access to.
-        system_prompt: The additional instructions the agent should have. Will go in
-            the system prompt.
+
+            In addition to custom tools you provide, deep agents include built-in tools for planning,
+            file management, and subagent spawning.
+        system_prompt: The additional instructions the agent should have.
+
+            Will go in the system prompt.
         middleware: Additional middleware to apply after standard middleware.
         subagents: The subagents to use.
 
@@ -93,7 +103,10 @@ def create_deep_agent(
             to the backend's `root_dir`. Later sources override earlier ones for skills with the
             same name (last one wins).
         memory: Optional list of memory file paths (`AGENTS.md` files) to load
-            (e.g., `["/memory/AGENTS.md"]`). Display names are automatically derived from paths.
+            (e.g., `["/memory/AGENTS.md"]`).
+
+            Display names are automatically derived from paths.
+
             Memory is loaded at agent startup and added into the system prompt.
         response_format: A structured output response format to use for the agent.
         context_schema: The schema of the deep agent.
@@ -104,6 +117,10 @@ def create_deep_agent(
             Pass either a `Backend` instance or a callable factory like `lambda rt: StateBackend(rt)`.
             For execution support, use a backend that implements `SandboxBackendProtocol`.
         interrupt_on: Mapping of tool names to interrupt configs.
+
+            Pass to pause agent execution at specified tool calls for human approval or modification.
+
+            Example: `interrupt_on={"edit_file": True}` pauses before every edit.
         debug: Whether to enable debug mode. Passed through to `create_agent`.
         name: The name of the agent. Passed through to `create_agent`.
         cache: The cache to use for the agent. Passed through to `create_agent`.

deepagents/middleware/filesystem.py

@@ -20,10 +20,8 @@ from langgraph.types import Command
 from typing_extensions import TypedDict
 
 from deepagents.backends import StateBackend
-
-# Re-export type here for backwards compatibility
-from deepagents.backends.protocol import BACKEND_TYPES as BACKEND_TYPES
 from deepagents.backends.protocol import (
+    BACKEND_TYPES as BACKEND_TYPES,  # Re-export for backwards compatibility
     BackendProtocol,
     EditResult,
     SandboxBackendProtocol,
@@ -801,21 +799,33 @@ Here are the first 10 lines of the result:
 class FilesystemMiddleware(AgentMiddleware):
     """Middleware for providing filesystem and optional execution tools to an agent.
 
-    This middleware adds filesystem tools to the agent: ls, read_file, write_file,
-    edit_file, glob, and grep. Files can be stored using any backend that implements
-    the BackendProtocol.
+    This middleware adds filesystem tools to the agent: `ls`, `read_file`, `write_file`,
+    `edit_file`, `glob`, and `grep`. Files can be stored using any backend that implements
+    the `BackendProtocol`.
 
-    If the backend implements SandboxBackendProtocol, an execute tool is also added
+    If the backend implements `SandboxBackendProtocol`, an `execute` tool is also added
     for running shell commands.
 
+    This middleware also automatically evicts large tool results to the file system when
+    they exceed a token threshold, preventing context window saturation.
+
     Args:
-        backend: Backend for file storage and optional execution. If not provided, defaults to StateBackend
-            (ephemeral storage in agent state). For persistent storage or hybrid setups,
-            use CompositeBackend with custom routes. For execution support, use a backend
-            that implements SandboxBackendProtocol.
+        backend: Backend for file storage and optional execution.
+
+            If not provided, defaults to `StateBackend` (ephemeral storage in agent state).
+
+            For persistent storage or hybrid setups, use `CompositeBackend` with custom routes.
+
+            For execution support, use a backend that implements `SandboxBackendProtocol`.
         system_prompt: Optional custom system prompt override.
         custom_tool_descriptions: Optional custom tool descriptions override.
-        tool_token_limit_before_evict: Optional token limit before evicting a tool result to the filesystem.
+        tool_token_limit_before_evict: Token limit before evicting a tool result to the
+            filesystem.
+
+            Defaults to 20,000 tokens.
+
+            When exceeded, writes the result using the configured backend and replaces it
+            with a truncated preview and file reference.
 
     Example:
         ```python

deepagents/middleware/subagents.py

@@ -21,41 +21,70 @@ class SubAgent(TypedDict):
     will be applied first, followed by any `middleware` specified in this spec.
     To use only custom middleware without the defaults, pass `default_middleware=[]`
     to `SubAgentMiddleware`.
+
+    Required fields:
+        name: Unique identifier for the subagent.
+
+            The main agent uses this name when calling the `task()` tool.
+        description: What this subagent does.
+
+            Be specific and action-oriented. The main agent uses this to decide when to delegate.
+        system_prompt: Instructions for the subagent.
+
+            Include tool usage guidance and output format requirements.
+        tools: Tools the subagent can use.
+
+            Keep this minimal and include only what's needed.
+
+    Optional fields:
+        model: Override the main agent's model.
+
+            Use the format `'provider:model-name'` (e.g., `'openai:gpt-4o'`).
+        middleware: Additional middleware for custom behavior, logging, or rate limiting.
+        interrupt_on: Configure human-in-the-loop for specific tools.
+
+            Requires a checkpointer.
     """
 
     name: str
-    """The name of the agent."""
+    """Unique identifier for the subagent."""
 
     description: str
-    """The description of the agent."""
+    """What this subagent does. The main agent uses this to decide when to delegate."""
 
     system_prompt: str
-    """The system prompt to use for the agent."""
+    """Instructions for the subagent."""
 
     tools: Sequence[BaseTool | Callable | dict[str, Any]]
-    """The tools to use for the agent."""
+    """Tools the subagent can use."""
 
     model: NotRequired[str | BaseChatModel]
-    """The model for the agent. Defaults to `default_model`."""
+    """Override the main agent's model. Use `'provider:model-name'` format."""
 
     middleware: NotRequired[list[AgentMiddleware]]
-    """Additional middleware to append after `default_middleware`."""
+    """Additional middleware for custom behavior."""
 
     interrupt_on: NotRequired[dict[str, bool | InterruptOnConfig]]
-    """The tool configs to use for the agent."""
+    """Configure human-in-the-loop for specific tools."""
 
 
 class CompiledSubAgent(TypedDict):
-    """A pre-compiled agent spec."""
+    """A pre-compiled agent spec.
+
+    Important: The runnable's state schema must include a 'messages' key.
+    This is required for the subagent to communicate results back to the main agent.
+    When the subagent completes, the final message in the 'messages' list will be
+    extracted and returned as a ToolMessage to the parent agent.
+    """
 
     name: str
-    """The name of the agent."""
+    """Unique identifier for the subagent."""
 
     description: str
-    """The description of the agent."""
+    """What this subagent does."""
 
     runnable: Runnable
-    """The Runnable to use for the agent."""
+    """The Runnable to use for the agent. Must return a state with a 'messages' key."""
 
 
 DEFAULT_SUBAGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools."
@@ -251,6 +280,7 @@ def _get_subagents(
             system_prompt=DEFAULT_SUBAGENT_PROMPT,
             tools=default_tools,
             middleware=general_purpose_middleware,
+            name="general-purpose",
         )
         agents["general-purpose"] = general_purpose_subagent
         subagent_descriptions.append(f"- general-purpose: {DEFAULT_GENERAL_PURPOSE_DESCRIPTION}")
@@ -277,6 +307,7 @@ def _get_subagents(
             system_prompt=agent_["system_prompt"],
             tools=_tools,
             middleware=_middleware,
+            name=agent_["name"],
         )
     return agents, subagent_descriptions
 
@@ -318,6 +349,15 @@ def _create_task_tool(
     subagent_description_str = "\n".join(subagent_descriptions)
 
     def _return_command_with_state_update(result: dict, tool_call_id: str) -> Command:
+        # Validate that the result contains a 'messages' key
+        if "messages" not in result:
+            error_msg = (
+                "CompiledSubAgent must return a state containing a 'messages' key. "
+                "Custom StateGraphs used with CompiledSubAgent should include 'messages' "
+                "in their state schema to communicate results back to the main agent."
+            )
+            raise ValueError(error_msg)
+
         state_update = {k: v for k, v in result.items() if k not in _EXCLUDED_STATE_KEYS}
         # Strip trailing whitespace to prevent API errors with Anthropic
         message_text = result["messages"][-1].text.rstrip() if result["messages"][-1].text else ""
@@ -352,7 +392,7 @@ def _create_task_tool(
             allowed_types = ", ".join([f"`{k}`" for k in subagent_graphs])
             return f"We cannot invoke subagent {subagent_type} because it does not exist, the only allowed types are {allowed_types}"
         subagent, subagent_state = _validate_and_prepare_state(subagent_type, description, runtime)
-        result = subagent.invoke(subagent_state, runtime.config)
+        result = subagent.invoke(subagent_state)
         if not runtime.tool_call_id:
             value_error_msg = "Tool call ID is required for subagent invocation"
             raise ValueError(value_error_msg)
@@ -367,7 +407,7 @@ def _create_task_tool(
             allowed_types = ", ".join([f"`{k}`" for k in subagent_graphs])
             return f"We cannot invoke subagent {subagent_type} because it does not exist, the only allowed types are {allowed_types}"
         subagent, subagent_state = _validate_and_prepare_state(subagent_type, description, runtime)
-        result = await subagent.ainvoke(subagent_state, runtime.config)
+        result = await subagent.ainvoke(subagent_state)
         if not runtime.tool_call_id:
             value_error_msg = "Tool call ID is required for subagent invocation"
             raise ValueError(value_error_msg)

{deepagents-0.3.5.dist-info → deepagents-0.3.6.dist-info}/METADATA

@@ -1,26 +1,26 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.3.5
+Version: 0.3.6
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
 Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
 Project-URL: Source, https://github.com/langchain-ai/deepagents
-Project-URL: Twitter, https://x.com/LangChainAI
+Project-URL: Twitter, https://x.com/LangChain
 Project-URL: Slack, https://www.langchain.com/join-community
 Project-URL: Reddit, https://www.reddit.com/r/LangChain/
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: langchain-core<2.0.0,>=1.2.6
-Requires-Dist: langchain<2.0.0,>=1.2.3
+Requires-Dist: langchain<2.0.0,>=1.2.4
 Requires-Dist: langchain-anthropic<2.0.0,>=1.3.1
 Requires-Dist: langchain-google-genai<5.0.0,>=4.1.3
 Requires-Dist: wcmatch
 
 # 🧠🤖Deep Agents
 
-Using an LLM to call tools in a loop is the simplest form of an agent. 
-This architecture, however, can yield agents that are “shallow” and fail to plan and act over longer, more complex tasks. 
+Using an LLM to call tools in a loop is the simplest form of an agent.
+This architecture, however, can yield agents that are “shallow” and fail to plan and act over longer, more complex tasks.
 
 Applications like “Deep Research”, "Manus", and “Claude Code” have gotten around this limitation by implementing a combination of four things:
 a **planning tool**, **sub agents**, access to a **file system**, and a **detailed prompt**.
@@ -46,7 +46,9 @@ poetry add deepagents
 
 ## Usage
 
-(To run the example below, you will need to `pip install tavily-python`).
+> **Note:** `deepagents` requires using a LLM that supports [tool calling](https://python.langchain.com/docs/concepts/tool_calling/).
+
+This example uses [Tavily](https://tavily.com/) as an example search provider, but you can substitute any search API (e.g., DuckDuckGo, SerpAPI, Brave Search). To run the example below, you will need to `pip install tavily-python`.
 
 Make sure to set `TAVILY_API_KEY` in your environment. You can generate one [here](https://www.tavily.com/).
 
@@ -100,21 +102,22 @@ The agent created with `create_deep_agent` is just a LangGraph graph - so you ca
 in the same way you would any LangGraph agent.
 
 ## Core Capabilities
+
 **Planning & Task Decomposition**
 
- Deep Agents include a built-in `write_todos` tool that enables agents to break down complex tasks into discrete steps, track progress, and adapt plans as new information emerges.
+Deep Agents include a built-in `write_todos` tool that enables agents to break down complex tasks into discrete steps, track progress, and adapt plans as new information emerges.
 
 **Context Management**
 
- File system tools (`ls`, `read_file`, `write_file`, `edit_file`, `glob`, `grep`) allow agents to offload large context to memory, preventing context window overflow and enabling work with variable-length tool results.
+File system tools (`ls`, `read_file`, `write_file`, `edit_file`, `glob`, `grep`) allow agents to offload large context to memory, preventing context window overflow and enabling work with variable-length tool results.
 
 **Subagent Spawning**
 
- A built-in `task` tool enables agents to spawn specialized subagents for context isolation. This keeps the main agent’s context clean while still going deep on specific subtasks.
+A built-in `task` tool enables agents to spawn specialized subagents for context isolation. This keeps the main agent's context clean while still going deep on specific subtasks.
 
 **Long-term Memory**
 
- Extend agents with persistent memory across threads using LangGraph’s Store. Agents can save and retrieve information from previous conversations.
+Extend agents with persistent memory across threads using LangGraph's `BaseStore`. Agents can save and retrieve information from previous conversations.
 
 ## Customizing Deep Agents
 
@@ -122,19 +125,20 @@ There are several parameters you can pass to `create_deep_agent` to create your
 
 ### `model`
 
-By default, `deepagents` uses `"claude-sonnet-4-5-20250929"`. You can customize this by passing any [LangChain model object](https://python.langchain.com/docs/integrations/chat/).
+By default, `deepagents` uses `claude-sonnet-4-5-20250929`. You can customize this by passing any [LangChain model object](https://python.langchain.com/docs/integrations/chat/).
+
+> **Tip:** Use the `provider:model` format (e.g., `openai:gpt-5`) to quickly switch between models. See the [reference](https://reference.langchain.com/python/langchain/models/#langchain.chat_models.init_chat_model(model)) for more info.
 
 ```python
 from langchain.chat_models import init_chat_model
 from deepagents import create_deep_agent
 
-model = init_chat_model("openai:gpt-4o")
-agent = create_deep_agent(
-    model=model,
-)
+model = init_chat_model(model="openai:gpt-5")
+agent = create_deep_agent(model=model)
 ```
 
 ### `system_prompt`
+
 Deep Agents come with a built-in system prompt. This is relatively detailed prompt that is heavily based on and inspired by [attempts](https://github.com/kn1026/cc/blob/main/claudecode.md) to [replicate](https://github.com/asgeirtj/system_prompts_leaks/blob/main/Anthropic/claude-code.md)
 Claude Code's system prompt. It was made more general purpose than Claude Code's system prompt. The default prompt contains detailed instructions for how to use the built-in planning tool, file system tools, and sub agents.
 
@@ -153,7 +157,7 @@ agent = create_deep_agent(
 
 ### `tools`
 
-Just like with tool-calling agents, you can provide a deep agent with a set of tools that it has access to.
+In addition to custom tools you provide, `deepagents` include built-in tools for planning (`write_todos`), file management (`ls`, `read_file`, `write_file`, `edit_file`, `glob`, `grep`), and subagent spawning (`task`).
 
 ```python
 import os
@@ -183,7 +187,8 @@ agent = create_deep_agent(
 ```
 
 ### `middleware`
-`create_deep_agent` is implemented with middleware that can be customized. You can provide additional middleware to extend functionality, add tools, or implement custom hooks. 
+
+`create_deep_agent` is implemented with middleware that can be customized. You can provide additional middleware to extend functionality, add tools, or implement custom hooks.
 
 ```python
 from langchain_core.tools import tool
@@ -231,7 +236,7 @@ class CompiledSubAgent(TypedDict):
     runnable: Runnable
 ```
 
-**SubAgent fields:**
+**`SubAgent` fields:**
 - **name**: This is the name of the subagent, and how the main agent will call the subagent
 - **description**: This is the description of the subagent that is shown to the main agent
 - **system_prompt**: This is the system prompt used for the subagent
@@ -243,9 +248,9 @@ class CompiledSubAgent(TypedDict):
 **CompiledSubAgent fields:**
 - **name**: This is the name of the subagent, and how the main agent will call the subagent
 - **description**: This is the description of the subagent that is shown to the main agent  
-- **runnable**: A pre-built LangGraph graph/agent that will be used as the subagent
+- **runnable**: A pre-built LangGraph graph/agent that will be used as the subagent. **Important:** The runnable's state schema must include a `messages` key. This is required for the subagent to communicate results back to the main agent.
 
-#### Using SubAgent
+#### Using `SubAgent`
 
 ```python
 import os
@@ -284,9 +289,9 @@ agent = create_deep_agent(
 )
 ```
 
-#### Using CustomSubAgent
+#### Using `CompiledSubAgent`
 
-For more complex use cases, you can provide your own pre-built LangGraph graph as a subagent:
+For complex workflows, use a pre-built LangGraph graph:
 
 ```python
 # Create a custom agent graph
@@ -296,7 +301,7 @@ custom_graph = create_agent(
     prompt="You are a specialized agent for data analysis..."
 )
 
-# Use it as a custom subagent
+# Use it as a compiled subagent
 custom_subagent = CompiledSubAgent(
     name="data-analyzer",
     description="Specialized agent for complex data analysis tasks",
@@ -314,7 +319,10 @@ agent = create_deep_agent(
 ```
 
 ### `interrupt_on`
-A common reality for agents is that some tool operations may be sensitive and require human approval before execution. Deep Agents supports human-in-the-loop workflows through LangGraph’s interrupt capabilities. You can configure which tools require approval using a checkpointer.
+
+The harness can pause agent execution at specified tool calls to allow human approval or modification. This feature is opt-in via the `interrupt_on` parameter.
+
+Pass `interrupt_on` to `create_deep_agent` with a mapping of tool names to interrupt configurations. Example: `interrupt_on={"edit_file": True}` pauses before every edit.
 
 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.
 
@@ -342,6 +350,7 @@ agent = create_deep_agent(
 ## Deep Agents Middleware
 
 Deep Agents are built with a modular middleware architecture. As a reminder, Deep Agents have access to:
+
 - A planning tool
 - A filesystem for storing context and long-term memories
 - The ability to spawn subagents
@@ -350,11 +359,11 @@ Each of these features is implemented as separate middleware. When you create a
 
 Middleware is a composable concept, and you can choose to add as many or as few middleware to an agent depending on your use case. That means that you can also use any of the aforementioned middleware independently!
 
-### TodoListMiddleware
+### `TodoListMiddleware`
 
-Planning is integral to solving complex problems. If you’ve used claude code recently, you’ll notice how it writes out a To-Do list before tackling complex, multi-part tasks. You’ll also notice how it can adapt and update this To-Do list on the fly as more information comes in.
+Planning is integral to solving complex problems. If you've used Claude Code recently, you'll notice how it writes out a to-do list before tackling complex, multi-part tasks. You'll also notice how it can adapt and update this to-do list on the fly as more information comes in.
 
-**TodoListMiddleware** provides your agent with a tool specifically for updating this To-Do list. Before, and while it executes a multi-part task, the agent is prompted to use the write_todos tool to keep track of what its doing, and what still needs to be done.
+`TodoListMiddleware` provides your agent with a tool specifically for updating this to-do list. Before, and while it executes a multi-part task, the agent is prompted to use the `write_todos` tool to keep track of what it's doing, and what still needs to be done.
 
 ```python
 from langchain.agents import create_agent
@@ -373,14 +382,15 @@ agent = create_agent(
 )
 ```
 
-### FilesystemMiddleware
+### `FilesystemMiddleware`
+
+Context engineering is one of the main challenges in building effective agents. This can be particularly hard when using tools that can return variable length results (e.g., `web_search`, RAG), as long tool results can quickly fill up your context window.
+`FilesystemMiddleware` provides four tools to your agent to interact with both short-term and long-term memory:
 
-Context engineering is one of the main challenges in building effective agents. This can be particularly hard when using tools that can return variable length results (ex. web_search, rag), as long ToolResults can quickly fill up your context window.
-**FilesystemMiddleware** provides four tools to your agent to interact with both short-term and long-term memory.
-- **ls**: List the files in your filesystem
-- **read_file**: Read an entire file, or a certain number of lines from a file
-- **write_file**: Write a new file to your filesystem
-- **edit_file**: Edit an existing file in your filesystem
+- `ls`: List the files in your filesystem
+- `read_file`: Read an entire file, or a certain number of lines from a file
+- `write_file`: Write a new file to your filesystem
+- `edit_file`: Edit an existing file in your filesystem
 
 ```python
 from langchain.agents import create_agent
@@ -404,9 +414,9 @@ agent = create_agent(
 )
 ```
 
-### SubAgentMiddleware
+### `SubAgentMiddleware`
 
-Handing off tasks to subagents is a great way to isolate context, keeping the context window of the main (supervisor) agent clean while still going deep on a task. The subagents middleware allows you supply subagents through a task tool.
+Handing off tasks to subagents is a great way to isolate context, keeping the context window of the main (supervisor) agent clean while still going deep on a task. `SubAgentMiddleware` allows you to supply subagents through a `task` tool.
 
 A subagent is defined with a name, description, system prompt, and tools. You can also provide a subagent with a custom model, or with additional middleware. This can be particularly useful when you want to give the subagent an additional state key to share with the main agent.
 
@@ -446,14 +456,16 @@ For more complex use cases, you can also provide your own pre-built LangGraph gr
 
 ```python
 # Create a custom LangGraph graph
+# Important: Your state must include a 'messages' key
 def create_weather_graph():
     workflow = StateGraph(...)
     # Build your custom graph
+    # Make sure your state schema includes 'messages'
     return workflow.compile()
 
 weather_graph = create_weather_graph()
 
-# Wrap it in a CompiledSubAgent
+# Wrap it in a `CompiledSubAgent`
 weather_subagent = CompiledSubAgent(
     name="weather",
     description="This subagent can get weather in cities.",
@@ -474,13 +486,12 @@ agent = create_agent(
 
 ## Sync vs Async
 
-Prior versions of deepagents separated sync and async agent factories. 
+Prior versions of deepagents separated sync and async agent factories.
 
 `async_create_deep_agent` has been folded in to `create_deep_agent`.
 
 **You should use `create_deep_agent` as the factory for both sync and async agents**
 
-
 ## 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).

{deepagents-0.3.5.dist-info → deepagents-0.3.6.dist-info}/RECORD

@@ -1,5 +1,5 @@
 deepagents/__init__.py,sha256=LHQm0v_7N9Gd4pmpRjhnlOCMIK2O0jQ4cEU8RiXEI8k,447
-deepagents/graph.py,sha256=TmMBtFZP9uT5KrzT6XRFIUCAD2_BCvfGLbd6zCMaWM8,8622
+deepagents/graph.py,sha256=oqcL-H14t-oYxc7RvMkNCge1twVjqogFcLCzH-4vSdc,9161
 deepagents/backends/__init__.py,sha256=BOKu2cQ1OdMyO_l2rLqZQiXppYFmQbx7OIQb7WYwvZc,457
 deepagents/backends/composite.py,sha256=WZ_dnn63BmrU19ZJ5-m728f99pSa0Uq_CnwZjwmxz1U,26198
 deepagents/backends/filesystem.py,sha256=kGBFuW3ie0LLz4wXCPGJm3WAiYpimJTgEwodJSnXWCs,21477
@@ -7,14 +7,14 @@ deepagents/backends/protocol.py,sha256=HUmIrwYGduPfDcs_wtOzVU2QPA9kICZuGO-sUwxzz
 deepagents/backends/sandbox.py,sha256=8Bi8itqjW2PpXORlIfT8thMN1aBXExgHz8cm8xwVaxI,10864
 deepagents/backends/state.py,sha256=Qq4uRjKg6POEqLl4tNnWnXzbmLBpu3bZdMkcUROIgHw,7899
 deepagents/backends/store.py,sha256=0mmeTsim4J8bjcf62dljwNrDv4PavT2KHdGbaBzVzRE,15197
-deepagents/backends/utils.py,sha256=Iyk2jW-gfoLvMnz-W_2FRCoJW_j3r1zoumU9iww-jd0,13973
+deepagents/backends/utils.py,sha256=wXMzfrUxp-ZAKlbl3QFZXlSSPRmIXQIUEehqsy2Agy8,13933
 deepagents/middleware/__init__.py,sha256=2smUxjwghA3Eml_wp0kd4dAY-rwLyW-XQPBE3dAoo50,467
-deepagents/middleware/filesystem.py,sha256=XrES4aPaeOliNfcECpmT7Zw4CFa1QQfNylNhW2vsXp0,47228
+deepagents/middleware/filesystem.py,sha256=Qx9NuRZPNuK1NVYomPCRauDY0ZqZ5j_wro9MRYyvcx0,47563
 deepagents/middleware/memory.py,sha256=E1UAtBAyIxkyNHuG2-j_X_fClMbbSwobdKa3e_P0FDk,15883
 deepagents/middleware/patch_tool_calls.py,sha256=PdNhxPaQqwnFkhEAZEE2kEzadTNAOO3_iJRA30WqpGE,1981
 deepagents/middleware/skills.py,sha256=EABvIq4ES_NHGFL9USUnlH1WwiZgnAacoOLz2kkkVkw,24043
-deepagents/middleware/subagents.py,sha256=Gpky0NsQehZ-iyXIetczmu4CkBuxAnDQv6pZXIDHp8M,24427
-deepagents-0.3.5.dist-info/METADATA,sha256=Due_n90XpZX-mI-tkk9h8BKfQnD2qcn-He6ZkaMfyzg,18823
-deepagents-0.3.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deepagents-0.3.5.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
-deepagents-0.3.5.dist-info/RECORD,,
+deepagents/middleware/subagents.py,sha256=c_JxFb2Z3yBWEInqNEciC9Rlu4uGo1tpuN9tLXivWeY,26196
+deepagents-0.3.6.dist-info/METADATA,sha256=KpjDBOFZXmVrZYfuec3UiFsm193LLjfkigSlFhULJE4,19743
+deepagents-0.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deepagents-0.3.6.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
+deepagents-0.3.6.dist-info/RECORD,,