deepagents 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

deepagents/middleware/filesystem.py

@@ -1,12 +1,9 @@
 """Middleware for providing filesystem tools to an agent."""
 # ruff: noqa: E501
 
-from collections.abc import Awaitable, Callable, Sequence
-from typing import Annotated
-from typing_extensions import NotRequired
-
 import os
-from typing import Literal, Optional
+from collections.abc import Awaitable, Callable, Sequence
+from typing import Annotated, Literal, NotRequired
 
 from langchain.agents.middleware.types import (
     AgentMiddleware,
@@ -21,14 +18,21 @@ from langchain_core.tools import BaseTool, tool
 from langgraph.types import Command
 from typing_extensions import TypedDict
 
-from deepagents.backends.protocol import BackendProtocol, BackendFactory, WriteResult, EditResult
 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 (
+    BackendProtocol,
+    EditResult,
+    SandboxBackendProtocol,
+    WriteResult,
+)
 from deepagents.backends.utils import (
-    update_file_data,
     format_content_with_line_numbers,
     format_grep_matches,
-    truncate_if_too_long,
     sanitize_tool_call_id,
+    truncate_if_too_long,
 )
 
 EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents"
@@ -36,10 +40,6 @@ MAX_LINE_LENGTH = 2000
 LINE_NUMBER_WIDTH = 6
 DEFAULT_READ_OFFSET = 0
 DEFAULT_READ_LIMIT = 500
-BACKEND_TYPES = (
-    BackendProtocol
-    | BackendFactory
-)
 
 
 class FileData(TypedDict):
@@ -135,6 +135,7 @@ def _validate_path(path: str, *, allowed_prefixes: Sequence[str] | None = None)
 
     return normalized
 
+
 class FilesystemState(AgentState):
     """State for the filesystem middleware."""
 
@@ -217,6 +218,50 @@ Examples:
 - Search Python files only: `grep(pattern="import", glob="*.py")`
 - Show matching lines: `grep(pattern="error", output_mode="content")`"""
 
+EXECUTE_TOOL_DESCRIPTION = """Executes a given command in the sandbox environment with proper handling and security measures.
+
+Before executing the command, please follow these steps:
+
+1. Directory Verification:
+   - If the command will create new directories or files, first use the ls tool to verify the parent directory exists and is the correct location
+   - For example, before running "mkdir foo/bar", first use ls to check that "foo" exists and is the intended parent directory
+
+2. Command Execution:
+   - Always quote file paths that contain spaces with double quotes (e.g., cd "path with spaces/file.txt")
+   - Examples of proper quoting:
+     - cd "/Users/name/My Documents" (correct)
+     - cd /Users/name/My Documents (incorrect - will fail)
+     - python "/path/with spaces/script.py" (correct)
+     - python /path/with spaces/script.py (incorrect - will fail)
+   - After ensuring proper quoting, execute the command
+   - Capture the output of the command
+
+Usage notes:
+  - The command parameter is required
+  - Commands run in an isolated sandbox environment
+  - Returns combined stdout/stderr output with exit code
+  - If the output is very large, it may be truncated
+  - VERY IMPORTANT: You MUST avoid using search commands like find and grep. Instead use the grep, glob tools to search. You MUST avoid read tools like cat, head, tail, and use read_file to read files.
+  - When issuing multiple commands, use the ';' or '&&' operator to separate them. DO NOT use newlines (newlines are ok in quoted strings)
+    - Use '&&' when commands depend on each other (e.g., "mkdir dir && cd dir")
+    - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail
+  - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of cd
+
+Examples:
+  Good examples:
+    - execute(command="pytest /foo/bar/tests")
+    - execute(command="python /path/to/script.py")
+    - execute(command="npm install && npm test")
+
+  Bad examples (avoid these):
+    - execute(command="cd /foo/bar && pytest tests")  # Use absolute path instead
+    - execute(command="cat file.txt")  # Use read_file tool instead
+    - execute(command="find . -name '*.py'")  # Use glob tool instead
+    - execute(command="grep -r 'pattern' .")  # Use grep tool instead
+
+Note: This tool is only available if the backend supports execution (SandboxBackendProtocol).
+If execution is not supported, the tool will return an error message."""
+
 FILESYSTEM_SYSTEM_PROMPT = """## Filesystem Tools `ls`, `read_file`, `write_file`, `edit_file`, `glob`, `grep`
 
 You have access to a filesystem which you can interact with using these tools.
@@ -229,6 +274,13 @@ All file paths must start with a /.
 - glob: find files matching a pattern (e.g., "**/*.py")
 - grep: search for text within files"""
 
+EXECUTION_SYSTEM_PROMPT = """## Execute Tool `execute`
+
+You have access to an `execute` tool for running shell commands in a sandboxed environment.
+Use this tool to run commands, scripts, tests, builds, and other shell operations.
+
+- execute: run a shell command in the sandbox (returns output and exit code)"""
+
 
 def _get_backend(backend: BACKEND_TYPES, runtime: ToolRuntime) -> BackendProtocol:
     """Get the resolved backend instance from backend or factory.
@@ -327,15 +379,17 @@ def _write_file_tool_generator(
             return res.error
         # If backend returns state update, wrap into Command with ToolMessage
         if res.files_update is not None:
-            return Command(update={
-                "files": res.files_update,
-                "messages": [
-                    ToolMessage(
-                        content=f"Updated file {res.path}",
-                        tool_call_id=runtime.tool_call_id,
-                    )
-                ],
-            })
+            return Command(
+                update={
+                    "files": res.files_update,
+                    "messages": [
+                        ToolMessage(
+                            content=f"Updated file {res.path}",
+                            tool_call_id=runtime.tool_call_id,
+                        )
+                    ],
+                }
+            )
         return f"Updated file {res.path}"
 
     return write_file
@@ -371,15 +425,17 @@ def _edit_file_tool_generator(
         if res.error:
             return res.error
         if res.files_update is not None:
-            return Command(update={
-                "files": res.files_update,
-                "messages": [
-                    ToolMessage(
-                        content=f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'",
-                        tool_call_id=runtime.tool_call_id,
-                    )
-                ],
-            })
+            return Command(
+                update={
+                    "files": res.files_update,
+                    "messages": [
+                        ToolMessage(
+                            content=f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'",
+                            tool_call_id=runtime.tool_call_id,
+                        )
+                    ],
+                }
+            )
         return f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'"
 
     return edit_file
@@ -428,7 +484,7 @@ def _grep_tool_generator(
     def grep(
         pattern: str,
         runtime: ToolRuntime[None, FilesystemState],
-        path: Optional[str] = None,
+        path: str | None = None,
         glob: str | None = None,
         output_mode: Literal["files_with_matches", "content", "count"] = "files_with_matches",
     ) -> str:
@@ -442,6 +498,80 @@ def _grep_tool_generator(
     return grep
 
 
+def _supports_execution(backend: BackendProtocol) -> bool:
+    """Check if a backend supports command execution.
+
+    For CompositeBackend, checks if the default backend supports execution.
+    For other backends, checks if they implement SandboxBackendProtocol.
+
+    Args:
+        backend: The backend to check.
+
+    Returns:
+        True if the backend supports execution, False otherwise.
+    """
+    # Import here to avoid circular dependency
+    from deepagents.backends.composite import CompositeBackend
+
+    # For CompositeBackend, check the default backend
+    if isinstance(backend, CompositeBackend):
+        return isinstance(backend.default, SandboxBackendProtocol)
+
+    # For other backends, use isinstance check
+    return isinstance(backend, SandboxBackendProtocol)
+
+
+def _execute_tool_generator(
+    backend: BackendProtocol | Callable[[ToolRuntime], BackendProtocol],
+    custom_description: str | None = None,
+) -> BaseTool:
+    """Generate the execute tool for sandbox command execution.
+
+    Args:
+        backend: Backend to use for execution, or a factory function that takes runtime and returns a backend.
+        custom_description: Optional custom description for the tool.
+
+    Returns:
+        Configured execute tool that runs commands if backend supports SandboxBackendProtocol.
+    """
+    tool_description = custom_description or EXECUTE_TOOL_DESCRIPTION
+
+    @tool(description=tool_description)
+    def execute(
+        command: str,
+        runtime: ToolRuntime[None, FilesystemState],
+    ) -> str:
+        resolved_backend = _get_backend(backend, runtime)
+
+        # Runtime check - fail gracefully if not supported
+        if not _supports_execution(resolved_backend):
+            return (
+                "Error: Execution not available. This agent's backend "
+                "does not support command execution (SandboxBackendProtocol). "
+                "To use the execute tool, provide a backend that implements SandboxBackendProtocol."
+            )
+
+        try:
+            result = resolved_backend.execute(command)
+        except NotImplementedError as e:
+            # Handle case where execute() exists but raises NotImplementedError
+            return f"Error: Execution not available. {e}"
+
+        # Format output for LLM consumption
+        parts = [result.output]
+
+        if result.exit_code is not None:
+            status = "succeeded" if result.exit_code == 0 else "failed"
+            parts.append(f"\n[Command {status} with exit code {result.exit_code}]")
+
+        if result.truncated:
+            parts.append("\n[Output was truncated due to size limits]")
+
+        return "".join(parts)
+
+    return execute
+
+
 TOOL_GENERATORS = {
     "ls": _ls_tool_generator,
     "read_file": _read_file_tool_generator,
@@ -449,6 +579,7 @@ TOOL_GENERATORS = {
     "edit_file": _edit_file_tool_generator,
     "glob": _glob_tool_generator,
     "grep": _grep_tool_generator,
+    "execute": _execute_tool_generator,
 }
 
 
@@ -456,18 +587,19 @@ def _get_filesystem_tools(
     backend: BackendProtocol,
     custom_tool_descriptions: dict[str, str] | None = None,
 ) -> list[BaseTool]:
-    """Get filesystem tools.
+    """Get filesystem and execution tools.
 
     Args:
-        backend: Backend to use for file storage, or a factory function that takes runtime and returns a backend.
+        backend: Backend to use for file storage and optional execution, or a factory function that takes runtime and returns a backend.
         custom_tool_descriptions: Optional custom descriptions for tools.
 
     Returns:
-        List of configured filesystem tools (ls, read_file, write_file, edit_file, glob, grep).
+        List of configured tools: ls, read_file, write_file, edit_file, glob, grep, execute.
     """
     if custom_tool_descriptions is None:
         custom_tool_descriptions = {}
     tools = []
+
     for tool_name, tool_generator in TOOL_GENERATORS.items():
         tool = tool_generator(backend, custom_tool_descriptions.get(tool_name))
         tools.append(tool)
@@ -485,16 +617,20 @@ Here are the first 10 lines of the result:
 
 
 class FilesystemMiddleware(AgentMiddleware):
-    """Middleware for providing filesystem tools to an agent.
+    """Middleware for providing filesystem and optional execution tools to an agent.
 
-    This middleware adds six filesystem tools to the agent: ls, read_file, write_file,
+    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
+    for running shell commands.
+
     Args:
-        backend: Backend for file storage. If not provided, defaults to StateBackend
+        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.
+            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.
@@ -502,18 +638,21 @@ class FilesystemMiddleware(AgentMiddleware):
     Example:
         ```python
         from deepagents.middleware.filesystem import FilesystemMiddleware
-        from deepagents.memory.backends import StateBackend, StoreBackend, CompositeBackend
+        from deepagents.backends import StateBackend, StoreBackend, CompositeBackend
         from langchain.agents import create_agent
 
-        # Ephemeral storage only (default)
+        # Ephemeral storage only (default, no execution)
         agent = create_agent(middleware=[FilesystemMiddleware()])
 
         # With hybrid storage (ephemeral + persistent /memories/)
-        backend = CompositeBackend(
-            default=StateBackend(),
-            routes={"/memories/": StoreBackend()}
-        )
-        agent = create_agent(middleware=[FilesystemMiddleware(memory_backend=backend)])
+        backend = CompositeBackend(default=StateBackend(), routes={"/memories/": StoreBackend()})
+        agent = create_agent(middleware=[FilesystemMiddleware(backend=backend)])
+
+        # With sandbox backend (supports execution)
+        from my_sandbox import DockerSandboxBackend
+
+        sandbox = DockerSandboxBackend(container_id="my-container")
+        agent = create_agent(middleware=[FilesystemMiddleware(backend=sandbox)])
         ```
     """
 
@@ -530,7 +669,8 @@ class FilesystemMiddleware(AgentMiddleware):
         """Initialize the filesystem middleware.
 
         Args:
-            backend: Backend for file storage, or a factory callable. Defaults to StateBackend if not provided.
+            backend: Backend for file storage and optional execution, or a factory callable.
+                Defaults to StateBackend if not provided.
             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.
@@ -540,8 +680,8 @@ class FilesystemMiddleware(AgentMiddleware):
         # Use provided backend or default to StateBackend factory
         self.backend = backend if backend is not None else (lambda rt: StateBackend(rt))
 
-        # Set system prompt (allow full override)
-        self.system_prompt = system_prompt if system_prompt is not None else FILESYSTEM_SYSTEM_PROMPT
+        # Set system prompt (allow full override or None to generate dynamically)
+        self._custom_system_prompt = system_prompt
 
         self.tools = _get_filesystem_tools(self.backend, custom_tool_descriptions)
 
@@ -563,7 +703,7 @@ class FilesystemMiddleware(AgentMiddleware):
         request: ModelRequest,
         handler: Callable[[ModelRequest], ModelResponse],
     ) -> ModelResponse:
-        """Update the system prompt to include instructions on using the filesystem.
+        """Update the system prompt and filter tools based on backend capabilities.
 
         Args:
             request: The model request being processed.
@@ -572,8 +712,37 @@ class FilesystemMiddleware(AgentMiddleware):
         Returns:
             The model response from the handler.
         """
-        if self.system_prompt is not None:
-            request.system_prompt = request.system_prompt + "\n\n" + self.system_prompt if request.system_prompt else self.system_prompt
+        # Check if execute tool is present and if backend supports it
+        has_execute_tool = any((tool.name if hasattr(tool, "name") else tool.get("name")) == "execute" for tool in request.tools)
+
+        backend_supports_execution = False
+        if has_execute_tool:
+            # Resolve backend to check execution support
+            backend = self._get_backend(request.runtime)
+            backend_supports_execution = _supports_execution(backend)
+
+            # If execute tool exists but backend doesn't support it, filter it out
+            if not backend_supports_execution:
+                filtered_tools = [tool for tool in request.tools if (tool.name if hasattr(tool, "name") else tool.get("name")) != "execute"]
+                request = request.override(tools=filtered_tools)
+                has_execute_tool = False
+
+        # Use custom system prompt if provided, otherwise generate dynamically
+        if self._custom_system_prompt is not None:
+            system_prompt = self._custom_system_prompt
+        else:
+            # Build dynamic system prompt based on available tools
+            prompt_parts = [FILESYSTEM_SYSTEM_PROMPT]
+
+            # Add execution instructions if execute tool is available
+            if has_execute_tool and backend_supports_execution:
+                prompt_parts.append(EXECUTION_SYSTEM_PROMPT)
+
+            system_prompt = "\n\n".join(prompt_parts)
+
+        if system_prompt:
+            request = request.override(system_prompt=request.system_prompt + "\n\n" + system_prompt if request.system_prompt else system_prompt)
+
         return handler(request)
 
     async def awrap_model_call(
@@ -581,7 +750,7 @@ class FilesystemMiddleware(AgentMiddleware):
         request: ModelRequest,
         handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
     ) -> ModelResponse:
-        """(async) Update the system prompt to include instructions on using the filesystem.
+        """(async) Update the system prompt and filter tools based on backend capabilities.
 
         Args:
             request: The model request being processed.
@@ -590,8 +759,37 @@ class FilesystemMiddleware(AgentMiddleware):
         Returns:
             The model response from the handler.
         """
-        if self.system_prompt is not None:
-            request.system_prompt = request.system_prompt + "\n\n" + self.system_prompt if request.system_prompt else self.system_prompt
+        # Check if execute tool is present and if backend supports it
+        has_execute_tool = any((tool.name if hasattr(tool, "name") else tool.get("name")) == "execute" for tool in request.tools)
+
+        backend_supports_execution = False
+        if has_execute_tool:
+            # Resolve backend to check execution support
+            backend = self._get_backend(request.runtime)
+            backend_supports_execution = _supports_execution(backend)
+
+            # If execute tool exists but backend doesn't support it, filter it out
+            if not backend_supports_execution:
+                filtered_tools = [tool for tool in request.tools if (tool.name if hasattr(tool, "name") else tool.get("name")) != "execute"]
+                request = request.override(tools=filtered_tools)
+                has_execute_tool = False
+
+        # Use custom system prompt if provided, otherwise generate dynamically
+        if self._custom_system_prompt is not None:
+            system_prompt = self._custom_system_prompt
+        else:
+            # Build dynamic system prompt based on available tools
+            prompt_parts = [FILESYSTEM_SYSTEM_PROMPT]
+
+            # Add execution instructions if execute tool is available
+            if has_execute_tool and backend_supports_execution:
+                prompt_parts.append(EXECUTION_SYSTEM_PROMPT)
+
+            system_prompt = "\n\n".join(prompt_parts)
+
+        if system_prompt:
+            request = request.override(system_prompt=request.system_prompt + "\n\n" + system_prompt if request.system_prompt else system_prompt)
+
         return await handler(request)
 
     def _process_large_message(
@@ -608,7 +806,7 @@ class FilesystemMiddleware(AgentMiddleware):
         result = resolved_backend.write(file_path, content)
         if result.error:
             return message, None
-        content_sample = format_content_with_line_numbers(content.splitlines()[:10], start_line=1)
+        content_sample = format_content_with_line_numbers([line[:1000] for line in content.splitlines()[:10]], start_line=1)
         processed_message = ToolMessage(
             TOO_LARGE_TOOL_MSG.format(
                 tool_call_id=message.tool_call_id,
@@ -621,20 +819,25 @@ class FilesystemMiddleware(AgentMiddleware):
 
     def _intercept_large_tool_result(self, tool_result: ToolMessage | Command, runtime: ToolRuntime) -> ToolMessage | Command:
         if isinstance(tool_result, ToolMessage) and isinstance(tool_result.content, str):
-            if not (self.tool_token_limit_before_evict and
-                    len(tool_result.content) > 4 * self.tool_token_limit_before_evict):
+            if not (self.tool_token_limit_before_evict and len(tool_result.content) > 4 * self.tool_token_limit_before_evict):
                 return tool_result
             resolved_backend = self._get_backend(runtime)
             processed_message, files_update = self._process_large_message(
                 tool_result,
                 resolved_backend,
             )
-            return (Command(update={
-                "files": files_update,
-                "messages": [processed_message],
-            }) if files_update is not None else processed_message)
+            return (
+                Command(
+                    update={
+                        "files": files_update,
+                        "messages": [processed_message],
+                    }
+                )
+                if files_update is not None
+                else processed_message
+            )
 
-        elif isinstance(tool_result, Command):
+        if isinstance(tool_result, Command):
             update = tool_result.update
             if update is None:
                 return tool_result
@@ -643,10 +846,12 @@ class FilesystemMiddleware(AgentMiddleware):
             resolved_backend = self._get_backend(runtime)
             processed_messages = []
             for message in command_messages:
-                if not (self.tool_token_limit_before_evict and
-                        isinstance(message, ToolMessage) and
-                        isinstance(message.content, str) and
-                        len(message.content) > 4 * self.tool_token_limit_before_evict):
+                if not (
+                    self.tool_token_limit_before_evict
+                    and isinstance(message, ToolMessage)
+                    and isinstance(message.content, str)
+                    and len(message.content) > 4 * self.tool_token_limit_before_evict
+                ):
                     processed_messages.append(message)
                     continue
                 processed_message, files_update = self._process_large_message(

deepagents/middleware/resumable_shell.py

@@ -2,17 +2,18 @@
 
 from __future__ import annotations
 
-from typing import Any, Awaitable, Callable, cast
+from collections.abc import Awaitable, Callable
+from typing import Any, cast
 
 from langchain.agents.middleware.shell_tool import (
     ShellToolMiddleware,
+    ShellToolState,
     _PersistentShellTool,
     _SessionResources,
-    ShellToolState,
 )
 from langchain.agents.middleware.types import AgentState
-from langchain_core.messages import ToolMessage
 from langchain.tools.tool_node import ToolCallRequest
+from langchain_core.messages import ToolMessage
 from langgraph.types import Command
 
 
@@ -78,7 +79,7 @@ class ResumableShellToolMiddleware(ShellToolMiddleware):
             return resources
 
         new_resources = self._create_resources()
-        cast(dict[str, Any], state)["shell_session_resources"] = new_resources
+        cast("dict[str, Any]", state)["shell_session_resources"] = new_resources
         return new_resources
 
 

deepagents/middleware/subagents.py

@@ -1,8 +1,7 @@
 """Middleware for providing subagents to an agent via a `task` tool."""
 
 from collections.abc import Awaitable, Callable, Sequence
-from typing import Any, TypedDict, cast
-from typing_extensions import NotRequired
+from typing import Any, NotRequired, TypedDict, cast
 
 from langchain.agents import create_agent
 from langchain.agents.middleware import HumanInTheLoopMiddleware, InterruptOnConfig
@@ -323,10 +322,7 @@ def _create_task_tool(
         )
 
     def _validate_and_prepare_state(subagent_type: str, description: str, runtime: ToolRuntime) -> tuple[Runnable, dict]:
-        """Validate subagent type and prepare state for invocation."""
-        if subagent_type not in subagent_graphs:
-            msg = f"Error: invoked agent of type {subagent_type}, the only allowed types are {[f'`{k}`' for k in subagent_graphs]}"
-            raise ValueError(msg)
+        """Prepare state for invocation."""
         subagent = subagent_graphs[subagent_type]
         # Create a new state dict to avoid mutating the original
         subagent_state = {k: v for k, v in runtime.state.items() if k not in _EXCLUDED_STATE_KEYS}
@@ -345,6 +341,9 @@ def _create_task_tool(
         subagent_type: str,
         runtime: ToolRuntime,
     ) -> str | Command:
+        if subagent_type not in subagent_graphs:
+            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)
         if not runtime.tool_call_id:
@@ -357,6 +356,9 @@ def _create_task_tool(
         subagent_type: str,
         runtime: ToolRuntime,
     ) -> str | Command:
+        if subagent_type not in subagent_graphs:
+            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)
         if not runtime.tool_call_id:

{deepagents-0.2.4.dist-info → deepagents-0.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.4
+Version: 0.2.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
@@ -11,18 +11,13 @@ 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
-License-File: LICENSE
 Requires-Dist: langchain-anthropic<2.0.0,>=1.0.0
 Requires-Dist: langchain<2.0.0,>=1.0.2
 Requires-Dist: langchain-core<2.0.0,>=1.0.0
 Requires-Dist: wcmatch
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: pytest-cov; extra == "dev"
-Requires-Dist: build; extra == "dev"
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: langchain-openai; extra == "dev"
-Dynamic: license-file
+Requires-Dist: daytona>=0.113.0
+Requires-Dist: runloop-api-client>=0.66.1
+Requires-Dist: tavily>=1.1.0
 
 # 🧠🤖Deep Agents
 
@@ -353,7 +348,7 @@ Deep Agents are built with a modular middleware architecture. As a reminder, Dee
 - A filesystem for storing context and long-term memories
 - The ability to spawn subagents
 
-Each of these features is implemented as separate middleware. When you create a deep agent with `create_deep_agent`, we automatically attach **PlanningMiddleware**, **FilesystemMiddleware** and **SubAgentMiddleware** to your agent.
+Each of these features is implemented as separate middleware. When you create a deep agent with `create_deep_agent`, we automatically attach **TodoListMiddleware**, **FilesystemMiddleware** and **SubAgentMiddleware** to your agent.
 
 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!
 

deepagents-0.2.6.dist-info/RECORD

@@ -0,0 +1,19 @@
+deepagents/__init__.py,sha256=9BVNn4lfF5N8l2KY8Ttxi82zO609I-fGqoSIF7DAxiU,342
+deepagents/graph.py,sha256=c6ggWJIPaFOK2OCWxZdGEPDfuDvjdDuqHY06-bUiqPg,6379
+deepagents/backends/__init__.py,sha256=BOKu2cQ1OdMyO_l2rLqZQiXppYFmQbx7OIQb7WYwvZc,457
+deepagents/backends/composite.py,sha256=2BSyAurAt1FXV7iFyajzVaRZvjGkUPBybg7J8E6kRNE,9548
+deepagents/backends/filesystem.py,sha256=SsVDx__j_AARIwRzaDuokbxbkquJ_Lw3Qi7dLWaqRUs,18674
+deepagents/backends/protocol.py,sha256=Hi6u3MWIfMUGFWwnIFwvmwJbHYsx8IxeU2aaoP_9OMk,5831
+deepagents/backends/sandbox.py,sha256=JueMe_2cZcA359JIqIi8kDUkmdtevC4VbKHw-fBPOWs,10125
+deepagents/backends/state.py,sha256=ST_tUExPxArJaA3U8vc1dyzxuYl2BQH-HU7P0eu_Ty8,6518
+deepagents/backends/store.py,sha256=f2LVSl65Dg-BZl-cY3pl3RqrUJCBMBm2kuAzZEODwsE,13098
+deepagents/backends/utils.py,sha256=Iyk2jW-gfoLvMnz-W_2FRCoJW_j3r1zoumU9iww-jd0,13973
+deepagents/middleware/__init__.py,sha256=x7UHqGcrKlhzORNdChPvnUwa_PIJCbFUHY6zTKVfloI,418
+deepagents/middleware/filesystem.py,sha256=3PAetXqWy0i9bE6moM0FDZAEmjMm_M48B4AWWYl4Luk,37271
+deepagents/middleware/patch_tool_calls.py,sha256=PdNhxPaQqwnFkhEAZEE2kEzadTNAOO3_iJRA30WqpGE,1981
+deepagents/middleware/resumable_shell.py,sha256=KjhafjKu28Nf_8pDmSk_aWRK7pgkXZoubvWQljIEv3w,3382
+deepagents/middleware/subagents.py,sha256=RbNpWLXC0Bhr0nUIs40whybNnzNkhxG9Fie7QKsICRk,23748
+deepagents-0.2.6.dist-info/METADATA,sha256=gcNhcchWORoY_wyqYv8xU1lvvYccmOhuVDZIYTubNYI,18887
+deepagents-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deepagents-0.2.6.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
+deepagents-0.2.6.dist-info/RECORD,,