deepagents 0.2.4__tar.gz → 0.2.6__tar.gz

{deepagents-0.2.4/src/deepagents.egg-info → deepagents-0.2.6}/PKG-INFO

@@ -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.4 → deepagents-0.2.6}/README.md

@@ -327,7 +327,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.4/src → deepagents-0.2.6}/deepagents/backends/composite.py

@@ -1,14 +1,18 @@
 """CompositeBackend: Route operations to different backends based on path prefix."""
 
-from typing import Optional
-
-from deepagents.backends.protocol import BackendProtocol, WriteResult, EditResult
+from deepagents.backends.protocol import (
+    BackendProtocol,
+    EditResult,
+    ExecuteResponse,
+    FileInfo,
+    GrepMatch,
+    SandboxBackendProtocol,
+    WriteResult,
+)
 from deepagents.backends.state import StateBackend
-from deepagents.backends.utils import FileInfo, GrepMatch
 
 
 class CompositeBackend:
-    
     def __init__(
         self,
         default: BackendProtocol | StateBackend,
@@ -19,16 +23,16 @@ class CompositeBackend:
 
         # Virtual routes
         self.routes = routes
-        
+
         # Sort routes by length (longest first) for correct prefix matching
         self.sorted_routes = sorted(routes.items(), key=lambda x: len(x[0]), reverse=True)
 
     def _get_backend_and_key(self, key: str) -> tuple[BackendProtocol, str]:
         """Determine which backend handles this key and strip prefix.
-        
+
         Args:
             key: Original file path
-        
+
         Returns:
             Tuple of (backend, stripped_key) where stripped_key has the route
             prefix removed (but keeps leading slash).
@@ -38,12 +42,12 @@ class CompositeBackend:
             if key.startswith(prefix):
                 # Strip full prefix and ensure a leading slash remains
                 # e.g., "/memories/notes.txt" → "/notes.txt"; "/memories/" → "/"
-                suffix = key[len(prefix):]
+                suffix = key[len(prefix) :]
                 stripped_key = f"/{suffix}" if suffix else "/"
                 return backend, stripped_key
-        
+
         return self.default, key
-    
+
     def ls_info(self, path: str) -> list[FileInfo]:
         """List files and directories in the specified directory (non-recursive).
 
@@ -58,7 +62,7 @@ class CompositeBackend:
         for route_prefix, backend in self.sorted_routes:
             if path.startswith(route_prefix.rstrip("/")):
                 # Query only the matching routed backend
-                suffix = path[len(route_prefix):]
+                suffix = path[len(route_prefix) :]
                 search_path = f"/{suffix}" if suffix else "/"
                 infos = backend.ls_info(search_path)
                 prefixed: list[FileInfo] = []
@@ -74,12 +78,14 @@ class CompositeBackend:
             results.extend(self.default.ls_info(path))
             for route_prefix, backend in self.sorted_routes:
                 # Add the route itself as a directory (e.g., /memories/)
-                results.append({
-                    "path": route_prefix,
-                    "is_dir": True,
-                    "size": 0,
-                    "modified_at": "",
-                })
+                results.append(
+                    {
+                        "path": route_prefix,
+                        "is_dir": True,
+                        "size": 0,
+                        "modified_at": "",
+                    }
+                )
 
             results.sort(key=lambda x: x.get("path", ""))
             return results
@@ -87,15 +93,14 @@ class CompositeBackend:
         # Path doesn't match a route: query only default backend
         return self.default.ls_info(path)
 
-
     def read(
-        self, 
+        self,
         file_path: str,
         offset: int = 0,
         limit: int = 2000,
     ) -> str:
         """Read file content, routing to appropriate backend.
-        
+
         Args:
             file_path: Absolute file path
             offset: Line offset to start reading from (0-indexed)
@@ -105,17 +110,16 @@ class CompositeBackend:
         backend, stripped_key = self._get_backend_and_key(file_path)
         return backend.read(stripped_key, offset=offset, limit=limit)
 
-
     def grep_raw(
         self,
         pattern: str,
-        path: Optional[str] = None,
-        glob: Optional[str] = None,
+        path: str | None = None,
+        glob: str | None = None,
     ) -> list[GrepMatch] | str:
         # If path targets a specific route, search only that backend
         for route_prefix, backend in self.sorted_routes:
             if path is not None and path.startswith(route_prefix.rstrip("/")):
-                search_path = path[len(route_prefix) - 1:]
+                search_path = path[len(route_prefix) - 1 :]
                 raw = backend.grep_raw(pattern, search_path if search_path else "/", glob)
                 if isinstance(raw, str):
                     return raw
@@ -137,19 +141,16 @@ class CompositeBackend:
             all_matches.extend({**m, "path": f"{route_prefix[:-1]}{m['path']}"} for m in raw)
 
         return all_matches
-    
+
     def glob_info(self, pattern: str, path: str = "/") -> list[FileInfo]:
         results: list[FileInfo] = []
 
         # Route based on path, not pattern
         for route_prefix, backend in self.sorted_routes:
             if path.startswith(route_prefix.rstrip("/")):
-                search_path = path[len(route_prefix) - 1:]
+                search_path = path[len(route_prefix) - 1 :]
                 infos = backend.glob_info(pattern, search_path if search_path else "/")
-                return [
-                    {**fi, "path": f"{route_prefix[:-1]}{fi['path']}"}
-                    for fi in infos
-                ]
+                return [{**fi, "path": f"{route_prefix[:-1]}{fi['path']}"} for fi in infos]
 
         # Path doesn't match any specific route - search default backend AND all routed backends
         results.extend(self.default.glob_info(pattern, path))
@@ -162,11 +163,10 @@ class CompositeBackend:
         results.sort(key=lambda x: x.get("path", ""))
         return results
 
-
     def write(
-            self,
-            file_path: str,
-            content: str,
+        self,
+        file_path: str,
+        content: str,
     ) -> WriteResult:
         """Create a new file, routing to appropriate backend.
 
@@ -191,11 +191,11 @@ class CompositeBackend:
         return res
 
     def edit(
-            self,
-            file_path: str,
-            old_string: str,
-            new_string: str,
-            replace_all: bool = False,
+        self,
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,
     ) -> EditResult:
         """Edit a file, routing to appropriate backend.
 
@@ -220,5 +220,30 @@ class CompositeBackend:
                 pass
         return res
 
+    def execute(
+        self,
+        command: str,
+    ) -> ExecuteResponse:
+        """Execute a command via the default backend.
+
+        Execution is not path-specific, so it always delegates to the default backend.
+        The default backend must implement SandboxBackendProtocol for this to work.
 
- 
+        Args:
+            command: Full shell command string to execute.
+
+        Returns:
+            ExecuteResponse with combined output, exit code, and truncation flag.
+
+        Raises:
+            NotImplementedError: If default backend doesn't support execution.
+        """
+        if isinstance(self.default, SandboxBackendProtocol):
+            return self.default.execute(command)
+
+        # This shouldn't be reached if the runtime check in the execute tool works correctly,
+        # but we include it as a safety fallback.
+        raise NotImplementedError(
+            "Default backend doesn't support command execution (SandboxBackendProtocol). "
+            "To enable execution, provide a default backend that implements SandboxBackendProtocol."
+        )

{deepagents-0.2.4/src → deepagents-0.2.6}/deepagents/backends/filesystem.py

@@ -7,26 +7,24 @@ Security and search upgrades:
   and optional glob include filtering, while preserving virtual path behavior
 """
 
+import json
 import os
 import re
-import json
 import subprocess
 from datetime import datetime
 from pathlib import Path
-from typing import Optional
 
-from .utils import (
+import wcmatch.glob as wcglob
+
+from deepagents.backends.protocol import BackendProtocol, EditResult, FileInfo, GrepMatch, WriteResult
+from deepagents.backends.utils import (
     check_empty_content,
     format_content_with_line_numbers,
     perform_string_replacement,
 )
-import wcmatch.glob as wcglob
-from deepagents.backends.utils import FileInfo, GrepMatch
-from deepagents.backends.protocol import WriteResult, EditResult
-
 
 
-class FilesystemBackend:
+class FilesystemBackend(BackendProtocol):
     """Backend that reads and writes files directly from the filesystem.
 
     Files are accessed using their actual filesystem paths. Relative paths are
@@ -35,13 +33,13 @@ class FilesystemBackend:
     """
 
     def __init__(
-        self, 
-        root_dir: Optional[str | Path] = None,
+        self,
+        root_dir: str | Path | None = None,
         virtual_mode: bool = False,
         max_file_size_mb: int = 10,
     ) -> None:
         """Initialize filesystem backend.
-        
+
         Args:
             root_dir: Optional root directory for file operations. If provided,
                      all file paths will be resolved relative to this directory.
@@ -118,32 +116,36 @@ class FilesystemBackend:
                     if is_file:
                         try:
                             st = child_path.stat()
-                            results.append({
-                                "path": abs_path,
-                                "is_dir": False,
-                                "size": int(st.st_size),
-                                "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
-                            })
+                            results.append(
+                                {
+                                    "path": abs_path,
+                                    "is_dir": False,
+                                    "size": int(st.st_size),
+                                    "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                                }
+                            )
                         except OSError:
                             results.append({"path": abs_path, "is_dir": False})
                     elif is_dir:
                         try:
                             st = child_path.stat()
-                            results.append({
-                                "path": abs_path + "/",
-                                "is_dir": True,
-                                "size": 0,
-                                "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
-                            })
+                            results.append(
+                                {
+                                    "path": abs_path + "/",
+                                    "is_dir": True,
+                                    "size": 0,
+                                    "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                                }
+                            )
                         except OSError:
                             results.append({"path": abs_path + "/", "is_dir": True})
                 else:
                     # Virtual mode: strip cwd prefix
                     if abs_path.startswith(cwd_str):
-                        relative_path = abs_path[len(cwd_str):]
+                        relative_path = abs_path[len(cwd_str) :]
                     elif abs_path.startswith(str(self.cwd)):
                         # Handle case where cwd doesn't end with /
-                        relative_path = abs_path[len(str(self.cwd)):].lstrip("/")
+                        relative_path = abs_path[len(str(self.cwd)) :].lstrip("/")
                     else:
                         # Path is outside cwd, return as-is or skip
                         relative_path = abs_path
@@ -153,23 +155,27 @@ class FilesystemBackend:
                     if is_file:
                         try:
                             st = child_path.stat()
-                            results.append({
-                                "path": virt_path,
-                                "is_dir": False,
-                                "size": int(st.st_size),
-                                "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
-                            })
+                            results.append(
+                                {
+                                    "path": virt_path,
+                                    "is_dir": False,
+                                    "size": int(st.st_size),
+                                    "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                                }
+                            )
                         except OSError:
                             results.append({"path": virt_path, "is_dir": False})
                     elif is_dir:
                         try:
                             st = child_path.stat()
-                            results.append({
-                                "path": virt_path + "/",
-                                "is_dir": True,
-                                "size": 0,
-                                "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
-                            })
+                            results.append(
+                                {
+                                    "path": virt_path + "/",
+                                    "is_dir": True,
+                                    "size": 0,
+                                    "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                                }
+                            )
                         except OSError:
                             results.append({"path": virt_path + "/", "is_dir": True})
         except (OSError, PermissionError):
@@ -180,15 +186,15 @@ class FilesystemBackend:
         return results
 
     # Removed legacy ls() convenience to keep lean surface
-    
+
     def read(
-        self, 
+        self,
         file_path: str,
         offset: int = 0,
         limit: int = 2000,
     ) -> str:
         """Read file content with line numbers.
-        
+
         Args:
             file_path: Absolute or relative file path
             offset: Line offset to start reading from (0-indexed)
@@ -196,10 +202,10 @@ class FilesystemBackend:
             Formatted file content with line numbers, or error message.
         """
         resolved_path = self._resolve_path(file_path)
-        
+
         if not resolved_path.exists() or not resolved_path.is_file():
             return f"Error: File '{file_path}' not found"
-        
+
         try:
             # Open with O_NOFOLLOW where available to avoid symlink traversal
             try:
@@ -208,27 +214,27 @@ class FilesystemBackend:
                     content = f.read()
             except OSError:
                 # Fallback to normal open if O_NOFOLLOW unsupported or fails
-                with open(resolved_path, "r", encoding="utf-8") as f:
+                with open(resolved_path, encoding="utf-8") as f:
                     content = f.read()
-            
+
             empty_msg = check_empty_content(content)
             if empty_msg:
                 return empty_msg
-            
+
             lines = content.splitlines()
             start_idx = offset
             end_idx = min(start_idx + limit, len(lines))
-            
+
             if start_idx >= len(lines):
                 return f"Error: Line offset {offset} exceeds file length ({len(lines)} lines)"
-            
+
             selected_lines = lines[start_idx:end_idx]
             return format_content_with_line_numbers(selected_lines, start_line=start_idx + 1)
         except (OSError, UnicodeDecodeError) as e:
             return f"Error reading file '{file_path}': {e}"
-    
+
     def write(
-        self, 
+        self,
         file_path: str,
         content: str,
     ) -> WriteResult:
@@ -236,10 +242,10 @@ class FilesystemBackend:
         Returns WriteResult. External storage sets files_update=None.
         """
         resolved_path = self._resolve_path(file_path)
-        
+
         if resolved_path.exists():
             return WriteResult(error=f"Cannot write to {file_path} because it already exists. Read and then make an edit, or write to a new path.")
-        
+
         try:
             # Create parent directories if needed
             resolved_path.parent.mkdir(parents=True, exist_ok=True)
@@ -251,13 +257,13 @@ class FilesystemBackend:
             fd = os.open(resolved_path, flags, 0o644)
             with os.fdopen(fd, "w", encoding="utf-8") as f:
                 f.write(content)
-            
+
             return WriteResult(path=file_path, files_update=None)
         except (OSError, UnicodeEncodeError) as e:
             return WriteResult(error=f"Error writing file '{file_path}': {e}")
-    
+
     def edit(
-        self, 
+        self,
         file_path: str,
         old_string: str,
         new_string: str,
@@ -267,10 +273,10 @@ class FilesystemBackend:
         Returns EditResult. External storage sets files_update=None.
         """
         resolved_path = self._resolve_path(file_path)
-        
+
         if not resolved_path.exists() or not resolved_path.is_file():
             return EditResult(error=f"Error: File '{file_path}' not found")
-        
+
         try:
             # Read securely
             try:
@@ -278,16 +284,16 @@ class FilesystemBackend:
                 with os.fdopen(fd, "r", encoding="utf-8") as f:
                     content = f.read()
             except OSError:
-                with open(resolved_path, "r", encoding="utf-8") as f:
+                with open(resolved_path, encoding="utf-8") as f:
                     content = f.read()
-            
+
             result = perform_string_replacement(content, old_string, new_string, replace_all)
-            
+
             if isinstance(result, str):
                 return EditResult(error=result)
-            
+
             new_content, occurrences = result
-            
+
             # Write securely
             flags = os.O_WRONLY | os.O_TRUNC
             if hasattr(os, "O_NOFOLLOW"):
@@ -295,18 +301,18 @@ class FilesystemBackend:
             fd = os.open(resolved_path, flags)
             with os.fdopen(fd, "w", encoding="utf-8") as f:
                 f.write(new_content)
-            
+
             return EditResult(path=file_path, files_update=None, occurrences=int(occurrences))
         except (OSError, UnicodeDecodeError, UnicodeEncodeError) as e:
             return EditResult(error=f"Error editing file '{file_path}': {e}")
-    
+
     # Removed legacy grep() convenience to keep lean surface
 
     def grep_raw(
         self,
         pattern: str,
-        path: Optional[str] = None,
-        glob: Optional[str] = None,
+        path: str | None = None,
+        glob: str | None = None,
     ) -> list[GrepMatch] | str:
         # Validate regex
         try:
@@ -334,9 +340,7 @@ class FilesystemBackend:
                 matches.append({"path": fpath, "line": int(line_num), "text": line_text})
         return matches
 
-    def _ripgrep_search(
-        self, pattern: str, base_full: Path, include_glob: Optional[str]
-    ) -> Optional[dict[str, list[tuple[int, str]]]]:
+    def _ripgrep_search(self, pattern: str, base_full: Path, include_glob: str | None) -> dict[str, list[tuple[int, str]]] | None:
         cmd = ["rg", "--json"]
         if include_glob:
             cmd.extend(["--glob", include_glob])
@@ -381,9 +385,7 @@ class FilesystemBackend:
 
         return results
 
-    def _python_search(
-        self, pattern: str, base_full: Path, include_glob: Optional[str]
-    ) -> dict[str, list[tuple[int, str]]]:
+    def _python_search(self, pattern: str, base_full: Path, include_glob: str | None) -> dict[str, list[tuple[int, str]]]:
         try:
             regex = re.compile(pattern)
         except re.error:
@@ -418,7 +420,7 @@ class FilesystemBackend:
                     results.setdefault(virt_path, []).append((line_num, line))
 
         return results
-    
+
     def glob_info(self, pattern: str, path: str = "/") -> list[FileInfo]:
         if pattern.startswith("/"):
             pattern = pattern.lstrip("/")
@@ -441,12 +443,14 @@ class FilesystemBackend:
                 if not self.virtual_mode:
                     try:
                         st = matched_path.stat()
-                        results.append({
-                            "path": abs_path,
-                            "is_dir": False,
-                            "size": int(st.st_size),
-                            "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
-                        })
+                        results.append(
+                            {
+                                "path": abs_path,
+                                "is_dir": False,
+                                "size": int(st.st_size),
+                                "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                            }
+                        )
                     except OSError:
                         results.append({"path": abs_path, "is_dir": False})
                 else:
@@ -454,20 +458,22 @@ class FilesystemBackend:
                     if not cwd_str.endswith("/"):
                         cwd_str += "/"
                     if abs_path.startswith(cwd_str):
-                        relative_path = abs_path[len(cwd_str):]
+                        relative_path = abs_path[len(cwd_str) :]
                     elif abs_path.startswith(str(self.cwd)):
-                        relative_path = abs_path[len(str(self.cwd)):].lstrip("/")
+                        relative_path = abs_path[len(str(self.cwd)) :].lstrip("/")
                     else:
                         relative_path = abs_path
                     virt = "/" + relative_path
                     try:
                         st = matched_path.stat()
-                        results.append({
-                            "path": virt,
-                            "is_dir": False,
-                            "size": int(st.st_size),
-                            "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
-                        })
+                        results.append(
+                            {
+                                "path": virt,
+                                "is_dir": False,
+                                "size": int(st.st_size),
+                                "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                            }
+                        )
                     except OSError:
                         results.append({"path": virt, "is_dir": False})
         except (OSError, ValueError):