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

deepagents/backends/composite.py

@@ -1,10 +1,14 @@
 """CompositeBackend: Route operations to different backends based on path prefix."""
 
+from collections import defaultdict
+
 from deepagents.backends.protocol import (
     BackendProtocol,
     EditResult,
     ExecuteResponse,
+    FileDownloadResponse,
     FileInfo,
+    FileUploadResponse,
     GrepMatch,
     SandboxBackendProtocol,
     WriteResult,
@@ -247,3 +251,86 @@ class CompositeBackend:
             "Default backend doesn't support command execution (SandboxBackendProtocol). "
             "To enable execution, provide a default backend that implements SandboxBackendProtocol."
         )
+
+    def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        """Upload multiple files, batching by backend for efficiency.
+
+        Groups files by their target backend, calls each backend's upload_files
+        once with all files for that backend, then merges results in original order.
+
+        Args:
+            files: List of (path, content) tuples to upload.
+
+        Returns:
+            List of FileUploadResponse objects, one per input file.
+            Response order matches input order.
+        """
+        # Pre-allocate result list
+        results: list[FileUploadResponse | None] = [None] * len(files)
+
+        # Group files by backend, tracking original indices
+        from collections import defaultdict
+
+        backend_batches: dict[BackendProtocol, list[tuple[int, str, bytes]]] = defaultdict(list)
+
+        for idx, (path, content) in enumerate(files):
+            backend, stripped_path = self._get_backend_and_key(path)
+            backend_batches[backend].append((idx, stripped_path, content))
+
+        # Process each backend's batch
+        for backend, batch in backend_batches.items():
+            # Extract data for backend call
+            indices, stripped_paths, contents = zip(*batch, strict=False)
+            batch_files = list(zip(stripped_paths, contents, strict=False))
+
+            # Call backend once with all its files
+            batch_responses = backend.upload_files(batch_files)
+
+            # Place responses at original indices with original paths
+            for i, orig_idx in enumerate(indices):
+                results[orig_idx] = FileUploadResponse(
+                    path=files[orig_idx][0],  # Original path
+                    error=batch_responses[i].error if i < len(batch_responses) else None,
+                )
+
+        return results  # type: ignore[return-value]
+
+    def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Download multiple files, batching by backend for efficiency.
+
+        Groups paths by their target backend, calls each backend's download_files
+        once with all paths for that backend, then merges results in original order.
+
+        Args:
+            paths: List of file paths to download.
+
+        Returns:
+            List of FileDownloadResponse objects, one per input path.
+            Response order matches input order.
+        """
+        # Pre-allocate result list
+        results: list[FileDownloadResponse | None] = [None] * len(paths)
+
+        backend_batches: dict[BackendProtocol, list[tuple[int, str]]] = defaultdict(list)
+
+        for idx, path in enumerate(paths):
+            backend, stripped_path = self._get_backend_and_key(path)
+            backend_batches[backend].append((idx, stripped_path))
+
+        # Process each backend's batch
+        for backend, batch in backend_batches.items():
+            # Extract data for backend call
+            indices, stripped_paths = zip(*batch, strict=False)
+
+            # Call backend once with all its paths
+            batch_responses = backend.download_files(list(stripped_paths))
+
+            # Place responses at original indices with original paths
+            for i, orig_idx in enumerate(indices):
+                results[orig_idx] = FileDownloadResponse(
+                    path=paths[orig_idx],  # Original path
+                    content=batch_responses[i].content if i < len(batch_responses) else None,
+                    error=batch_responses[i].error if i < len(batch_responses) else None,
+                )
+
+        return results  # type: ignore[return-value]

deepagents/backends/filesystem.py

@@ -16,7 +16,15 @@ from pathlib import Path
 
 import wcmatch.glob as wcglob
 
-from deepagents.backends.protocol import BackendProtocol, EditResult, FileInfo, GrepMatch, WriteResult
+from deepagents.backends.protocol import (
+    BackendProtocol,
+    EditResult,
+    FileDownloadResponse,
+    FileInfo,
+    FileUploadResponse,
+    GrepMatch,
+    WriteResult,
+)
 from deepagents.backends.utils import (
     check_empty_content,
     format_content_with_line_numbers,
@@ -185,8 +193,6 @@ class FilesystemBackend(BackendProtocol):
         results.sort(key=lambda x: x.get("path", ""))
         return results
 
-    # Removed legacy ls() convenience to keep lean surface
-
     def read(
         self,
         file_path: str,
@@ -208,14 +214,9 @@ class FilesystemBackend(BackendProtocol):
 
         try:
             # Open with O_NOFOLLOW where available to avoid symlink traversal
-            try:
-                fd = os.open(resolved_path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
-                with os.fdopen(fd, "r", encoding="utf-8") as f:
-                    content = f.read()
-            except OSError:
-                # Fallback to normal open if O_NOFOLLOW unsupported or fails
-                with open(resolved_path, encoding="utf-8") as f:
-                    content = f.read()
+            fd = os.open(resolved_path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
+            with os.fdopen(fd, "r", encoding="utf-8") as f:
+                content = f.read()
 
             empty_msg = check_empty_content(content)
             if empty_msg:
@@ -279,13 +280,9 @@ class FilesystemBackend(BackendProtocol):
 
         try:
             # Read securely
-            try:
-                fd = os.open(resolved_path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
-                with os.fdopen(fd, "r", encoding="utf-8") as f:
-                    content = f.read()
-            except OSError:
-                with open(resolved_path, encoding="utf-8") as f:
-                    content = f.read()
+            fd = os.open(resolved_path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
+            with os.fdopen(fd, "r", encoding="utf-8") as f:
+                content = f.read()
 
             result = perform_string_replacement(content, old_string, new_string, replace_all)
 
@@ -481,3 +478,73 @@ class FilesystemBackend(BackendProtocol):
 
         results.sort(key=lambda x: x.get("path", ""))
         return results
+
+    def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        """Upload multiple files to the filesystem.
+
+        Args:
+            files: List of (path, content) tuples where content is bytes.
+
+        Returns:
+            List of FileUploadResponse objects, one per input file.
+            Response order matches input order.
+        """
+        responses: list[FileUploadResponse] = []
+        for path, content in files:
+            try:
+                resolved_path = self._resolve_path(path)
+
+                # Create parent directories if needed
+                resolved_path.parent.mkdir(parents=True, exist_ok=True)
+
+                flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
+                if hasattr(os, "O_NOFOLLOW"):
+                    flags |= os.O_NOFOLLOW
+                fd = os.open(resolved_path, flags, 0o644)
+                with os.fdopen(fd, "wb") as f:
+                    f.write(content)
+
+                responses.append(FileUploadResponse(path=path, error=None))
+            except FileNotFoundError:
+                responses.append(FileUploadResponse(path=path, error="file_not_found"))
+            except PermissionError:
+                responses.append(FileUploadResponse(path=path, error="permission_denied"))
+            except (ValueError, OSError) as e:
+                # ValueError from _resolve_path for path traversal, OSError for other file errors
+                if isinstance(e, ValueError) or "invalid" in str(e).lower():
+                    responses.append(FileUploadResponse(path=path, error="invalid_path"))
+                else:
+                    # Generic error fallback
+                    responses.append(FileUploadResponse(path=path, error="invalid_path"))
+
+        return responses
+
+    def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Download multiple files from the filesystem.
+
+        Args:
+            paths: List of file paths to download.
+
+        Returns:
+            List of FileDownloadResponse objects, one per input path.
+        """
+        responses: list[FileDownloadResponse] = []
+        for path in paths:
+            try:
+                resolved_path = self._resolve_path(path)
+                # Use flags to optionally prevent symlink following if
+                # supported by the OS
+                fd = os.open(resolved_path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
+                with os.fdopen(fd, "rb") as f:
+                    content = f.read()
+                responses.append(FileDownloadResponse(path=path, content=content, error=None))
+            except FileNotFoundError:
+                responses.append(FileDownloadResponse(path=path, content=None, error="file_not_found"))
+            except PermissionError:
+                responses.append(FileDownloadResponse(path=path, content=None, error="permission_denied"))
+            except IsADirectoryError:
+                responses.append(FileDownloadResponse(path=path, content=None, error="is_directory"))
+            except ValueError:
+                responses.append(FileDownloadResponse(path=path, content=None, error="invalid_path"))
+            # Let other errors propagate
+        return responses

deepagents/backends/protocol.py

@@ -7,12 +7,83 @@ database, etc.) and provide a uniform interface for file operations.
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any, Protocol, TypeAlias, TypedDict, runtime_checkable
+from typing import Any, Literal, NotRequired, Protocol, TypeAlias, runtime_checkable
 
 from langchain.tools import ToolRuntime
