deepagents 0.2.0__tar.gz → 0.2.1rc2__tar.gz

{deepagents-0.2.0/src/deepagents.egg-info → deepagents-0.2.1rc2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.0
+Version: 0.2.1rc2
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: langchain-anthropic<2.0.0,>=1.0.0
-Requires-Dist: langchain<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: wcmatch
 Provides-Extra: dev

{deepagents-0.2.0 → deepagents-0.2.1rc2}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "deepagents"
-version = "0.2.0"
+version = "0.2.1rc2"
 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.0,<2.0.0",
+    "langchain>=1.0.2,<2.0.0",
     "langchain-core>=1.0.0,<2.0.0",
     "wcmatch"
 ]

{deepagents-0.2.0 → deepagents-0.2.1rc2}/src/deepagents/backends/composite.py

@@ -1,13 +1,10 @@
 """CompositeBackend: Route operations to different backends based on path prefix."""
 
-from typing import Any, Literal, Optional, TYPE_CHECKING
+from typing import Optional
 
-from langchain.tools import ToolRuntime
-
-from deepagents.backends.protocol import BackendProtocol, BackendFactory, WriteResult, EditResult
+from deepagents.backends.protocol import BackendProtocol, WriteResult, EditResult
 from deepagents.backends.state import StateBackend
 from deepagents.backends.utils import FileInfo, GrepMatch
-from deepagents.backends.protocol import BackendFactory
 
 
 class CompositeBackend:
@@ -48,13 +45,14 @@ class CompositeBackend:
         return self.default, key
     
     def ls_info(self, path: str) -> list[FileInfo]:
-        """List files from backends, with appropriate prefixes.
-        
+        """List files and directories in the specified directory (non-recursive).
+
         Args:
             path: Absolute path to directory.
-        
+
         Returns:
-            List of FileInfo-like dicts with route prefixes added.
+            List of FileInfo-like dicts with route prefixes added, for files and directories directly in the directory.
+            Directories have a trailing / in their path and is_dir=True.
         """
         # Check if path matches a specific route
         for route_prefix, backend in self.sorted_routes:
@@ -75,11 +73,14 @@ class CompositeBackend:
             results: list[FileInfo] = []
             results.extend(self.default.ls_info(path))
             for route_prefix, backend in self.sorted_routes:
-                infos = backend.ls_info("/")
-                for fi in infos:
-                    fi = dict(fi)
-                    fi["path"] = f"{route_prefix[:-1]}{fi['path']}"
-                    results.append(fi)
+                # 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
 

{deepagents-0.2.0 → deepagents-0.2.1rc2}/src/deepagents/backends/filesystem.py

@@ -13,16 +13,12 @@ import json
 import subprocess
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Optional, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from langchain.tools import ToolRuntime
+from typing import Optional
 
 from .utils import (
     check_empty_content,
     format_content_with_line_numbers,
     perform_string_replacement,
-    truncate_if_too_long,
 )
 import wcmatch.glob as wcglob
 from deepagents.backends.utils import FileInfo, GrepMatch
@@ -51,7 +47,7 @@ class FilesystemBackend:
                      all file paths will be resolved relative to this directory.
                      If not provided, uses the current working directory.
         """
-        self.cwd = Path(root_dir) if root_dir else Path.cwd()
+        self.cwd = Path(root_dir).resolve() if root_dir else Path.cwd()
         self.virtual_mode = virtual_mode
         self.max_file_size_bytes = max_file_size_mb * 1024 * 1024
 
@@ -77,7 +73,7 @@ class FilesystemBackend:
             try:
                 full.relative_to(self.cwd)
             except ValueError:
-                raise ValueError(f"Path outside root directory: {key}") from None
+                raise ValueError(f"Path:{full} outside root directory: {self.cwd}") from None
             return full
 
         path = Path(key)
@@ -86,13 +82,14 @@ class FilesystemBackend:
         return (self.cwd / path).resolve()
 
     def ls_info(self, path: str) -> list[FileInfo]:
-        """List files from filesystem.
+        """List files and directories in the specified directory (non-recursive).
 
         Args:
             path: Absolute directory path to list files from.
-        
+
         Returns:
