deepagents-cli 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

deepagents/default_agent_prompt.md

@@ -62,30 +62,3 @@ When referencing code, use format: `file_path:line_number`
 - Do NOT create excessive markdown summary/documentation files after completing work
 - Focus on the work itself, not documenting what you did
 - Only create documentation when explicitly requested
-
-## Long-term Memory
-You have access to a long-term memory system using the `/memories/` path prefix.
-Files stored in `/memories/` persist across sessions and are stored in your agent directory.
-
-Your system prompt is loaded from `/memories/agent.md` at startup. You can update your own instructions by editing this file.
-
-**When to update memories:**
-- **IMMEDIATELY when the user describes your role or how you should behave** (e.g., "you are a web researcher", "you are an expert in X")
-- **IMMEDIATELY when the user gives feedback on your work** - Before continuing, update memories to capture what was wrong and how to do it better
-- When the user explicitly asks you to remember something
-- When patterns or preferences emerge (coding styles, conventions, workflows)
-- After significant work where context would help in future sessions
-
-**Learning from feedback:**
-- When user says something is better/worse, capture WHY and encode it as a pattern
-- Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions
-
-**What to store where:**
-- **`/memories/agent.md`**: Update this to modify your core instructions and behavioral patterns
-- **Other `/memories/` files**: Use for project-specific context, reference information, or structured notes
-  - If you create additional memory files, add references to them in `/memories/agent.md` so you remember to consult them
-
-The portion of your system prompt that comes from `/memories/agent.md` is marked with `<agent_memory>` tags so you can identify what instructions come from your persistent memory.
-
-Example: `edit_file('/memories/agent.md', ...)` to update your instructions
-Example: `write_file('/memories/project_context.md', ...)` for project-specific notes, then reference it in agent.md

deepagents/graph.py

@@ -2,7 +2,6 @@
 
 from collections.abc import Callable, Sequence
 from typing import Any
-import os
 
 from langchain.agents import create_agent
 from langchain.agents.middleware import HumanInTheLoopMiddleware, InterruptOnConfig, TodoListMiddleware
@@ -11,7 +10,6 @@ from langchain.agents.middleware.types import AgentMiddleware
 from langchain.agents.structured_output import ResponseFormat
 from langchain_anthropic import ChatAnthropic
 from langchain_anthropic.middleware import AnthropicPromptCachingMiddleware
-from langchain.agents.middleware import ShellToolMiddleware, HostExecutionPolicy
 from langchain_core.language_models import BaseChatModel
 from langchain_core.tools import BaseTool
 from langgraph.cache.base import BaseCache
@@ -19,8 +17,9 @@ from langgraph.graph.state import CompiledStateGraph
 from langgraph.store.base import BaseStore
 from langgraph.types import Checkpointer
 
+from deepagents.memory.protocol import MemoryBackend
 from deepagents.middleware.filesystem import FilesystemMiddleware
-from deepagents.middleware.local_filesystem import LocalFilesystemMiddleware
+from deepagents.middleware.patch_tool_calls import PatchToolCallsMiddleware
 from deepagents.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
 
 BASE_AGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools."
