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

deepagents/state.py

@@ -1,33 +0,0 @@
-from langchain.agents.middleware import AgentState
-from typing import NotRequired, Annotated
-from typing import Literal
-from typing_extensions import TypedDict
-
-
-class Todo(TypedDict):
-    """Todo to track."""
-
-    content: str
-    status: Literal["pending", "in_progress", "completed"]
-
-
-def file_reducer(l, r):
-    if l is None:
-        return r
-    elif r is None:
-        return l
-    else:
-        return {**l, **r}
-
-
-class DeepAgentState(AgentState):
-    todos: NotRequired[list[Todo]]
-    files: Annotated[NotRequired[dict[str, str]], file_reducer]
-
-
-class PlanningState(AgentState):
-    todos: NotRequired[list[Todo]]
-
-
-class FilesystemState(AgentState):
-    files: Annotated[NotRequired[dict[str, str]], file_reducer]

deepagents/tools.py

@@ -1,313 +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 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/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.12rc1.dist-info/RECORD

@@ -1,18 +0,0 @@
-deepagents/__init__.py,sha256=fA_91ByxPb3e8aPfci43zOXrWz8ylh_CFQALo7EUKi8,312
-deepagents/graph.py,sha256=1zK8l-kKwpyoAtNXyB0HfEFPEp5aF7G1dMN0xsm4q18,7163
-deepagents/middleware.py,sha256=Yovjyr3Zls3vNIeY7mawFk-9tAWpqCQbAN1vaegEk3I,8180
-deepagents/model.py,sha256=VyRIkdeXJH8HqLrudTKucHpBTtrwMFTQGRlXBj0kUyo,155
-deepagents/prompts.py,sha256=nnLAiPNY20-GNwhOzxe9Ia2CzcdrJqILSchPpPKNuZU,26228
-deepagents/state.py,sha256=8so3MgL-zRPYP8Ci_OuVg4wHrs5uAXCErKF1AjjCSt8,726
-deepagents/tools.py,sha256=lspab_EnKxVY4_SJP9sFJJBDks9EmHGXNcR4ebX8lHM,14567
-deepagents/types.py,sha256=5KBSUPlWOnv9It3SnJCMHrOtp9Y4_NQGtGCp69JsEjE,694
-deepagents-0.0.12rc1.dist-info/licenses/LICENSE,sha256=c__BaxUCK69leo2yEKynf8lWndu8iwYwge1CbyqAe-E,1071
-tests/test_deepagents.py,sha256=nTILGu2lsM908sq6MRy0PEXV0wuVMyvXS6Bm2NmEAm4,7655
-tests/test_filesystem.py,sha256=jrYkUqCDw2OHD1rpv3Vux1eKjT_d8CqM25g1KuvZBwk,9119
-tests/test_hitl.py,sha256=B16ZFiyaVSOcDLz7mh1RTaQZ93EMTKOPUY-IEslkcfM,2460
-tests/test_middleware.py,sha256=3HYmTx0Jw4XTNJjqLYeyGS_QZzcqkFuKfShtajIDhF4,2146
-tests/utils.py,sha256=B7Mc6VMzEkCmx8lORjdYNXp82tn-W3nwBkrusfJjAx0,2912
-deepagents-0.0.12rc1.dist-info/METADATA,sha256=W6_O9UQhpExMT9swmLRc4Nj55pI1Omegr0sPeCswGG8,17334
-deepagents-0.0.12rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deepagents-0.0.12rc1.dist-info/top_level.txt,sha256=_w9VMQtG4YDNg5A5eAeUre7dF7x7hk9zRpT9zsFaukY,17
-deepagents-0.0.12rc1.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],
-                    system_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])