deepagents 0.2.8__tar.gz → 0.3.0__tar.gz

{deepagents-0.2.8 → deepagents-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.8
+Version: 0.3.0
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
@@ -11,9 +11,9 @@ Project-URL: Slack, https://www.langchain.com/join-community
 Project-URL: Reddit, https://www.reddit.com/r/LangChain/
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: langchain-anthropic<2.0.0,>=1.0.0
-Requires-Dist: langchain<2.0.0,>=1.0.2
-Requires-Dist: langchain-core<2.0.0,>=1.0.0
+Requires-Dist: langchain-anthropic<2.0.0,>=1.2.0
+Requires-Dist: langchain<2.0.0,>=1.1.0
+Requires-Dist: langchain-core<2.0.0,>=1.1.0
 Requires-Dist: wcmatch
 
 # 🧠🤖Deep Agents

{deepagents-0.2.8 → deepagents-0.3.0}/deepagents/backends/composite.py

@@ -97,6 +97,43 @@ class CompositeBackend:
         # Path doesn't match a route: query only default backend
         return self.default.ls_info(path)
 
+    async def als_info(self, path: str) -> list[FileInfo]:
+        """Async version of ls_info."""
+        # 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 = await backend.als_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(await self.default.als_info(path))
+            for route_prefix, backend in self.sorted_routes:
+                # Add the route itself as a directory (e.g., /memories/)
+                results.append(
+                    {
+                        "path": route_prefix,
+                        "is_dir": True,
+                        "size": 0,
+                        "modified_at": "",
+                    }
+                )
+
+            results.sort(key=lambda x: x.get("path", ""))
+            return results
+
+        # Path doesn't match a route: query only default backend
+        return await self.default.als_info(path)
+
     def read(
         self,
         file_path: str,
@@ -106,14 +143,26 @@ class CompositeBackend:
         """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:
+            file_path: Absolute file path.
+            offset: Line offset to start reading from (0-indexed).
+            limit: Maximum number of lines to read.
+
+        Returns:
             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)
 
+    async def aread(
+        self,
+        file_path: str,
+        offset: int = 0,
+        limit: int = 2000,
+    ) -> str:
+        """Async version of read."""
+        backend, stripped_key = self._get_backend_and_key(file_path)
+        return await backend.aread(stripped_key, offset=offset, limit=limit)
+
     def grep_raw(
         self,
         pattern: str,
@@ -146,6 +195,39 @@ class CompositeBackend:
 
         return all_matches
 
+    async def agrep_raw(
+        self,
+        pattern: str,
+        path: str | None = None,
+        glob: str | None = None,
+    ) -> list[GrepMatch] | str:
+        """Async version of grep_raw."""
+        # 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 = await backend.agrep_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 = await self.default.agrep_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 = await backend.agrep_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] = []
 
@@ -167,6 +249,28 @@ class CompositeBackend:
         results.sort(key=lambda x: x.get("path", ""))
         return results
 
+    async def aglob_info(self, pattern: str, path: str = "/") -> list[FileInfo]:
+        """Async version of glob_info."""
+        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 = await backend.aglob_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(await self.default.aglob_info(pattern, path))
+
+        for route_prefix, backend in self.routes.items():
+            infos = await backend.aglob_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,
@@ -175,8 +279,10 @@ class CompositeBackend:
         """Create a new file, routing to appropriate backend.
 
         Args:
-            file_path: Absolute file path
-            content: File content as a stringReturns:
+            file_path: Absolute file path.
+            content: File content as a string.
+
+        Returns:
             Success message or Command object, or error if file already exists.
         """
         backend, stripped_key = self._get_backend_and_key(file_path)
@@ -194,6 +300,27 @@ class CompositeBackend:
                 pass
         return res
 
+    async def awrite(
+        self,
+        file_path: str,
+        content: str,
+    ) -> WriteResult:
+        """Async version of write."""
+        backend, stripped_key = self._get_backend_and_key(file_path)
+        res = await backend.awrite(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,
@@ -204,10 +331,12 @@ class CompositeBackend:
         """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:
+            file_path: Absolute file path.
+            old_string: String to find and replace.
+            new_string: Replacement string.
+            replace_all: If True, replace all occurrences.
+
+        Returns:
             Success message or Command object, or error message on failure.
         """
         backend, stripped_key = self._get_backend_and_key(file_path)
@@ -224,6 +353,28 @@ class CompositeBackend:
                 pass
         return res
 
+    async def aedit(
+        self,
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,
+    ) -> EditResult:
+        """Async version of edit."""
+        backend, stripped_key = self._get_backend_and_key(file_path)
+        res = await backend.aedit(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 execute(
         self,
         command: str,
@@ -252,6 +403,21 @@ class CompositeBackend:
             "To enable execution, provide a default backend that implements SandboxBackendProtocol."
         )
 
+    async def aexecute(
+        self,
+        command: str,
+    ) -> ExecuteResponse:
+        """Async version of execute."""
+        if isinstance(self.default, SandboxBackendProtocol):
+            return await self.default.aexecute(command)
+
+        # This shouldn't be reached if the runtime check in the execute tool works correctly,
+        # but we include it as a safety fallback.
+        raise NotImplementedError(
+            "Default backend doesn't support command execution (SandboxBackendProtocol). "
+            "To enable execution, provide a default backend that implements SandboxBackendProtocol."
+        )
+
     def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
         """Upload multiple files, batching by backend for efficiency.
 
@@ -295,6 +461,36 @@ class CompositeBackend:
 
         return results  # type: ignore[return-value]
 
+    async def aupload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        """Async version of upload_files."""
+        # Pre-allocate result list
+        results: list[FileUploadResponse | None] = [None] * len(files)
+
+        # Group files by backend, tracking original indices
+        backend_batches: dict[BackendProtocol, list[tuple[int, str, bytes]]] = defaultdict(list)
+
+        for idx, (path, content) in enumerate(files):
+            backend, stripped_path = self._get_backend_and_key(path)
+            backend_batches[backend].append((idx, stripped_path, content))
+
+        # Process each backend's batch
+        for backend, batch in backend_batches.items():
+            # Extract data for backend call
+            indices, stripped_paths, contents = zip(*batch, strict=False)
+            batch_files = list(zip(stripped_paths, contents, strict=False))
+
+            # Call backend once with all its files
+            batch_responses = await backend.aupload_files(batch_files)
+
+            # Place responses at original indices with original paths
+            for i, orig_idx in enumerate(indices):
+                results[orig_idx] = FileUploadResponse(
+                    path=files[orig_idx][0],  # Original path
+                    error=batch_responses[i].error if i < len(batch_responses) else None,
+                )
+
+        return results  # type: ignore[return-value]
+
     def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
         """Download multiple files, batching by backend for efficiency.
 
@@ -334,3 +530,32 @@ class CompositeBackend:
                 )
 
         return results  # type: ignore[return-value]
+
+    async def adownload_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Async version of download_files."""
+        # Pre-allocate result list
+        results: list[FileDownloadResponse | None] = [None] * len(paths)
+
+        backend_batches: dict[BackendProtocol, list[tuple[int, str]]] = defaultdict(list)
+
+        for idx, path in enumerate(paths):
+            backend, stripped_path = self._get_backend_and_key(path)
+            backend_batches[backend].append((idx, stripped_path))
+
+        # Process each backend's batch
+        for backend, batch in backend_batches.items():
+            # Extract data for backend call
+            indices, stripped_paths = zip(*batch, strict=False)
+
+            # Call backend once with all its paths
+            batch_responses = await backend.adownload_files(list(stripped_paths))
+
+            # Place responses at original indices with original paths
+            for i, orig_idx in enumerate(indices):
+                results[orig_idx] = FileDownloadResponse(
+                    path=paths[orig_idx],  # Original path
+                    content=batch_responses[i].content if i < len(batch_responses) else None,
+                    error=batch_responses[i].error if i < len(batch_responses) else None,
+                )
+
+        return results  # type: ignore[return-value]

{deepagents-0.2.8 → deepagents-0.3.0}/deepagents/backends/filesystem.py

@@ -202,9 +202,11 @@ class FilesystemBackend(BackendProtocol):
         """Read file content with line numbers.
 
         Args:
-            file_path: Absolute or relative file path
-            offset: Line offset to start reading from (0-indexed)
-            limit: Maximum number of lines to readReturns:
+            file_path: Absolute or relative file path.
+            offset: Line offset to start reading from (0-indexed).
+            limit: Maximum number of lines to read.
+
+        Returns:
             Formatted file content with line numbers, or error message.
         """
         resolved_path = self._resolve_path(file_path)
@@ -303,8 +305,6 @@ class FilesystemBackend(BackendProtocol):
         except (OSError, UnicodeDecodeError, UnicodeEncodeError) as e:
             return EditResult(error=f"Error editing file '{file_path}': {e}")
 
-    # Removed legacy grep() convenience to keep lean surface
-
     def grep_raw(
         self,
         pattern: str,

{deepagents-0.2.8 → deepagents-0.3.0}/deepagents/backends/protocol.py

@@ -5,9 +5,11 @@ must follow. Backends can store files in different locations (state, filesystem,
 database, etc.) and provide a uniform interface for file operations.
 """
 
+import abc
+import asyncio
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any, Literal, NotRequired, Protocol, TypeAlias, runtime_checkable
+from typing import Any, Literal, NotRequired, TypeAlias
 
 from langchain.tools import ToolRuntime
 from typing_extensions import TypedDict
@@ -156,8 +158,7 @@ class EditResult:
     occurrences: int | None = None
 
 
-@runtime_checkable
-class BackendProtocol(Protocol):
+class BackendProtocol(abc.ABC):
     """Protocol for pluggable memory backends (single, unified).
 
     Backends can store files in different locations (state, filesystem, database, etc.)
@@ -172,8 +173,23 @@ class BackendProtocol(Protocol):
     """
 
     def ls_info(self, path: str) -> list["FileInfo"]:
-        """Structured listing with file metadata."""
-        ...
+        """List all files in a directory with metadata.
+
+        Args:
+            path: Absolute path to the directory to list. Must start with '/'.
+
+        Returns:
+            List of FileInfo dicts containing file metadata:
+
+            - `path` (required): Absolute file path
+            - `is_dir` (optional): True if directory
+            - `size` (optional): File size in bytes
+            - `modified_at` (optional): ISO 8601 timestamp
+        """
+
+    async def als_info(self, path: str) -> list["FileInfo"]:
+        """Async version of ls_info."""
+        return await asyncio.to_thread(self.ls_info, path)
 
     def read(
         self,
@@ -181,8 +197,35 @@ class BackendProtocol(Protocol):
         offset: int = 0,
         limit: int = 2000,
     ) -> str:
-        """Read file content with line numbers or an error string."""
-        ...
+        """Read file content with line numbers.
+
+        Args:
+            file_path: Absolute path to the file to read. Must start with '/'.
+            offset: Line number to start reading from (0-indexed). Default: 0.
+            limit: Maximum number of lines to read. Default: 2000.
+
+        Returns:
+            String containing file content formatted with line numbers (cat -n format),
+            starting at line 1. Lines longer than 2000 characters are truncated.
+
+            Returns an error string if the file doesn't exist or can't be read.
+
+        !!! note
+            - Use pagination (offset/limit) for large files to avoid context overflow
+            - First scan: `read(path, limit=100)` to see file structure
+            - Read more: `read(path, offset=100, limit=200)` for next section
+            - ALWAYS read a file before editing it
+            - If file exists but is empty, you'll receive a system reminder warning
+        """
+
+    async def aread(
+        self,
+        file_path: str,
+        offset: int = 0,
+        limit: int = 2000,
+    ) -> str:
+        """Async version of read."""
+        return await asyncio.to_thread(self.read, file_path, offset, limit)
 
     def grep_raw(
         self,
@@ -190,20 +233,94 @@ class BackendProtocol(Protocol):
         path: str | None = None,
         glob: str | None = None,
     ) -> list["GrepMatch"] | str:
-        """Structured search results or error string for invalid input."""
-        ...
+        """Search for a literal text pattern in files.
+
+        Args:
+            pattern: Literal string to search for (NOT regex).
+                     Performs exact substring matching within file content.
+                     Example: "TODO" matches any line containing "TODO"
+
+            path: Optional directory path to search in.
+                  If None, searches in current working directory.
+                  Example: "/workspace/src"
+
+            glob: Optional glob pattern to filter which FILES to search.
+                  Filters by filename/path, not content.
+                  Supports standard glob wildcards:
+                  - `*` matches any characters in filename
+                  - `**` matches any directories recursively
+                  - `?` matches single character
+                  - `[abc]` matches one character from set
+
+        Examples:
+                  - "*.py" - only search Python files
+                  - "**/*.txt" - search all .txt files recursively
+                  - "src/**/*.js" - search JS files under src/
+                  - "test[0-9].txt" - search test0.txt, test1.txt, etc.
+
+        Returns:
+            On success: list[GrepMatch] with structured results containing:
+                - path: Absolute file path
+                - line: Line number (1-indexed)
+                - text: Full line content containing the match
+
+            On error: str with error message (e.g., invalid path, permission denied)
+        """
+
+    async def agrep_raw(
+        self,
+        pattern: str,
+        path: str | None = None,
+        glob: str | None = None,
+    ) -> list["GrepMatch"] | str:
+        """Async version of grep_raw."""
+        return await asyncio.to_thread(self.grep_raw, pattern, path, glob)
 
     def glob_info(self, pattern: str, path: str = "/") -> list["FileInfo"]:
-        """Structured glob matching returning FileInfo dicts."""
-        ...
+        """Find files matching a glob pattern.
+
+        Args:
+            pattern: Glob pattern with wildcards to match file paths.
+                     Supports standard glob syntax:
+                     - `*` matches any characters within a filename/directory
+                     - `**` matches any directories recursively
+                     - `?` matches a single character
+                     - `[abc]` matches one character from set
+
+            path: Base directory to search from. Default: "/" (root).
+                  The pattern is applied relative to this path.
+
+        Returns:
+            list of FileInfo
+        """
+
+    async def aglob_info(self, pattern: str, path: str = "/") -> list["FileInfo"]:
+        """Async version of glob_info."""
+        return await asyncio.to_thread(self.glob_info, pattern, path)
 
     def write(
         self,
         file_path: str,
         content: str,
     ) -> WriteResult:
-        """Create a new file. Returns WriteResult; error populated on failure."""
-        ...
+        """Write content to a new file in the filesystem, error if file exists.
+
+        Args:
+            file_path: Absolute path where the file should be created.
+                       Must start with '/'.
+            content: String content to write to the file.
+
+        Returns:
+            WriteResult
+        """
+
+    async def awrite(
+        self,
+        file_path: str,
+        content: str,
+    ) -> WriteResult:
+        """Async version of write."""
+        return await asyncio.to_thread(self.write, file_path, content)
 
     def edit(
         self,
@@ -212,8 +329,30 @@ class BackendProtocol(Protocol):
         new_string: str,
         replace_all: bool = False,
     ) -> EditResult:
-        """Edit a file by replacing string occurrences. Returns EditResult."""
-        ...
+        """Perform exact string replacements in an existing file.
+
+        Args:
+            file_path: Absolute path to the file to edit. Must start with '/'.
+            old_string: Exact string to search for and replace.
+                       Must match exactly including whitespace and indentation.
+            new_string: String to replace old_string with.
+                       Must be different from old_string.
+            replace_all: If True, replace all occurrences. If False (default),
+                        old_string must be unique in the file or the edit fails.
+
+        Returns:
+            EditResult
+        """
+
+    async def aedit(
+        self,
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,
+    ) -> EditResult:
+        """Async version of edit."""
+        return await asyncio.to_thread(self.edit, file_path, old_string, new_string, replace_all)
 
     def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
         """Upload multiple files to the sandbox.
@@ -239,7 +378,10 @@ class BackendProtocol(Protocol):
             )
             ```
         """
-        ...
+
+    async def aupload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        """Async version of upload_files."""
+        return await asyncio.to_thread(self.upload_files, files)
 
     def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
         """Download multiple files from the sandbox.
@@ -255,7 +397,10 @@ class BackendProtocol(Protocol):
             Response order matches input order (response[i] for paths[i]).
             Check the error field to determine success/failure per file.
         """
-        ...
+
+    async def adownload_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Async version of download_files."""
+        return await asyncio.to_thread(self.download_files, paths)
 
 
 @dataclass
@@ -275,8 +420,7 @@ class ExecuteResponse:
     """Whether the output was truncated due to backend limitations."""
 
 
-@runtime_checkable
-class SandboxBackendProtocol(BackendProtocol, Protocol):
+class SandboxBackendProtocol(BackendProtocol):
     """Protocol for sandboxed backends with isolated runtime.
 
     Sandboxed backends run in isolated environments (e.g., separate processes,
@@ -297,12 +441,17 @@ class SandboxBackendProtocol(BackendProtocol, Protocol):
         Returns:
             ExecuteResponse with combined output, exit code, optional signal, and truncation flag.
         """
-        ...
+
+    async def aexecute(
+        self,
+        command: str,
+    ) -> ExecuteResponse:
+        """Async version of execute."""
+        return await asyncio.to_thread(self.execute, command)
 
     @property
     def id(self) -> str:
         """Unique identifier for the sandbox backend instance."""
-        ...
 
 
 BackendFactory: TypeAlias = Callable[[ToolRuntime], BackendProtocol]

{deepagents-0.2.8 → deepagents-0.3.0}/deepagents/backends/sandbox.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import base64
 import json
+import shlex
 from abc import ABC, abstractmethod
 
 from deepagents.backends.protocol import (
@@ -272,10 +273,10 @@ except PermissionError:
         glob: str | None = None,
     ) -> list[GrepMatch] | str:
         """Structured search results or error string for invalid input."""
-        search_path = path or "."
+        search_path = shlex.quote(path or ".")
 
         # Build grep command to get structured output
-        grep_opts = "-rHn"  # recursive, with filename, with line number
+        grep_opts = "-rHnF"  # recursive, with filename, with line number, fixed-strings (literal)
 
         # Add glob pattern if specified
         glob_pattern = ""
@@ -283,9 +284,9 @@ except PermissionError:
             glob_pattern = f"--include='{glob}'"
 
         # Escape pattern for shell
-        pattern_escaped = pattern.replace("'", "'\\\\''")
+        pattern_escaped = shlex.quote(pattern)
 
-        cmd = f"grep {grep_opts} {glob_pattern} -e '{pattern_escaped}' '{search_path}' 2>/dev/null || true"
+        cmd = f"grep {grep_opts} {glob_pattern} -e {pattern_escaped} {search_path} 2>/dev/null || true"
         result = self.execute(cmd)
 
         output = result.output.rstrip()

{deepagents-0.2.8 → deepagents-0.3.0}/deepagents/backends/state.py

@@ -99,9 +99,11 @@ class StateBackend(BackendProtocol):
         """Read file content with line numbers.
 
         Args:
-            file_path: Absolute file path
-            offset: Line offset to start reading from (0-indexed)
-            limit: Maximum number of lines to readReturns:
+            file_path: Absolute file path.
+            offset: Line offset to start reading from (0-indexed).
+            limit: Maximum number of lines to read.
+
+        Returns:
             Formatted file content with line numbers, or error message.
         """
         files = self.runtime.state.get("files", {})

{deepagents-0.2.8 → deepagents-0.3.0}/deepagents/backends/store.py

@@ -38,17 +38,18 @@ class StoreBackend(BackendProtocol):
         """Initialize StoreBackend with runtime.
 
         Args:
+            runtime: The ToolRuntime instance providing store access and configuration.
         """
         self.runtime = runtime
 
     def _get_store(self) -> BaseStore:
         """Get the store instance.
 
-        Args:Returns:
-            BaseStore instance
+        Returns:
+            BaseStore instance from the runtime.
 
         Raises:
-            ValueError: If no store is available or runtime not provided
+            ValueError: If no store is available in the runtime.
         """
         store = self.runtime.store
         if store is None:
@@ -257,8 +258,9 @@ class StoreBackend(BackendProtocol):
         """Read file content with line numbers.
 
         Args:
-            file_path: Absolute file path
-            offset: Line offset to start reading from (0-indexed)limit: Maximum number of lines to read
+            file_path: Absolute file path.
+            offset: Line offset to start reading from (0-indexed).
+            limit: Maximum number of lines to read.
 
         Returns:
             Formatted file content with line numbers, or error message.

{deepagents-0.2.8 → deepagents-0.3.0}/deepagents/graph.py

@@ -98,6 +98,18 @@ def create_deep_agent(
     if model is None:
         model = get_default_model()
 
+    if (
+        model.profile is not None
+        and isinstance(model.profile, dict)
+        and "max_input_tokens" in model.profile
+        and isinstance(model.profile["max_input_tokens"], int)
+    ):
+        trigger = ("fraction", 0.85)
+        keep = ("fraction", 0.10)
+    else:
+        trigger = ("tokens", 170000)
+        keep = ("messages", 6)
+
     deepagent_middleware = [
         TodoListMiddleware(),
         FilesystemMiddleware(backend=backend),
@@ -110,8 +122,9 @@ def create_deep_agent(
                 FilesystemMiddleware(backend=backend),
                 SummarizationMiddleware(
                     model=model,
-                    max_tokens_before_summary=170000,
-                    messages_to_keep=6,
+                    trigger=trigger,
+                    keep=keep,
+                    trim_tokens_to_summarize=None,
                 ),
                 AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
                 PatchToolCallsMiddleware(),
@@ -121,8 +134,9 @@ def create_deep_agent(
         ),
         SummarizationMiddleware(
             model=model,
-            max_tokens_before_summary=170000,
-            messages_to_keep=6,
+            trigger=trigger,
+            keep=keep,
+            trim_tokens_to_summarize=None,
         ),
         AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
         PatchToolCallsMiddleware(),

{deepagents-0.2.8 → deepagents-0.3.0}/deepagents/middleware/filesystem.py

@@ -15,7 +15,7 @@ from langchain.agents.middleware.types import (
 from langchain.tools import ToolRuntime
 from langchain.tools.tool_node import ToolCallRequest
 from langchain_core.messages import ToolMessage
-from langchain_core.tools import BaseTool, tool
+from langchain_core.tools import BaseTool, StructuredTool
 from langgraph.types import Command
 from typing_extensions import TypedDict
 
@@ -325,8 +325,8 @@ def _ls_tool_generator(
     """
     tool_description = custom_description or LIST_FILES_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def ls(runtime: ToolRuntime[None, FilesystemState], path: str) -> str:
+    def sync_ls(runtime: ToolRuntime[None, FilesystemState], path: str) -> str:
+        """Synchronous wrapper for ls tool."""
         resolved_backend = _get_backend(backend, runtime)
         validated_path = _validate_path(path)
         infos = resolved_backend.ls_info(validated_path)
@@ -334,7 +334,21 @@ def _ls_tool_generator(
         result = truncate_if_too_long(paths)
         return str(result)
 
-    return ls
+    async def async_ls(runtime: ToolRuntime[None, FilesystemState], path: str) -> str:
+        """Asynchronous wrapper for ls tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        validated_path = _validate_path(path)
+        infos = await resolved_backend.als_info(validated_path)
+        paths = [fi.get("path", "") for fi in infos]
+        result = truncate_if_too_long(paths)
+        return str(result)
+
+    return StructuredTool.from_function(
+        name="ls",
+        description=tool_description,
+        func=sync_ls,
+        coroutine=async_ls,
+    )
 
 
 def _read_file_tool_generator(
@@ -352,18 +366,34 @@ def _read_file_tool_generator(
     """
     tool_description = custom_description or READ_FILE_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def read_file(
+    def sync_read_file(
         file_path: str,
         runtime: ToolRuntime[None, FilesystemState],
         offset: int = DEFAULT_READ_OFFSET,
         limit: int = DEFAULT_READ_LIMIT,
     ) -> str:
+        """Synchronous wrapper for read_file tool."""
         resolved_backend = _get_backend(backend, runtime)
         file_path = _validate_path(file_path)
         return resolved_backend.read(file_path, offset=offset, limit=limit)
 
-    return read_file
+    async def async_read_file(
+        file_path: str,
+        runtime: ToolRuntime[None, FilesystemState],
+        offset: int = DEFAULT_READ_OFFSET,
+        limit: int = DEFAULT_READ_LIMIT,
+    ) -> str:
+        """Asynchronous wrapper for read_file tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        file_path = _validate_path(file_path)
+        return await resolved_backend.aread(file_path, offset=offset, limit=limit)
+
+    return StructuredTool.from_function(
+        name="read_file",
+        description=tool_description,
+        func=sync_read_file,
+        coroutine=async_read_file,
+    )
 
 
 def _write_file_tool_generator(
@@ -381,12 +411,12 @@ def _write_file_tool_generator(
     """
     tool_description = custom_description or WRITE_FILE_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def write_file(
+    def sync_write_file(
         file_path: str,
         content: str,
         runtime: ToolRuntime[None, FilesystemState],
     ) -> Command | str:
+        """Synchronous wrapper for write_file tool."""
         resolved_backend = _get_backend(backend, runtime)
         file_path = _validate_path(file_path)
         res: WriteResult = resolved_backend.write(file_path, content)
@@ -407,7 +437,38 @@ def _write_file_tool_generator(
             )
         return f"Updated file {res.path}"
 
-    return write_file
+    async def async_write_file(
+        file_path: str,
+        content: str,
+        runtime: ToolRuntime[None, FilesystemState],
+    ) -> Command | str:
+        """Asynchronous wrapper for write_file tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        file_path = _validate_path(file_path)
+        res: WriteResult = await resolved_backend.awrite(file_path, content)
+        if res.error:
+            return res.error
+        # If backend returns state update, wrap into Command with ToolMessage
+        if res.files_update is not None:
+            return Command(
+                update={
+                    "files": res.files_update,
+                    "messages": [
+                        ToolMessage(
+                            content=f"Updated file {res.path}",
+                            tool_call_id=runtime.tool_call_id,
+                        )
+                    ],
+                }
+            )
+        return f"Updated file {res.path}"
+
+    return StructuredTool.from_function(
+        name="write_file",
+        description=tool_description,
+        func=sync_write_file,
+        coroutine=async_write_file,
+    )
 
 
 def _edit_file_tool_generator(
@@ -425,8 +486,7 @@ def _edit_file_tool_generator(
     """
     tool_description = custom_description or EDIT_FILE_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def edit_file(
+    def sync_edit_file(
         file_path: str,
         old_string: str,
         new_string: str,
@@ -434,6 +494,7 @@ def _edit_file_tool_generator(
         *,
         replace_all: bool = False,
     ) -> Command | str:
+        """Synchronous wrapper for edit_file tool."""
         resolved_backend = _get_backend(backend, runtime)
         file_path = _validate_path(file_path)
         res: EditResult = resolved_backend.edit(file_path, old_string, new_string, replace_all=replace_all)
@@ -453,7 +514,40 @@ def _edit_file_tool_generator(
             )
         return f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'"
 
-    return edit_file
+    async def async_edit_file(
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        runtime: ToolRuntime[None, FilesystemState],
+        *,
+        replace_all: bool = False,
+    ) -> Command | str:
+        """Asynchronous wrapper for edit_file tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        file_path = _validate_path(file_path)
+        res: EditResult = await resolved_backend.aedit(file_path, old_string, new_string, replace_all=replace_all)
+        if res.error:
+            return res.error
+        if res.files_update is not None:
+            return Command(
+                update={
+                    "files": res.files_update,
+                    "messages": [
+                        ToolMessage(
+                            content=f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'",
+                            tool_call_id=runtime.tool_call_id,
+                        )
+                    ],
+                }
+            )
+        return f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'"
+
+    return StructuredTool.from_function(
+        name="edit_file",
+        description=tool_description,
+        func=sync_edit_file,
+        coroutine=async_edit_file,
+    )
 
 
 def _glob_tool_generator(
@@ -471,15 +565,28 @@ def _glob_tool_generator(
     """
     tool_description = custom_description or GLOB_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def glob(pattern: str, runtime: ToolRuntime[None, FilesystemState], path: str = "/") -> str:
+    def sync_glob(pattern: str, runtime: ToolRuntime[None, FilesystemState], path: str = "/") -> str:
+        """Synchronous wrapper for glob tool."""
         resolved_backend = _get_backend(backend, runtime)
         infos = resolved_backend.glob_info(pattern, path=path)
         paths = [fi.get("path", "") for fi in infos]
         result = truncate_if_too_long(paths)
         return str(result)
 
-    return glob
+    async def async_glob(pattern: str, runtime: ToolRuntime[None, FilesystemState], path: str = "/") -> str:
+        """Asynchronous wrapper for glob tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        infos = await resolved_backend.aglob_info(pattern, path=path)
+        paths = [fi.get("path", "") for fi in infos]
+        result = truncate_if_too_long(paths)
+        return str(result)
+
+    return StructuredTool.from_function(
+        name="glob",
+        description=tool_description,
+        func=sync_glob,
+        coroutine=async_glob,
+    )
 
 
 def _grep_tool_generator(
@@ -497,14 +604,14 @@ def _grep_tool_generator(
     """
     tool_description = custom_description or GREP_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def grep(
+    def sync_grep(
         pattern: str,
         runtime: ToolRuntime[None, FilesystemState],
         path: str | None = None,
         glob: str | None = None,
         output_mode: Literal["files_with_matches", "content", "count"] = "files_with_matches",
     ) -> str:
+        """Synchronous wrapper for grep tool."""
         resolved_backend = _get_backend(backend, runtime)
         raw = resolved_backend.grep_raw(pattern, path=path, glob=glob)
         if isinstance(raw, str):
@@ -512,7 +619,27 @@ def _grep_tool_generator(
         formatted = format_grep_matches(raw, output_mode)
         return truncate_if_too_long(formatted)  # type: ignore[arg-type]
 
-    return grep
+    async def async_grep(
+        pattern: str,
+        runtime: ToolRuntime[None, FilesystemState],
+        path: str | None = None,
+        glob: str | None = None,
+        output_mode: Literal["files_with_matches", "content", "count"] = "files_with_matches",
+    ) -> str:
+        """Asynchronous wrapper for grep tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        raw = await resolved_backend.agrep_raw(pattern, path=path, glob=glob)
+        if isinstance(raw, str):
+            return raw
+        formatted = format_grep_matches(raw, output_mode)
+        return truncate_if_too_long(formatted)  # type: ignore[arg-type]
+
+    return StructuredTool.from_function(
+        name="grep",
+        description=tool_description,
+        func=sync_grep,
+        coroutine=async_grep,
+    )
 
 
 def _supports_execution(backend: BackendProtocol) -> bool:
@@ -553,11 +680,11 @@ def _execute_tool_generator(
     """
     tool_description = custom_description or EXECUTE_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def execute(
+    def sync_execute(
         command: str,
         runtime: ToolRuntime[None, FilesystemState],
     ) -> str:
+        """Synchronous wrapper for execute tool."""
         resolved_backend = _get_backend(backend, runtime)
 
         # Runtime check - fail gracefully if not supported
@@ -586,7 +713,45 @@ def _execute_tool_generator(
 
         return "".join(parts)
 
-    return execute
+    async def async_execute(
+        command: str,
+        runtime: ToolRuntime[None, FilesystemState],
+    ) -> str:
+        """Asynchronous wrapper for execute tool."""
+        resolved_backend = _get_backend(backend, runtime)
+
+        # Runtime check - fail gracefully if not supported
+        if not _supports_execution(resolved_backend):
+            return (
+                "Error: Execution not available. This agent's backend "
+                "does not support command execution (SandboxBackendProtocol). "
+                "To use the execute tool, provide a backend that implements SandboxBackendProtocol."
+            )
+
+        try:
+            result = await resolved_backend.aexecute(command)
+        except NotImplementedError as e:
+            # Handle case where execute() exists but raises NotImplementedError
+            return f"Error: Execution not available. {e}"
+
+        # Format output for LLM consumption
+        parts = [result.output]
+
+        if result.exit_code is not None:
+            status = "succeeded" if result.exit_code == 0 else "failed"
+            parts.append(f"\n[Command {status} with exit code {result.exit_code}]")
+
+        if result.truncated:
+            parts.append("\n[Output was truncated due to size limits]")
+
+        return "".join(parts)
+
+    return StructuredTool.from_function(
+        name="execute",
+        description=tool_description,
+        func=sync_execute,
+        coroutine=async_execute,
+    )
 
 
 TOOL_GENERATORS = {

{deepagents-0.2.8 → deepagents-0.3.0}/deepagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.8
+Version: 0.3.0
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
@@ -11,9 +11,9 @@ Project-URL: Slack, https://www.langchain.com/join-community
 Project-URL: Reddit, https://www.reddit.com/r/LangChain/
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: langchain-anthropic<2.0.0,>=1.0.0
-Requires-Dist: langchain<2.0.0,>=1.0.2
-Requires-Dist: langchain-core<2.0.0,>=1.0.0
+Requires-Dist: langchain-anthropic<2.0.0,>=1.2.0
+Requires-Dist: langchain<2.0.0,>=1.1.0
+Requires-Dist: langchain-core<2.0.0,>=1.1.0
 Requires-Dist: wcmatch
 
 # 🧠🤖Deep Agents

deepagents-0.3.0/deepagents.egg-info/requires.txt

@@ -0,0 +1,4 @@
+langchain-anthropic<2.0.0,>=1.2.0
+langchain<2.0.0,>=1.1.0
+langchain-core<2.0.0,>=1.1.0
+wcmatch

{deepagents-0.2.8 → deepagents-0.3.0}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "deepagents"
-version = "0.2.8"
+version = "0.3.0"
 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" }
 requires-python = ">=3.11,<4.0"
 dependencies = [
-    "langchain-anthropic>=1.0.0,<2.0.0",
-    "langchain>=1.0.2,<2.0.0",
-    "langchain-core>=1.0.0,<2.0.0",
+    "langchain-anthropic>=1.2.0,<2.0.0",
+    "langchain>=1.1.0,<2.0.0",
+    "langchain-core>=1.1.0,<2.0.0",
     "wcmatch",
 ]
 
@@ -29,6 +29,7 @@ test = [
   "pytest-xdist",
   "ruff>=0.12.2,<0.13.0",
   "mypy>=1.18.1,<1.19.0",
+  "pytest-asyncio>=1.3.0",
 ]
 
 dev = [
@@ -93,3 +94,6 @@ enable_error_code = ["deprecated"]
 # Optional: reduce strictness if needed
 disallow_any_generics = false
 warn_return_any = false
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

deepagents-0.2.8/deepagents.egg-info/requires.txt

@@ -1,4 +0,0 @@
-langchain-anthropic<2.0.0,>=1.0.0
-langchain<2.0.0,>=1.0.2
-langchain-core<2.0.0,>=1.0.0
-wcmatch