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

deepagents/tools.py

@@ -1,201 +0,0 @@
-from re import L
-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,
-)
-from ai_filesystem import FilesystemClient
-import os
-
-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/", "")
-
-@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"""
-    files = []
-    files.extend(list(state.get("files", {}).keys()))
-    # Special handling for longterm filesystem
-    if os.getenv("LONGTERM_FILESYSTEM_NAME") and os.getenv("AGENT_FS_API_KEY"):
-        filesystem_client = FilesystemClient(
-            filesystem=os.getenv("LONGTERM_FILESYSTEM_NAME")
-        )
-        file_data_list = filesystem_client._list_files()
-        memories_files = [f"memories/{f.path}" for f in file_data_list]
-        files.extend(memories_files)
-    return files
-
-
-@tool(description=READ_FILE_TOOL_DESCRIPTION)
-def read_file(
-    file_path: str,
-    state: Annotated[FilesystemState, InjectedState],
-    offset: int = 0,
-    limit: int = 2000,
-) -> str:
-    # Special handling for longterm filesystem
-    if os.getenv("LONGTERM_FILESYSTEM_NAME") and os.getenv("AGENT_FS_API_KEY") and has_memories_prefix(file_path):
-        filesystem_client = FilesystemClient(
-            filesystem=os.getenv("LONGTERM_FILESYSTEM_NAME")
-        )
-        file_path = strip_memories_prefix(file_path)
-        content = filesystem_client.read_file(file_path)
-        return content
-
-    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:
-    # Special handling for longterm filesystem
-    if os.getenv("LONGTERM_FILESYSTEM_NAME") and os.getenv("AGENT_FS_API_KEY") and has_memories_prefix(file_path):
-        filesystem_client = FilesystemClient(
-            filesystem=os.getenv("LONGTERM_FILESYSTEM_NAME")
-        )
-        short_file_path = strip_memories_prefix(file_path)
-        filesystem_client.create_file(short_file_path, content)
-        return Command(
-            update={
-                "messages": [ToolMessage(f"Updated longterm memories file {file_path}", tool_call_id=tool_call_id)]
-            }
-        )
-
-    files = state.get("files", {})
-    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."""
-    # Special handling for longterm filesystem
-    if os.getenv("LONGTERM_FILESYSTEM_NAME") and os.getenv("AGENT_FS_API_KEY") and has_memories_prefix(file_path):
-        filesystem_client = FilesystemClient(
-            filesystem=os.getenv("LONGTERM_FILESYSTEM_NAME")
-        )
-        short_file_path = strip_memories_prefix(file_path)
-        filesystem_client.edit_file(short_file_path, old_string, new_string, replace_all)
-        return Command(
-            update={
-                "messages": [ToolMessage(f"Successfully edited longterm memories file {file_path}", tool_call_id=tool_call_id)]
-            }
-        )
-
-    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)],
-        }
-    )

deepagents/types.py

@@ -1,21 +0,0 @@
-from typing import NotRequired, Union, Any
-from typing_extensions import TypedDict
-from langchain_core.language_models import LanguageModelLike
-from langchain.agents.middleware import AgentMiddleware
-from langchain_core.runnables import Runnable
-from langchain_core.tools import BaseTool
-
-class SubAgent(TypedDict):
-    name: str
-    description: str
-    prompt: str
-    tools: NotRequired[list[BaseTool]]
-    # Optional per-subagent model: can be either a model instance OR dict settings
-    model: NotRequired[Union[LanguageModelLike, dict[str, Any]]]
-    middleware: NotRequired[list[AgentMiddleware]]
-
-
-class CustomSubAgent(TypedDict):
-    name: str
-    description: str
-    graph: Runnable

deepagents-0.0.11rc1.dist-info/RECORD