-            List of FileInfo-like dicts.
+            List of FileInfo-like dicts for files and directories directly in the directory.
+            Directories have a trailing / in their path and is_dir=True.
         """
         dir_path = self._resolve_path(path)
         if not dir_path.exists() or not dir_path.is_dir():
@@ -105,18 +102,22 @@ class FilesystemBackend:
         if not cwd_str.endswith("/"):
             cwd_str += "/"
 
-        # Walk the directory tree
+        # List only direct children (non-recursive)
         try:
-            for path in dir_path.rglob("*"):
+            for child_path in dir_path.iterdir():
                 try:
-                    is_file = path.is_file()
+                    is_file = child_path.is_file()
+                    is_dir = child_path.is_dir()
                 except OSError:
                     continue
-                if is_file:
-                    abs_path = str(path)
-                    if not self.virtual_mode:
+
+                abs_path = str(child_path)
+
+                if not self.virtual_mode:
+                    # Non-virtual mode: use absolute paths
+                    if is_file:
                         try:
-                            st = path.stat()
+                            st = child_path.stat()
                             results.append({
                                 "path": abs_path,
                                 "is_dir": False,
@@ -125,8 +126,19 @@ class FilesystemBackend:
                             })
                         except OSError:
                             results.append({"path": abs_path, "is_dir": False})
-                        continue
-                    # Strip the cwd prefix if present
+                    elif is_dir:
+                        try:
+                            st = child_path.stat()
+                            results.append({
+                                "path": abs_path + "/",
+                                "is_dir": True,
+                                "size": 0,
+                                "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                            })
+                        except OSError:
+                            results.append({"path": abs_path + "/", "is_dir": True})
+                else:
+                    # Virtual mode: strip cwd prefix
                     if abs_path.startswith(cwd_str):
                         relative_path = abs_path[len(cwd_str):]
                     elif abs_path.startswith(str(self.cwd)):
@@ -137,16 +149,29 @@ class FilesystemBackend:
                         relative_path = abs_path
 
                     virt_path = "/" + relative_path
-                    try:
-                        st = path.stat()
-                        results.append({
-                            "path": virt_path,
-                            "is_dir": False,
-                            "size": int(st.st_size),
-                            "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
-                        })
-                    except OSError:
-                        results.append({"path": virt_path, "is_dir": False})
+
+                    if is_file:
+                        try:
+                            st = child_path.stat()
+                            results.append({
+                                "path": virt_path,
+                                "is_dir": False,
+                                "size": int(st.st_size),
+                                "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                            })
+                        except OSError:
+                            results.append({"path": virt_path, "is_dir": False})
+                    elif is_dir:
+                        try:
+                            st = child_path.stat()
+                            results.append({
+                                "path": virt_path + "/",
+                                "is_dir": True,
+                                "size": 0,
+                                "modified_at": datetime.fromtimestamp(st.st_mtime).isoformat(),
+                            })
+                        except OSError:
+                            results.append({"path": virt_path + "/", "is_dir": True})
         except (OSError, PermissionError):
             pass
 

{deepagents-0.2.0 → deepagents-0.2.1rc2}/src/deepagents/backends/state.py

@@ -40,19 +40,38 @@ class StateBackend:
         self.runtime = runtime
     
     def ls_info(self, path: str) -> list[FileInfo]:
-        """List files from state.
-        
+        """List files and directories in the specified directory (non-recursive).
+
         Args:
             path: Absolute path to directory.
-        
+
         Returns:
-            List of FileInfo-like dicts.
+            List of FileInfo-like dicts for files and directories directly in the directory.
+            Directories have a trailing / in their path and is_dir=True.
         """
         files = self.runtime.state.get("files", {})
         infos: list[FileInfo] = []
+        subdirs: set[str] = set()
+
+        # Normalize path to have trailing slash for proper prefix matching
+        normalized_path = path if path.endswith("/") else path + "/"
+
         for k, fd in files.items():
-            if not k.startswith(path):
+            # Check if file is in the specified directory or a subdirectory
+            if not k.startswith(normalized_path):
+                continue
+
+            # Get the relative path after the directory
+            relative = k[len(normalized_path):]
+
+            # If relative path contains '/', it's in a subdirectory
+            if "/" in relative:
+                # Extract the immediate subdirectory name
+                subdir_name = relative.split("/")[0]
+                subdirs.add(normalized_path + subdir_name + "/")
                 continue
+
+            # This is a file directly in the current directory
             size = len("\n".join(fd.get("content", [])))
             infos.append({
                 "path": k,
@@ -60,6 +79,16 @@ class StateBackend:
                 "size": int(size),
                 "modified_at": fd.get("modified_at", ""),
             })
+
+        # Add directories to the results
+        for subdir in sorted(subdirs):
+            infos.append({
+                "path": subdir,
+                "is_dir": True,
+                "size": 0,
+                "modified_at": "",
+            })
+
         infos.sort(key=lambda x: x.get("path", ""))
         return infos
 

{deepagents-0.2.0 → deepagents-0.2.1rc2}/src/deepagents/backends/store.py

@@ -179,24 +179,43 @@ class StoreBackend:
         return all_items
     
     def ls_info(self, path: str) -> list[FileInfo]:
-        """List files from store.
-        
+        """List files and directories in the specified directory (non-recursive).
+
         Args:
             path: Absolute path to directory.
-        
+
         Returns:
-            List of FileInfo-like dicts.
+            List of FileInfo-like dicts for files and directories directly in the directory.
+            Directories have a trailing / in their path and is_dir=True.
         """
         store = self._get_store()
         namespace = self._get_namespace()
-        
+
         # Retrieve all items and filter by path prefix locally to avoid
         # coupling to store-specific filter semantics
         items = self._search_store_paginated(store, namespace)
         infos: list[FileInfo] = []
+        subdirs: set[str] = set()
+
+        # Normalize path to have trailing slash for proper prefix matching
+        normalized_path = path if path.endswith("/") else path + "/"
+
         for item in items:
-            if not str(item.key).startswith(path):
+            # Check if file is in the specified directory or a subdirectory
+            if not str(item.key).startswith(normalized_path):
                 continue
+
+            # Get the relative path after the directory
+            relative = str(item.key)[len(normalized_path):]
+
+            # If relative path contains '/', it's in a subdirectory
+            if "/" in relative:
+                # Extract the immediate subdirectory name
+                subdir_name = relative.split("/")[0]
+                subdirs.add(normalized_path + subdir_name + "/")
+                continue
+
+            # This is a file directly in the current directory
             try:
                 fd = self._convert_store_item_to_file_data(item)
             except ValueError:
@@ -208,6 +227,16 @@ class StoreBackend:
                 "size": int(size),
                 "modified_at": fd.get("modified_at", ""),
             })
+
+        # Add directories to the results
+        for subdir in sorted(subdirs):
+            infos.append({
+                "path": subdir,
+                "is_dir": True,
+                "size": 0,
+                "modified_at": "",
+            })
+
         infos.sort(key=lambda x: x.get("path", ""))
         return infos
 

{deepagents-0.2.0 → deepagents-0.2.1rc2}/src/deepagents/backends/utils.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from typing import Any, Literal, TypedDict, List, Dict
 
 EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents"
-MAX_LINE_LENGTH = 2000
+MAX_LINE_LENGTH = 10000
 LINE_NUMBER_WIDTH = 6
 TOOL_RESULT_TOKEN_LIMIT = 20000  # Same threshold as eviction
 TRUNCATION_GUIDANCE = "... [results truncated, try being more specific with your parameters]"
@@ -37,18 +37,29 @@ class GrepMatch(TypedDict):
     text: str
 
 
+def sanitize_tool_call_id(tool_call_id: str) -> str:
+    """Sanitize tool_call_id to prevent path traversal and separator issues. 
+    
+    Replaces dangerous characters (., /, \) with underscores.
+    """
+    sanitized = tool_call_id.replace(".", "_").replace("/", "_").replace("\\", "_")
+    return sanitized
+
+
 def format_content_with_line_numbers(
     content: str | list[str],
     start_line: int = 1,
 ) -> str:
     """Format file content with line numbers (cat -n style).