+from typing_extensions import TypedDict
+
+FileOperationError = Literal[
+    "file_not_found",  # Download: file doesn't exist
+    "permission_denied",  # Both: access denied
+    "is_directory",  # Download: tried to download directory as file
+    "invalid_path",  # Both: path syntax malformed (parent dir missing, invalid chars)
+]
+"""Standardized error codes for file upload/download operations.
+
+These represent common, recoverable errors that an LLM can understand and potentially fix:
+- file_not_found: The requested file doesn't exist (download)
+- parent_not_found: The parent directory doesn't exist (upload)
+- permission_denied: Access denied for the operation
+- is_directory: Attempted to download a directory as a file
+- invalid_path: Path syntax is malformed or contains invalid characters
+"""
+
+
+@dataclass
+class FileDownloadResponse:
+    """Result of a single file download operation.
+
+    The response is designed to allow partial success in batch operations.
+    The errors are standardized using FileOperationError literals
+    for certain recoverable conditions for use cases that involve
+    LLMs performing file operations.
+
+    Attributes:
+        path: The file path that was requested. Included for easy correlation
+            when processing batch results, especially useful for error messages.
+        content: File contents as bytes on success, None on failure.
+        error: Standardized error code on failure, None on success.
+            Uses FileOperationError literal for structured, LLM-actionable error reporting.
+
+    Examples:
+        >>> # Success
+        >>> FileDownloadResponse(path="/app/config.json", content=b"{...}", error=None)
+        >>> # Failure
+        >>> FileDownloadResponse(path="/wrong/path.txt", content=None, error="file_not_found")
+    """
 
