deepagents 0.0.12rc1__py3-none-any.whl → 0.0.12rc2__py3-none-any.whl

tests/test_filesystem.py

@@ -1,196 +0,0 @@
-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
-

tests/test_hitl.py

@@ -1,51 +0,0 @@
-from deepagents.graph import create_deep_agent
-from tests.utils import assert_all_deepagent_qualities, get_weather, sample_tool, get_soccer_scores
-from langgraph.checkpoint.memory import MemorySaver
-from langgraph.types import Command
-import uuid
-
-SAMPLE_TOOL_CONFIG = {
-    "sample_tool": True,
-    "get_weather": False,
-    "get_soccer_scores": {
-        "allow_accept": True,
-        "allow_reject": True,
-        "allow_respond": False,
-        "description": "Ohohohooooo"
-    },
-}
-
-class TestHITL:
-    def test_hitl_agent(self):
-        checkpointer = MemorySaver()
-        agent = create_deep_agent(tools=[sample_tool, get_weather, get_soccer_scores], tool_configs=SAMPLE_TOOL_CONFIG, checkpointer=checkpointer)
-        config = {
-            "configurable": {
-                "thread_id": uuid.uuid4()
-            }
-        }
-        assert_all_deepagent_qualities(agent)
-        result = agent.invoke({"messages": [{"role": "user", "content": "Call the sample tool, get the weather in New York and get scores for the latest soccer games in parallel"}]}, config=config)
-        agent_messages = [msg for msg in result.get("messages", []) if msg.type == "ai"]
-        tool_calls = [tool_call for msg in agent_messages for tool_call in msg.tool_calls]
-        assert any([tool_call["name"] == "sample_tool" for tool_call in tool_calls])
-        assert any([tool_call["name"] == "get_weather" for tool_call in tool_calls])
-        assert any([tool_call["name"] == "get_soccer_scores" for tool_call in tool_calls])
-        
-        assert result["__interrupt__"] is not None
-        interrupts = result["__interrupt__"][0].value
-        assert len(interrupts) == 2
-        assert any([interrupt["action_request"]["action"] == "sample_tool" for interrupt in interrupts])
-        assert any([interrupt["action_request"]["action"] == "get_soccer_scores" for interrupt in interrupts])
-
-        result2 = agent.invoke(
-            Command(
-                resume=[{"type": "accept"}, {"type": "accept"}]
-            ),
-            config=config
-        )
-        tool_results = [msg for msg in result2.get("messages", []) if msg.type == "tool"]
-        assert any([tool_result.name == "sample_tool" for tool_result in tool_results])
-        assert any([tool_result.name == "get_weather" for tool_result in tool_results])
-        assert any([tool_result.name == "get_soccer_scores" for tool_result in tool_results])
-        assert "__interrupt__" not in result2

tests/test_middleware.py

@@ -1,57 +0,0 @@
-from langchain.agents import create_agent
-from deepagents.middleware import (
-    PlanningMiddleware,
-    FilesystemMiddleware,
-    SubAgentMiddleware,
-)
-
-SAMPLE_MODEL = "claude-3-5-sonnet-20240620"
-
-class TestAddMiddleware:
-    def test_planning_middleware(self):
-        middleware = [PlanningMiddleware()]
-        agent = create_agent(model=SAMPLE_MODEL, middleware=middleware, tools=[])
-        assert "todos" in agent.stream_channels
-        assert "write_todos" in agent.nodes["tools"].bound._tools_by_name.keys()
-
-    def test_filesystem_middleware(self):
-        middleware = [FilesystemMiddleware()]
-        agent = create_agent(model=SAMPLE_MODEL, middleware=middleware, tools=[])
-        assert "files" in agent.stream_channels
-        agent_tools = agent.nodes["tools"].bound._tools_by_name.keys()
-        assert "ls" in agent_tools
-        assert "read_file" in agent_tools
-        assert "write_file" in agent_tools
-        assert "edit_file" in agent_tools
-
-    def test_subagent_middleware(self):
-        middleware = [
-            SubAgentMiddleware(
-                default_subagent_tools=[],
-                subagents=[],
-                model=SAMPLE_MODEL
-            )
-        ]
-        agent = create_agent(model=SAMPLE_MODEL, middleware=middleware, tools=[])
-        assert "task" in agent.nodes["tools"].bound._tools_by_name.keys()
-
-    def test_multiple_middleware(self):
-        middleware = [
-            PlanningMiddleware(),
-            FilesystemMiddleware(),
-            SubAgentMiddleware(
-                default_subagent_tools=[],
-                subagents=[],
-                model=SAMPLE_MODEL
-            )
-        ]
-        agent = create_agent(model=SAMPLE_MODEL, middleware=middleware, tools=[])
-        assert "todos" in agent.stream_channels
-        assert "files" in agent.stream_channels
-        agent_tools = agent.nodes["tools"].bound._tools_by_name.keys()
-        assert "write_todos" in agent_tools
-        assert "ls" in agent_tools
-        assert "read_file" in agent_tools
-        assert "write_file" in agent_tools
-        assert "edit_file" in agent_tools
-        assert "task" in agent_tools