-    
+
+    Chunks lines longer than MAX_LINE_LENGTH with continuation markers (e.g., 5.1, 5.2).
+
     Args:
         content: File content as string or list of lines
         start_line: Starting line number (default: 1)
-    
+
     Returns:
-        Formatted content with line numbers
+        Formatted content with line numbers and continuation markers
     """
     if isinstance(content, str):
         lines = content.split("\n")
@@ -56,11 +67,29 @@ def format_content_with_line_numbers(
             lines = lines[:-1]
     else:
         lines = content
-    
-    return "\n".join(
-        f"{i + start_line:{LINE_NUMBER_WIDTH}d}\t{line[:MAX_LINE_LENGTH]}" 
-        for i, line in enumerate(lines)
-    )
+
+    result_lines = []
+    for i, line in enumerate(lines):
+        line_num = i + start_line
+
+        if len(line) <= MAX_LINE_LENGTH:
+            result_lines.append(f"{line_num:{LINE_NUMBER_WIDTH}d}\t{line}")
+        else:
+            # Split long line into chunks with continuation markers
+            num_chunks = (len(line) + MAX_LINE_LENGTH - 1) // MAX_LINE_LENGTH
+            for chunk_idx in range(num_chunks):
+                start = chunk_idx * MAX_LINE_LENGTH
+                end = min(start + MAX_LINE_LENGTH, len(line))
+                chunk = line[start:end]
+                if chunk_idx == 0:
+                    # First chunk: use normal line number
+                    result_lines.append(f"{line_num:{LINE_NUMBER_WIDTH}d}\t{chunk}")
+                else:
+                    # Continuation chunks: use decimal notation (e.g., 5.1, 5.2)
+                    continuation_marker = f"{line_num}.{chunk_idx}"
+                    result_lines.append(f"{continuation_marker:>{LINE_NUMBER_WIDTH}}\t{chunk}")
+
+    return "\n".join(result_lines)
 
 
 def check_empty_content(content: str) -> str | None:
@@ -91,18 +120,17 @@ def file_data_to_string(file_data: dict[str, Any]) -> str:
 
 def create_file_data(content: str, created_at: str | None = None) -> dict[str, Any]:
     """Create a FileData object with timestamps.
-    
+
     Args:
         content: File content as string
         created_at: Optional creation timestamp (ISO format)
-    
+
     Returns:
         FileData dict with content and timestamps
     """
     lines = content.split("\n") if isinstance(content, str) else content
-    lines = [line[i:i+MAX_LINE_LENGTH] for line in lines for i in range(0, len(line) or 1, MAX_LINE_LENGTH)]
     now = datetime.now(UTC).isoformat()
-    
+
     return {
         "content": lines,
         "created_at": created_at or now,
@@ -112,18 +140,17 @@ def create_file_data(content: str, created_at: str | None = None) -> dict[str, A
 
 def update_file_data(file_data: dict[str, Any], content: str) -> dict[str, Any]:
     """Update FileData with new content, preserving creation timestamp.
-    
+
     Args:
         file_data: Existing FileData dict
         content: New content as string