+    path: str
+    content: bytes | None = None
+    error: FileOperationError | None = None
+
+
+@dataclass
+class FileUploadResponse:
+    """Result of a single file upload operation.
+
+    The response is designed to allow partial success in batch operations.
+    The errors are standardized using FileOperationError literals
+    for certain recoverable conditions for use cases that involve
+    LLMs performing file operations.
+
+    Attributes:
+        path: The file path that was requested. Included for easy correlation
+            when processing batch results and for clear error messages.
+        error: Standardized error code on failure, None on success.
+            Uses FileOperationError literal for structured, LLM-actionable error reporting.
+
+    Examples:
+        >>> # Success
+        >>> FileUploadResponse(path="/app/data.txt", error=None)
+        >>> # Failure
+        >>> FileUploadResponse(path="/readonly/file.txt", error="permission_denied")
+    """
 
-class FileInfo(TypedDict, total=False):
+    path: str
+    error: FileOperationError | None = None
+
+
+class FileInfo(TypedDict):
     """Structured file listing info.
 
     Minimal contract used across backends. Only "path" is required.
@@ -20,9 +91,9 @@ class FileInfo(TypedDict, total=False):
     """
 
     path: str
-    is_dir: bool
-    size: int  # bytes (approx)
-    modified_at: str  # ISO timestamp if known
+    is_dir: NotRequired[bool]
+    size: NotRequired[int]  # bytes (approx)
+    modified_at: NotRequired[str]  # ISO timestamp if known
 
 
 class GrepMatch(TypedDict):
@@ -94,9 +165,9 @@ class BackendProtocol(Protocol):
 
     All file data is represented as dicts with the following structure:
     {
-        "content": list[str],      # Lines of text content
-        "created_at": str,         # ISO format timestamp
-        "modified_at": str,        # ISO format timestamp
+        "content": list[str], # Lines of text content
+        "created_at": str, # ISO format timestamp
+        "modified_at": str, # ISO format timestamp
     }
     """
 
@@ -144,6 +215,48 @@ class BackendProtocol(Protocol):
         """Edit a file by replacing string occurrences. Returns EditResult."""
         ...
 
+    def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        """Upload multiple files to the sandbox.
+
+        This API is designed to allow developers to use it either directly or
+        by exposing it to LLMs via custom tools.
+
+        Args:
+            files: List of (path, content) tuples to upload.
+
+        Returns:
+            List of FileUploadResponse objects, one per input file.
+            Response order matches input order (response[i] for files[i]).
+            Check the error field to determine success/failure per file.
+
+        Examples:
+            ```python
+            responses = sandbox.upload_files(
+                [
+                    ("/app/config.json", b"{...}"),
+                    ("/app/data.txt", b"content"),
+                ]
+            )
+            ```
+        """
+        ...
+
+    def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Download multiple files from the sandbox.
+
+        This API is designed to allow developers to use it either directly or
+        by exposing it to LLMs via custom tools.
+
+        Args:
+            paths: List of file paths to download.
+
+        Returns:
+            List of FileDownloadResponse objects, one per input path.
+            Response order matches input order (response[i] for paths[i]).
+            Check the error field to determine success/failure per file.
+        """
+        ...
+
 
 @dataclass
 class ExecuteResponse:
