deepagents 0.1.4__py3-none-any.whl → 0.1.5rc1__py3-none-any.whl

deepagents/backends/__init__.py

@@ -0,0 +1,16 @@
+"""Memory backends for pluggable file storage."""
+
+from deepagents.backends.composite import CompositeBackend, build_composite_state_backend
+from deepagents.backends.filesystem import FilesystemBackend
+from deepagents.backends.state import StateBackend
+from deepagents.backends.store import StoreBackend
+from deepagents.backends.protocol import BackendProtocol
+
+__all__ = [
+    "BackendProtocol",
+    "CompositeBackend",
+    "build_composite_state_backend",
+    "FilesystemBackend",
+    "StateBackend",
+    "StoreBackend",
+]

deepagents/backends/composite.py

@@ -0,0 +1,235 @@
+"""CompositeBackend: Route operations to different backends based on path prefix."""
+
+from typing import Any, Literal, Optional, TYPE_CHECKING
+
+from langchain.tools import ToolRuntime
+
+from deepagents.backends.protocol import BackendProtocol, BackendFactory, WriteResult, EditResult
+from deepagents.backends.state import StateBackend
+from deepagents.backends.utils import FileInfo, GrepMatch
+from deepagents.backends.protocol import BackendFactory
+
+
+class CompositeBackend:
+    
+    def __init__(
+        self,
+        default: BackendProtocol | StateBackend,
+        routes: dict[str, BackendProtocol],
+    ) -> None:
+        # Default backend
+        self.default = default
+
+        # 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).
+        """
+        # Check routes in order of length (longest first)
+        for prefix, backend in self.sorted_routes:
+            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):]
+                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 from backends, with appropriate prefixes.
+        
+        Args:
+            path: Absolute path to directory.
+        
+        Returns:
+            List of FileInfo-like dicts with route prefixes added.
+        """
+        # Check if path matches a specific route
+        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):]
+                search_path = f"/{suffix}" if suffix else "/"
+                infos = backend.ls_info(search_path)
+                prefixed: list[FileInfo] = []
+                for fi in infos:
+                    fi = dict(fi)
+                    fi["path"] = f"{route_prefix[:-1]}{fi['path']}"
+                    prefixed.append(fi)
+                return prefixed
+
+        # At root, aggregate default and all routed backends
+        if path == "/":
+            results: list[FileInfo] = []
+            results.extend(self.default.ls_info(path))
+            for route_prefix, backend in self.sorted_routes:
+                infos = backend.ls_info("/")
+                for fi in infos:
+                    fi = dict(fi)
+                    fi["path"] = f"{route_prefix[:-1]}{fi['path']}"
+                    results.append(fi)
+            results.sort(key=lambda x: x.get("path", ""))
+            return results
+
+        # Path doesn't match a route: query only default backend
+        return self.default.ls_info(path)
+
+
+    def read(
+        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)
+            limit: Maximum number of lines to readReturns:
+            Formatted file content with line numbers, or error message.
+        """
+        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,
+    ) -> 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:]
+                raw = backend.grep_raw(pattern, search_path if search_path else "/", glob)
+                if isinstance(raw, str):
+                    return raw
+                return [{**m, "path": f"{route_prefix[:-1]}{m['path']}"} for m in raw]
+
+        # Otherwise, search default and all routed backends and merge
+        all_matches: list[GrepMatch] = []
+        raw_default = self.default.grep_raw(pattern, path, glob)  # type: ignore[attr-defined]
+        if isinstance(raw_default, str):
+            # This happens if error occurs
+            return raw_default
+        all_matches.extend(raw_default)
+
+        for route_prefix, backend in self.routes.items():
+            raw = backend.grep_raw(pattern, "/", glob)
+            if isinstance(raw, str):
+                # This happens if error occurs
+                return raw
+            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:]
+                infos = backend.glob_info(pattern, search_path if search_path else "/")
+                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))
+
+        for route_prefix, backend in self.routes.items():
+            infos = backend.glob_info(pattern, "/")
+            results.extend({**fi, "path": f"{route_prefix[:-1]}{fi['path']}"} for fi in infos)
+
+        # Deterministic ordering
+        results.sort(key=lambda x: x.get("path", ""))
+        return results
+
+
+    def write(
+            self,
+            file_path: str,
+            content: str,
+    ) -> WriteResult:
+        """Create a new file, routing to appropriate backend.
+
+        Args:
+            file_path: Absolute file path
+            content: File content as a stringReturns:
+            Success message or Command object, or error if file already exists.
+        """
+        backend, stripped_key = self._get_backend_and_key(file_path)
+        res = backend.write(stripped_key, content)
+        # If this is a state-backed update and default has state, merge so listings reflect changes
+        if res.files_update:
+            try:
+                runtime = getattr(self.default, "runtime", None)
+                if runtime is not None:
+                    state = runtime.state
+                    files = state.get("files", {})
+                    files.update(res.files_update)
+                    state["files"] = files
+            except Exception:
+                pass
+        return res
+
+    def edit(
+            self,
+            file_path: str,
+            old_string: str,
+            new_string: str,
+            replace_all: bool = False,
+    ) -> EditResult:
+        """Edit a file, routing to appropriate backend.
+
+        Args:
+            file_path: Absolute file path
+            old_string: String to find and replace
+            new_string: Replacement string
+            replace_all: If True, replace all occurrencesReturns:
+            Success message or Command object, or error message on failure.
+        """
+        backend, stripped_key = self._get_backend_and_key(file_path)
+        res = backend.edit(stripped_key, old_string, new_string, replace_all=replace_all)
+        if res.files_update:
+            try:
+                runtime = getattr(self.default, "runtime", None)
+                if runtime is not None:
+                    state = runtime.state
+                    files = state.get("files", {})
+                    files.update(res.files_update)
+                    state["files"] = files
+            except Exception:
+                pass
+        return res
+
+
+def build_composite_state_backend(
+    runtime: ToolRuntime,
+    *,
+    routes: dict[str, BackendProtocol | BackendFactory],
+) -> BackendProtocol:
+    built_routes: dict[str, BackendProtocol] = {}
+    for k, v in routes.items():
+        if isinstance(v, BackendProtocol):
+            built_routes[k] = v
+        else:
+            built_routes[k] = v(runtime)
+    default_state = StateBackend(runtime)
+    return CompositeBackend(default=default_state, routes=built_routes)