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

deepagents/memory/protocol.py

@@ -1,164 +0,0 @@
-"""Protocol definition for pluggable memory backends.
-
-This module defines the MemoryBackend protocol that all backend implementations
-must follow. Backends can store files in different locations (state, filesystem,
-database, etc.) and provide a uniform interface for file operations.
-"""
-
-from typing import TYPE_CHECKING, Optional, Protocol, runtime_checkable
-from langgraph.types import Command
-
-if TYPE_CHECKING:
-    from langchain.tools import ToolRuntime
-
-
-@runtime_checkable
-class MemoryBackend(Protocol):
-    """Protocol for pluggable memory backends.
-
-    Backends can store files in different locations (state, filesystem, database, etc.)
-    and provide a uniform interface for file operations.
-
-    All file data is represented as dicts with the following structure:
-    {
-        "content": list[str],      # Lines of text content
-        "created_at": str,         # ISO format timestamp
-        "modified_at": str,        # ISO format timestamp
-    }
-    """
-    
-    def ls(self, path: str) -> list[str]:
-        """List all file paths in a directory.
-        
-        Args:
-            path: Absolute path to directory (e.g., "/", "/subdir/", "/memories/")
-        
-        Returns:
-            List of absolute file paths in the specified directory.
-        """
-        ...
-    
-    def read(
-        self, 
-        file_path: str,
-        offset: int = 0,
-        limit: int = 2000,
-    ) -> str:
-        """Read file content with line numbers.
-        
-        Args:
-            file_path: Absolute file path (e.g., "/notes.txt", "/memories/agent.md")
-            offset: Line offset to start reading from (0-indexed)
-            limit: Maximum number of lines to read
-        
-        Returns:
-            Formatted file content with line numbers (cat -n style), or error message.
-            Returns "Error: File '{file_path}' not found" if file doesn't exist.
-            Returns "System reminder: File exists but has empty contents" for empty files.
-        """
-        ...
-    
-    def write(
-        self, 
-        file_path: str,
-        content: str,
-    ) -> Command | str:
-        """Create a new file with content.
-        
-        Args:
-            file_path: Absolute file path (e.g., "/notes.txt", "/memories/agent.md")
-            content: File content as a string
-        
-        Returns:
-            - Command object for StateBackend (uses_state=True) to update LangGraph state
-            - Success message string for other backends, or error if file already exists
-        
-        Error cases:
-            - Returns error message if file already exists (should use edit instead)
-        """
-        ...
-    
-    def edit(
-        self, 
-        file_path: str,
-        old_string: str,
-        new_string: str,
-        replace_all: bool = False,
-    ) -> Command | str:
-        """Edit a file by replacing string occurrences.
-        
-        Args:
-            file_path: Absolute file path (e.g., "/notes.txt", "/memories/agent.md")
-            old_string: String to find and replace
-            new_string: Replacement string
-            replace_all: If True, replace all occurrences; if False, require unique match
-        
-        Returns:
-            - Command object for StateBackend (uses_state=True) to update LangGraph state
-            - Success message string for other backends, or error message on failure
-            
-        Error cases:
-            - "Error: File '{file_path}' not found" if file doesn't exist
-            - "Error: String not found in file: '{old_string}'" if string not found
-            - "Error: String '{old_string}' appears {n} times. Use replace_all=True..."
-              if multiple matches found and replace_all=False
-        """
-        ...
-    
-    def delete(self, file_path: str) -> Command | None:
-        """Delete a file by path.
-        
-        Args:
-            file_path: Absolute file path to delete
-        
-        Returns:
-            - None for backends that modify storage directly (uses_state=False)
-            - Command object for StateBackend (uses_state=True) to update LangGraph state
-        """
-        ...
-    
-    def grep(
-        self,
-        pattern: str,
-        path: str = "/",
-        glob: Optional[str] = None,
-        output_mode: str = "files_with_matches",
-    ) -> str:
-        """Search for a pattern in files.
-        
-        TODO: This implementation is significantly less capable than Claude Code's Grep tool.
-        Missing features to add in the future:
-        - Context lines: -A (after), -B (before), -C (context) parameters
-        - Line numbers: -n parameter to show line numbers in output
-        - Case sensitivity: -i parameter for case-insensitive search
-        - Output limiting: head_limit parameter for large result sets
-        - File type filter: type parameter (e.g., "py", "js")
-        - Multiline support: multiline parameter for cross-line pattern matching
-        - Pattern semantics: Clarify if pattern is regex or literal string
-        See /memories/memory_backend_vs_claude_code_comparison.md for full details.
-        
-        Args:
-            pattern: String pattern to search for (currently literal string)
-            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"
-                - files_with_matches: List file paths that contain matches
-                - content: Show matching lines with file paths and line numbers
-                - count: Show count of matches per file
-        
-        Returns:
-            Formatted search results based on output_mode, or message if no matches found.
-        """
-        ...
-    
-    def glob(self, pattern: str, path: str = "/") -> list[str]:
-        """Find files matching a glob pattern.
-
-        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.
-        """
-        ...

