deepagents 0.2.2__tar.gz → 0.2.5__tar.gz

{deepagents-0.2.2/src/deepagents.egg-info → deepagents-0.2.5}/PKG-INFO

@@ -1,8 +1,14 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.2
+Version: 0.2.5
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
+Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
+Project-URL: Documentation, https://reference.langchain.com/python/deepagents/
+Project-URL: Source, https://github.com/langchain-ai/deepagents
+Project-URL: Twitter, https://x.com/LangChainAI
+Project-URL: 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
@@ -10,12 +16,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
-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
 
 # 🧠🤖Deep Agents

{deepagents-0.2.2/src → deepagents-0.2.5/libs}/deepagents/backends/composite.py

@@ -1,14 +1,11 @@
 """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, WriteResult
 from deepagents.backends.state import StateBackend
 from deepagents.backends.utils import FileInfo, GrepMatch
 
 
 class CompositeBackend:
-    
     def __init__(
         self,
         default: BackendProtocol | StateBackend,
@@ -19,16 +16,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 +35,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 +55,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 +71,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 +86,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 +103,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 +134,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 +156,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 +184,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.
 
@@ -219,6 +212,3 @@ class CompositeBackend:
             except Exception:
                 pass
         return res
-
-
- 

{deepagents-0.2.2/src → deepagents-0.2.5/libs}/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):