deepagents 0.0.11__tar.gz → 0.0.12rc1__tar.gz

{deepagents-0.0.11 → deepagents-0.0.12rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.0.11
+Version: 0.0.12rc1
 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

{deepagents-0.0.11 → deepagents-0.0.12rc1}/deepagents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepagents
-Version: 0.0.11
+Version: 0.0.12rc1
 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

{deepagents-0.0.11 → deepagents-0.0.12rc1}/deepagents.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ src/deepagents/state.py
 src/deepagents/tools.py
 src/deepagents/types.py
 tests/test_deepagents.py
+tests/test_filesystem.py
 tests/test_hitl.py
 tests/test_middleware.py
 tests/utils.py

{deepagents-0.0.11 → deepagents-0.0.12rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepagents"
-version = "0.0.11"
+version = "0.0.12rc1"
 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" }

{deepagents-0.0.11 → deepagents-0.0.12rc1}/src/deepagents/graph.py

@@ -2,6 +2,7 @@ from typing import Sequence, Union, Callable, Any, Type, Optional
 from langchain_core.tools import BaseTool
 from langchain_core.language_models import LanguageModelLike
 from langgraph.types import Checkpointer
+from langgraph.store.base import BaseStore
 from langchain.agents import create_agent
 from langchain.agents.middleware import AgentMiddleware, SummarizationMiddleware, HumanInTheLoopMiddleware
 from langchain.agents.middleware.human_in_the_loop import ToolConfig
@@ -20,6 +21,8 @@ def agent_builder(
     subagents: Optional[list[SubAgent | CustomSubAgent]] = None,
     context_schema: Optional[Type[Any]] = None,
     checkpointer: Optional[Checkpointer] = None,
+    store: Optional[BaseStore] = None,
+    use_longterm_memory: bool = False,
     is_async: bool = False,
 ):
     if model is None:
@@ -27,7 +30,9 @@ def agent_builder(
 
     deepagent_middleware = [
         PlanningMiddleware(),
-        FilesystemMiddleware(),
+        FilesystemMiddleware(
+            use_longterm_memory=use_longterm_memory,
+        ),
         SubAgentMiddleware(
             default_subagent_tools=tools,   # NOTE: These tools are piped to the general-purpose subagent.
             subagents=subagents if subagents is not None else [],
@@ -55,6 +60,7 @@ def agent_builder(
         middleware=deepagent_middleware,
         context_schema=context_schema,
         checkpointer=checkpointer,
+        store=store,
     )
 
 def create_deep_agent(
@@ -65,6 +71,8 @@ def create_deep_agent(
     subagents: Optional[list[SubAgent | CustomSubAgent]] = None,
     context_schema: Optional[Type[Any]] = None,
     checkpointer: Optional[Checkpointer] = None,
+    store: Optional[BaseStore] = None,
+    use_longterm_memory: bool = False,
     tool_configs: Optional[dict[str, bool | ToolConfig]] = None,
 ):
     """Create a deep agent.
@@ -85,6 +93,8 @@ def create_deep_agent(
                 - (optional) `middleware` (list of AgentMiddleware)
         context_schema: The schema of the deep agent.
         checkpointer: Optional checkpointer for persisting agent state between runs.
+        store: Optional store for persisting longterm memories.
+        use_longterm_memory: Whether to use longterm memory - you must provide a store in order to use longterm memory.
         tool_configs: Optional Dict[str, HumanInTheLoopConfig] mapping tool names to interrupt configs.
     """
     return agent_builder(
@@ -95,6 +105,8 @@ def create_deep_agent(
         subagents=subagents,
         context_schema=context_schema,
         checkpointer=checkpointer,
+        store=store,
+        use_longterm_memory=use_longterm_memory,
         tool_configs=tool_configs,
         is_async=False,
     )
@@ -107,6 +119,8 @@ def async_create_deep_agent(
     subagents: Optional[list[SubAgent | CustomSubAgent]] = None,
     context_schema: Optional[Type[Any]] = None,
     checkpointer: Optional[Checkpointer] = None,
+    store: Optional[BaseStore] = None,
+    use_longterm_memory: bool = False,
     tool_configs: Optional[dict[str, bool | ToolConfig]] = None,
 ):
     """Create a deep agent.
@@ -127,6 +141,8 @@ def async_create_deep_agent(
                 - (optional) `middleware` (list of AgentMiddleware)
         context_schema: The schema of the deep agent.
         checkpointer: Optional checkpointer for persisting agent state between runs.
+        use_longterm_memory: Whether to use longterm memory - you must provide a store in order to use longterm memory.
+        store: Optional store for persisting longterm memories.
         tool_configs: Optional Dict[str, HumanInTheLoopConfig] mapping tool names to interrupt configs.
     """
     return agent_builder(
@@ -137,6 +153,8 @@ def async_create_deep_agent(
         subagents=subagents,
         context_schema=context_schema,
         checkpointer=checkpointer,
+        store=store,
+        use_longterm_memory=use_longterm_memory,
         tool_configs=tool_configs,
         is_async=True,
     )

{deepagents-0.0.11 → deepagents-0.0.12rc1}/src/deepagents/middleware.py

@@ -11,8 +11,8 @@ from langgraph.runtime import Runtime
 from langchain.tools.tool_node import InjectedState
 from typing import Annotated
 from deepagents.state import PlanningState, FilesystemState
-from deepagents.tools import write_todos, ls, read_file, write_file, edit_file
-from deepagents.prompts import WRITE_TODOS_SYSTEM_PROMPT, TASK_SYSTEM_PROMPT, FILESYSTEM_SYSTEM_PROMPT, TASK_TOOL_DESCRIPTION, BASE_AGENT_PROMPT
+from deepagents.tools import write_todos, get_filesystem_tools
+from deepagents.prompts import WRITE_TODOS_SYSTEM_PROMPT, TASK_SYSTEM_PROMPT, FILESYSTEM_SYSTEM_PROMPT, FILESYSTEM_SYSTEM_PROMPT_LONGTERM_SUPPLEMENT, TASK_TOOL_DESCRIPTION, BASE_AGENT_PROMPT
 from deepagents.types import SubAgent, CustomSubAgent
 
 ###########################
@@ -24,7 +24,10 @@ class PlanningMiddleware(AgentMiddleware):
     tools = [write_todos]
 
     def modify_model_request(self, request: ModelRequest, agent_state: PlanningState, runtime: Runtime) -> ModelRequest:
-        request.system_prompt = request.system_prompt + "\n\n" + WRITE_TODOS_SYSTEM_PROMPT
+        if request.system_prompt is None:
+            request.system_prompt = WRITE_TODOS_SYSTEM_PROMPT
+        else:
+            request.system_prompt = request.system_prompt + "\n\n" + WRITE_TODOS_SYSTEM_PROMPT
         return request
 
 ###########################
@@ -33,10 +36,21 @@ class PlanningMiddleware(AgentMiddleware):
 
 class FilesystemMiddleware(AgentMiddleware):
     state_schema = FilesystemState
-    tools = [ls, read_file, write_file, edit_file]
+
+    def __init__(self, *, use_longterm_memory: bool = False, system_prompt: str = None, custom_tool_descriptions: dict[str, str] = {}) -> None:
+        self.system_prompt = FILESYSTEM_SYSTEM_PROMPT
+        if system_prompt is not None:
+            self.system_prompt = system_prompt
+        elif use_longterm_memory:
+            self.system_prompt += FILESYSTEM_SYSTEM_PROMPT_LONGTERM_SUPPLEMENT
+        
+        self.tools = get_filesystem_tools(use_longterm_memory, custom_tool_descriptions)
 
     def modify_model_request(self, request: ModelRequest, agent_state: FilesystemState, runtime: Runtime) -> ModelRequest:
-        request.system_prompt = request.system_prompt + "\n\n" + FILESYSTEM_SYSTEM_PROMPT
+        if request.system_prompt is None:
+            request.system_prompt = self.system_prompt
+        else:
+            request.system_prompt = request.system_prompt + "\n\n" + self.system_prompt
         return request
 
 ###########################
@@ -61,7 +75,10 @@ class SubAgentMiddleware(AgentMiddleware):
         self.tools = [task_tool]
 
     def modify_model_request(self, request: ModelRequest, agent_state: AgentState, runtime: Runtime) -> ModelRequest:
-        request.system_prompt = request.system_prompt + "\n\n" + TASK_SYSTEM_PROMPT
+        if request.system_prompt is None:
+            request.system_prompt = TASK_SYSTEM_PROMPT
+        else:
+            request.system_prompt = request.system_prompt + "\n\n" + TASK_SYSTEM_PROMPT
         return request
 
 def _get_agents(

{deepagents-0.0.11 → deepagents-0.0.12rc1}/src/deepagents/prompts.py

@@ -323,14 +323,15 @@ Since the user is greeting, use the greeting-responder agent to respond with a f
 assistant: "I'm going to use the Task tool to launch with the greeting-responder agent"
 </example>"""
 
-LIST_FILES_TOOL_DESCRIPTION = """Lists all files in the local filesystem.
+LIST_FILES_TOOL_DESCRIPTION = """Lists all files in the filesystem.
 
 Usage:
-- The list_files tool will return a list of all files in the local filesystem.
+- The list_files tool will return a list of all files in the filesystem.
 - This is very useful for exploring the file system and finding the right file to read or edit.
 - You should almost ALWAYS use this tool before using the Read or Edit tools."""
+LIST_FILES_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT = "\n- Files from the longterm filesystem will be prefixed with the memories/ path."
 
-READ_FILE_TOOL_DESCRIPTION = """Reads a file from the local filesystem. You can access any file directly by using this tool.
+READ_FILE_TOOL_DESCRIPTION = """Reads a file from the filesystem. You can access any file directly by using this tool.
 Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
 
 Usage:
@@ -339,27 +340,47 @@ Usage:
 - 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
 - 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. 
+- 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.
 - If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
 - You should ALWAYS make sure a file has been read before editing it."""
+READ_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT = "\n- file_paths prefixed with the memories/ path will be read from the longterm filesystem."
 
-EDIT_FILE_TOOL_DESCRIPTION = """Performs exact string replacements in files. 
+EDIT_FILE_TOOL_DESCRIPTION = """Performs exact string replacements in files.
 
 Usage:
-- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. 
+- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file.
 - When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
 - ALWAYS prefer editing existing files. NEVER write new files unless explicitly required.
 - Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
-- The edit will FAIL if `old_string` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`. 
+- The edit will FAIL if `old_string` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`.
 - Use `replace_all` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance."""
+EDIT_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT = "\n- You can edit files in the longterm filesystem by prefixing the filename with the memories/ path."
 
-WRITE_FILE_TOOL_DESCRIPTION = """Writes to a file in the local filesystem.
+WRITE_FILE_TOOL_DESCRIPTION = """Writes to a new file in the filesystem.
 
 Usage:
 - The file_path parameter must be an absolute path, not a relative path
 - The content parameter must be a string
 - The write_file tool will create the a new file.
-- Prefer to edit existing files over creating new ones when possible."""
+- Prefer to edit existing files over creating new ones when possible.
+- file_paths prefixed with the memories/ path will be written to the longterm filesystem."""
+WRITE_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT = "\n- file_paths prefixed with the memories/ path will be written to the longterm filesystem."
+
+FILESYSTEM_SYSTEM_PROMPT = """## Filesystem Tools `ls`, `read_file`, `write_file`, `edit_file`
+
+You have access to a filesystem which you can interact with using these tools.
+Do not prepend a / to file_paths.
+
+- ls: list all files in the filesystem
+- read_file: read a file from the filesystem
+- write_file: write to a file in the filesystem
+- edit_file: edit a file in the filesystem"""
+FILESYSTEM_SYSTEM_PROMPT_LONGTERM_SUPPLEMENT = """
+
+You also have access to a longterm filesystem in which you can store files that you want to keep around for longer than the current conversation.
+In order to interact with the longterm filesystem, you can use those same tools, but filenames must be prefixed with the memories/ path.
+Remember, to interact with the longterm filesystem, you must prefix the filename with the memories/ path."""
+
 
 WRITE_TODOS_SYSTEM_PROMPT = """## `write_todos`
 
@@ -403,14 +424,6 @@ When NOT to use the task tool:
 - Remember to use the `task` tool to silo independent tasks within a multi-part objective.
 - You should use the `task` tool whenever you have a complex task that will take multiple steps, and is independent from other tasks that the agent needs to complete. These agents are highly competent and efficient."""
 
-FILESYSTEM_SYSTEM_PROMPT = """## Filesystem Tools `ls`, `read_file`, `write_file`, `edit_file`
-
-You have access to a local, private filesystem which you can interact with using these tools.
-- ls: list all files in the local filesystem
-- read_file: read a file from the local filesystem
-- write_file: write to a file in the local filesystem
-- edit_file: edit a file in the local filesystem"""
-
 BASE_AGENT_PROMPT = """
 In order to complete the objective that the user asks of you, you have access to a number of standard tools.
 """

deepagents-0.0.12rc1/src/deepagents/tools.py

@@ -0,0 +1,313 @@
+from re import L
+from langchain_core.tools import tool, InjectedToolCallId
+from langchain_core.messages import ToolMessage
+from langgraph.types import Command
+from langgraph.runtime import get_runtime, Runtime
+from langchain.tools.tool_node import InjectedState
+from typing import Annotated, Any
+from deepagents.state import Todo, FilesystemState
+from deepagents.prompts import (
+    WRITE_TODOS_TOOL_DESCRIPTION,
+    LIST_FILES_TOOL_DESCRIPTION,
+    READ_FILE_TOOL_DESCRIPTION,
+    WRITE_FILE_TOOL_DESCRIPTION,
+    EDIT_FILE_TOOL_DESCRIPTION,
+    LIST_FILES_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT,
+    READ_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT,
+    WRITE_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT,
+    EDIT_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT,
+)
+
+def has_memories_prefix(file_path: str) -> bool:
+    return file_path.startswith("memories/")
+
+def append_memories_prefix(file_path: str) -> str:
+    return f"memories/{file_path}"
+
+def strip_memories_prefix(file_path: str) -> str:
+    return file_path.replace("memories/", "")
+
+def get_namespace(runtime: Runtime[Any]) -> tuple[str, str]:
+    namespace = ("filesystem")
+    if runtime.context is None:
+        return namespace
+    assistant_id = runtime.context.get("assistant_id")
+    if assistant_id is None:
+        return namespace
+    return (assistant_id, "filesystem")
+
+@tool(description=WRITE_TODOS_TOOL_DESCRIPTION)
+def write_todos(
+    todos: list[Todo], tool_call_id: Annotated[str, InjectedToolCallId]
+) -> Command:
+    return Command(
+        update={
+            "todos": todos,
+            "messages": [
+                ToolMessage(f"Updated todo list to {todos}", tool_call_id=tool_call_id)
+            ],
+        }
+    )
+
+def ls_tool_generator(has_longterm_memory: bool, custom_description: str = None) -> tool:
+    tool_description = LIST_FILES_TOOL_DESCRIPTION
+    if custom_description:
+        tool_description = custom_description
+    elif has_longterm_memory:
+        tool_description += LIST_FILES_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT
+
+    if has_longterm_memory:
+        # Tool with Long-term memory
+        @tool(description=tool_description)
+        def ls(state: Annotated[FilesystemState, InjectedState]) -> list[str]:
+            files = []
+            files.extend(list(state.get("files", {}).keys()))
+
+            runtime = get_runtime()
+            store = runtime.store
+            if store is None: 
+                raise ValueError("Longterm memory is enabled, but no store is available")
+            namespace = get_namespace(runtime)
+            file_data_list = store.search(namespace)
+            memories_files = [append_memories_prefix(f.key) for f in file_data_list]
+            files.extend(memories_files)
+            return files
+    else:
+        # Tool without long-term memory
+        @tool(description=tool_description)
+        def ls(state: Annotated[FilesystemState, InjectedState]) -> list[str]:
+            files = list(state.get("files", {}).keys())
+            return files
+    return ls
+    
+
+def read_file_tool_generator(has_longterm_memory: bool, custom_description: str = None) -> tool:
+    tool_description = READ_FILE_TOOL_DESCRIPTION
+    if custom_description:
+        tool_description = custom_description
+    elif has_longterm_memory:
+        tool_description += READ_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT
+
+    if has_longterm_memory:
+        # Tool with Long-term memory
+        @tool(description=tool_description)
+        def read_file(
+            file_path: str,
+            state: Annotated[FilesystemState, InjectedState],
+            offset: int = 0,
+            limit: int = 2000,
+        ) -> str:
+            if has_memories_prefix(file_path):
+                stripped_file_path = strip_memories_prefix(file_path)
+                runtime = get_runtime()
+                store = runtime.store
+                if store is None:
+                    raise ValueError("Longterm memory is enabled, but no store is available")
+                namespace = get_namespace(runtime)
+                item = store.get(namespace, stripped_file_path)
+                if item is None:
+                    return f"Error: File '{file_path}' not found"
+                content = item.value
+            else: 
+                mock_filesystem = state.get("files", {})
+                if file_path not in mock_filesystem:
+                    return f"Error: File '{file_path}' not found"
+                content = mock_filesystem[file_path]
+            if not content or content.strip() == "":
+                return "System reminder: File exists but has empty contents"
+            lines = content.splitlines()
+            start_idx = offset
+            end_idx = min(start_idx + limit, len(lines))
+            if start_idx >= len(lines):
+                return f"Error: Line offset {offset} exceeds file length ({len(lines)} lines)"
+            result_lines = []
+            for i in range(start_idx, end_idx):
+                line_content = lines[i]
+                if len(line_content) > 2000:
+                    line_content = line_content[:2000]
+                line_number = i + 1
+                result_lines.append(f"{line_number:6d}\t{line_content}")
+
+            return "\n".join(result_lines)
+    else:
+        # Tool without long-term memory
+        @tool(description=tool_description)
+        def read_file(
+            file_path: str,
+            state: Annotated[FilesystemState, InjectedState],
+            offset: int = 0,
+            limit: int = 2000,
+        ) -> str:
+            mock_filesystem = state.get("files", {})
+            if file_path not in mock_filesystem:
+                return f"Error: File '{file_path}' not found"
+            content = mock_filesystem[file_path]
+            if not content or content.strip() == "":
+                return "System reminder: File exists but has empty contents"
+            lines = content.splitlines()
+            start_idx = offset
+            end_idx = min(start_idx + limit, len(lines))
+            if start_idx >= len(lines):
+                return f"Error: Line offset {offset} exceeds file length ({len(lines)} lines)"
+            result_lines = []
+            for i in range(start_idx, end_idx):
+                line_content = lines[i]
+                if len(line_content) > 2000:
+                    line_content = line_content[:2000]
+                line_number = i + 1
+                result_lines.append(f"{line_number:6d}\t{line_content}")
+
+            return "\n".join(result_lines)
+    return read_file
+
+
+def write_file_tool_generator(has_longterm_memory: bool, custom_description: str = None) -> tool:
+    tool_description = WRITE_FILE_TOOL_DESCRIPTION
+    if custom_description:
+        tool_description = custom_description
+    elif has_longterm_memory:
+        tool_description += WRITE_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT
+
+    if has_longterm_memory:
+        # Tool with Long-term memory
+        @tool(description=tool_description)
+        def write_file(file_path: str, content: str, state: Annotated[FilesystemState, InjectedState], tool_call_id: Annotated[str, InjectedToolCallId]) -> Command:
+            if has_memories_prefix(file_path):
+                stripped_file_path = strip_memories_prefix(file_path)
+                runtime = get_runtime()
+                store = runtime.store
+                if store is None:
+                    raise ValueError("Longterm memory is enabled, but no store is available")
+                namespace = get_namespace(runtime)
+                store.put(namespace, stripped_file_path, content)
+                return Command(
+                    update={
+                        "messages": [ToolMessage(f"Updated longterm memories file {file_path}", tool_call_id=tool_call_id)]
+                    }
+                )
+            else:
+                mock_filesystem = state.get("files", {})
+                mock_filesystem[file_path] = content
+                return Command(
+                    update={
+                        "files": mock_filesystem,
+                        "messages": [ToolMessage(f"Updated file {file_path}", tool_call_id=tool_call_id)]
+                    }
+                )
+    else:
+        # Tool without long-term memory
+        @tool(description=tool_description)
+        def write_file(file_path: str, content: str, state: Annotated[FilesystemState, InjectedState], tool_call_id: Annotated[str, InjectedToolCallId]) -> Command:
+            mock_filesystem = state.get("files", {})
+            mock_filesystem[file_path] = content
+            return Command(
+                update={
+                    "files": mock_filesystem,
+                    "messages": [ToolMessage(f"Updated file {file_path}", tool_call_id=tool_call_id)]
+                }
+            )
+    return write_file
+
+
+def edit_file_tool_generator(has_longterm_memory: bool, custom_description: str = None) -> tool:
+    tool_description = EDIT_FILE_TOOL_DESCRIPTION
+    if custom_description:
+        tool_description = custom_description
+    elif has_longterm_memory:
+        tool_description += EDIT_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT
+
+    if has_longterm_memory:
+        # Tool with Long-term memory
+        @tool(description=tool_description)
+        def edit_file(file_path: str, old_string: str, new_string: str, state: Annotated[FilesystemState, InjectedState], tool_call_id: Annotated[str, InjectedToolCallId], replace_all: bool = False) -> Command:
+            if has_memories_prefix(file_path):
+                stripped_file_path = strip_memories_prefix(file_path)
+                runtime = get_runtime()
+                store = runtime.store
+                if store is None:
+                    raise ValueError("Longterm memory is enabled, but no store is available")
+                namespace = get_namespace(runtime)
+                item = store.get(namespace, stripped_file_path)
+                if item is None:
+                    return f"Error: File '{file_path}' not found"
+                content = item.value
+                if old_string not in content:
+                    return f"Error: String not found in file: '{old_string}'"
+                if not replace_all:
+                    occurrences = content.count(old_string)
+                    if occurrences > 1:
+                        return f"Error: String '{old_string}' appears {occurrences} times in file. Use replace_all=True to replace all instances, or provide a more specific string with surrounding context."
+                    elif occurrences == 0:
+                        return f"Error: String not found in file: '{old_string}'"
+                new_content = content.replace(old_string, new_string)
+                replacement_count = content.count(old_string)
+                store.put(namespace, stripped_file_path, new_content)
+                return Command(
+                    update={
+                        "messages": [ToolMessage(f"Successfully replaced {replacement_count} instance(s) of the string in '{file_path}'", tool_call_id=tool_call_id)]
+                    }
+                )
+            else:
+                mock_filesystem = state.get("files", {})
+                if file_path not in mock_filesystem:
+                    return f"Error: File '{file_path}' not found"
+                content = mock_filesystem[file_path]
+                if old_string not in content:
+                    return f"Error: String not found in file: '{old_string}'"
+                if not replace_all:
+                    occurrences = content.count(old_string)
+                    if occurrences > 1:
+                        return f"Error: String '{old_string}' appears {occurrences} times in file. Use replace_all=True to replace all instances, or provide a more specific string with surrounding context."
+                    elif occurrences == 0:
+                        return f"Error: String not found in file: '{old_string}'"
+                new_content = content.replace(old_string, new_string)
+                replacement_count = content.count(old_string)
+                result_msg = f"Successfully replaced {replacement_count} instance(s) of the string in '{file_path}'"
+                mock_filesystem[file_path] = new_content
+                return Command(
+                    update={
+                        "files": mock_filesystem,
+                        "messages": [ToolMessage(result_msg, tool_call_id=tool_call_id)],
+                    }
+                )
+    else:
+        # Tool without long-term memory
+        @tool(description=tool_description)
+        def edit_file(file_path: str, old_string: str, new_string: str, state: Annotated[FilesystemState, InjectedState], tool_call_id: Annotated[str, InjectedToolCallId], replace_all: bool = False) -> Command:
+            mock_filesystem = state.get("files", {})
+            if file_path not in mock_filesystem:
+                return f"Error: File '{file_path}' not found"
+            content = mock_filesystem[file_path]
+            if old_string not in content:
+                return f"Error: String not found in file: '{old_string}'"
+            if not replace_all:
+                occurrences = content.count(old_string)
+                if occurrences > 1:
+                    return f"Error: String '{old_string}' appears {occurrences} times in file. Use replace_all=True to replace all instances, or provide a more specific string with surrounding context."
+                elif occurrences == 0:
+                    return f"Error: String not found in file: '{old_string}'"
+            new_content = content.replace(old_string, new_string)
+            replacement_count = content.count(old_string)
+            result_msg = f"Successfully replaced {replacement_count} instance(s) of the string in '{file_path}'"
+            mock_filesystem[file_path] = new_content
+            return Command(
+                update={
+                    "files": mock_filesystem,
+                    "messages": [ToolMessage(result_msg, tool_call_id=tool_call_id)],
+                }
+            )
+    return edit_file
+
+TOOL_GENERATORS = {
+    "ls": ls_tool_generator,
+    "read_file": read_file_tool_generator,
+    "write_file": write_file_tool_generator,
+    "edit_file": edit_file_tool_generator,
+}
+
+def get_filesystem_tools(has_longterm_memory: bool, custom_tool_descriptions: dict[str, str] = {}) -> list[tool]:
+    tools = []
+    for tool_name, tool_generator in TOOL_GENERATORS.items():
+        tool = tool_generator(has_longterm_memory, custom_tool_descriptions.get(tool_name, None))
+        tools.append(tool)
+    return tools

deepagents-0.0.12rc1/tests/test_filesystem.py

@@ -0,0 +1,196 @@
+from deepagents.graph import create_deep_agent
+from deepagents.middleware import FilesystemMiddleware
+from deepagents.prompts import WRITE_FILE_TOOL_DESCRIPTION, WRITE_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT
+from langchain.agents import create_agent
+import pytest
+from langchain_core.messages import HumanMessage
+from langchain_anthropic import ChatAnthropic
+from langgraph.store.memory import InMemoryStore
+from langgraph.checkpoint.memory import MemorySaver
+import uuid
+
+class TestFilesystem:
+    def test_create_deepagent_without_store_and_with_longterm_memory_should_fail(self):
+        with pytest.raises(ValueError):
+            deepagent = create_deep_agent(tools=[], use_longterm_memory=True)
+            deepagent.invoke({"messages": [HumanMessage(content="List all of the files in your filesystem?")]})
+
+    def test_filesystem_system_prompt_override(self):
+        agent = create_agent(
+            model=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
+            middleware=[
+                FilesystemMiddleware(
+                    use_longterm_memory=False,
+                    system_prompt="In every single response, you must say the word 'pokemon'! You love it!"
+                )
+            ]
+        )
+        response = agent.invoke({"messages": [HumanMessage(content="What do you like?")]})
+        assert "pokemon" in response["messages"][1].text.lower()
+
+    def test_filesystem_system_prompt_override_with_longterm_memory(self):
+        agent = create_agent(
+            model=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
+            middleware=[
+                FilesystemMiddleware(
+                    use_longterm_memory=True,
+                    system_prompt="In every single response, you must say the word 'pokemon'! You love it!"
+                )
+            ],
+            store=InMemoryStore()
+        )
+        response = agent.invoke({"messages": [HumanMessage(content="What do you like?")]})
+        assert "pokemon" in response["messages"][1].text.lower()
+
+    def test_filesystem_tool_prompt_override(self):
+        agent = create_agent(
+            model=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
+            middleware=[
+                FilesystemMiddleware(
+                    use_longterm_memory=False,
+                    custom_tool_descriptions={
+                        "ls": "Charmander",
+                        "read_file": "Bulbasaur",
+                        "edit_file": "Squirtle"
+                    }
+                )
+            ],
+        )
+        tools = agent.nodes["tools"].bound._tools_by_name
+        assert "ls" in tools
+        assert tools["ls"].description == "Charmander"
+        assert "read_file" in tools
+        assert tools["read_file"].description == "Bulbasaur"
+        assert "write_file" in tools
+        assert tools["write_file"].description == WRITE_FILE_TOOL_DESCRIPTION
+        assert "edit_file" in tools
+        assert tools["edit_file"].description == "Squirtle"
+
+    def test_filesystem_tool_prompt_override_with_longterm_memory(self):
+        agent = create_agent(
+            model=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
+            middleware=[
+                FilesystemMiddleware(
+                    use_longterm_memory=True,
+                    custom_tool_descriptions={
+                        "ls": "Charmander",
+                        "read_file": "Bulbasaur",
+                        "edit_file": "Squirtle"
+                    }
+                )
+            ],
+            store=InMemoryStore()
+        )
+        tools = agent.nodes["tools"].bound._tools_by_name
+        assert "ls" in tools
+        assert tools["ls"].description == "Charmander"
+        assert "read_file" in tools
+        assert tools["read_file"].description == "Bulbasaur"
+        assert "write_file" in tools
+        assert tools["write_file"].description == WRITE_FILE_TOOL_DESCRIPTION + WRITE_FILE_TOOL_DESCRIPTION_LONGTERM_SUPPLEMENT
+        assert "edit_file" in tools
+        assert tools["edit_file"].description == "Squirtle"
+
+
+    def test_longterm_memory_tools(self):
+        checkpointer = MemorySaver()
+        store = InMemoryStore()
+        agent = create_agent(
+            model=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
+            middleware=[
+                FilesystemMiddleware(
+                    use_longterm_memory=True,
+                )
+            ],
+            checkpointer=checkpointer,
+            store=store
+        )
+        assert_longterm_mem_tools(agent, store)
+
+
+    def test_longterm_memory_tools_deepagent(self):
+        checkpointer = MemorySaver()
+        store = InMemoryStore()
+        agent = create_deep_agent(
+            use_longterm_memory=True,
+            checkpointer=checkpointer,
+            store=store
+        )
+        assert_longterm_mem_tools(agent, store)
+
+    
+    def test_shortterm_memory_tools_deepagent(self):
+        checkpointer = MemorySaver()
+        store = InMemoryStore()
+        agent = create_deep_agent(
+            use_longterm_memory=False,
+            checkpointer=checkpointer,
+            store=store
+        )
+        assert_shortterm_mem_tools(agent)
+
+
+def assert_longterm_mem_tools(agent, store):
+    config = {"configurable": {"thread_id": uuid.uuid4()}}
+    agent.invoke({"messages": [HumanMessage(content="Write a haiku about Charmander to longterm memory in charmander.txt, use the word 'fiery'")]}, config=config)
+
+    namespaces = store.list_namespaces()
+    assert len(namespaces) == 1
+    assert namespaces[0] == "filesystem"
+    file_item = store.get(("filesystem"), "charmander.txt")
+    assert file_item is not None
+    assert file_item.key == "charmander.txt"
+
+    config2 = {"configurable": {"thread_id": uuid.uuid4()}}
+    response = agent.invoke({"messages": [HumanMessage(content="Read the haiku about Charmander from longterm memory at charmander.txt")]}, config=config2)
+
+    messages = response["messages"]
+    read_file_message = next(message for message in messages if message.type == "tool" and message.name == "read_file")
+    assert "fiery" in read_file_message.content or "Fiery" in read_file_message.content
+
+    config3 = {"configurable": {"thread_id": uuid.uuid4()}}
+    response = agent.invoke({"messages": [HumanMessage(content="List all of the files in longterm memory")]}, config=config3)
+    messages = response["messages"]
+    ls_message = next(message for message in messages if message.type == "tool" and message.name == "ls")
+    assert "memories/charmander.txt" in ls_message.content
+
+    config4 = {"configurable": {"thread_id": uuid.uuid4()}}
+    response = agent.invoke({"messages": [HumanMessage(content="Edit the haiku about Charmander in longterm memory to use the word 'ember'")]}, config=config4)
+    file_item = store.get(("filesystem"), "charmander.txt")
+    assert file_item is not None
+    assert file_item.key == "charmander.txt"
+    assert "ember" in file_item.value or "Ember" in file_item.value
+
+    config5 = {"configurable": {"thread_id": uuid.uuid4()}}
+    response = agent.invoke({"messages": [HumanMessage(content="Read the haiku about Charmander from longterm memory at charmander.txt")]}, config=config5)
+    messages = response["messages"]
+    read_file_message = next(message for message in messages if message.type == "tool" and message.name == "read_file")
+    assert "ember" in read_file_message.content or "Ember" in read_file_message.content
+
+
+def assert_shortterm_mem_tools(agent):
+    config = {"configurable": {"thread_id": uuid.uuid4()}}
+    response = agent.invoke({"messages": [HumanMessage(content="Write a haiku about Charmander to charmander.txt, use the word 'fiery'")]}, config=config)
+    files = response["files"]
+    assert "charmander.txt" in files
+
+    response = agent.invoke({"messages": [HumanMessage(content="Read the haiku about Charmander from charmander.txt")]}, config=config)
+    messages = response["messages"]
+    read_file_message = next(message for message in reversed(messages) if message.type == "tool" and message.name == "read_file")
+    assert "fiery" in read_file_message.content or "Fiery" in read_file_message.content
+
+    response = agent.invoke({"messages": [HumanMessage(content="List all of the files in memory")]}, config=config)
+    messages = response["messages"]
+    ls_message = next(message for message in messages if message.type == "tool" and message.name == "ls")
+    assert "charmander.txt" in ls_message.content
+
+    response = agent.invoke({"messages": [HumanMessage(content="Edit the haiku about Charmander to use the word 'ember'")]}, config=config)
+    files = response["files"]
+    assert "charmander.txt" in files
+    assert "ember" in files["charmander.txt"] or "Ember" in files["charmander.txt"]
+
+    response = agent.invoke({"messages": [HumanMessage(content="Read the haiku about Charmander at charmander.txt")]}, config=config)
+    messages = response["messages"]
+    read_file_message = next(message for message in reversed(messages) if message.type == "tool" and message.name == "read_file")
+    assert "ember" in read_file_message.content or "Ember" in read_file_message.content
+

deepagents-0.0.11/src/deepagents/tools.py

@@ -1,148 +0,0 @@
-from langchain_core.tools import tool, InjectedToolCallId
-from langchain_core.messages import ToolMessage
-from langgraph.types import Command
-from langchain.tools.tool_node import InjectedState
-from typing import Annotated, Union
-from deepagents.state import Todo, FilesystemState
-from deepagents.prompts import (
-    WRITE_TODOS_TOOL_DESCRIPTION,
-    LIST_FILES_TOOL_DESCRIPTION,
-    READ_FILE_TOOL_DESCRIPTION,
-    WRITE_FILE_TOOL_DESCRIPTION,
-    EDIT_FILE_TOOL_DESCRIPTION,
-)
-
-
-@tool(description=WRITE_TODOS_TOOL_DESCRIPTION)
-def write_todos(
-    todos: list[Todo], tool_call_id: Annotated[str, InjectedToolCallId]
-) -> Command:
-    return Command(
-        update={
-            "todos": todos,
-            "messages": [
-                ToolMessage(f"Updated todo list to {todos}", tool_call_id=tool_call_id)
-            ],
-        }
-    )
-
-
-@tool(description=LIST_FILES_TOOL_DESCRIPTION)
-def ls(state: Annotated[FilesystemState, InjectedState]) -> list[str]:
-    """List all files"""
-    return list(state.get("files", {}).keys())
-
-
-@tool(description=READ_FILE_TOOL_DESCRIPTION)
-def read_file(
-    file_path: str,
-    state: Annotated[FilesystemState, InjectedState],
-    offset: int = 0,
-    limit: int = 2000,
-) -> str:
-    mock_filesystem = state.get("files", {})
-    if file_path not in mock_filesystem:
-        return f"Error: File '{file_path}' not found"
-
-    # Get file content
-    content = mock_filesystem[file_path]
-
-    # Handle empty file
-    if not content or content.strip() == "":
-        return "System reminder: File exists but has empty contents"
-
-    # Split content into lines
-    lines = content.splitlines()
-
-    # Apply line offset and limit
-    start_idx = offset
-    end_idx = min(start_idx + limit, len(lines))
-
-    # Handle case where offset is beyond file length
-    if start_idx >= len(lines):
-        return f"Error: Line offset {offset} exceeds file length ({len(lines)} lines)"
-
-    # Format output with line numbers (cat -n format)
-    result_lines = []
-    for i in range(start_idx, end_idx):
-        line_content = lines[i]
-
-        # Truncate lines longer than 2000 characters
-        if len(line_content) > 2000:
-            line_content = line_content[:2000]
-
-        # Line numbers start at 1, so add 1 to the index
-        line_number = i + 1
-        result_lines.append(f"{line_number:6d}\t{line_content}")
-
-    return "\n".join(result_lines)
-
-
-@tool(description=WRITE_FILE_TOOL_DESCRIPTION)
-def write_file(
-    file_path: str,
-    content: str,
-    state: Annotated[FilesystemState, InjectedState],
-    tool_call_id: Annotated[str, InjectedToolCallId],
-) -> Command:
-    files = state.get("files", {})
-    files[file_path] = content
-    return Command(
-        update={
-            "files": files,
-            "messages": [
-                ToolMessage(f"Updated file {file_path}", tool_call_id=tool_call_id)
-            ],
-        }
-    )
-
-
-@tool(description=EDIT_FILE_TOOL_DESCRIPTION)
-def edit_file(
-    file_path: str,
-    old_string: str,
-    new_string: str,
-    state: Annotated[FilesystemState, InjectedState],
-    tool_call_id: Annotated[str, InjectedToolCallId],
-    replace_all: bool = False,
-) -> Union[Command, str]:
-    """Write to a file."""
-    mock_filesystem = state.get("files", {})
-    # Check if file exists in mock filesystem
-    if file_path not in mock_filesystem:
-        return f"Error: File '{file_path}' not found"
-
-    # Get current file content
-    content = mock_filesystem[file_path]
-
-    # Check if old_string exists in the file
-    if old_string not in content:
-        return f"Error: String not found in file: '{old_string}'"
-
-    # If not replace_all, check for uniqueness
-    if not replace_all:
-        occurrences = content.count(old_string)
-        if occurrences > 1:
-            return f"Error: String '{old_string}' appears {occurrences} times in file. Use replace_all=True to replace all instances, or provide a more specific string with surrounding context."
-        elif occurrences == 0:
-            return f"Error: String not found in file: '{old_string}'"
-
-    # Perform the replacement
-    if replace_all:
-        new_content = content.replace(old_string, new_string)
-        replacement_count = content.count(old_string)
-        result_msg = f"Successfully replaced {replacement_count} instance(s) of the string in '{file_path}'"
-    else:
-        new_content = content.replace(
-            old_string, new_string, 1
-        )  # Replace only first occurrence
-        result_msg = f"Successfully replaced string in '{file_path}'"
-
-    # Update the mock filesystem
-    mock_filesystem[file_path] = new_content
-    return Command(
-        update={
-            "files": mock_filesystem,
-            "messages": [ToolMessage(result_msg, tool_call_id=tool_call_id)],
-        }
-    )