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

deepagents/graph.py

@@ -1,144 +0,0 @@
-"""Deepagents come with planning, filesystem, and subagents."""
-
-from collections.abc import Callable, Sequence
-from typing import Any
-
-from langchain.agents import create_agent
-from langchain.agents.middleware import HumanInTheLoopMiddleware, InterruptOnConfig, TodoListMiddleware
-from langchain.agents.middleware.summarization import SummarizationMiddleware
-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_core.language_models import BaseChatModel
-from langchain_core.tools import BaseTool
-from langgraph.cache.base import BaseCache
-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.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."
-
-
-def get_default_model() -> ChatAnthropic:
-    """Get the default model for deep agents.
-
-    Returns:
-        ChatAnthropic instance configured with Claude Sonnet 4.
-    """
-    return ChatAnthropic(
-        model_name="claude-sonnet-4-5-20250929",
-        max_tokens=20000,
-    )
-
-
-def create_deep_agent(
-    model: str | BaseChatModel | None = None,
-    tools: Sequence[BaseTool | Callable | dict[str, Any]] | None = None,
-    *,
-    system_prompt: str | None = None,
-    middleware: Sequence[AgentMiddleware] = (),
-    subagents: list[SubAgent | CompiledSubAgent] | None = None,
-    response_format: ResponseFormat | None = None,
-    context_schema: type[Any] | None = None,
-    checkpointer: Checkpointer | None = None,
-    store: BaseStore | None = None,
-    memory_backend: MemoryBackend | None = None,
-    interrupt_on: dict[str, bool | InterruptOnConfig] | None = None,
-    debug: bool = False,
-    name: str | None = None,
-    cache: BaseCache | None = None,
-) -> CompiledStateGraph:
-    """Create a deep agent.
-
-    This agent will by default have access to a tool to write todos (write_todos),
-    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.
-        subagents: The subagents to use. Each subagent should be a dictionary with the
-            following keys:
-                - `name`
-                - `description` (used by the main agent to decide whether to call the
-                  sub agent)
-                - `prompt` (used as the system prompt in the subagent)
-                - (optional) `tools`
-                - (optional) `model` (either a LanguageModelLike instance or dict
-                  settings)
-                - (optional) `middleware` (list of AgentMiddleware)
-        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 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.
-        name: The name of the agent. Passed through to create_agent.
-        cache: The cache to use for the agent. Passed through to create_agent.
-
-    Returns:
-        A configured deep agent.
-    """
-    if model is None:
-        model = get_default_model()
-
-    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"),
-                PatchToolCallsMiddleware(),
-            ],
-            default_interrupt_on=interrupt_on,
-            general_purpose_agent=True,
-        ),
-        SummarizationMiddleware(
-            model=model,
-            max_tokens_before_summary=170000,
-            messages_to_keep=6,
-        ),
-        AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
-        PatchToolCallsMiddleware(),
-    ]
-    if interrupt_on is not None:
-        deepagent_middleware.append(HumanInTheLoopMiddleware(interrupt_on=interrupt_on))
-    if middleware is not None:
-        deepagent_middleware.extend(middleware)
-
-    return create_agent(
-        model,
-        system_prompt=system_prompt + "\n\n" + BASE_AGENT_PROMPT if system_prompt else BASE_AGENT_PROMPT,
-        tools=tools,
-        middleware=deepagent_middleware,
-        response_format=response_format,
-        context_schema=context_schema,
-        checkpointer=checkpointer,
-        store=store,
-        debug=debug,
-        name=name,
-        cache=cache,
-    ).with_config({"recursion_limit": 1000})

deepagents/memory/__init__.py

@@ -1,17 +0,0 @@
-"""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

@@ -1,15 +0,0 @@
-"""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

@@ -1,250 +0,0 @@
-"""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)