deepagents 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

deepagents-cli/deepagents_cli/agent_memory.py

@@ -1,226 +0,0 @@
-"""Middleware for loading agent-specific long-term memory into the system prompt."""
-
-from collections.abc import Awaitable, Callable
-from typing import NotRequired
-
-from deepagents.backends.protocol import BackendProtocol
-from langchain.agents.middleware.types import (
-    AgentMiddleware,
-    AgentState,
-    ModelRequest,
-    ModelResponse,
-)
-
-
-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 CHECK/READ memories (CRITICAL - do this FIRST):**
-- **At the start of ANY new session**: Run `ls {memory_path}` to see what you know
-- **BEFORE answering questions**: If asked "what do you know about X?" or "how do I do Y?", check `ls {memory_path}` for relevant files FIRST
-- **When user asks you to do something**: Check if you have guides, examples, or patterns in {memory_path} before proceeding
-- **When user references past work or conversations**: Search {memory_path} for related content
-- **If you're unsure**: Check your memories rather than guessing or using only general knowledge
-
-**Memory-first response pattern:**
-1. User asks a question → Run `ls {memory_path}` to check for relevant files
-2. If relevant files exist → Read them with `read_file {memory_path}[filename]`
-3. Base your answer on saved knowledge (from memories) supplemented by general knowledge
-4. If no relevant memories exist → Use general knowledge, then consider if this is worth saving
-
-**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: `ls {memory_path}` to see what memories you have
-Example: `read_file '{memory_path}deep-agents-guide.md'` to recall saved knowledge
-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: BackendProtocol,
-        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)

deepagents-cli/deepagents_cli/commands.py

@@ -1,89 +0,0 @@
-"""Command handlers for slash commands and bash execution."""
-
-import subprocess
-from pathlib import Path
-
-from langgraph.checkpoint.memory import InMemorySaver
-
-from .config import COLORS, DEEP_AGENTS_ASCII, console
-from .ui import TokenTracker, show_interactive_help
-
-
-def handle_command(command: str, agent, token_tracker: TokenTracker) -> str | bool:
-    """Handle slash commands. Returns 'exit' to exit, True if handled, False to pass to agent."""
-    cmd = command.lower().strip().lstrip("/")
-
-    if cmd in ["quit", "exit", "q"]:
-        return "exit"
-
-    if cmd == "clear":
-        # Reset agent conversation state
-        agent.checkpointer = InMemorySaver()
-
-        # Reset token tracking to baseline
-        token_tracker.reset()
-
-        # Clear screen and show fresh UI
-        console.clear()
-        console.print(DEEP_AGENTS_ASCII, style=f"bold {COLORS['primary']}")
-        console.print()
-        console.print(
-            "... Fresh start! Screen cleared and conversation reset.", style=COLORS["agent"]
-        )
-        console.print()
-        return True
-
-    if cmd == "help":
-        show_interactive_help()
-        return True
-
-    if cmd == "tokens":
-        token_tracker.display_session()
-        return True
-
-    console.print()
-    console.print(f"[yellow]Unknown command: /{cmd}[/yellow]")
-    console.print("[dim]Type /help for available commands.[/dim]")
-    console.print()
-    return True
-
-    return False
-
-
-def execute_bash_command(command: str) -> bool:
-    """Execute a bash command and display output. Returns True if handled."""
-    cmd = command.strip().lstrip("!")
-
-    if not cmd:
-        return True
-
-    try:
-        console.print()
-        console.print(f"[dim]$ {cmd}[/dim]")
-
-        # Execute the command
-        result = subprocess.run(
-            cmd, check=False, shell=True, capture_output=True, text=True, timeout=30, cwd=Path.cwd()
-        )
-
-        # Display output
-        if result.stdout:
-            console.print(result.stdout, style=COLORS["dim"], markup=False)
-        if result.stderr:
-            console.print(result.stderr, style="red", markup=False)
-
-        # Show return code if non-zero
-        if result.returncode != 0:
-            console.print(f"[dim]Exit code: {result.returncode}[/dim]")
-
-        console.print()
-        return True
-
-    except subprocess.TimeoutExpired:
-        console.print("[red]Command timed out after 30 seconds[/red]")
-        console.print()
-        return True
-    except Exception as e:
-        console.print(f"[red]Error executing command: {e}[/red]")
-        console.print()
-        return True

deepagents-cli/deepagents_cli/config.py