tests/utils.py

@@ -1,81 +0,0 @@
-from langchain_core.tools import tool, InjectedToolCallId
-from langchain.agents.middleware import AgentMiddleware
-from typing import Annotated
-from langchain.tools.tool_node import InjectedState
-from langchain.agents.middleware import AgentMiddleware, AgentState
-from langgraph.types import Command
-from langchain_core.messages import ToolMessage
-
-def assert_all_deepagent_qualities(agent):
-    assert "todos" in agent.stream_channels
-    assert "files" in agent.stream_channels
-    assert "write_todos" in agent.nodes["tools"].bound._tools_by_name.keys()
-    assert "ls" in agent.nodes["tools"].bound._tools_by_name.keys()
-    assert "read_file" in agent.nodes["tools"].bound._tools_by_name.keys()
-    assert "write_file" in agent.nodes["tools"].bound._tools_by_name.keys()
-    assert "edit_file" in agent.nodes["tools"].bound._tools_by_name.keys()
-    assert "task" in agent.nodes["tools"].bound._tools_by_name.keys()
-
-###########################
-# Mock tools and middleware
-###########################
-
-SAMPLE_MODEL = "claude-3-5-sonnet-20240620"
-
-@tool(description="Use this tool to get the weather")
-def get_weather(location: str):
-    return f"The weather in {location} is sunny."
-
-@tool(description="Use this tool to get the latest soccer scores")
-def get_soccer_scores(team: str):
-    return f"The latest soccer scores for {team} are 2-1."
-
-@tool(description="Sample tool")
-def sample_tool(sample_input: str):
-    return sample_input
-
-@tool(description="Sample tool with injected state")
-def sample_tool_with_injected_state(sample_input: str, state: Annotated[dict, InjectedState]):
-    return sample_input + state["sample_input"]
-
-TOY_BASKETBALL_RESEARCH = "Lebron James is the best basketball player of all time with over 40k points and 21 seasons in the NBA."
-
-@tool(description="Use this tool to conduct research into basketball and save it to state")
-def research_basketball(
-    topic: str,
-    state: Annotated[dict, InjectedState],
-    tool_call_id: Annotated[str, InjectedToolCallId]
-):
-    current_research = state.get("research", "")
-    research = f"{current_research}\n\nResearching on {topic}... Done! {TOY_BASKETBALL_RESEARCH}"
-    return Command(
-        update={
-            "research": research,
-            "messages": [
-                ToolMessage(research, tool_call_id=tool_call_id)
-            ]
-        }
-    )
-
-class ResearchState(AgentState):
-    research: str
-
-class ResearchMiddlewareWithTools(AgentMiddleware):
-    state_schema = ResearchState
-    tools = [research_basketball]
-
-class ResearchMiddleware(AgentMiddleware):
-    state_schema = ResearchState
-
-class SampleMiddlewareWithTools(AgentMiddleware):
-    tools = [sample_tool]
-
-class SampleState(AgentState):
-    sample_input: str
-
-class SampleMiddlewareWithToolsAndState(AgentMiddleware):
-    state_schema = SampleState
-    tools = [sample_tool]
-
-class WeatherToolMiddleware(AgentMiddleware):
-    tools = [get_weather]