deepagents 0.2.1rc1__tar.gz → 0.2.2__tar.gz

{deepagents-0.2.1rc1/src/deepagents.egg-info → deepagents-0.2.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.1rc1
+Version: 0.2.2
 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.1rc1 → deepagents-0.2.2}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "deepagents"
-version = "0.2.1rc1"
+version = "0.2.2"
 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"
 ]
@@ -93,3 +93,8 @@ enable_error_code = ["deprecated"]
 # Optional: reduce strictness if needed
 disallow_any_generics = false
 warn_return_any = false
+
+[tool.uv.workspace]
+members = [
+    "libs/deepagents-cli",
+]

{deepagents-0.2.1rc1 → deepagents-0.2.2}/src/deepagents/backends/utils.py

@@ -37,6 +37,15 @@ 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,

{deepagents-0.2.1rc1 → deepagents-0.2.2}/src/deepagents/graph.py

@@ -123,10 +123,10 @@ def create_deep_agent(
         AnthropicPromptCachingMiddleware(unsupported_model_behavior="ignore"),
         PatchToolCallsMiddleware(),
     ]
+    if middleware:
+        deepagent_middleware.extend(middleware)
     if interrupt_on is not None:
         deepagent_middleware.append(HumanInTheLoopMiddleware(interrupt_on=interrupt_on))