@@ -49,10 +48,7 @@ def create_deep_agent(
     context_schema: type[Any] | None = None,
     checkpointer: Checkpointer | None = None,
     store: BaseStore | None = None,
-    use_longterm_memory: bool = False,
-    use_local_filesystem: bool = False,
-    long_term_memory: bool = False,
-    skills: list[dict[str, Any]] | None = None,
+    memory_backend: MemoryBackend | None = None,
     interrupt_on: dict[str, bool | InterruptOnConfig] | None = None,
     debug: bool = False,
     name: str | None = None,
@@ -61,15 +57,15 @@ def create_deep_agent(
     """Create a deep agent.
 
     This agent will by default have access to a tool to write todos (write_todos),
-    four file editing tools: write_file, ls, read_file, edit_file, and a tool to call
-    subagents.
+    six file editing tools: write_file, ls, read_file, edit_file, glob_search, grep_search,
+    and a tool to call subagents.
 
     Args:
+        model: The model to use. Defaults to Claude Sonnet 4.
         tools: The tools the agent should have access to.
         system_prompt: The additional instructions the agent should have. Will go in
             the system prompt.
         middleware: Additional middleware to apply after standard middleware.
-        model: The model to use.
         subagents: The subagents to use. Each subagent should be a dictionary with the
             following keys:
                 - `name`
@@ -83,17 +79,10 @@ def create_deep_agent(
         response_format: A structured output response format to use for the agent.
         context_schema: The schema of the deep agent.
         checkpointer: Optional checkpointer for persisting agent state between runs.
-        store: Optional store for persisting longterm memories.
-        use_longterm_memory: Whether to use longterm memory - you must provide a store
-            in order to use longterm memory.
-        use_local_filesystem: If True, injects LocalFilesystemMiddleware (tools operate on disk).
-            When True, longterm memory is not supported and `use_longterm_memory` must be False.
-            Skills are automatically discovered from ~/.deepagents/skills/ and ./.deepagents/skills/.
-            The agent_name for memory storage can be passed via config: {"configurable": {"agent_name": "myagent"}}.
-        long_term_memory: If True, enables long-term memory features like agent.md persistence
-            and memories folder. Only applies when use_local_filesystem=True.
-        skills: Optional list of SkillDefinition for virtual filesystem mode. Only valid when
-            use_local_filesystem=False. Skills are loaded into /skills/<name>/ in virtual filesystem.
+        store: Optional store for persistent storage (required if memory_backend uses StoreBackend).
+        memory_backend: Optional backend for file storage. Defaults to StateBackend (ephemeral
+            storage in agent state). For persistent or hybrid storage, use CompositeBackend.
+            Example: CompositeBackend(default=StateBackend(), routes={"/memories/": StoreBackend()})
         interrupt_on: Optional Dict[str, bool | InterruptOnConfig] mapping tool names to
             interrupt configs.
         debug: Whether to enable debug mode. Passed through to create_agent.
@@ -106,38 +95,24 @@ def create_deep_agent(
     if model is None:
         model = get_default_model()
 
-    if use_local_filesystem and skills is not None:
-        raise ValueError(
-            "Cannot provide skill definitions with use_local_filesystem=True. "
-            "Skills are automatically discovered from ~/.deepagents/skills/ and ./.deepagents/skills/. "
-            "To use custom skills, set use_local_filesystem=False."
-        )
-
-    # Choose filesystem middleware kind
-    def _fs_middleware() -> list[AgentMiddleware]:
-        if use_local_filesystem:
-            shell_middleware = ShellToolMiddleware(
-                workspace_root=os.getcwd(),
-                execution_policy=HostExecutionPolicy()
-            )
-            return [LocalFilesystemMiddleware(long_term_memory=long_term_memory), shell_middleware]
-        return [FilesystemMiddleware(long_term_memory=use_longterm_memory, skills=skills)]
-
     deepagent_middleware = [
         TodoListMiddleware(),
+        FilesystemMiddleware(memory_backend=memory_backend),
         SubAgentMiddleware(
             default_model=model,
             default_tools=tools,
             subagents=subagents if subagents is not None else [],
             default_middleware=[
                 TodoListMiddleware(),
+                FilesystemMiddleware(memory_backend=memory_backend),
                 SummarizationMiddleware(
                     model=model,
                     max_tokens_before_summary=170000,
                     messages_to_keep=6,
                 ),
                 AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
-            ] + _fs_middleware(),
+                PatchToolCallsMiddleware(),
+            ],
             default_interrupt_on=interrupt_on,
             general_purpose_agent=True,
         ),
@@ -147,7 +122,8 @@ def create_deep_agent(
             messages_to_keep=6,
         ),
         AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
-    ] + _fs_middleware()
+        PatchToolCallsMiddleware(),
+    ]
     if interrupt_on is not None:
         deepagent_middleware.append(HumanInTheLoopMiddleware(interrupt_on=interrupt_on))
     if middleware is not None:

deepagents/memory/__init__.py

@@ -0,0 +1,17 @@
+"""Memory backends for pluggable file storage."""
+
+from deepagents.memory.backends import (
+    CompositeBackend,
+    FilesystemBackend,
+    StateBackend,
+    StoreBackend,
+)
+from deepagents.memory.protocol import MemoryBackend
+
+__all__ = [
+    "MemoryBackend",
+    "CompositeBackend",
+    "FilesystemBackend",
+    "StateBackend",
+    "StoreBackend",
+]

deepagents/memory/backends/__init__.py

@@ -0,0 +1,15 @@
+"""Backend implementations for pluggable memory storage."""
+
+from deepagents.memory.backends.composite import CompositeBackend
+from deepagents.memory.backends.filesystem import FilesystemBackend
+from deepagents.memory.backends.state import StateBackend
+from deepagents.memory.backends.store import StoreBackend
+from deepagents.memory.backends import utils
+
+__all__ = [
+    "CompositeBackend",
+    "FilesystemBackend",
+    "StateBackend",
+    "StoreBackend",
+    "utils",
+]

deepagents/memory/backends/composite.py

@@ -0,0 +1,250 @@
+"""CompositeBackend: Route operations to different backends based on path prefix."""
+
+from typing import Any, Literal, Optional, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from langchain.tools import ToolRuntime
+
+from deepagents.memory.protocol import MemoryBackend
+from langgraph.types import Command
+
+
+class CompositeBackend:
+    """Backend that routes operations to different backends based on path prefix.
+    
+    This backend enables hybrid storage strategies, such as:
+    - Short-term files (/*) → StateBackend (ephemeral)
+    - Long-term files (/memories/*) → StoreBackend or FilesystemBackend (persistent)
+    
+    The routing is transparent to tools - they just call backend.get(path) and
+    CompositeBackend handles the routing internally.
+    
+    Example:
+        ```python
+        # Create a factory function that returns CompositeBackend with resolved backends
+        backend_factory = lambda runtime: CompositeBackend(
+            default=StateBackend(runtime),  # StateBackend needs runtime
+            routes={"/memories/": FilesystemBackend("/data/memories")}  # FilesystemBackend doesn't
+        )
+        
+        # Then pass this factory to the middleware
+        middleware = FilesystemMiddleware(memory_backend=backend_factory)
+        ```
+    """
+    
+    def __init__(
+        self,
+        default: MemoryBackend,
+        routes: dict[str, MemoryBackend],
+    ) -> None:
+        """Initialize composite backend with routing rules.
+        
+        Args:
+            default: Default backend for paths that don't match any route (must be resolved backend instance).
+            routes: Dict mapping path prefixes to backends (must be resolved backend instances). 
+                   Keys should include trailing slash (e.g., "/memories/").
+        
+        Note: If you need backends that require runtime (like StateBackend), wrap the CompositeBackend
+        itself in a factory function:
+            lambda runtime: CompositeBackend(
+                default=StateBackend(runtime),
+                routes={"/memories/": FilesystemBackend("./data")}
+            )
+        """
+        self.default = default
+        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[MemoryBackend, 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 prefix but keep leading slash
+                # e.g., "/memories/notes.txt" → "/notes.txt"
+                stripped_key = key[len(prefix) - 1:] if key[len(prefix) - 1:] else "/"
+                return backend, stripped_key
+        
+        return self.default, key
+    
+    def ls(self, path: str) -> list[str]:
+        """List files from backends, with appropriate prefixes.
+        
+        Args:
+            path: Absolute path to directory.
+        
+        Returns:
+            List of file paths 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
+                search_path = path[len(route_prefix) - 1:]
+                keys = backend.ls(search_path if search_path else "/")
+                return [f"{route_prefix[:-1]}{key}" for key in keys]
+        
+        # Path doesn't match a route: query only default backend
+        return self.default.ls(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 write(
+        self, 
+        file_path: str,
+        content: str,
+    ) -> Command | str:
+        """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)
+        return backend.write(stripped_key, content)
+    
+    def edit(
+        self, 
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,
+    ) -> Command | str:
+        """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)
+        return backend.edit(stripped_key, old_string, new_string, replace_all=replace_all)
+    
+    def delete(self, file_path: str) -> Command | None:
+        """Delete file, routing to appropriate backend.
+        
+        Args:
+            file_path: File path to deleteReturns:
+            Return value from backend (None or Command).
+        """
+        backend, stripped_key = self._get_backend_and_key(file_path)
+        return backend.delete(stripped_key)
+    
+    def grep(
+        self,
+        pattern: str,
+        path: str = "/",
+        glob: Optional[str] = None,
+        output_mode: str = "files_with_matches",
+    ) -> str:
+        """Search for a pattern in files, routing to appropriate backend(s).
+        
+        Args:
+            pattern: String pattern to search for
+            path: Path to search in (default "/")
+            glob: Optional glob pattern to filter files (e.g., "*.py")
+            output_mode: Output format - "files_with_matches", "content", or "count"Returns:
+            Formatted search results based on output_mode.
+        """
+        for route_prefix, backend in self.sorted_routes:
+            if path.startswith(route_prefix.rstrip("/")):
+                search_path = path[len(route_prefix) - 1:]
+                result = backend.grep(pattern, search_path if search_path else "/", glob, output_mode)
+                if result.startswith("No matches found"):
+                    return result
+                
+                lines = result.split("\n")
+                prefixed_lines = []
+                for line in lines:
+                    if output_mode == "files_with_matches" or line.endswith(":") or ": " in line.split(":", 1)[0]:
+                        if line and not line.startswith(" "):
+                            prefixed_lines.append(f"{route_prefix[:-1]}{line}")
+                        else:
+                            prefixed_lines.append(line)
+                    else:
+                        prefixed_lines.append(line)
+                return "\n".join(prefixed_lines)
+        
+        all_results = []
+        
+        default_result = self.default.grep(pattern, path, glob, output_mode)
+        if not default_result.startswith("No matches found"):
+            all_results.append(default_result)
+        
+        for route_prefix, backend in self.routes.items():
+            result = backend.grep(pattern, "/", glob, output_mode)
+            if not result.startswith("No matches found"):
+                lines = result.split("\n")
+                prefixed_lines = []
+                for line in lines:
+                    if output_mode == "files_with_matches" or line.endswith(":") or (": " in line and not line.startswith(" ")):
+                        if line and not line.startswith(" "):
+                            prefixed_lines.append(f"{route_prefix[:-1]}{line}")
+                        else:
+                            prefixed_lines.append(line)
+                    else:
+                        prefixed_lines.append(line)
+                all_results.append("\n".join(prefixed_lines))
+        
+        if not all_results:
+            return f"No matches found for pattern: '{pattern}'"
+        
+        return "\n".join(all_results)
+    
+    def glob(self, pattern: str, path: str = "/") -> list[str]:
+        """Find files matching a glob pattern across all backends.
+
+        Args:
+            pattern: Glob pattern (e.g., "**/*.py", "*.txt", "/subdir/**/*.md")
+            path: Base path to search from (default "/")Returns:
+            List of absolute file paths matching the pattern.
+        """
+        results = []
+
+        # Route based on path, not pattern
+        for route_prefix, backend in self.sorted_routes:
+            if path.startswith(route_prefix.rstrip("/")):
+                # Path matches a specific route - search only that backend
+                search_path = path[len(route_prefix) - 1:]
+                matches = backend.glob(pattern, search_path if search_path else "/")
+                results.extend(f"{route_prefix[:-1]}{match}" for match in matches)
+                return sorted(results)
+
+        # Path doesn't match any specific route - search default backend AND all routed backends
+        default_matches = self.default.glob(pattern, path)
+        results.extend(default_matches)
+
+        # Also search in all routed backends and prefix results
+        for route_prefix, backend in self.routes.items():
+            matches = backend.glob(pattern, "/")
+            results.extend(f"{route_prefix[:-1]}{match}" for match in matches)
+
+        return sorted(results)