deepagents 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

deepagents/middleware/filesystem.py

@@ -2,6 +2,7 @@
 # ruff: noqa: E501
 
 import os
+import re
 from collections.abc import Awaitable, Callable, Sequence
 from typing import Annotated, Literal, NotRequired
 
@@ -14,7 +15,7 @@ from langchain.agents.middleware.types import (
 from langchain.tools import ToolRuntime
 from langchain.tools.tool_node import ToolCallRequest
 from langchain_core.messages import ToolMessage
-from langchain_core.tools import BaseTool, tool
+from langchain_core.tools import BaseTool, StructuredTool
 from langgraph.types import Command
 from typing_extensions import TypedDict
 
@@ -92,12 +93,16 @@ def _file_data_reducer(left: dict[str, FileData] | None, right: dict[str, FileDa
 
 
 def _validate_path(path: str, *, allowed_prefixes: Sequence[str] | None = None) -> str:
-    """Validate and normalize file path for security.
+    r"""Validate and normalize file path for security.
 
     Ensures paths are safe to use by preventing directory traversal attacks
     and enforcing consistent formatting. All paths are normalized to use
     forward slashes and start with a leading slash.
 
+    This function is designed for virtual filesystem paths and rejects
+    Windows absolute paths (e.g., C:/..., F:/...) to maintain consistency
+    and prevent path format ambiguity.
+
     Args:
         path: The path to validate and normalize.
         allowed_prefixes: Optional list of allowed path prefixes. If provided,
@@ -107,14 +112,16 @@ def _validate_path(path: str, *, allowed_prefixes: Sequence[str] | None = None)
         Normalized canonical path starting with `/` and using forward slashes.
 
     Raises:
-        ValueError: If path contains traversal sequences (`..` or `~`) or does
-            not start with an allowed prefix when `allowed_prefixes` is specified.
+        ValueError: If path contains traversal sequences (`..` or `~`), is a
+            Windows absolute path (e.g., C:/...), or does not start with an
+            allowed prefix when `allowed_prefixes` is specified.
 
     Example:
         ```python
         validate_path("foo/bar")  # Returns: "/foo/bar"
         validate_path("/./foo//bar")  # Returns: "/foo/bar"
         validate_path("../etc/passwd")  # Raises ValueError
+        validate_path(r"C:\\Users\\file.txt")  # Raises ValueError
         validate_path("/data/file.txt", allowed_prefixes=["/data/"])  # OK
         validate_path("/etc/file.txt", allowed_prefixes=["/data/"])  # Raises ValueError
         ```
@@ -123,6 +130,12 @@ def _validate_path(path: str, *, allowed_prefixes: Sequence[str] | None = None)
         msg = f"Path traversal not allowed: {path}"
         raise ValueError(msg)
 
+    # Reject Windows absolute paths (e.g., C:\..., D:/...)
+    # This maintains consistency in virtual filesystem paths
+    if re.match(r"^[a-zA-Z]:", path):
+        msg = f"Windows absolute paths are not supported: {path}. Please use virtual paths starting with / (e.g., /workspace/file.txt)"
+        raise ValueError(msg)
+
     normalized = os.path.normpath(path)
     normalized = normalized.replace("\\", "/")
 
@@ -312,14 +325,30 @@ def _ls_tool_generator(
     """
     tool_description = custom_description or LIST_FILES_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def ls(runtime: ToolRuntime[None, FilesystemState], path: str) -> list[str]:
+    def sync_ls(runtime: ToolRuntime[None, FilesystemState], path: str) -> str:
+        """Synchronous wrapper for ls tool."""
         resolved_backend = _get_backend(backend, runtime)
         validated_path = _validate_path(path)
         infos = resolved_backend.ls_info(validated_path)
-        return [fi.get("path", "") for fi in infos]
+        paths = [fi.get("path", "") for fi in infos]
+        result = truncate_if_too_long(paths)
+        return str(result)
 
-    return ls
+    async def async_ls(runtime: ToolRuntime[None, FilesystemState], path: str) -> str:
+        """Asynchronous wrapper for ls tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        validated_path = _validate_path(path)
+        infos = await resolved_backend.als_info(validated_path)
+        paths = [fi.get("path", "") for fi in infos]
+        result = truncate_if_too_long(paths)
+        return str(result)
+
+    return StructuredTool.from_function(
+        name="ls",
+        description=tool_description,
+        func=sync_ls,
+        coroutine=async_ls,
+    )
 
 
 def _read_file_tool_generator(
@@ -337,18 +366,34 @@ def _read_file_tool_generator(
     """
     tool_description = custom_description or READ_FILE_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def read_file(
+    def sync_read_file(
         file_path: str,
         runtime: ToolRuntime[None, FilesystemState],
         offset: int = DEFAULT_READ_OFFSET,
         limit: int = DEFAULT_READ_LIMIT,
     ) -> str:
+        """Synchronous wrapper for read_file tool."""
         resolved_backend = _get_backend(backend, runtime)
         file_path = _validate_path(file_path)
         return resolved_backend.read(file_path, offset=offset, limit=limit)
 
-    return read_file
+    async def async_read_file(
+        file_path: str,
+        runtime: ToolRuntime[None, FilesystemState],
+        offset: int = DEFAULT_READ_OFFSET,
+        limit: int = DEFAULT_READ_LIMIT,
+    ) -> str:
+        """Asynchronous wrapper for read_file tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        file_path = _validate_path(file_path)
+        return await resolved_backend.aread(file_path, offset=offset, limit=limit)
+
+    return StructuredTool.from_function(
+        name="read_file",
+        description=tool_description,
+        func=sync_read_file,
+        coroutine=async_read_file,
+    )
 
 
 def _write_file_tool_generator(
@@ -366,12 +411,12 @@ def _write_file_tool_generator(
     """
     tool_description = custom_description or WRITE_FILE_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def write_file(
+    def sync_write_file(
         file_path: str,
         content: str,
         runtime: ToolRuntime[None, FilesystemState],
     ) -> Command | str:
+        """Synchronous wrapper for write_file tool."""
         resolved_backend = _get_backend(backend, runtime)
         file_path = _validate_path(file_path)
         res: WriteResult = resolved_backend.write(file_path, content)
@@ -392,7 +437,38 @@ def _write_file_tool_generator(
             )
         return f"Updated file {res.path}"
 
-    return write_file
+    async def async_write_file(
+        file_path: str,
+        content: str,
+        runtime: ToolRuntime[None, FilesystemState],
+    ) -> Command | str:
+        """Asynchronous wrapper for write_file tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        file_path = _validate_path(file_path)
+        res: WriteResult = await resolved_backend.awrite(file_path, content)
+        if res.error:
+            return res.error
+        # If backend returns state update, wrap into Command with ToolMessage
+        if res.files_update is not None:
+            return Command(
+                update={
+                    "files": res.files_update,
+                    "messages": [
+                        ToolMessage(
+                            content=f"Updated file {res.path}",
+                            tool_call_id=runtime.tool_call_id,
+                        )
+                    ],
+                }
+            )
+        return f"Updated file {res.path}"
+
+    return StructuredTool.from_function(
+        name="write_file",
+        description=tool_description,
+        func=sync_write_file,
+        coroutine=async_write_file,
+    )
 
 
 def _edit_file_tool_generator(
@@ -410,8 +486,7 @@ def _edit_file_tool_generator(
     """
     tool_description = custom_description or EDIT_FILE_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def edit_file(
+    def sync_edit_file(
         file_path: str,
         old_string: str,
         new_string: str,
@@ -419,6 +494,7 @@ def _edit_file_tool_generator(
         *,
         replace_all: bool = False,
     ) -> Command | str:
+        """Synchronous wrapper for edit_file tool."""
         resolved_backend = _get_backend(backend, runtime)
         file_path = _validate_path(file_path)
         res: EditResult = resolved_backend.edit(file_path, old_string, new_string, replace_all=replace_all)
@@ -438,7 +514,40 @@ def _edit_file_tool_generator(
             )
         return f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'"
 
-    return edit_file
+    async def async_edit_file(
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        runtime: ToolRuntime[None, FilesystemState],
+        *,
+        replace_all: bool = False,
+    ) -> Command | str:
+        """Asynchronous wrapper for edit_file tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        file_path = _validate_path(file_path)
+        res: EditResult = await resolved_backend.aedit(file_path, old_string, new_string, replace_all=replace_all)
+        if res.error:
+            return res.error
+        if res.files_update is not None:
+            return Command(
+                update={
+                    "files": res.files_update,
+                    "messages": [
+                        ToolMessage(
+                            content=f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'",
+                            tool_call_id=runtime.tool_call_id,
+                        )
+                    ],
+                }
+            )
+        return f"Successfully replaced {res.occurrences} instance(s) of the string in '{res.path}'"
+
+    return StructuredTool.from_function(
+        name="edit_file",
+        description=tool_description,
+        func=sync_edit_file,
+        coroutine=async_edit_file,
+    )
 
 
 def _glob_tool_generator(
@@ -456,13 +565,28 @@ def _glob_tool_generator(
     """
     tool_description = custom_description or GLOB_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def glob(pattern: str, runtime: ToolRuntime[None, FilesystemState], path: str = "/") -> list[str]:
+    def sync_glob(pattern: str, runtime: ToolRuntime[None, FilesystemState], path: str = "/") -> str:
+        """Synchronous wrapper for glob tool."""
         resolved_backend = _get_backend(backend, runtime)
         infos = resolved_backend.glob_info(pattern, path=path)
-        return [fi.get("path", "") for fi in infos]
+        paths = [fi.get("path", "") for fi in infos]
+        result = truncate_if_too_long(paths)
+        return str(result)
+
+    async def async_glob(pattern: str, runtime: ToolRuntime[None, FilesystemState], path: str = "/") -> str:
+        """Asynchronous wrapper for glob tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        infos = await resolved_backend.aglob_info(pattern, path=path)
+        paths = [fi.get("path", "") for fi in infos]
+        result = truncate_if_too_long(paths)
+        return str(result)
 
-    return glob
+    return StructuredTool.from_function(
+        name="glob",
+        description=tool_description,
+        func=sync_glob,
+        coroutine=async_glob,
+    )
 
 
 def _grep_tool_generator(
@@ -480,14 +604,14 @@ def _grep_tool_generator(
     """
     tool_description = custom_description or GREP_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def grep(
+    def sync_grep(
         pattern: str,
         runtime: ToolRuntime[None, FilesystemState],
         path: str | None = None,
         glob: str | None = None,
         output_mode: Literal["files_with_matches", "content", "count"] = "files_with_matches",
     ) -> str:
+        """Synchronous wrapper for grep tool."""
         resolved_backend = _get_backend(backend, runtime)
         raw = resolved_backend.grep_raw(pattern, path=path, glob=glob)
         if isinstance(raw, str):
@@ -495,7 +619,27 @@ def _grep_tool_generator(
         formatted = format_grep_matches(raw, output_mode)
         return truncate_if_too_long(formatted)  # type: ignore[arg-type]
 
-    return grep
+    async def async_grep(
+        pattern: str,
+        runtime: ToolRuntime[None, FilesystemState],
+        path: str | None = None,
+        glob: str | None = None,
+        output_mode: Literal["files_with_matches", "content", "count"] = "files_with_matches",
+    ) -> str:
+        """Asynchronous wrapper for grep tool."""
+        resolved_backend = _get_backend(backend, runtime)
+        raw = await resolved_backend.agrep_raw(pattern, path=path, glob=glob)
+        if isinstance(raw, str):
+            return raw
+        formatted = format_grep_matches(raw, output_mode)
+        return truncate_if_too_long(formatted)  # type: ignore[arg-type]
+
+    return StructuredTool.from_function(
+        name="grep",
+        description=tool_description,
+        func=sync_grep,
+        coroutine=async_grep,
+    )
 
 
 def _supports_execution(backend: BackendProtocol) -> bool:
@@ -536,11 +680,11 @@ def _execute_tool_generator(
     """
     tool_description = custom_description or EXECUTE_TOOL_DESCRIPTION
 
-    @tool(description=tool_description)
-    def execute(
+    def sync_execute(
         command: str,
         runtime: ToolRuntime[None, FilesystemState],
     ) -> str:
+        """Synchronous wrapper for execute tool."""
         resolved_backend = _get_backend(backend, runtime)
 
         # Runtime check - fail gracefully if not supported
@@ -569,7 +713,45 @@ def _execute_tool_generator(
 
         return "".join(parts)
 
-    return execute
+    async def async_execute(
+        command: str,
+        runtime: ToolRuntime[None, FilesystemState],
+    ) -> str:
+        """Asynchronous wrapper for execute tool."""
+        resolved_backend = _get_backend(backend, runtime)
+
+        # Runtime check - fail gracefully if not supported
+        if not _supports_execution(resolved_backend):
+            return (
+                "Error: Execution not available. This agent's backend "
+                "does not support command execution (SandboxBackendProtocol). "
+                "To use the execute tool, provide a backend that implements SandboxBackendProtocol."
+            )
+
+        try:
+            result = await resolved_backend.aexecute(command)
+        except NotImplementedError as e:
+            # Handle case where execute() exists but raises NotImplementedError
+            return f"Error: Execution not available. {e}"
+
+        # Format output for LLM consumption
+        parts = [result.output]
+
+        if result.exit_code is not None:
+            status = "succeeded" if result.exit_code == 0 else "failed"
+            parts.append(f"\n[Command {status} with exit code {result.exit_code}]")
+
+        if result.truncated:
+            parts.append("\n[Output was truncated due to size limits]")
+
+        return "".join(parts)
+
+    return StructuredTool.from_function(
+        name="execute",
+        description=tool_description,
+        func=sync_execute,
+        coroutine=async_execute,
+    )
 
 
 TOOL_GENERATORS = {

deepagents/middleware/subagents.py

@@ -468,7 +468,8 @@ class SubAgentMiddleware(AgentMiddleware):
     ) -> ModelResponse:
         """Update the system prompt to include instructions on using subagents."""
         if self.system_prompt is not None:
-            request.system_prompt = request.system_prompt + "\n\n" + self.system_prompt if request.system_prompt else self.system_prompt
+            system_prompt = request.system_prompt + "\n\n" + self.system_prompt if request.system_prompt else self.system_prompt
+            return handler(request.override(system_prompt=system_prompt))
         return handler(request)
 
     async def awrap_model_call(
@@ -478,5 +479,6 @@ class SubAgentMiddleware(AgentMiddleware):
     ) -> ModelResponse:
         """(async) Update the system prompt to include instructions on using subagents."""
         if self.system_prompt is not None:
-            request.system_prompt = request.system_prompt + "\n\n" + self.system_prompt if request.system_prompt else self.system_prompt
+            system_prompt = request.system_prompt + "\n\n" + self.system_prompt if request.system_prompt else self.system_prompt
+            return await handler(request.override(system_prompt=system_prompt))
         return await handler(request)

{deepagents-0.2.7.dist-info → deepagents-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.2.7
+Version: 0.3.0
 Summary: General purpose 'deep agent' with sub-agent spawning, todo list capabilities, and mock file system. Built on LangGraph.
 License: MIT
 Project-URL: Homepage, https://docs.langchain.com/oss/python/deepagents/overview
@@ -11,13 +11,10 @@ Project-URL: Slack, https://www.langchain.com/join-community
 Project-URL: Reddit, https://www.reddit.com/r/LangChain/
 Requires-Python: <4.0,>=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: langchain-anthropic<2.0.0,>=1.0.0
-Requires-Dist: langchain<2.0.0,>=1.0.2
-Requires-Dist: langchain-core<2.0.0,>=1.0.0
+Requires-Dist: langchain-anthropic<2.0.0,>=1.2.0
+Requires-Dist: langchain<2.0.0,>=1.1.0
+Requires-Dist: langchain-core<2.0.0,>=1.1.0
 Requires-Dist: wcmatch
-Requires-Dist: daytona>=0.113.0
-Requires-Dist: runloop-api-client>=0.66.1
-Requires-Dist: tavily>=1.1.0
 
 # 🧠🤖Deep Agents
 
@@ -27,7 +24,7 @@ This architecture, however, can yield agents that are “shallow” and fail to
 Applications like “Deep Research”, "Manus", and “Claude Code” have gotten around this limitation by implementing a combination of four things:
 a **planning tool**, **sub agents**, access to a **file system**, and a **detailed prompt**.
 
-<img src="deep_agents.png" alt="deep agent" width="600"/>
+<img src="../../deep_agents.png" alt="deep agent" width="600"/>
 
 `deepagents` is a Python package that implements these in a general purpose way so that you can easily create a Deep Agent for your application. For a full overview and quickstart of `deepagents`, the best resource is our [docs](https://docs.langchain.com/oss/python/deepagents/overview).
 

deepagents-0.3.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+deepagents/__init__.py,sha256=9BVNn4lfF5N8l2KY8Ttxi82zO609I-fGqoSIF7DAxiU,342
+deepagents/graph.py,sha256=u3gLVZMLA1xdZV_Mo0RPyQGOqO5VZkckoz1xPRWuZxw,6776
+deepagents/backends/__init__.py,sha256=BOKu2cQ1OdMyO_l2rLqZQiXppYFmQbx7OIQb7WYwvZc,457
+deepagents/backends/composite.py,sha256=A7J301EPlKJtTM1q1dL3hX-rDns-wallUsT66R_TaVA,22557
+deepagents/backends/filesystem.py,sha256=kGBFuW3ie0LLz4wXCPGJm3WAiYpimJTgEwodJSnXWCs,21477
+deepagents/backends/protocol.py,sha256=HUmIrwYGduPfDcs_wtOzVU2QPA9kICZuGO-sUwxzz5I,15997
+deepagents/backends/sandbox.py,sha256=8Bi8itqjW2PpXORlIfT8thMN1aBXExgHz8cm8xwVaxI,10864
+deepagents/backends/state.py,sha256=yRfrEyHAl5NemkpMhBTU0TLAfgxF5t-TZpE3Pd3_PJg,6387
+deepagents/backends/store.py,sha256=0mmeTsim4J8bjcf62dljwNrDv4PavT2KHdGbaBzVzRE,15197
+deepagents/backends/utils.py,sha256=Iyk2jW-gfoLvMnz-W_2FRCoJW_j3r1zoumU9iww-jd0,13973
+deepagents/middleware/__init__.py,sha256=_OGIHcHZ2pRD0gzUBS7R48agwI6P7-FCBKBgjyaWlsg,303
+deepagents/middleware/filesystem.py,sha256=8_W5XNDYMN37BQjbqMyUAVWYv2KmRP87xwwomQ37K1w,44568
+deepagents/middleware/patch_tool_calls.py,sha256=PdNhxPaQqwnFkhEAZEE2kEzadTNAOO3_iJRA30WqpGE,1981
+deepagents/middleware/subagents.py,sha256=JOvFBXT-wqy-7zWKFL4-76zI0cfD-2f1ALDUTJDZVuE,23886
+deepagents-0.3.0.dist-info/METADATA,sha256=g2Xwexi4cMWi6GcCt-_sJGJCieGnOQWMNyMP_LuI45s,18790
+deepagents-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deepagents-0.3.0.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
+deepagents-0.3.0.dist-info/RECORD,,

deepagents-0.2.7.dist-info/RECORD

@@ -1,18 +0,0 @@
-deepagents/__init__.py,sha256=9BVNn4lfF5N8l2KY8Ttxi82zO609I-fGqoSIF7DAxiU,342
-deepagents/graph.py,sha256=c6ggWJIPaFOK2OCWxZdGEPDfuDvjdDuqHY06-bUiqPg,6379
-deepagents/backends/__init__.py,sha256=BOKu2cQ1OdMyO_l2rLqZQiXppYFmQbx7OIQb7WYwvZc,457
-deepagents/backends/composite.py,sha256=2BSyAurAt1FXV7iFyajzVaRZvjGkUPBybg7J8E6kRNE,9548
-deepagents/backends/filesystem.py,sha256=SsVDx__j_AARIwRzaDuokbxbkquJ_Lw3Qi7dLWaqRUs,18674
-deepagents/backends/protocol.py,sha256=Hi6u3MWIfMUGFWwnIFwvmwJbHYsx8IxeU2aaoP_9OMk,5831
-deepagents/backends/sandbox.py,sha256=JueMe_2cZcA359JIqIi8kDUkmdtevC4VbKHw-fBPOWs,10125
-deepagents/backends/state.py,sha256=ST_tUExPxArJaA3U8vc1dyzxuYl2BQH-HU7P0eu_Ty8,6518
-deepagents/backends/store.py,sha256=f2LVSl65Dg-BZl-cY3pl3RqrUJCBMBm2kuAzZEODwsE,13098
-deepagents/backends/utils.py,sha256=Iyk2jW-gfoLvMnz-W_2FRCoJW_j3r1zoumU9iww-jd0,13973
-deepagents/middleware/__init__.py,sha256=_OGIHcHZ2pRD0gzUBS7R48agwI6P7-FCBKBgjyaWlsg,303
-deepagents/middleware/filesystem.py,sha256=3PAetXqWy0i9bE6moM0FDZAEmjMm_M48B4AWWYl4Luk,37271
-deepagents/middleware/patch_tool_calls.py,sha256=PdNhxPaQqwnFkhEAZEE2kEzadTNAOO3_iJRA30WqpGE,1981
-deepagents/middleware/subagents.py,sha256=RbNpWLXC0Bhr0nUIs40whybNnzNkhxG9Fie7QKsICRk,23748
-deepagents-0.2.7.dist-info/METADATA,sha256=H5FgpjWX5qzV5uHcpm0ba4F1Jwtw_Kvj79U9mdUR3Os,18887
-deepagents-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deepagents-0.2.7.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
-deepagents-0.2.7.dist-info/RECORD,,