deepagents 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

deepagents/middleware/filesystem.py

@@ -19,7 +19,15 @@ from langgraph.types import Command
 from typing_extensions import TypedDict
 
 from deepagents.backends import StateBackend
-from deepagents.backends.protocol import BackendFactory, BackendProtocol, EditResult, WriteResult
+
+# 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 (
     format_content_with_line_numbers,
     format_grep_matches,
@@ -32,7 +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):
@@ -211,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.
@@ -223,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.
@@ -440,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,
@@ -447,6 +579,7 @@ TOOL_GENERATORS = {
     "edit_file": _edit_file_tool_generator,
     "glob": _glob_tool_generator,
     "grep": _grep_tool_generator,
+    "execute": _execute_tool_generator,
 }
 
 
@@ -454,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)
@@ -483,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.
@@ -500,15 +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)])
+        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)])
         ```
     """
 
@@ -525,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.
@@ -535,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)
 
@@ -558,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.
@@ -567,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(
@@ -576,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.
@@ -585,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(

deepagents/middleware/subagents.py

@@ -322,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}
@@ -344,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:
@@ -356,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.5.dist-info → deepagents-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.5
+Version: 0.2.7
 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,12 +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
-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
 
@@ -347,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.7.dist-info/RECORD

@@ -0,0 +1,18 @@
+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=_OGIHcHZ2pRD0gzUBS7R48agwI6P7-FCBKBgjyaWlsg,303
+deepagents/middleware/filesystem.py,sha256=3PAetXqWy0i9bE6moM0FDZAEmjMm_M48B4AWWYl4Luk,37271
+deepagents/middleware/patch_tool_calls.py,sha256=PdNhxPaQqwnFkhEAZEE2kEzadTNAOO3_iJRA30WqpGE,1981
+deepagents/middleware/subagents.py,sha256=RbNpWLXC0Bhr0nUIs40whybNnzNkhxG9Fie7QKsICRk,23748
+deepagents-0.2.7.dist-info/METADATA,sha256=H5FgpjWX5qzV5uHcpm0ba4F1Jwtw_Kvj79U9mdUR3Os,18887
+deepagents-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deepagents-0.2.7.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
+deepagents-0.2.7.dist-info/RECORD,,

deepagents-0.2.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+deepagents

deepagents/middleware/resumable_shell.py

@@ -1,86 +0,0 @@
-"""Shell tool middleware that survives HITL pauses."""
-
-from __future__ import annotations
-
-from collections.abc import Awaitable, Callable
-from typing import Any, cast
-
-from langchain.agents.middleware.shell_tool import (
-    ShellToolMiddleware,
-    ShellToolState,
-    _PersistentShellTool,
-    _SessionResources,
-)
-from langchain.agents.middleware.types import AgentState
-from langchain.tools.tool_node import ToolCallRequest
-from langchain_core.messages import ToolMessage
-from langgraph.types import Command
-
-
-class ResumableShellToolMiddleware(ShellToolMiddleware):
-    """Shell middleware that recreates session resources after human interrupts.
-
-    ``ShellToolMiddleware`` stores its session handle in middleware state using an
-    ``UntrackedValue``. When a run pauses for human approval, that attribute is not
-    checkpointed. Upon resuming, LangGraph restores the state without the shell
-    resources, so the next tool execution fails with
-    ``Shell session resources are unavailable``.
-
-    This subclass lazily recreates the shell session the first time a resumed run
-    touches the shell tool again and only performs shutdown when a session is
-    actually active. This keeps behaviour identical for uninterrupted runs while
-    allowing HITL pauses to succeed.
-    """
-
-    def wrap_tool_call(
-        self,
-        request: ToolCallRequest,
-        handler: Callable[[ToolCallRequest], ToolMessage | Command],
-    ) -> ToolMessage | Command:
-        if isinstance(request.tool, _PersistentShellTool):
-            resources = self._get_or_create_resources(request.state)
-            return self._run_shell_tool(
-                resources,
-                request.tool_call["args"],
-                tool_call_id=request.tool_call.get("id"),
-            )
-        return super().wrap_tool_call(request, handler)
-
-    async def awrap_tool_call(
-        self,
-        request: ToolCallRequest,
-        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
-    ) -> ToolMessage | Command:
-        if isinstance(request.tool, _PersistentShellTool):
-            resources = self._get_or_create_resources(request.state)
-            return self._run_shell_tool(
-                resources,
-                request.tool_call["args"],
-                tool_call_id=request.tool_call.get("id"),
-            )
-        return await super().awrap_tool_call(request, handler)
-
-    def after_agent(self, state: ShellToolState, runtime) -> None:  # type: ignore[override]
-        if self._has_resources(state):
-            super().after_agent(state, runtime)
-
-    async def aafter_agent(self, state: ShellToolState, runtime) -> None:  # type: ignore[override]
-        if self._has_resources(state):
-            await super().aafter_agent(state, runtime)
-
-    @staticmethod
-    def _has_resources(state: AgentState) -> bool:
-        resources = state.get("shell_session_resources")
-        return isinstance(resources, _SessionResources)
-
-    def _get_or_create_resources(self, state: AgentState) -> _SessionResources:
-        resources = state.get("shell_session_resources")
-        if isinstance(resources, _SessionResources):
-            return resources
-
-        new_resources = self._create_resources()
-        cast("dict[str, Any]", state)["shell_session_resources"] = new_resources
-        return new_resources
-
-
-__all__ = ["ResumableShellToolMiddleware"]

deepagents-0.2.5.dist-info/RECORD

@@ -1,38 +0,0 @@
-deepagents/__init__.py,sha256=9BVNn4lfF5N8l2KY8Ttxi82zO609I-fGqoSIF7DAxiU,342
-deepagents/graph.py,sha256=pwRKF9EsmBtc2LabAcqted92kIhG5b4SaEfACT2G4Ps,6094
-deepagents/backends/__init__.py,sha256=BOKu2cQ1OdMyO_l2rLqZQiXppYFmQbx7OIQb7WYwvZc,457
-deepagents/backends/composite.py,sha256=0jvuo2YBlr3LT3N10uE0p1-vVSCdkzK0uLciPRcUg8o,8431
-deepagents/backends/filesystem.py,sha256=SsVDx__j_AARIwRzaDuokbxbkquJ_Lw3Qi7dLWaqRUs,18674
-deepagents/backends/protocol.py,sha256=wmXk24BBN1vo3ALYTIZmCi5fjxNZeH8y06v1OXc5ABU,4555
-deepagents/backends/state.py,sha256=ST_tUExPxArJaA3U8vc1dyzxuYl2BQH-HU7P0eu_Ty8,6518
-deepagents/backends/store.py,sha256=HWGZ0euXp9ww4HvWYg1S-tEH17cuFy3F1lg3DiGN6CY,13232
-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=7O2GUeGPQBslNBU1Gdser-tkL2DO_f8nZ9yZsGC3INs,28294
-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=dI9w_TXKb4I6-InHua993sICTQ4fw5GapgNkHc-q50I,23474
-deepagents-0.2.5.dist-info/licenses/LICENSE,sha256=c__BaxUCK69leo2yEKynf8lWndu8iwYwge1CbyqAe-E,1071
-deepagents-cli/README.md,sha256=LQksI_Z2qG3IMbIZ7ZRBQlWTufPZmIevGt7uya_HObg,49
-deepagents-cli/deepagents_cli/README.md,sha256=ajP946mBaKQRn_k3vViWfQn8v1BKiaw58gqb0xKmp4o,7413
-deepagents-cli/deepagents_cli/__init__.py,sha256=2W9tHzQianR_Q0ku9hc_ZI3kUYsilXQ6I_kUnpg9bzg,108
-deepagents-cli/deepagents_cli/__main__.py,sha256=J9-RNZv_zxw4SyjWRI_N7k7m8G4--vclD8vKxYIiXPQ,128
-deepagents-cli/deepagents_cli/agent.py,sha256=8GFi9XtfedYTL0J-f72ARb_glklIIFCyzI_9buAg3h4,11066
-deepagents-cli/deepagents_cli/agent_memory.py,sha256=Ma4P8sFpZ84ytb8GtqRcTv9Uy5E15oXqJzuBV9vuKmU,9147
-deepagents-cli/deepagents_cli/commands.py,sha256=rHsHij1xGs13N_m46YcBP2M2_MRGqRbSlnWaZaMnoco,2606
-deepagents-cli/deepagents_cli/config.py,sha256=gcYPDPltyhgMIiTNXQOaoKGqsAc-izNGPOlAqf_o7I0,4403
-deepagents-cli/deepagents_cli/default_agent_prompt.md,sha256=Pi9SvgOAa74qhgDUMexm2-S_OfUO_CTic3zdbUnuB4s,4964
-deepagents-cli/deepagents_cli/execution.py,sha256=2VqjnrT_LQn0b7eLqIIPW6oB4GeLFSR1w2X_3kjU4Lg,26498
-deepagents-cli/deepagents_cli/file_ops.py,sha256=LQ7NTXPWLwePbiTBDA-22_VHxEGil7NpBltHZx1C7r4,12362
-deepagents-cli/deepagents_cli/input.py,sha256=KXv9Kq13V1fK5bSRLfJxheYn8FH6_xc_l4fpcQlwqNc,10177
-deepagents-cli/deepagents_cli/main.py,sha256=cIyLfAU-eJrAf2i7aCEElVTO7xXPXW8jsje4REACfcg,7142
-deepagents-cli/deepagents_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deepagents-cli/deepagents_cli/token_utils.py,sha256=tEeghLW2-vsitc-ba9cklKYnjLgRpvK7rK7PRiUu8jA,2439
-deepagents-cli/deepagents_cli/tools.py,sha256=Av92Luq-vGgUr25DqErGi7aI6y6DdFSXLigffhNLxYk,4287
-deepagents-cli/deepagents_cli/ui.py,sha256=d5hMHuTYerAINehGHohTI0ln4u9vojPvK1fN4OrqEEI,18667
-deepagents-cli/tests/test_file_ops.py,sha256=xtu1UCmVf6gPadK0H33CtscCon8GAChi5oCboZfq-hg,3008
-deepagents-cli/tests/test_placeholder.py,sha256=awIMcOR8rWGq0p_kljsIkZKinVdDlyx3MqDMQgPSi6U,101
-deepagents-0.2.5.dist-info/METADATA,sha256=PiLwTOCG0BRgMteCvhAf4JhOOYxZW3EPq5Qb0_95fec,18828
-deepagents-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deepagents-0.2.5.dist-info/top_level.txt,sha256=7lDw_vmqmbQPyEVg2wcsIMEM9rjFC8i4pDXlksJ7vao,26
-deepagents-0.2.5.dist-info/RECORD,,

deepagents-0.2.5.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Harrison Chase
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

deepagents-0.2.5.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-deepagents
-deepagents-cli

deepagents-cli/README.md

@@ -1,3 +0,0 @@
-# deepagents cli
-
-This is the CLI for deepagents