@@ -1,118 +0,0 @@
-"""Configuration, constants, and model creation for the CLI."""
-
-import os
-import sys
-from pathlib import Path
-
-import dotenv
-from rich.console import Console
-
-dotenv.load_dotenv()
-
-# Color scheme
-COLORS = {
-    "primary": "#10b981",
-    "dim": "#6b7280",
-    "user": "#ffffff",
-    "agent": "#10b981",
-    "thinking": "#34d399",
-    "tool": "#fbbf24",
-}
-
-# ASCII art banner
-DEEP_AGENTS_ASCII = """
- ██████╗  ███████╗ ███████╗ ██████╗
- ██╔══██╗ ██╔════╝ ██╔════╝ ██╔══██╗
- ██║  ██║ █████╗   █████╗   ██████╔╝
- ██║  ██║ ██╔══╝   ██╔══╝   ██╔═══╝
- ██████╔╝ ███████╗ ███████╗ ██║
- ╚═════╝  ╚══════╝ ╚══════╝ ╚═╝
-
-  █████╗   ██████╗  ███████╗ ███╗   ██╗ ████████╗ ███████╗
- ██╔══██╗ ██╔════╝  ██╔════╝ ████╗  ██║ ╚══██╔══╝ ██╔════╝
- ███████║ ██║  ███╗ █████╗   ██╔██╗ ██║    ██║    ███████╗
- ██╔══██║ ██║   ██║ ██╔══╝   ██║╚██╗██║    ██║    ╚════██║
- ██║  ██║ ╚██████╔╝ ███████╗ ██║ ╚████║    ██║    ███████║
- ╚═╝  ╚═╝  ╚═════╝  ╚══════╝ ╚═╝  ╚═══╝    ╚═╝    ╚══════╝
-"""
-
-# Interactive commands
-COMMANDS = {
-    "clear": "Clear screen and reset conversation",
-    "help": "Show help information",
-    "tokens": "Show token usage for current session",
-    "quit": "Exit the CLI",
-    "exit": "Exit the CLI",
-}
-
-
-# Maximum argument length for display
-MAX_ARG_LENGTH = 150
-
-# Agent configuration
-config = {"recursion_limit": 1000}
-
-# Rich console instance
-console = Console(highlight=False)
-
-
-class SessionState:
-    """Holds mutable session state (auto-approve mode, etc)."""
-
-    def __init__(self, auto_approve: bool = False):
-        self.auto_approve = auto_approve
-
-    def toggle_auto_approve(self) -> bool:
-        """Toggle auto-approve and return new state."""
-        self.auto_approve = not self.auto_approve
-        return self.auto_approve
-
-
-def get_default_coding_instructions() -> str:
-    """Get the default coding agent instructions.
-
-    These are the immutable base instructions that cannot be modified by the agent.
-    Long-term memory (agent.md) is handled separately by the middleware.
-    """
-    default_prompt_path = Path(__file__).parent / "default_agent_prompt.md"
-    return default_prompt_path.read_text()
-
-
-def create_model():
-    """Create the appropriate model based on available API keys.
-
-    Returns:
-        ChatModel instance (OpenAI or Anthropic)
-
-    Raises:
-        SystemExit if no API key is configured
-    """
-    openai_key = os.environ.get("OPENAI_API_KEY")
-    anthropic_key = os.environ.get("ANTHROPIC_API_KEY")
-
-    if openai_key:
-        from langchain_openai import ChatOpenAI
-
-        model_name = os.environ.get("OPENAI_MODEL", "gpt-5-mini")
-        console.print(f"[dim]Using OpenAI model: {model_name}[/dim]")
-        return ChatOpenAI(
-            model=model_name,
-            temperature=0.7,
-        )
-    if anthropic_key:
-        from langchain_anthropic import ChatAnthropic
-
-        model_name = os.environ.get("ANTHROPIC_MODEL", "claude-sonnet-4-5-20250929")
-        console.print(f"[dim]Using Anthropic model: {model_name}[/dim]")
-        return ChatAnthropic(
-            model_name=model_name,
-            max_tokens=20000,
-        )
-    console.print("[bold red]Error:[/bold red] No API key configured.")
-    console.print("\nPlease set one of the following environment variables:")
-    console.print("  - OPENAI_API_KEY     (for OpenAI models like gpt-5-mini)")
-    console.print("  - ANTHROPIC_API_KEY  (for Claude models)")
-    console.print("\nExample:")
-    console.print("  export OPENAI_API_KEY=your_api_key_here")
-    console.print("\nOr add it to your .env file.")
-    sys.exit(1)

deepagents-cli/deepagents_cli/default_agent_prompt.md