deepagents/middleware/__init__.py

@@ -1,13 +0,0 @@
-"""Middleware for the DeepAgent."""
-
-from deepagents.middleware.agent_memory import AgentMemoryMiddleware
-from deepagents.middleware.filesystem import FilesystemMiddleware
-from deepagents.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
-
-__all__ = [
-    "AgentMemoryMiddleware",
-    "CompiledSubAgent",
-    "FilesystemMiddleware",
-    "SubAgent",
-    "SubAgentMiddleware",
-]

deepagents/middleware/agent_memory.py

@@ -1,207 +0,0 @@
-"""Middleware for loading agent-specific long-term memory into the system prompt."""
-
-from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from langgraph.runtime import Runtime
-
-from langchain.agents.middleware.types import (
-    AgentMiddleware,
-    AgentState,
-    ModelRequest,
-    ModelResponse,
-)
-from typing_extensions import NotRequired, TypedDict
-
-from deepagents.memory.protocol import MemoryBackend
-
-
-class AgentMemoryState(AgentState):
-    """State for the agent memory middleware."""
-
-    agent_memory: NotRequired[str | None]
-    """Long-term memory content for the agent."""
-
-
-AGENT_MEMORY_FILE_PATH = "/agent.md"
-
-# Long-term Memory Documentation
-LONGTERM_MEMORY_SYSTEM_PROMPT = """
-
-## Long-term Memory
-
-You have access to a long-term memory system using the {memory_path} path prefix.
-Files stored in {memory_path} persist across sessions and conversations.
-
-Your system prompt is loaded from {memory_path}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
-- When user says "you should remember X" or "be careful about Y", treat this as HIGH PRIORITY - update memories IMMEDIATELY
-- Look for the underlying principle behind corrections, not just the specific mistake
-- If it's something you "should have remembered", identify where that instruction should live permanently
-
-**What to store where:**
-- **{memory_path}agent.md**: Update this to modify your core instructions and behavioral patterns
-- **Other {memory_path} files**: Use for project-specific context, reference information, or structured notes
-  - If you create additional memory files, add references to them in {memory_path}agent.md so you remember to consult them
-
-The portion of your system prompt that comes from {memory_path}agent.md is marked with `<agent_memory>` tags so you can identify what instructions come from your persistent memory.
-
-Example: `edit_file('{memory_path}agent.md', ...)` to update your instructions
-Example: `write_file('{memory_path}project_context.md', ...)` for project-specific notes, then reference it in agent.md
-
-Remember: To interact with the longterm filesystem, you must prefix the filename with the {memory_path} path."""
-
-
-DEFAULT_MEMORY_SNIPPET = """<agent_memory>
-{agent_memory}
-</agent_memory>
-"""
-
-class AgentMemoryMiddleware(AgentMiddleware):
-    """Middleware for loading agent-specific long-term memory.
-
-    This middleware loads the agent's long-term memory from a file (agent.md)
-    and injects it into the system prompt. The memory is loaded once at the
-    start of the conversation and stored in state.
-
-    Args:
-        backend: Backend to use for loading the agent memory file.
-        system_prompt_template: Optional custom template for how to inject
-            the agent memory into the system prompt. Use {agent_memory} as
-            a placeholder. Defaults to a simple section header.
-
-    Example:
-        ```python
-        from deepagents.middleware.agent_memory import AgentMemoryMiddleware
-        from deepagents.memory.backends import FilesystemBackend
-        from pathlib import Path
-
-        # Set up backend pointing to agent's directory
-        agent_dir = Path.home() / ".deepagents" / "my-agent"
-        backend = FilesystemBackend(root_dir=agent_dir)
-        
-        # Create middleware
-        middleware = AgentMemoryMiddleware(backend=backend)
-        ```
-    """
-
-    state_schema = AgentMemoryState
-
-    def __init__(
-        self,
-        *,
-        backend: MemoryBackend,
-        memory_path: str,
-        system_prompt_template: str | None = None,
-    ) -> None:
-        """Initialize the agent memory middleware.
-
-        Args:
-            backend: Backend to use for loading the agent memory file.
-            system_prompt_template: Optional custom template for injecting
-                agent memory into system prompt.
-        """
-        self.backend = backend
-        self.memory_path = memory_path
-        self.system_prompt_template = system_prompt_template or DEFAULT_MEMORY_SNIPPET
-
-    def before_agent(
-        self,
-        state: AgentMemoryState,
-        runtime,
-    ) -> AgentMemoryState:
-        """Load agent memory from file before agent execution.
-
-        Args:
-            state: Current agent state.
-            handler: Handler function to call after loading memory.
-
-        Returns:
-            Updated state with agent_memory populated.
-        """
-        # Only load memory if it hasn't been loaded yet
-        if "agent_memory" not in state or state.get("agent_memory") is None:
-            file_data = self.backend.read(AGENT_MEMORY_FILE_PATH)
-            return {"agent_memory": file_data}
-
-    async def abefore_agent(
-        self,
-        state: AgentMemoryState,
-        runtime,
-    ) -> AgentMemoryState:
-        """(async) Load agent memory from file before agent execution.
-
-        Args:
-            state: Current agent state.
-            handler: Handler function to call after loading memory.
-
-        Returns:
-            Updated state with agent_memory populated.
-        """
-        # Only load memory if it hasn't been loaded yet
-        if "agent_memory" not in state or state.get("agent_memory") is None:
-            file_data = self.backend.read(AGENT_MEMORY_FILE_PATH)
-            return {"agent_memory": file_data}
-
-    def wrap_model_call(
-        self,
-        request: ModelRequest,
-        handler: Callable[[ModelRequest], ModelResponse],
-    ) -> ModelResponse:
-        """Inject agent memory into the system prompt.
-
-        Args:
-            request: The model request being processed.
-            handler: The handler function to call with the modified request.
-
-        Returns:
-            The model response from the handler.
-        """
-        # Get agent memory from state
-        agent_memory = request.state.get("agent_memory", "")
-        
-        memory_section = self.system_prompt_template.format(agent_memory=agent_memory)
-        if request.system_prompt:
-            request.system_prompt = memory_section + "\n\n" + request.system_prompt
-        else:
-            request.system_prompt = memory_section
-        request.system_prompt = request.system_prompt + "\n\n" + LONGTERM_MEMORY_SYSTEM_PROMPT.format(memory_path=self.memory_path)
-
-        return handler(request)
-
-    async def awrap_model_call(
-        self,
-        request: ModelRequest,
-        handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
-    ) -> ModelResponse:
-        """(async) Inject agent memory into the system prompt.
-
-        Args:
-            request: The model request being processed.
-            handler: The handler function to call with the modified request.
-
-        Returns:
-            The model response from the handler.
-        """
-        # Get agent memory from state
-        agent_memory = request.state.get("agent_memory", "")
-        
-        memory_section = self.system_prompt_template.format(agent_memory=agent_memory)
-        if request.system_prompt:
-            request.system_prompt = memory_section + "\n\n" + request.system_prompt
-        else:
-            request.system_prompt = memory_section
-        request.system_prompt = request.system_prompt + "\n\n" + LONGTERM_MEMORY_SYSTEM_PROMPT.format(memory_path=self.memory_path)
-
-        return await handler(request)