@@ -1,17 +0,0 @@
-deepagents/__init__.py,sha256=fA_91ByxPb3e8aPfci43zOXrWz8ylh_CFQALo7EUKi8,312
-deepagents/graph.py,sha256=sLN0gWJma9dGgJI_RHDK-I1cEZMCo8nfxuF4a8vN7Po,6288
-deepagents/middleware.py,sha256=P2y1crsedTH1uZlKS3fpc7pd4jwz8dR8jnw7repUjLk,7254
-deepagents/model.py,sha256=VyRIkdeXJH8HqLrudTKucHpBTtrwMFTQGRlXBj0kUyo,155
-deepagents/prompts.py,sha256=hiyiUriv-B3IQ0lwRqiJsvtgvwSS4wdeMNdXojHUisc,25603
-deepagents/state.py,sha256=8so3MgL-zRPYP8Ci_OuVg4wHrs5uAXCErKF1AjjCSt8,726
-deepagents/tools.py,sha256=kTS-O8jWJsUnX0tBl19Iyg8fSR2jhD8c7jDz_xNrw0I,7138
-deepagents/types.py,sha256=5KBSUPlWOnv9It3SnJCMHrOtp9Y4_NQGtGCp69JsEjE,694
-deepagents-0.0.11rc1.dist-info/licenses/LICENSE,sha256=c__BaxUCK69leo2yEKynf8lWndu8iwYwge1CbyqAe-E,1071
-tests/test_deepagents.py,sha256=SwtOiJF4c1O3r_Q3AiM7XZu6tVq4uMIcZlnsfRjx8Ig,7648
-tests/test_hitl.py,sha256=B16ZFiyaVSOcDLz7mh1RTaQZ93EMTKOPUY-IEslkcfM,2460
-tests/test_middleware.py,sha256=3HYmTx0Jw4XTNJjqLYeyGS_QZzcqkFuKfShtajIDhF4,2146
-tests/utils.py,sha256=Ln_DYaMkwAVBo4XQ-QKwlCWP8zZYMenWTcFhsneoL0g,2913
-deepagents-0.0.11rc1.dist-info/METADATA,sha256=nWOCcZljXdWY9tm3Gc_0Wyt7ZK0WScU0MhZY-jlJKuY,17331
-deepagents-0.0.11rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deepagents-0.0.11rc1.dist-info/top_level.txt,sha256=_w9VMQtG4YDNg5A5eAeUre7dF7x7hk9zRpT9zsFaukY,17
-deepagents-0.0.11rc1.dist-info/RECORD,,

tests/test_deepagents.py