@@ -188,7 +301,7 @@ class SandboxBackendProtocol(BackendProtocol, Protocol):
 
     @property
     def id(self) -> str:
-        """Unique identifier for the sandbox backend."""
+        """Unique identifier for the sandbox backend instance."""
         ...
 
 

deepagents/backends/sandbox.py

@@ -14,7 +14,9 @@ from abc import ABC, abstractmethod
 from deepagents.backends.protocol import (
     EditResult,
     ExecuteResponse,
+    FileDownloadResponse,
     FileInfo,
+    FileUploadResponse,
     GrepMatch,
     SandboxBackendProtocol,
     WriteResult,
@@ -338,4 +340,20 @@ except PermissionError:
     @property
     @abstractmethod
     def id(self) -> str:
-        """Unique identifier for this backend instance."""
+        """Unique identifier for the sandbox backend."""
+
+    @abstractmethod
+    def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        """Upload multiple files to the sandbox.
+
+        Implementations must support partial success - catch exceptions per-file
+        and return errors in FileUploadResponse objects rather than raising.
+        """
+
+    @abstractmethod
+    def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Download multiple files from the sandbox.
+
+        Implementations must support partial success - catch exceptions per-file
+        and return errors in FileDownloadResponse objects rather than raising.
+        """

deepagents/backends/state.py

@@ -90,8 +90,6 @@ class StateBackend(BackendProtocol):
         infos.sort(key=lambda x: x.get("path", ""))
         return infos
 
-    # Removed legacy ls() convenience to keep lean surface
-
     def read(
         self,
         file_path: str,
@@ -156,8 +154,6 @@ class StateBackend(BackendProtocol):
         new_file_data = update_file_data(file_data, new_content)
         return EditResult(path=file_path, files_update={file_path: new_file_data}, occurrences=int(occurrences))
 
-    # Removed legacy grep() convenience to keep lean surface
-
     def grep_raw(
         self,
         pattern: str,
@@ -168,6 +164,7 @@ class StateBackend(BackendProtocol):
         return grep_matches_from_files(files, pattern, path, glob)
 
     def glob_info(self, pattern: str, path: str = "/") -> list[FileInfo]:
+        """Get FileInfo for files matching glob pattern."""
         files = self.runtime.state.get("files", {})
         result = _glob_search_files(files, pattern, path)
         if result == "No files found":
@@ -186,6 +183,3 @@ class StateBackend(BackendProtocol):
                 }
             )
         return infos
-
-
-# Provider classes removed: prefer callables like `lambda rt: StateBackend(rt)`

deepagents/backends/store.py

@@ -5,7 +5,15 @@ from typing import Any
 from langgraph.config import get_config
 from langgraph.store.base import BaseStore, Item
 
-from deepagents.backends.protocol import BackendProtocol, EditResult, FileInfo, GrepMatch, WriteResult
+from deepagents.backends.protocol import (
+    BackendProtocol,
+    EditResult,
+    FileDownloadResponse,
+    FileInfo,
+    FileUploadResponse,
+    GrepMatch,
+    WriteResult,
+)
 from deepagents.backends.utils import (
     _glob_search_files,
     create_file_data,
@@ -240,8 +248,6 @@ class StoreBackend(BackendProtocol):
         infos.sort(key=lambda x: x.get("path", ""))
         return infos
 
-    # Removed legacy ls() convenience to keep lean surface
-
     def read(
         self,
         file_path: str,
@@ -376,3 +382,59 @@ class StoreBackend(BackendProtocol):
                 }
             )
         return infos
+
+    def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        """Upload multiple files to the store.
+
+        Args:
+            files: List of (path, content) tuples where content is bytes.
+
+        Returns:
+            List of FileUploadResponse objects, one per input file.
+            Response order matches input order.
+        """
+        store = self._get_store()
+        namespace = self._get_namespace()
+        responses: list[FileUploadResponse] = []
+
+        for path, content in files:
+            content_str = content.decode("utf-8")
+            # Create file data
+            file_data = create_file_data(content_str)
+            store_value = self._convert_file_data_to_store_value(file_data)
+
+            # Store the file
+            store.put(namespace, path, store_value)
+            responses.append(FileUploadResponse(path=path, error=None))
+
+        return responses
+
+    def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Download multiple files from the store.
+
+        Args:
+            paths: List of file paths to download.
+
+        Returns:
+            List of FileDownloadResponse objects, one per input path.
+            Response order matches input order.
+        """
+        store = self._get_store()
+        namespace = self._get_namespace()
+        responses: list[FileDownloadResponse] = []
+
+        for path in paths:
+            item = store.get(namespace, path)
+
+            if item is None:
+                responses.append(FileDownloadResponse(path=path, content=None, error="file_not_found"))
+                continue
+
+            file_data = self._convert_store_item_to_file_data(item)
+            # Convert file data to bytes
+            content_str = file_data_to_string(file_data)
+            content_bytes = content_str.encode("utf-8")
+
+            responses.append(FileDownloadResponse(path=path, content=content_bytes, error=None))
+
+        return responses

deepagents/middleware/__init__.py

@@ -1,13 +1,11 @@
 """Middleware for the DeepAgent."""
 
 from deepagents.middleware.filesystem import FilesystemMiddleware
-from deepagents.middleware.resumable_shell import ResumableShellToolMiddleware
 from deepagents.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
 
 __all__ = [
     "CompiledSubAgent",
     "FilesystemMiddleware",
-    "ResumableShellToolMiddleware",
     "SubAgent",
     "SubAgentMiddleware",
 ]

deepagents/middleware/filesystem.py

@@ -2,6 +2,7 @@
 # ruff: noqa: E501
 
 import os
+import re
 from collections.abc import Awaitable, Callable, Sequence
 from typing import Annotated, Literal, NotRequired
 
@@ -92,12 +93,16 @@ def _file_data_reducer(left: dict[str, FileData] | None, right: dict[str, FileDa
 
 
 def _validate_path(path: str, *, allowed_prefixes: Sequence[str] | None = None) -> str:
-    """Validate and normalize file path for security.
+    r"""Validate and normalize file path for security.
 
     Ensures paths are safe to use by preventing directory traversal attacks
     and enforcing consistent formatting. All paths are normalized to use
     forward slashes and start with a leading slash.
 
+    This function is designed for virtual filesystem paths and rejects
+    Windows absolute paths (e.g., C:/..., F:/...) to maintain consistency
+    and prevent path format ambiguity.
+
     Args:
         path: The path to validate and normalize.
         allowed_prefixes: Optional list of allowed path prefixes. If provided,
@@ -107,14 +112,16 @@ def _validate_path(path: str, *, allowed_prefixes: Sequence[str] | None = None)
         Normalized canonical path starting with `/` and using forward slashes.
 
     Raises:
-        ValueError: If path contains traversal sequences (`..` or `~`) or does
-            not start with an allowed prefix when `allowed_prefixes` is specified.
+        ValueError: If path contains traversal sequences (`..` or `~`), is a
+            Windows absolute path (e.g., C:/...), or does not start with an
+            allowed prefix when `allowed_prefixes` is specified.
 
     Example:
         ```python
         validate_path("foo/bar")  # Returns: "/foo/bar"
         validate_path("/./foo//bar")  # Returns: "/foo/bar"
         validate_path("../etc/passwd")  # Raises ValueError
+        validate_path(r"C:\\Users\\file.txt")  # Raises ValueError
         validate_path("/data/file.txt", allowed_prefixes=["/data/"])  # OK
         validate_path("/etc/file.txt", allowed_prefixes=["/data/"])  # Raises ValueError
         ```
@@ -123,6 +130,12 @@ def _validate_path(path: str, *, allowed_prefixes: Sequence[str] | None = None)
         msg = f"Path traversal not allowed: {path}"
         raise ValueError(msg)
 
+    # Reject Windows absolute paths (e.g., C:\..., D:/...)
+    # This maintains consistency in virtual filesystem paths
+    if re.match(r"^[a-zA-Z]:", path):
+        msg = f"Windows absolute paths are not supported: {path}. Please use virtual paths starting with / (e.g., /workspace/file.txt)"
+        raise ValueError(msg)
+
     normalized = os.path.normpath(path)
     normalized = normalized.replace("\\", "/")
 
@@ -313,11 +326,13 @@ def _ls_tool_generator(
     tool_description = custom_description or LIST_FILES_TOOL_DESCRIPTION
 
     @tool(description=tool_description)
-    def ls(runtime: ToolRuntime[None, FilesystemState], path: str) -> list[str]:
+    def ls(runtime: ToolRuntime[None, FilesystemState], path: str) -> str:
         resolved_backend = _get_backend(backend, runtime)
         validated_path = _validate_path(path)
         infos = resolved_backend.ls_info(validated_path)
-        return [fi.get("path", "") for fi in infos]
+        paths = [fi.get("path", "") for fi in infos]
+        result = truncate_if_too_long(paths)
+        return str(result)
 
     return ls
 
@@ -457,10 +472,12 @@ def _glob_tool_generator(
     tool_description = custom_description or GLOB_TOOL_DESCRIPTION
 
     @tool(description=tool_description)
-    def glob(pattern: str, runtime: ToolRuntime[None, FilesystemState], path: str = "/") -> list[str]:
+    def glob(pattern: str, runtime: ToolRuntime[None, FilesystemState], path: str = "/") -> str:
         resolved_backend = _get_backend(backend, runtime)
         infos = resolved_backend.glob_info(pattern, path=path)
-        return [fi.get("path", "") for fi in infos]
+        paths = [fi.get("path", "") for fi in infos]
+        result = truncate_if_too_long(paths)
+        return str(result)
 
     return glob
 

deepagents/middleware/subagents.py

@@ -468,7 +468,8 @@ class SubAgentMiddleware(AgentMiddleware):
     ) -> ModelResponse:
         """Update the system prompt to include instructions on using subagents."""
         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
+            system_prompt = request.system_prompt + "\n\n" + self.system_prompt if request.system_prompt else self.system_prompt
+            return handler(request.override(system_prompt=system_prompt))
         return handler(request)
 
     async def awrap_model_call(
@@ -478,5 +479,6 @@ class SubAgentMiddleware(AgentMiddleware):
     ) -> ModelResponse:
         """(async) Update the system prompt to include instructions on using subagents."""
         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
+            system_prompt = request.system_prompt + "\n\n" + self.system_prompt if request.system_prompt else self.system_prompt
+            return await handler(request.override(system_prompt=system_prompt))
         return await handler(request)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.6
+Version: 0.2.8
 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
@@ -15,9 +15,6 @@ 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
-Requires-Dist: daytona>=0.113.0
-Requires-Dist: runloop-api-client>=0.66.1
-Requires-Dist: tavily>=1.1.0
 
 # 🧠🤖Deep Agents
 
@@ -27,7 +24,7 @@ This architecture, however, can yield agents that are “shallow” and fail to
 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**.
 
-<img src="deep_agents.png" alt="deep agent" width="600"/>
+<img src="../../deep_agents.png" alt="deep agent" width="600"/>
 
 `deepagents` is a Python package that implements these in a general purpose way so that you can easily create a Deep Agent for your application. For a full overview and quickstart of `deepagents`, the best resource is our [docs](https://docs.langchain.com/oss/python/deepagents/overview).
 

deepagents-0.2.8.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=3u3NaLHOado3zbYS7OQMiQ_qLgdMhAOIwGkXh5L7JNI,13233
+deepagents/backends/filesystem.py,sha256=UHEzG8lVoTsonr9IGJkHyxKpcLvRyAtg8YAe6h_nZQY,21526
+deepagents/backends/protocol.py,sha256=kv6pufIJyB5hA288u0EpQaPWjbmnshBQgN1UOG-jiVw,10122
+deepagents/backends/sandbox.py,sha256=ERBW3Tc8TACkZeMNdOAv9_GkG-AkEDpy3w9rVIpu9qM,10827
+deepagents/backends/state.py,sha256=RMjDkG7MWPKYbnbMNFTf_qKwQnP6EMkPPsV7-SuLJts,6374
+deepagents/backends/store.py,sha256=wAw7h5NCdWd7nRydjOMHTYMzafQIlaM0nDbmWvj4NUs,15088
+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=fuyRw2HaRPLD_7SKZnHnJUCrjkyeoBlgrejp4BIWxK8,38049
+deepagents/middleware/patch_tool_calls.py,sha256=PdNhxPaQqwnFkhEAZEE2kEzadTNAOO3_iJRA30WqpGE,1981
+deepagents/middleware/subagents.py,sha256=JOvFBXT-wqy-7zWKFL4-76zI0cfD-2f1ALDUTJDZVuE,23886
+deepagents-0.2.8.dist-info/METADATA,sha256=MJ0SNFWCysV5wwPU7wDVejmS7Ok36lB05tSMb6BR8YM,18790
+deepagents-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deepagents-0.2.8.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
+deepagents-0.2.8.dist-info/RECORD,,

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.6.dist-info/RECORD

@@ -1,19 +0,0 @@
-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,,