-    if middleware is not None:
-        deepagent_middleware.extend(middleware)
 
     return create_agent(
         model,

deepagents-0.2.2/src/deepagents/middleware/__init__.py

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

deepagents-0.2.2/src/deepagents/middleware/agent_memory.py

@@ -0,0 +1,222 @@
+"""Middleware for loading agent-specific long-term memory into the system prompt."""
+
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from langgraph.runtime import Runtime
+
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    AgentState,
+    ModelRequest,
+    ModelResponse,
+)
+from typing_extensions import NotRequired, TypedDict
+
+from deepagents.backends.protocol import BackendProtocol
+
+
+class AgentMemoryState(AgentState):
+    """State for the agent memory middleware."""
+
+    agent_memory: NotRequired[str | None]
+    """Long-term memory content for the agent."""
+
+
+AGENT_MEMORY_FILE_PATH = "/agent.md"
+
+# Long-term Memory Documentation
+LONGTERM_MEMORY_SYSTEM_PROMPT = """
+
+## Long-term Memory
+
+You have access to a long-term memory system using the {memory_path} path prefix.
+Files stored in {memory_path} persist across sessions and conversations.
+
+Your system prompt is loaded from {memory_path}agent.md at startup. You can update your own instructions by editing this file.
+
+**When to CHECK/READ memories (CRITICAL - do this FIRST):**
+- **At the start of ANY new session**: Run `ls {memory_path}` to see what you know
+- **BEFORE answering questions**: If asked "what do you know about X?" or "how do I do Y?", check `ls {memory_path}` for relevant files FIRST
+- **When user asks you to do something**: Check if you have guides, examples, or patterns in {memory_path} before proceeding
+- **When user references past work or conversations**: Search {memory_path} for related content
+- **If you're unsure**: Check your memories rather than guessing or using only general knowledge
+
+**Memory-first response pattern:**
+1. User asks a question → Run `ls {memory_path}` to check for relevant files
+2. If relevant files exist → Read them with `read_file {memory_path}[filename]`
+3. Base your answer on saved knowledge (from memories) supplemented by general knowledge
+4. If no relevant memories exist → Use general knowledge, then consider if this is worth saving
+
+**When to update memories:**
+- **IMMEDIATELY when the user describes your role or how you should behave** (e.g., "you are a web researcher", "you are an expert in X")
+- **IMMEDIATELY when the user gives feedback on your work** - Before continuing, update memories to capture what was wrong and how to do it better
+- When the user explicitly asks you to remember something
+- When patterns or preferences emerge (coding styles, conventions, workflows)
+- After significant work where context would help in future sessions
+
+**Learning from feedback:**
+- When user says something is better/worse, capture WHY and encode it as a pattern
+- Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions
+- When user says "you should remember X" or "be careful about Y", treat this as HIGH PRIORITY - update memories IMMEDIATELY
+- Look for the underlying principle behind corrections, not just the specific mistake
+- If it's something you "should have remembered", identify where that instruction should live permanently
+
+**What to store where:**
+- **{memory_path}agent.md**: Update this to modify your core instructions and behavioral patterns
+- **Other {memory_path} files**: Use for project-specific context, reference information, or structured notes
+  - If you create additional memory files, add references to them in {memory_path}agent.md so you remember to consult them
+
+The portion of your system prompt that comes from {memory_path}agent.md is marked with `<agent_memory>` tags so you can identify what instructions come from your persistent memory.
+
+Example: `ls {memory_path}` to see what memories you have
+Example: `read_file '{memory_path}deep-agents-guide.md'` to recall saved knowledge
+Example: `edit_file('{memory_path}agent.md', ...)` to update your instructions
+Example: `write_file('{memory_path}project_context.md', ...)` for project-specific notes, then reference it in agent.md
+
+Remember: To interact with the longterm filesystem, you must prefix the filename with the {memory_path} path."""
+
+
+DEFAULT_MEMORY_SNIPPET = """<agent_memory>
+{agent_memory}
+</agent_memory>
+"""
+
+class AgentMemoryMiddleware(AgentMiddleware):
+    """Middleware for loading agent-specific long-term memory.
+
+    This middleware loads the agent's long-term memory from a file (agent.md)
+    and injects it into the system prompt. The memory is loaded once at the
+    start of the conversation and stored in state.
+
+    Args:
+        backend: Backend to use for loading the agent memory file.
+        system_prompt_template: Optional custom template for how to inject
+            the agent memory into the system prompt. Use {agent_memory} as
+            a placeholder. Defaults to a simple section header.
+
+    Example:
+        ```python
+        from deepagents.middleware.agent_memory import AgentMemoryMiddleware
+        from deepagents.memory.backends import FilesystemBackend
+        from pathlib import Path
+
+        # Set up backend pointing to agent's directory
+        agent_dir = Path.home() / ".deepagents" / "my-agent"
+        backend = FilesystemBackend(root_dir=agent_dir)
+        
+        # Create middleware
+        middleware = AgentMemoryMiddleware(backend=backend)
+        ```
+    """
+
+    state_schema = AgentMemoryState
+
+    def __init__(
+        self,
+        *,
+        backend: BackendProtocol,
+        memory_path: str,
+        system_prompt_template: str | None = None,
+    ) -> None:
+        """Initialize the agent memory middleware.
+
+        Args:
+            backend: Backend to use for loading the agent memory file.
+            system_prompt_template: Optional custom template for injecting
+                agent memory into system prompt.
+        """
+        self.backend = backend
+        self.memory_path = memory_path
+        self.system_prompt_template = system_prompt_template or DEFAULT_MEMORY_SNIPPET
+
+    def before_agent(
+        self,
+        state: AgentMemoryState,
+        runtime,
+    ) -> AgentMemoryState:
+        """Load agent memory from file before agent execution.
+
+        Args:
+            state: Current agent state.
+            handler: Handler function to call after loading memory.
+
+        Returns:
+            Updated state with agent_memory populated.
+        """
+        # Only load memory if it hasn't been loaded yet
+        if "agent_memory" not in state or state.get("agent_memory") is None:
+            file_data = self.backend.read(AGENT_MEMORY_FILE_PATH)
+            return {"agent_memory": file_data}
+
+    async def abefore_agent(
+        self,
+        state: AgentMemoryState,
+        runtime,
+    ) -> AgentMemoryState:
+        """(async) Load agent memory from file before agent execution.
+
+        Args:
+            state: Current agent state.
+            handler: Handler function to call after loading memory.
+
+        Returns:
+            Updated state with agent_memory populated.
+        """
+        # Only load memory if it hasn't been loaded yet
+        if "agent_memory" not in state or state.get("agent_memory") is None:
+            file_data = self.backend.read(AGENT_MEMORY_FILE_PATH)
+            return {"agent_memory": file_data}
+
+    def wrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], ModelResponse],
+    ) -> ModelResponse:
+        """Inject agent memory into the system prompt.
+
+        Args:
+            request: The model request being processed.
+            handler: The handler function to call with the modified request.
+
+        Returns:
+            The model response from the handler.
+        """
+        # Get agent memory from state
+        agent_memory = request.state.get("agent_memory", "")
+        
+        memory_section = self.system_prompt_template.format(agent_memory=agent_memory)
+        if request.system_prompt:
+            request.system_prompt = memory_section + "\n\n" + request.system_prompt
+        else:
+            request.system_prompt = memory_section
+        request.system_prompt = request.system_prompt + "\n\n" + LONGTERM_MEMORY_SYSTEM_PROMPT.format(memory_path=self.memory_path)
+
+        return handler(request)
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
+    ) -> ModelResponse:
+        """(async) Inject agent memory into the system prompt.
+
+        Args:
+            request: The model request being processed.
+            handler: The handler function to call with the modified request.
+
+        Returns:
+            The model response from the handler.
+        """
+        # Get agent memory from state
+        agent_memory = request.state.get("agent_memory", "")
+        
+        memory_section = self.system_prompt_template.format(agent_memory=agent_memory)
+        if request.system_prompt:
+            request.system_prompt = memory_section + "\n\n" + request.system_prompt
+        else:
+            request.system_prompt = memory_section
+        request.system_prompt = request.system_prompt + "\n\n" + LONGTERM_MEMORY_SYSTEM_PROMPT.format(memory_path=self.memory_path)
+
+        return await handler(request)

{deepagents-0.2.1rc1 → deepagents-0.2.2}/src/deepagents/middleware/filesystem.py

@@ -24,18 +24,18 @@ 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"
 MAX_LINE_LENGTH = 2000
 LINE_NUMBER_WIDTH = 6
 DEFAULT_READ_OFFSET = 0