@@ -1,136 +0,0 @@
-from deepagents.graph import create_deep_agent
-from langchain.agents import create_agent
-from tests.utils import assert_all_deepagent_qualities, SAMPLE_MODEL, sample_tool, get_weather, get_soccer_scores, SampleMiddlewareWithTools, SampleMiddlewareWithToolsAndState, WeatherToolMiddleware, ResearchMiddleware, ResearchMiddlewareWithTools, TOY_BASKETBALL_RESEARCH
-
-class TestDeepAgents:
-    def test_base_deep_agent(self):
-        agent = create_deep_agent()
-        assert_all_deepagent_qualities(agent)
-
-    def test_deep_agent_with_tool(self):
-        agent = create_deep_agent(tools=[sample_tool])
-        assert_all_deepagent_qualities(agent)
-        assert "sample_tool" in agent.nodes["tools"].bound._tools_by_name.keys()
-
-    def test_deep_agent_with_middleware_with_tool(self):
-        agent = create_deep_agent(middleware=[SampleMiddlewareWithTools()])
-        assert_all_deepagent_qualities(agent)
-        assert "sample_tool" in agent.nodes["tools"].bound._tools_by_name.keys()
-
-    def test_deep_agent_with_middleware_with_tool_and_state(self):
-        agent = create_deep_agent(middleware=[SampleMiddlewareWithToolsAndState()])
-        assert_all_deepagent_qualities(agent)
-        assert "sample_tool" in agent.nodes["tools"].bound._tools_by_name.keys()
-        assert "sample_input" in agent.stream_channels
-
-    def test_deep_agent_with_subagents(self):
-        subagents = [
-            {
-                "name": "weather_agent",
-                "description": "Use this agent to get the weather",
-                "prompt": "You are a weather agent.",
-                "tools": [get_weather],
-                "model": SAMPLE_MODEL,
-            }
-        ]
-        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
-        assert_all_deepagent_qualities(agent)
-        result = agent.invoke({"messages": [{"role": "user", "content": "What is the weather in Tokyo?"}]})
-        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"] == "task" and tool_call["args"].get("subagent_type") == "weather_agent" for tool_call in tool_calls])
-
-    def test_deep_agent_with_subagents_gen_purpose(self):
-        subagents = [
-            {
-                "name": "weather_agent",
-                "description": "Use this agent to get the weather",
-                "prompt": "You are a weather agent.",
-                "tools": [get_weather],
-                "model": SAMPLE_MODEL,
-            }
-        ]
-        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
-        assert_all_deepagent_qualities(agent)
-        result = agent.invoke({"messages": [{"role": "user", "content": "Use the general purpose subagent to call the sample tool"}]})
-        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"] == "task" and tool_call["args"].get("subagent_type") == "general-purpose" for tool_call in tool_calls])
-
-    def test_deep_agent_with_subagents_with_middleware(self):
-        subagents = [
-            {
-                "name": "weather_agent",
-                "description": "Use this agent to get the weather",
-                "prompt": "You are a weather agent.",
-                "tools": [],
-                "model": SAMPLE_MODEL,
-                "middleware": [WeatherToolMiddleware()],
-            }
-        ]
-        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
-        assert_all_deepagent_qualities(agent)
-        result = agent.invoke({"messages": [{"role": "user", "content": "What is the weather in Tokyo?"}]})
-        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"] == "task" and tool_call["args"].get("subagent_type") == "weather_agent" for tool_call in tool_calls])
-
-    def test_deep_agent_with_custom_subagents(self):
-        subagents = [
-            {
-                "name": "weather_agent",
-                "description": "Use this agent to get the weather",
-                "prompt": "You are a weather agent.",
-                "tools": [get_weather],
-                "model": SAMPLE_MODEL,
-            },
-            {
-                "name": "soccer_agent",
-                "description": "Use this agent to get the latest soccer scores",
-                "graph": create_agent(
-                    model=SAMPLE_MODEL,
-                    tools=[get_soccer_scores],
-                    prompt="You are a soccer agent.",
-                )
-            }
-        ]
-        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
-        assert_all_deepagent_qualities(agent)
-        result = agent.invoke({"messages": [{"role": "user", "content": "Look up the weather in Tokyo, and the latest scores for Manchester City!"}]})
-        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"] == "task" and tool_call["args"].get("subagent_type") == "weather_agent" for tool_call in tool_calls])
-        assert any([tool_call["name"] == "task" and tool_call["args"].get("subagent_type") == "soccer_agent" for tool_call in tool_calls])
-
-    def test_deep_agent_with_extended_state_and_subagents(self):
-        subagents = [
-            {
-                "name": "basketball_info_agent",
-                "description": "Use this agent to get surface level info on any basketball topic",
-                "prompt": "You are a basketball info agent.",
-                "middleware": [ResearchMiddlewareWithTools()],
-            }
-        ]
-        agent = create_deep_agent(tools=[sample_tool], subagents=subagents, middleware=[ResearchMiddleware()])
-        assert_all_deepagent_qualities(agent)
-        assert "research" in agent.stream_channels
-        result = agent.invoke({"messages": [{"role": "user", "content": "Get surface level info on lebron james"}]}, config={"recursion_limit": 100})
-        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"] == "task" and tool_call["args"].get("subagent_type") == "basketball_info_agent" for tool_call in tool_calls])
-        assert TOY_BASKETBALL_RESEARCH in result["research"]
-
-    def test_deep_agent_with_subagents_no_tools(self):
-        subagents = [
-            {
-                "name": "basketball_info_agent",
-                "description": "Use this agent to get surface level info on any basketball topic",
-                "prompt": "You are a basketball info agent.",
-            }
-        ]
-        agent = create_deep_agent(tools=[sample_tool], subagents=subagents)
-        assert_all_deepagent_qualities(agent)
-        result = agent.invoke({"messages": [{"role": "user", "content": "Use the basketball info subagent to call the sample tool"}]}, config={"recursion_limit": 100})
-        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"] == "task" and tool_call["args"].get("subagent_type") == "basketball_info_agent" for tool_call in tool_calls])

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.agents.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]