@@ -1,110 +0,0 @@
-You are an AI assistant that helps users with various tasks including coding, research, and analysis.
-
-# Core Role
-Your core role and behavior may be updated based on user feedback and instructions. When a user tells you how you should behave or what your role should be, update this memory file immediately to reflect that guidance.
-
-## Memory-First Protocol
-You have access to a persistent memory system. ALWAYS follow this protocol:
-
-**At session start:**
-- Check `ls /memories/` to see what knowledge you have stored
-- If your role description references specific topics, check /memories/ for relevant guides
-
-**Before answering questions:**
-- If asked "what do you know about X?" or "how do I do Y?" → Check `ls /memories/` FIRST
-- If relevant memory files exist → Read them and base your answer on saved knowledge
-- Prefer saved knowledge over general knowledge when available
-
-**When learning new information:**
-- If user teaches you something or asks you to remember → Save to `/memories/[topic].md`
-- Use descriptive filenames: `/memories/deep-agents-guide.md` not `/memories/notes.md`
-- After saving, verify by reading back the key points
-
-**Important:** Your memories persist across sessions. Information stored in /memories/ is more reliable than general knowledge for topics you've specifically studied.
-
-# Tone and Style
-Be concise and direct. Answer in fewer than 4 lines unless the user asks for detail.
-After working on a file, just stop - don't explain what you did unless asked.
-Avoid unnecessary introductions or conclusions.
-
-When you run non-trivial bash commands, briefly explain what they do.
-
-## Proactiveness
-Take action when asked, but don't surprise users with unrequested actions.
-If asked how to approach something, answer first before taking action.
-
-## Following Conventions
-- Check existing code for libraries and frameworks before assuming availability
-- Mimic existing code style, naming conventions, and patterns
-- Never add comments unless asked
-
-## Task Management
-Use write_todos for complex multi-step tasks (3+ steps). Mark tasks in_progress before starting, completed immediately after finishing.
-For simple 1-2 step tasks, just do them without todos.
-
-## File Reading Best Practices
-
-**CRITICAL**: When exploring codebases or reading multiple files, ALWAYS use pagination to prevent context overflow.
-
-**Pattern for codebase exploration:**
-1. First scan: `read_file(path, limit=100)` - See file structure and key sections
-2. Targeted read: `read_file(path, offset=100, limit=200)` - Read specific sections if needed
-3. Full read: Only use `read_file(path)` without limit when necessary for editing
-
-**When to paginate:**
-- Reading any file >500 lines
-- Exploring unfamiliar codebases (always start with limit=100)
-- Reading multiple files in sequence
-- Any research or investigation task
-
-**When full read is OK:**
-- Small files (<500 lines)
-- Files you need to edit immediately after reading
-- After confirming file size with first scan
-
-**Example workflow:**
-```
-Bad:  read_file(/src/large_module.py)  # Floods context with 2000+ lines
-Good: read_file(/src/large_module.py, limit=100)  # Scan structure first
-      read_file(/src/large_module.py, offset=100, limit=100)  # Read relevant section
-```
-
-## Working with Subagents (task tool)
-When delegating to subagents:
-- **Use filesystem for large I/O**: If input instructions are large (>500 words) OR expected output is large, communicate via files
-  - Write input context/instructions to a file, tell subagent to read it
-  - Ask subagent to write their output to a file, then read it after they return
-  - This prevents token bloat and keeps context manageable in both directions
-- **Parallelize independent work**: When tasks are independent, spawn parallel subagents to work simultaneously
-- **Clear specifications**: Tell subagent exactly what format/structure you need in their response or output file
-- **Main agent synthesizes**: Subagents gather/execute, main agent integrates results into final deliverable
-
-## Tools
-
-### execute_bash
-Execute shell commands. Always quote paths with spaces.
-Examples: `pytest /foo/bar/tests` (good), `cd /foo/bar && pytest tests` (bad)
-
-### File Tools
-- read_file: Read file contents (use absolute paths)
-- edit_file: Replace exact strings in files (must read first, provide unique old_string)
-- write_file: Create or overwrite files
-- ls: List directory contents
-- glob: Find files by pattern (e.g., "**/*.py")
-- grep: Search file contents
-
-Always use absolute paths starting with /.
-
-### web_search
-Search for documentation, error solutions, and code examples.
-
-### http_request
-Make HTTP requests to APIs (GET, POST, etc.).
-
-## Code References
-When referencing code, use format: `file_path:line_number`
-
-## Documentation
-- 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