-DEFAULT_READ_LIMIT = 2000
+DEFAULT_READ_LIMIT = 500
 BACKEND_TYPES = (
     BackendProtocol
     | BackendFactory
@@ -155,8 +155,12 @@ Assume this tool is able to read all files on the machine. If the User provides
 
 Usage:
 - The file_path parameter must be an absolute path, not a relative path
-- By default, it reads up to 2000 lines starting from the beginning of the file
-- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- By default, it reads up to 500 lines starting from the beginning of the file
+- **IMPORTANT for large files and codebase exploration**: Use pagination with offset and limit parameters to avoid context overflow
+  - First scan: read_file(path, limit=100) to see file structure
+  - Read more sections: read_file(path, offset=100, limit=200) for next 200 lines
+  - Only omit limit (read full file) when necessary for editing
+- Specify offset and limit: read_file(path, offset=0, limit=100) reads first 100 lines
 - Any lines longer than 2000 characters will be truncated
 - Results are returned using cat -n format, with line numbers starting at 1
 - You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
@@ -227,6 +231,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 +545,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 +594,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 +678,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 +698,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.1rc1 → deepagents-0.2.2}/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.2/src/deepagents/middleware/resumable_shell.py

@@ -0,0 +1,85 @@
+"""Shell tool middleware that survives HITL pauses."""
+
+from __future__ import annotations
+
+from typing import Any, Awaitable, Callable, cast
+
+from langchain.agents.middleware.shell_tool import (
+    ShellToolMiddleware,
+    _PersistentShellTool,
+    _SessionResources,
+    ShellToolState,
+)
+from langchain.agents.middleware.types import AgentState
+from langchain_core.messages import ToolMessage
+from langchain.tools.tool_node import ToolCallRequest
+from langgraph.types import Command
+
+
+class ResumableShellToolMiddleware(ShellToolMiddleware):
+    """Shell middleware that recreates session resources after human interrupts.
+
+    ``ShellToolMiddleware`` stores its session handle in middleware state using an
+    ``UntrackedValue``. When a run pauses for human approval, that attribute is not
+    checkpointed. Upon resuming, LangGraph restores the state without the shell
+    resources, so the next tool execution fails with
+    ``Shell session resources are unavailable``.
+
+    This subclass lazily recreates the shell session the first time a resumed run
+    touches the shell tool again and only performs shutdown when a session is
+    actually active. This keeps behaviour identical for uninterrupted runs while
+    allowing HITL pauses to succeed.
+    """
+
+    def wrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], ToolMessage | Command],
+    ) -> ToolMessage | Command:
+        if isinstance(request.tool, _PersistentShellTool):
+            resources = self._get_or_create_resources(request.state)
+            return self._run_shell_tool(
+                resources,
+                request.tool_call["args"],
+                tool_call_id=request.tool_call.get("id"),
+            )
+        return super().wrap_tool_call(request, handler)
+
+    async def awrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+    ) -> ToolMessage | Command:
+        if isinstance(request.tool, _PersistentShellTool):
+            resources = self._get_or_create_resources(request.state)
+            return self._run_shell_tool(
+                resources,
+                request.tool_call["args"],
+                tool_call_id=request.tool_call.get("id"),
+            )
+        return await super().awrap_tool_call(request, handler)
+
+    def after_agent(self, state: ShellToolState, runtime) -> None:  # type: ignore[override]
+        if self._has_resources(state):
+            super().after_agent(state, runtime)
+
+    async def aafter_agent(self, state: ShellToolState, runtime) -> None:  # type: ignore[override]
+        if self._has_resources(state):
+            await super().aafter_agent(state, runtime)
+
+    @staticmethod
+    def _has_resources(state: AgentState) -> bool:
+        resources = state.get("shell_session_resources")
+        return isinstance(resources, _SessionResources)
+
+    def _get_or_create_resources(self, state: AgentState) -> _SessionResources:
+        resources = state.get("shell_session_resources")
+        if isinstance(resources, _SessionResources):
+            return resources
+
+        new_resources = self._create_resources()
+        cast(dict[str, Any], state)["shell_session_resources"] = new_resources
+        return new_resources
+
+
+__all__ = ["ResumableShellToolMiddleware"]

{deepagents-0.2.1rc1 → deepagents-0.2.2/src/deepagents.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.1rc1
+Version: 0.2.2
 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.1rc1 → deepagents-0.2.2}/src/deepagents.egg-info/SOURCES.txt

@@ -16,7 +16,9 @@ src/deepagents/backends/state.py
 src/deepagents/backends/store.py
 src/deepagents/backends/utils.py
 src/deepagents/middleware/__init__.py
+src/deepagents/middleware/agent_memory.py
 src/deepagents/middleware/filesystem.py
 src/deepagents/middleware/patch_tool_calls.py
+src/deepagents/middleware/resumable_shell.py
 src/deepagents/middleware/subagents.py
 tests/test_middleware.py

{deepagents-0.2.1rc1 → deepagents-0.2.2}/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.1rc1 → deepagents-0.2.2}/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 (
@@ -824,6 +824,113 @@ class TestFilesystemMiddleware:
         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:
@@ -867,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 = [
@@ -889,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 = [
@@ -923,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 = [
@@ -950,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:

deepagents-0.2.1rc1/src/deepagents/middleware/__init__.py

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