-    
+
     Returns:
         Updated FileData dict
     """
     lines = content.split("\n") if isinstance(content, str) else content
-    lines = [line[i:i+MAX_LINE_LENGTH] for line in lines for i in range(0, len(line) or 1, MAX_LINE_LENGTH)]
     now = datetime.now(UTC).isoformat()
-    
+
     return {
         "content": lines,
         "created_at": file_data["created_at"],

{deepagents-0.2.0 → deepagents-0.2.1rc2}/src/deepagents/middleware/filesystem.py

@@ -24,11 +24,11 @@ from typing_extensions import TypedDict
 from deepagents.backends.protocol import BackendProtocol, BackendFactory, WriteResult, EditResult
 from deepagents.backends import StateBackend
 from deepagents.backends.utils import (
-    create_file_data,
     update_file_data,
     format_content_with_line_numbers,
     format_grep_matches,
     truncate_if_too_long,
+    sanitize_tool_call_id,
 )
 
 EMPTY_CONTENT_WARNING = "System reminder: File exists but has empty contents"
@@ -227,6 +227,15 @@ All file paths must start with a /.
 
 
 def _get_backend(backend: BACKEND_TYPES, runtime: ToolRuntime) -> BackendProtocol:
+    """Get the resolved backend instance from backend or factory.
+
+    Args:
+        backend: Backend instance or factory function.
+        runtime: The tool runtime context.
+
+    Returns:
+        Resolved backend instance.
+    """
     if callable(backend):
         return backend(runtime)
     return backend
@@ -532,6 +541,19 @@ class FilesystemMiddleware(AgentMiddleware):
 
         self.tools = _get_filesystem_tools(self.backend, custom_tool_descriptions)
 
+    def _get_backend(self, runtime: ToolRuntime) -> BackendProtocol:
+        """Get the resolved backend instance from backend or factory.
+
+        Args:
+            runtime: The tool runtime context.
+
+        Returns:
+            Resolved backend instance.
+        """
+        if callable(self.backend):
+            return self.backend(runtime)
+        return self.backend
+
     def wrap_model_call(
         self,
         request: ModelRequest,
@@ -568,54 +590,70 @@ class FilesystemMiddleware(AgentMiddleware):
             request.system_prompt = request.system_prompt + "\n\n" + self.system_prompt if request.system_prompt else self.system_prompt
         return await handler(request)
 
-    def _intercept_large_tool_result(self, tool_result: ToolMessage | Command) -> ToolMessage | Command:
+    def _process_large_message(
+        self,
+        message: ToolMessage,
+        resolved_backend: BackendProtocol,
+    ) -> tuple[ToolMessage, dict[str, FileData] | None]:
+        content = message.content
+        if not isinstance(content, str) or len(content) <= 4 * self.tool_token_limit_before_evict:
+            return message, None
+
+        sanitized_id = sanitize_tool_call_id(message.tool_call_id)
+        file_path = f"/large_tool_results/{sanitized_id}"
+        result = resolved_backend.write(file_path, content)
+        if result.error:
+            return message, None
+        content_sample = format_content_with_line_numbers(content.splitlines()[:10], start_line=1)
+        processed_message = ToolMessage(
+            TOO_LARGE_TOOL_MSG.format(
+                tool_call_id=message.tool_call_id,
+                file_path=file_path,
+                content_sample=content_sample,
+            ),
+            tool_call_id=message.tool_call_id,
+        )
+        return processed_message, result.files_update
+
+    def _intercept_large_tool_result(self, tool_result: ToolMessage | Command, runtime: ToolRuntime) -> ToolMessage | Command:
         if isinstance(tool_result, ToolMessage) and isinstance(tool_result.content, str):
-            content = tool_result.content
-            if self.tool_token_limit_before_evict and len(content) > 4 * self.tool_token_limit_before_evict:
-                file_path = f"/large_tool_results/{tool_result.tool_call_id}"
-                file_data = create_file_data(content)
-                state_update = {
-                    "messages": [
-                        ToolMessage(
-                            TOO_LARGE_TOOL_MSG.format(
-                                tool_call_id=tool_result.tool_call_id,
-                                file_path=file_path,
-                                content_sample=format_content_with_line_numbers(file_data["content"][:10], start_line=1),
-                            ),
-                            tool_call_id=tool_result.tool_call_id,
-                        )
-                    ],
-                    "files": {file_path: file_data},
-                }
-                return Command(update=state_update)
+            if not (self.tool_token_limit_before_evict and
+                    len(tool_result.content) > 4 * self.tool_token_limit_before_evict):
+                return tool_result
+            resolved_backend = self._get_backend(runtime)
+            processed_message, files_update = self._process_large_message(
+                tool_result,
+                resolved_backend,
+            )
+            return (Command(update={
+                "files": files_update,
+                "messages": [processed_message],
+            }) if files_update is not None else processed_message)
+
         elif isinstance(tool_result, Command):
             update = tool_result.update
             if update is None:
                 return tool_result
-            message_updates = update.get("messages", [])
-            file_updates = update.get("files", {})
-
-            edited_message_updates = []
-            for message in message_updates:
-                if self.tool_token_limit_before_evict and isinstance(message, ToolMessage) and isinstance(message.content, str):
-                    content = message.content
-                    if len(content) > 4 * self.tool_token_limit_before_evict:
-                        file_path = f"/large_tool_results/{message.tool_call_id}"
-                        file_data = create_file_data(content)
-                        edited_message_updates.append(
-                            ToolMessage(
-                                TOO_LARGE_TOOL_MSG.format(
-                                    tool_call_id=message.tool_call_id,
-                                    file_path=file_path,
-                                    content_sample=format_content_with_line_numbers(file_data["content"][:10], start_line=1),
-                                ),
-                                tool_call_id=message.tool_call_id,
-                            )
-                        )
-                        file_updates[file_path] = file_data
-                        continue
-                edited_message_updates.append(message)
-            return Command(update={**update, "messages": edited_message_updates, "files": file_updates})
+            command_messages = update.get("messages", [])
+            accumulated_file_updates = dict(update.get("files", {}))
+            resolved_backend = self._get_backend(runtime)
+            processed_messages = []
+            for message in command_messages:
+                if not (self.tool_token_limit_before_evict and
+                        isinstance(message, ToolMessage) and
+                        isinstance(message.content, str) and
+                        len(message.content) > 4 * self.tool_token_limit_before_evict):
+                    processed_messages.append(message)
+                    continue
+                processed_message, files_update = self._process_large_message(
+                    message,
+                    resolved_backend,
+                )
+                processed_messages.append(processed_message)
+                if files_update is not None:
+                    accumulated_file_updates.update(files_update)
+            return Command(update={**update, "messages": processed_messages, "files": accumulated_file_updates})
+
         return tool_result
 
     def wrap_tool_call(
@@ -636,7 +674,7 @@ class FilesystemMiddleware(AgentMiddleware):
             return handler(request)
 
         tool_result = handler(request)
-        return self._intercept_large_tool_result(tool_result)
+        return self._intercept_large_tool_result(tool_result, request.runtime)
 
     async def awrap_tool_call(
         self,
@@ -656,4 +694,4 @@ class FilesystemMiddleware(AgentMiddleware):
             return await handler(request)
 
         tool_result = await handler(request)
-        return self._intercept_large_tool_result(tool_result)
+        return self._intercept_large_tool_result(tool_result, request.runtime)

{deepagents-0.2.0 → deepagents-0.2.1rc2}/src/deepagents/middleware/patch_tool_calls.py

@@ -3,9 +3,9 @@
 from typing import Any
 
 from langchain.agents.middleware import AgentMiddleware, AgentState
-from langchain_core.messages import RemoveMessage, ToolMessage
-from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from langchain_core.messages import ToolMessage
 from langgraph.runtime import Runtime
+from langgraph.types import Overwrite
 
 
 class PatchToolCallsMiddleware(AgentMiddleware):
@@ -41,4 +41,4 @@ class PatchToolCallsMiddleware(AgentMiddleware):
                             )
                         )
 
-        return {"messages": [RemoveMessage(id=REMOVE_ALL_MESSAGES), *patched_messages]}
+        return {"messages": Overwrite(patched_messages)}

{deepagents-0.2.0 → deepagents-0.2.1rc2}/src/deepagents/middleware/subagents.py

@@ -273,7 +273,6 @@ def _get_subagents(
             system_prompt=agent_["system_prompt"],
             tools=_tools,
             middleware=_middleware,
-            checkpointer=False,
         )
     return agents, subagent_descriptions
 

{deepagents-0.2.0 → deepagents-0.2.1rc2/src/deepagents.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.0
+Version: 0.2.1rc2
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: langchain-anthropic<2.0.0,>=1.0.0
-Requires-Dist: langchain<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: wcmatch
 Provides-Extra: dev

{deepagents-0.2.0 → deepagents-0.2.1rc2}/src/deepagents.egg-info/requires.txt

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

{deepagents-0.2.0 → deepagents-0.2.1rc2}/tests/test_middleware.py

@@ -8,7 +8,7 @@ from langchain_core.messages import (
     ToolCall,
     ToolMessage,
 )
-from langgraph.graph.message import add_messages
+from langgraph.types import Overwrite
 from langgraph.store.memory import InMemoryStore
 
 from deepagents.middleware.filesystem import (
@@ -168,8 +168,55 @@ class TestFilesystemMiddleware:
                 "runtime": ToolRuntime(state=state, context=None, tool_call_id="", store=None, stream_writer=lambda _: None, config={}),
             }
         )
+        # ls should only return files directly in /pokemon/, not in subdirectories
         assert "/pokemon/test2.txt" in result
         assert "/pokemon/charmander.txt" in result
+        assert "/pokemon/water/squirtle.txt" not in result  # In subdirectory, should NOT be listed
+        # ls should also list subdirectories with trailing /
+        assert "/pokemon/water/" in result
+
+    def test_ls_shortterm_lists_directories(self):
+        """Test that ls lists directories with trailing / for traversal."""
+        state = FilesystemState(
+            messages=[],
+            files={
+                "/test.txt": FileData(
+                    content=["Hello world"],
+                    modified_at="2021-01-01",
+                    created_at="2021-01-01",
+                ),
+                "/pokemon/charmander.txt": FileData(
+                    content=["Ember"],
+                    modified_at="2021-01-01",
+                    created_at="2021-01-01",
+                ),
+                "/pokemon/water/squirtle.txt": FileData(
+                    content=["Water"],
+                    modified_at="2021-01-01",
+                    created_at="2021-01-01",
+                ),
+                "/docs/readme.md": FileData(
+                    content=["Documentation"],
+                    modified_at="2021-01-01",
+                    created_at="2021-01-01",
+                ),
+            },
+        )
+        middleware = FilesystemMiddleware()
+        ls_tool = next(tool for tool in middleware.tools if tool.name == "ls")
+        result = ls_tool.invoke(
+            {
+                "path": "/",
+                "runtime": ToolRuntime(state=state, context=None, tool_call_id="", store=None, stream_writer=lambda _: None, config={}),
+            }
+        )
+        # ls should list both files and directories at root level
+        assert "/test.txt" in result
+        assert "/pokemon/" in result
+        assert "/docs/" in result
+        # But NOT subdirectory files
+        assert "/pokemon/charmander.txt" not in result
+        assert "/pokemon/water/squirtle.txt" not in result
 
     def test_glob_search_shortterm_simple_pattern(self):
         state = FilesystemState(
@@ -649,22 +696,21 @@ class TestFilesystemMiddleware:
         keys = {item.key for item in result}
         assert keys == {f"/file{i}.txt" for i in range(55)}
 
-    def test_create_file_data_splits_long_lines(self):
+    def test_create_file_data_preserves_long_lines(self):
+        """Test that create_file_data stores long lines as-is without splitting."""
         long_line = "a" * 3500
         short_line = "short line"
         content = f"{short_line}\n{long_line}"
 
         file_data = create_file_data(content)
 
-        for line in file_data["content"]:
-            assert len(line) <= 2000
-
-        assert len(file_data["content"]) == 3
+        assert len(file_data["content"]) == 2
         assert file_data["content"][0] == short_line
-        assert file_data["content"][1] == "a" * 2000
-        assert file_data["content"][2] == "a" * 1500
+        assert file_data["content"][1] == long_line
+        assert len(file_data["content"][1]) == 3500
 
-    def test_update_file_data_splits_long_lines(self):
+    def test_update_file_data_preserves_long_lines(self):
+        """Test that update_file_data stores long lines as-is without splitting."""
         initial_file_data = create_file_data("initial content")
 
         long_line = "b" * 5000
@@ -673,17 +719,218 @@ class TestFilesystemMiddleware:
 
         updated_file_data = update_file_data(initial_file_data, new_content)
 
-        for line in updated_file_data["content"]:
-            assert len(line) <= 2000
-
-        assert len(updated_file_data["content"]) == 4
+        assert len(updated_file_data["content"]) == 2
         assert updated_file_data["content"][0] == short_line
-        assert updated_file_data["content"][1] == "b" * 2000
-        assert updated_file_data["content"][2] == "b" * 2000
-        assert updated_file_data["content"][3] == "b" * 1000
+        assert updated_file_data["content"][1] == long_line
+        assert len(updated_file_data["content"][1]) == 5000
 
         assert updated_file_data["created_at"] == initial_file_data["created_at"]
 
+    def test_format_content_with_line_numbers_short_lines(self):
+        """Test that short lines (<=10000 chars) are displayed normally."""
+        from deepagents.backends.utils import format_content_with_line_numbers
+
+        content = ["short line 1", "short line 2", "short line 3"]
+        result = format_content_with_line_numbers(content, start_line=1)
+
+        lines = result.split("\n")
+        assert len(lines) == 3
+        assert "     1\tshort line 1" in lines[0]
+        assert "     2\tshort line 2" in lines[1]
+        assert "     3\tshort line 3" in lines[2]
+
+    def test_format_content_with_line_numbers_long_line_with_continuation(self):
+        """Test that long lines (>10000 chars) are split with continuation markers."""
+        from deepagents.backends.utils import format_content_with_line_numbers
+
+        long_line = "a" * 25000
+        content = ["short line", long_line, "another short line"]
+        result = format_content_with_line_numbers(content, start_line=1)
+
+        lines = result.split("\n")
+        assert len(lines) == 5
+        assert "     1\tshort line" in lines[0]
+        assert "     2\t" in lines[1]
+        assert lines[1].count("a") == 10000
+        assert "   2.1\t" in lines[2]
+        assert lines[2].count("a") == 10000
+        assert "   2.2\t" in lines[3]
+        assert lines[3].count("a") == 5000
+        assert "     3\tanother short line" in lines[4]
+
+    def test_format_content_with_line_numbers_multiple_long_lines(self):
+        """Test multiple long lines in sequence with proper line numbering."""
+        from deepagents.backends.utils import format_content_with_line_numbers
+
+        long_line_1 = "x" * 15000
+        long_line_2 = "y" * 15000
+        content = [long_line_1, "middle", long_line_2]
+        result = format_content_with_line_numbers(content, start_line=5)
+        lines = result.split("\n")
+        assert len(lines) == 5
+        assert "     5\t" in lines[0]
+        assert lines[0].count("x") == 10000
+        assert "   5.1\t" in lines[1]
+        assert lines[1].count("x") == 5000
+        assert "     6\tmiddle" in lines[2]
+        assert "     7\t" in lines[3]
+        assert lines[3].count("y") == 10000
+        assert "   7.1\t" in lines[4]
+        assert lines[4].count("y") == 5000
+
+    def test_format_content_with_line_numbers_exact_limit(self):
+        """Test that a line exactly at the 10000 char limit is not split."""
+        from deepagents.backends.utils import format_content_with_line_numbers
+
+        exact_line = "b" * 10000
+        content = [exact_line]
+        result = format_content_with_line_numbers(content, start_line=1)
+
+        lines = result.split("\n")
+        assert len(lines) == 1
+        assert "     1\t" in lines[0]
+        assert lines[0].count("b") == 10000
+
+    def test_read_file_with_long_lines_shows_continuation_markers(self):
+        """Test that read_file displays long lines with continuation markers."""
+        from deepagents.backends.utils import format_read_response, create_file_data
+
+        long_line = "z" * 15000
+        content = f"first line\n{long_line}\nthird line"
+        file_data = create_file_data(content)
+        result = format_read_response(file_data, offset=0, limit=100)
+        lines = result.split("\n")
+        assert len(lines) == 4
+        assert "     1\tfirst line" in lines[0]
+        assert "     2\t" in lines[1]
+        assert lines[1].count("z") == 10000
+        assert "   2.1\t" in lines[2]
+        assert lines[2].count("z") == 5000
+        assert "     3\tthird line" in lines[3]
+
+    def test_read_file_with_offset_and_long_lines(self):
+        """Test that read_file with offset handles long lines correctly."""
+        from deepagents.backends.utils import format_read_response, create_file_data
+
+        long_line = "m" * 12000
+        content = f"line1\nline2\n{long_line}\nline4"
+        file_data = create_file_data(content)
+        result = format_read_response(file_data, offset=2, limit=10)
+        lines = result.split("\n")
+        assert len(lines) == 3
+        assert "     3\t" in lines[0]
+        assert lines[0].count("m") == 10000
+        assert "   3.1\t" in lines[1]
+        assert lines[1].count("m") == 2000
+        assert "     4\tline4" in lines[2]
+
+    def test_intercept_short_toolmessage(self):
+        """Test that small ToolMessages pass through unchanged."""
+        middleware = FilesystemMiddleware(tool_token_limit_before_evict=1000)
+        state = FilesystemState(messages=[], files={})
+        runtime = ToolRuntime(state=state, context=None, tool_call_id="test_123", store=None, stream_writer=lambda _: None, config={})
+
+        small_content = "x" * 1000
+        tool_message = ToolMessage(content=small_content, tool_call_id="test_123")
+        result = middleware._intercept_large_tool_result(tool_message, runtime)
+
+        assert result == tool_message
+
+    def test_intercept_long_toolmessage(self):
+        """Test that large ToolMessages are intercepted and saved to filesystem."""
+        from langgraph.types import Command
+
+        middleware = FilesystemMiddleware(tool_token_limit_before_evict=1000)
+        state = FilesystemState(messages=[], files={})
+        runtime = ToolRuntime(state=state, context=None, tool_call_id="test_123", store=None, stream_writer=lambda _: None, config={})
+
+        large_content = "x" * 5000
+        tool_message = ToolMessage(content=large_content, tool_call_id="test_123")
+        result = middleware._intercept_large_tool_result(tool_message, runtime)
+
+        assert isinstance(result, Command)
+        assert "/large_tool_results/test_123" in result.update["files"]
+        assert "Tool result too large" in result.update["messages"][0].content
+
+    def test_intercept_command_with_short_toolmessage(self):
+        """Test that Commands with small messages pass through unchanged."""
+        from langgraph.types import Command
+
+        middleware = FilesystemMiddleware(tool_token_limit_before_evict=1000)
+        state = FilesystemState(messages=[], files={})
+        runtime = ToolRuntime(state=state, context=None, tool_call_id="test_123", store=None, stream_writer=lambda _: None, config={})
+
+        small_content = "x" * 1000
+        tool_message = ToolMessage(content=small_content, tool_call_id="test_123")
+        command = Command(update={"messages": [tool_message], "files": {}})
+        result = middleware._intercept_large_tool_result(command, runtime)
+
+        assert isinstance(result, Command)
+        assert result.update["messages"][0].content == small_content
+
+    def test_intercept_command_with_long_toolmessage(self):
+        """Test that Commands with large messages are intercepted."""
+        from langgraph.types import Command
+
+        middleware = FilesystemMiddleware(tool_token_limit_before_evict=1000)
+        state = FilesystemState(messages=[], files={})
+        runtime = ToolRuntime(state=state, context=None, tool_call_id="test_123", store=None, stream_writer=lambda _: None, config={})
+
+        large_content = "y" * 5000
+        tool_message = ToolMessage(content=large_content, tool_call_id="test_123")
+        command = Command(update={"messages": [tool_message], "files": {}})
+        result = middleware._intercept_large_tool_result(command, runtime)
+
+        assert isinstance(result, Command)
+        assert "/large_tool_results/test_123" in result.update["files"]
+        assert "Tool result too large" in result.update["messages"][0].content
+
+    def test_intercept_command_with_files_and_long_toolmessage(self):
+        """Test that file updates are properly merged with existing files and other keys preserved."""
+        from langgraph.types import Command
+
+        middleware = FilesystemMiddleware(tool_token_limit_before_evict=1000)
+        state = FilesystemState(messages=[], files={})
+        runtime = ToolRuntime(state=state, context=None, tool_call_id="test_123", store=None, stream_writer=lambda _: None, config={})
+
+        large_content = "z" * 5000
+        tool_message = ToolMessage(content=large_content, tool_call_id="test_123")
+        existing_file = FileData(content=["existing"], created_at="2021-01-01", modified_at="2021-01-01")
+        command = Command(update={
+            "messages": [tool_message],
+            "files": {"/existing.txt": existing_file},
+            "custom_key": "custom_value"
+        })
+        result = middleware._intercept_large_tool_result(command, runtime)
+
+        assert isinstance(result, Command)
+        assert "/existing.txt" in result.update["files"]
+        assert "/large_tool_results/test_123" in result.update["files"]
+        assert result.update["custom_key"] == "custom_value"
+
+    def test_sanitize_tool_call_id(self):
+        """Test that tool_call_id is sanitized to prevent path traversal."""
+        from deepagents.backends.utils import sanitize_tool_call_id
+
+        assert sanitize_tool_call_id("call_123") == "call_123"
+        assert sanitize_tool_call_id("call/123") == "call_123"
+        assert sanitize_tool_call_id("test.id") == "test_id"
+
+    def test_intercept_sanitizes_tool_call_id(self):
+        """Test that tool_call_id with dangerous characters is sanitized in file path."""
+        from langgraph.types import Command
+
+        middleware = FilesystemMiddleware(tool_token_limit_before_evict=1000)
+        state = FilesystemState(messages=[], files={})
+        runtime = ToolRuntime(state=state, context=None, tool_call_id="test_123", store=None, stream_writer=lambda _: None, config={})
+
+        large_content = "x" * 5000
+        tool_message = ToolMessage(content=large_content, tool_call_id="test/call.id")
+        result = middleware._intercept_large_tool_result(tool_message, runtime)
+
+        assert isinstance(result, Command)
+        assert "/large_tool_results/test_call_id" in result.update["files"]
+
 
 @pytest.mark.requires("langchain_openai")
 class TestSubagentMiddleware:
@@ -727,13 +974,14 @@ class TestPatchToolCallsMiddleware:
         middleware = PatchToolCallsMiddleware()
         state_update = middleware.before_agent({"messages": input_messages}, None)
         assert state_update is not None
-        assert len(state_update["messages"]) == 3
-        assert state_update["messages"][0].type == "remove"
-        assert state_update["messages"][1].type == "system"
-        assert state_update["messages"][1].content == "You are a helpful assistant."
-        assert state_update["messages"][2].type == "human"
-        assert state_update["messages"][2].content == "Hello, how are you?"
-        assert state_update["messages"][2].id == "2"
+        assert isinstance(state_update["messages"], Overwrite)
+        patched_messages = state_update["messages"].value
+        assert len(patched_messages) == 2
+        assert patched_messages[0].type == "system"
+        assert patched_messages[0].content == "You are a helpful assistant."
+        assert patched_messages[1].type == "human"
+        assert patched_messages[1].content == "Hello, how are you?"
+        assert patched_messages[1].id == "2"
 
     def test_missing_tool_call(self) -> None:
         input_messages = [
@@ -749,24 +997,23 @@ class TestPatchToolCallsMiddleware:
         middleware = PatchToolCallsMiddleware()
         state_update = middleware.before_agent({"messages": input_messages}, None)
         assert state_update is not None
-        assert len(state_update["messages"]) == 6
-        assert state_update["messages"][0].type == "remove"
-        assert state_update["messages"][1] == input_messages[0]
-        assert state_update["messages"][2] == input_messages[1]
-        assert state_update["messages"][3] == input_messages[2]
-        assert state_update["messages"][4].type == "tool"
-        assert state_update["messages"][4].tool_call_id == "123"
-        assert state_update["messages"][4].name == "get_events_for_days"
-        assert state_update["messages"][5] == input_messages[3]
-        updated_messages = add_messages(input_messages, state_update["messages"])
-        assert len(updated_messages) == 5
-        assert updated_messages[0] == input_messages[0]
-        assert updated_messages[1] == input_messages[1]
-        assert updated_messages[2] == input_messages[2]
-        assert updated_messages[3].type == "tool"
-        assert updated_messages[3].tool_call_id == "123"
-        assert updated_messages[3].name == "get_events_for_days"
-        assert updated_messages[4] == input_messages[3]
+        assert isinstance(state_update["messages"], Overwrite)
+        patched_messages = state_update["messages"].value
+        assert len(patched_messages) == 5
+        assert patched_messages[0].type == "system"
+        assert patched_messages[0].content == "You are a helpful assistant."
+        assert patched_messages[1].type == "human"
+        assert patched_messages[1].content == "Hello, how are you?"
+        assert patched_messages[2].type == "ai"
+        assert len(patched_messages[2].tool_calls) == 1
+        assert patched_messages[2].tool_calls[0]["id"] == "123"
+        assert patched_messages[2].tool_calls[0]["name"] == "get_events_for_days"
+        assert patched_messages[2].tool_calls[0]["args"] == {"date_str": "2025-01-01"}
+        assert patched_messages[3].type == "tool"
+        assert patched_messages[3].name == "get_events_for_days"
+        assert patched_messages[3].tool_call_id == "123"
+        assert patched_messages[4].type == "human"
+        assert patched_messages[4].content == "What is the weather in Tokyo?"
 
     def test_no_missing_tool_calls(self) -> None:
         input_messages = [
@@ -783,12 +1030,22 @@ class TestPatchToolCallsMiddleware:
         middleware = PatchToolCallsMiddleware()
         state_update = middleware.before_agent({"messages": input_messages}, None)
         assert state_update is not None
-        assert len(state_update["messages"]) == 6
-        assert state_update["messages"][0].type == "remove"
-        assert state_update["messages"][1:] == input_messages
-        updated_messages = add_messages(input_messages, state_update["messages"])
-        assert len(updated_messages) == 5
-        assert updated_messages == input_messages
+        assert isinstance(state_update["messages"], Overwrite)
+        patched_messages = state_update["messages"].value
+        assert len(patched_messages) == 5
+        assert patched_messages[0].type == "system"
+        assert patched_messages[0].content == "You are a helpful assistant."
+        assert patched_messages[1].type == "human"
+        assert patched_messages[1].content == "Hello, how are you?"
+        assert patched_messages[2].type == "ai"
+        assert len(patched_messages[2].tool_calls) == 1
+        assert patched_messages[2].tool_calls[0]["id"] == "123"
+        assert patched_messages[2].tool_calls[0]["name"] == "get_events_for_days"
+        assert patched_messages[2].tool_calls[0]["args"] == {"date_str": "2025-01-01"}
+        assert patched_messages[3].type == "tool"
+        assert patched_messages[3].tool_call_id == "123"
+        assert patched_messages[4].type == "human"
+        assert patched_messages[4].content == "What is the weather in Tokyo?"
 
     def test_two_missing_tool_calls(self) -> None:
         input_messages = [
@@ -810,34 +1067,33 @@ class TestPatchToolCallsMiddleware:
         middleware = PatchToolCallsMiddleware()
         state_update = middleware.before_agent({"messages": input_messages}, None)
         assert state_update is not None
-        assert len(state_update["messages"]) == 9
-        assert state_update["messages"][0].type == "remove"
-        assert state_update["messages"][1] == input_messages[0]
-        assert state_update["messages"][2] == input_messages[1]
-        assert state_update["messages"][3] == input_messages[2]
-        assert state_update["messages"][4].type == "tool"
-        assert state_update["messages"][4].tool_call_id == "123"
-        assert state_update["messages"][4].name == "get_events_for_days"
-        assert state_update["messages"][5] == input_messages[3]
-        assert state_update["messages"][6] == input_messages[4]
-        assert state_update["messages"][7].type == "tool"
-        assert state_update["messages"][7].tool_call_id == "456"
-        assert state_update["messages"][7].name == "get_events_for_days"
-        assert state_update["messages"][8] == input_messages[5]
-        updated_messages = add_messages(input_messages, state_update["messages"])
-        assert len(updated_messages) == 8
-        assert updated_messages[0] == input_messages[0]
-        assert updated_messages[1] == input_messages[1]
-        assert updated_messages[2] == input_messages[2]
-        assert updated_messages[3].type == "tool"
-        assert updated_messages[3].tool_call_id == "123"
-        assert updated_messages[3].name == "get_events_for_days"
-        assert updated_messages[4] == input_messages[3]
-        assert updated_messages[5] == input_messages[4]
-        assert updated_messages[6].type == "tool"
-        assert updated_messages[6].tool_call_id == "456"
-        assert updated_messages[6].name == "get_events_for_days"
-        assert updated_messages[7] == input_messages[5]
+        assert isinstance(state_update["messages"], Overwrite)
+        patched_messages = state_update["messages"].value
+        assert len(patched_messages) == 8
+        assert patched_messages[0].type == "system"
+        assert patched_messages[0].content == "You are a helpful assistant."
+        assert patched_messages[1].type == "human"
+        assert patched_messages[1].content == "Hello, how are you?"
+        assert patched_messages[2].type == "ai"
+        assert len(patched_messages[2].tool_calls) == 1
+        assert patched_messages[2].tool_calls[0]["id"] == "123"
+        assert patched_messages[2].tool_calls[0]["name"] == "get_events_for_days"
+        assert patched_messages[2].tool_calls[0]["args"] == {"date_str": "2025-01-01"}
+        assert patched_messages[3].type == "tool"
+        assert patched_messages[3].name == "get_events_for_days"
+        assert patched_messages[3].tool_call_id == "123"
+        assert patched_messages[4].type == "human"
+        assert patched_messages[4].content == "What is the weather in Tokyo?"
+        assert patched_messages[5].type == "ai"
+        assert len(patched_messages[5].tool_calls) == 1
+        assert patched_messages[5].tool_calls[0]["id"] == "456"
+        assert patched_messages[5].tool_calls[0]["name"] == "get_events_for_days"
+        assert patched_messages[5].tool_calls[0]["args"] == {"date_str": "2025-01-01"}
+        assert patched_messages[6].type == "tool"
+        assert patched_messages[6].name == "get_events_for_days"
+        assert patched_messages[6].tool_call_id == "456"
+        assert patched_messages[7].type == "human"
+        assert patched_messages[7].content == "What is the weather in Tokyo?"
 
 
 class TestTruncation: