deepagents 0.1.4__tar.gz → 0.1.5rc2__tar.gz

{deepagents-0.1.4/src/deepagents.egg-info → deepagents-0.1.5rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.1.4
+Version: 0.1.5rc2
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Requires-Python: <4.0,>=3.11
@@ -9,6 +9,7 @@ License-File: LICENSE
 Requires-Dist: langchain-anthropic<2.0.0,>=1.0.0
 Requires-Dist: langchain<2.0.0,>=1.0.0
 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"
@@ -128,9 +129,7 @@ By default, `deepagents` uses `"claude-sonnet-4-5-20250929"`. You can customize
 from langchain.chat_models import init_chat_model
 from deepagents import create_deep_agent
 
-model = init_chat_model(
-    model="openai:gpt-5",  
-)
+model = init_chat_model("openai:gpt-4o")
 agent = create_deep_agent(
     model=model,
 )
@@ -315,19 +314,30 @@ agent = create_deep_agent(
 )
 ```
 
-### `use_longterm_memory`
-Deep agents come with a local filesystem to offload memory to. This filesystem is stored in state, and is therefore transient to a single thread.
+### `backend`
+Deep agents come with a local filesystem to offload memory to. By default, this filesystem is stored in state (ephemeral, transient to a single thread).
 
-You can extend deep agents with long-term memory by providing a Store and setting use_longterm_memory=True.
+You can configure persistent long-term memory using a composite backend that routes a path prefix (for example, `/memories/`) to a persistent store.
 
 ```python
 from deepagents import create_deep_agent
+from deepagents.backends import build_composite_state_backend, StoreBackend
 from langgraph.store.memory import InMemoryStore
 
-store = InMemoryStore()  # Or any other Store object
+store = InMemoryStore()  # Or any other Store implementation
+
+# Provide a backend factory to the agent/middleware.
+# This builds a state-backed composite at runtime and routes /memories/ to StoreBackend.
+backend_factory = lambda rt: build_composite_state_backend(
+    rt,
+    routes={
+        "/memories/": (lambda r: StoreBackend(r)),
+    },
+)
+
 agent = create_deep_agent(
+    backend=backend_factory,
     store=store,
-    use_longterm_memory=True
 )
 ```
 
@@ -403,6 +413,11 @@ Context engineering is one of the main challenges in building effective agents.
 ```python
 from langchain.agents import create_agent
 from deepagents.middleware.filesystem import FilesystemMiddleware
+from deepagents.backends import (
+    StateBackend,
+    CompositeBackend,
+    StoreBackend,
+)
 
 # FilesystemMiddleware is included by default in create_deep_agent
 # You can customize it if building a custom agent
@@ -410,8 +425,13 @@ agent = create_agent(
     model="anthropic:claude-sonnet-4-20250514",
     middleware=[
         FilesystemMiddleware(
-            long_term_memory=False,  # Enables access to long-term memory, defaults to False. You must attach a store to use long-term memory.
-            system_prompt="Write to the filesystem when...",  # Optional custom addition to the system prompt
+            backend=(lambda rt: StateBackend(rt)),  # Optional: customize storage backend (defaults to lambda rt: )
+            # For persistent memory, use CompositeBackend:
+            # backend=CompositeBackend(
+            #     default=lambda rt: StateBackend(rt)
+            #     routes={"/memories/": lambda rt: StoreBackend(rt)}
+            # )
+            system_prompt="Write to the filesystem when...",  # Optional custom system prompt override
             custom_tool_descriptions={
                 "ls": "Use the ls tool when...",
                 "read_file": "Use the read_file tool to..."

{deepagents-0.1.4 → deepagents-0.1.5rc2}/README.md

@@ -109,9 +109,7 @@ By default, `deepagents` uses `"claude-sonnet-4-5-20250929"`. You can customize
 from langchain.chat_models import init_chat_model
 from deepagents import create_deep_agent
 
-model = init_chat_model(
-    model="openai:gpt-5",  
-)
+model = init_chat_model("openai:gpt-4o")
 agent = create_deep_agent(
     model=model,
 )
@@ -296,19 +294,30 @@ agent = create_deep_agent(
 )
 ```
 
-### `use_longterm_memory`
-Deep agents come with a local filesystem to offload memory to. This filesystem is stored in state, and is therefore transient to a single thread.
+### `backend`
+Deep agents come with a local filesystem to offload memory to. By default, this filesystem is stored in state (ephemeral, transient to a single thread).
 
-You can extend deep agents with long-term memory by providing a Store and setting use_longterm_memory=True.
+You can configure persistent long-term memory using a composite backend that routes a path prefix (for example, `/memories/`) to a persistent store.
 
 ```python
 from deepagents import create_deep_agent
+from deepagents.backends import build_composite_state_backend, StoreBackend
 from langgraph.store.memory import InMemoryStore
 
-store = InMemoryStore()  # Or any other Store object
+store = InMemoryStore()  # Or any other Store implementation
+
+# Provide a backend factory to the agent/middleware.
+# This builds a state-backed composite at runtime and routes /memories/ to StoreBackend.
+backend_factory = lambda rt: build_composite_state_backend(
+    rt,
+    routes={
+        "/memories/": (lambda r: StoreBackend(r)),
+    },
+)
+
 agent = create_deep_agent(
+    backend=backend_factory,
     store=store,
-    use_longterm_memory=True
 )
 ```
 
@@ -384,6 +393,11 @@ Context engineering is one of the main challenges in building effective agents.
 ```python
 from langchain.agents import create_agent
 from deepagents.middleware.filesystem import FilesystemMiddleware
+from deepagents.backends import (
+    StateBackend,
+    CompositeBackend,
+    StoreBackend,
+)
 
 # FilesystemMiddleware is included by default in create_deep_agent
 # You can customize it if building a custom agent
@@ -391,8 +405,13 @@ agent = create_agent(
     model="anthropic:claude-sonnet-4-20250514",
     middleware=[
         FilesystemMiddleware(
-            long_term_memory=False,  # Enables access to long-term memory, defaults to False. You must attach a store to use long-term memory.
-            system_prompt="Write to the filesystem when...",  # Optional custom addition to the system prompt
+            backend=(lambda rt: StateBackend(rt)),  # Optional: customize storage backend (defaults to lambda rt: )
+            # For persistent memory, use CompositeBackend:
+            # backend=CompositeBackend(
+            #     default=lambda rt: StateBackend(rt)
+            #     routes={"/memories/": lambda rt: StoreBackend(rt)}
+            # )
+            system_prompt="Write to the filesystem when...",  # Optional custom system prompt override
             custom_tool_descriptions={
                 "ls": "Use the ls tool when...",
                 "read_file": "Use the read_file tool to..."
@@ -509,4 +528,4 @@ async def main():
             chunk["messages"][-1].pretty_print()
 
 asyncio.run(main())
-```
+```

{deepagents-0.1.4 → deepagents-0.1.5rc2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepagents"
-version = "0.1.4"
+version = "0.1.5rc2"
 description = "General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph."
 readme = "README.md"
 license = { text = "MIT" }
@@ -9,6 +9,7 @@ dependencies = [
     "langchain-anthropic>=1.0.0,<2.0.0",
     "langchain>=1.0.0,<2.0.0",
     "langchain-core>=1.0.0,<2.0.0",
+    "wcmatch"
 ]
 
 [project.optional-dependencies]
@@ -17,7 +18,7 @@ dev = [
     "pytest-cov",
     "build",
     "twine",
-    "langchain-openai"
+    "langchain-openai",
 ]
 
 [dependency-groups]

deepagents-0.1.5rc2/src/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-0.1.5rc2/src/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)