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

deepagents/__init__.py

@@ -1,5 +1,7 @@
-from deepagents.graph import create_deep_agent, async_create_deep_agent
-from deepagents.middleware import PlanningMiddleware, FilesystemMiddleware, SubAgentMiddleware
-from deepagents.state import DeepAgentState
-from deepagents.types import SubAgent, CustomSubAgent
-from deepagents.model import get_default_model
+"""DeepAgents package."""
+
+from deepagents.graph import create_deep_agent
+from deepagents.middleware.filesystem import FilesystemMiddleware
+from deepagents.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
+
+__all__ = ["CompiledSubAgent", "FilesystemMiddleware", "SubAgent", "SubAgentMiddleware", "create_deep_agent"]

deepagents/graph.py

@@ -1,160 +1,140 @@
-from typing import Sequence, Union, Callable, Any, Type, Optional
+"""Deepagents come with planning, filesystem, and subagents."""
+
+from collections.abc import Callable, Sequence
+from typing import Any
+
+from langchain.agents import create_agent
+from langchain.agents.middleware import HumanInTheLoopMiddleware, InterruptOnConfig, TodoListMiddleware
+from langchain.agents.middleware.summarization import SummarizationMiddleware
+from langchain.agents.middleware.types import AgentMiddleware
+from langchain.agents.structured_output import ResponseFormat
+from langchain_anthropic import ChatAnthropic
+from langchain_core.language_models import BaseChatModel
 from langchain_core.tools import BaseTool
-from langchain_core.language_models import LanguageModelLike
-from langgraph.types import Checkpointer
+from langgraph.cache.base import BaseCache
+from langgraph.graph.state import CompiledStateGraph
 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
-from langchain.agents.middleware.prompt_caching import AnthropicPromptCachingMiddleware
-from deepagents.middleware import PlanningMiddleware, FilesystemMiddleware, SubAgentMiddleware
-from deepagents.prompts import BASE_AGENT_PROMPT
-from deepagents.model import get_default_model
-from deepagents.types import SubAgent, CustomSubAgent
+from langgraph.types import Checkpointer
 
-def agent_builder(
-    tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]],
-    instructions: str,
-    middleware: Optional[list[AgentMiddleware]] = None,
-    tool_configs: Optional[dict[str, bool | ToolConfig]] = None,
-    model: Optional[Union[str, LanguageModelLike]] = None,
-    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:
-        model = get_default_model()
+from deepagents.middleware.filesystem import FilesystemMiddleware
+from deepagents.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
 
-    deepagent_middleware = [
-        PlanningMiddleware(),
-        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 [],
-            model=model,
-            is_async=is_async,
-        ),
-        SummarizationMiddleware(
-            model=model,
-            max_tokens_before_summary=120000,
-            messages_to_keep=20,
-        ),
-        AnthropicPromptCachingMiddleware(ttl="5m", unsupported_model_behavior="ignore")
-    ]
-    # Add tool interrupt config if provided
-    if tool_configs is not None:
-        deepagent_middleware.append(HumanInTheLoopMiddleware(interrupt_on=tool_configs))
+BASE_AGENT_PROMPT = "In order to complete the objective that the user asks of you, you have access to a number of standard tools."
 
-    if middleware is not None:
-        deepagent_middleware.extend(middleware)
 
-    return create_agent(
-        model,
-        system_prompt=instructions + "\n\n" + BASE_AGENT_PROMPT,
-        tools=tools,
-        middleware=deepagent_middleware,
-        context_schema=context_schema,
-        checkpointer=checkpointer,
-        store=store,
-    )
+def get_default_model() -> ChatAnthropic:
+    """Get the default model for deep agents.
 
-def create_deep_agent(
-    tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]] = [],
-    instructions: str = "",
-    middleware: Optional[list[AgentMiddleware]] = None,
-    model: Optional[Union[str, LanguageModelLike]] = None,
-    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.
-    This agent will by default have access to a tool to write todos (write_todos),
-    four file editing tools: write_file, ls, read_file, edit_file, and a tool to call subagents.
-    Args:
-        tools: The tools the agent should have access to.
-        instructions: The additional instructions the agent should have. Will go in
-            the system prompt.
-        model: The model to use.
-        subagents: The subagents to use. Each subagent should be a dictionary with the
-            following keys:
-                - `name`
-                - `description` (used by the main agent to decide whether to call the sub agent)
-                - `prompt` (used as the system prompt in the subagent)
-                - (optional) `tools`
-                - (optional) `model` (either a LanguageModelLike instance or dict settings)
-                - (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.
+    Returns:
+        ChatAnthropic instance configured with Claude Sonnet 4.
     """
-    return agent_builder(
-        tools=tools,
-        instructions=instructions,
-        middleware=middleware,
-        model=model,
-        subagents=subagents,
-        context_schema=context_schema,
-        checkpointer=checkpointer,
-        store=store,
-        use_longterm_memory=use_longterm_memory,
-        tool_configs=tool_configs,
-        is_async=False,
+    return ChatAnthropic(
+        model_name="claude-sonnet-4-20250514",
+        max_tokens=64000,
     )
 
-def async_create_deep_agent(
-    tools: Sequence[Union[BaseTool, Callable, dict[str, Any]]] = [],
-    instructions: str = "",
-    middleware: Optional[list[AgentMiddleware]] = None,
-    model: Optional[Union[str, LanguageModelLike]] = None,
-    subagents: Optional[list[SubAgent | CustomSubAgent]] = None,
-    context_schema: Optional[Type[Any]] = None,
-    checkpointer: Optional[Checkpointer] = None,
-    store: Optional[BaseStore] = None,
+
+def create_deep_agent(
+    model: str | BaseChatModel | None = None,
+    tools: Sequence[BaseTool | Callable | dict[str, Any]] | None = None,
+    *,
+    system_prompt: str | None = None,
+    middleware: Sequence[AgentMiddleware] = (),
+    subagents: list[SubAgent | CompiledSubAgent] | None = None,
+    response_format: ResponseFormat | None = None,
+    context_schema: type[Any] | None = None,
+    checkpointer: Checkpointer | None = None,
+    store: BaseStore | None = None,
     use_longterm_memory: bool = False,
-    tool_configs: Optional[dict[str, bool | ToolConfig]] = None,
-):
+    interrupt_on: dict[str, bool | InterruptOnConfig] | None = None,
+    debug: bool = False,
+    name: str | None = None,
+    cache: BaseCache | None = None,
+) -> CompiledStateGraph:
     """Create a deep agent.
+
     This agent will by default have access to a tool to write todos (write_todos),
-    four file editing tools: write_file, ls, read_file, edit_file, and a tool to call subagents.
+    four file editing tools: write_file, ls, read_file, edit_file, and a tool to call
+    subagents.
+
     Args:
         tools: The tools the agent should have access to.
-        instructions: The additional instructions the agent should have. Will go in
+        system_prompt: The additional instructions the agent should have. Will go in
             the system prompt.
+        middleware: Additional middleware to apply after standard middleware.
         model: The model to use.
         subagents: The subagents to use. Each subagent should be a dictionary with the
             following keys:
                 - `name`
-                - `description` (used by the main agent to decide whether to call the sub agent)
+                - `description` (used by the main agent to decide whether to call the
+                  sub agent)
                 - `prompt` (used as the system prompt in the subagent)
                 - (optional) `tools`
-                - (optional) `model` (either a LanguageModelLike instance or dict settings)
+                - (optional) `model` (either a LanguageModelLike instance or dict
+                  settings)
                 - (optional) `middleware` (list of AgentMiddleware)
+        response_format: A structured output response format to use for the agent.
         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.
+        use_longterm_memory: Whether to use longterm memory - you must provide a store
+            in order to use longterm memory.
+        interrupt_on: Optional Dict[str, bool | InterruptOnConfig] mapping tool names to
+            interrupt configs.
+        debug: Whether to enable debug mode. Passed through to create_agent.
+        name: The name of the agent. Passed through to create_agent.
+        cache: The cache to use for the agent. Passed through to create_agent.
+
+    Returns:
+        A configured deep agent.
     """
-    return agent_builder(
+    if model is None:
+        model = get_default_model()
+
+    deepagent_middleware = [
+        TodoListMiddleware(),
+        FilesystemMiddleware(
+            long_term_memory=use_longterm_memory,
+        ),
+        SubAgentMiddleware(
+            default_model=model,
+            default_tools=tools,
+            subagents=subagents if subagents is not None else [],
+            default_middleware=[
+                TodoListMiddleware(),
+                FilesystemMiddleware(
+                    long_term_memory=use_longterm_memory,
+                ),
+                SummarizationMiddleware(
+                    model=model,
+                    max_tokens_before_summary=120000,
+                    messages_to_keep=20,
+                ),
+            ],
+            default_interrupt_on=interrupt_on,
+            general_purpose_agent=True,
+        ),
+        SummarizationMiddleware(
+            model=model,
+            max_tokens_before_summary=120000,
+            messages_to_keep=20,
+        ),
+    ]
+    if interrupt_on is not None:
+        deepagent_middleware.append(HumanInTheLoopMiddleware(interrupt_on=interrupt_on))
+    if middleware is not None:
+        deepagent_middleware.extend(middleware)
+
+    return create_agent(
+        model,
+        system_prompt=system_prompt + "\n\n" + BASE_AGENT_PROMPT if system_prompt else BASE_AGENT_PROMPT,
         tools=tools,
-        instructions=instructions,
-        middleware=middleware,
-        model=model,
-        subagents=subagents,
+        middleware=deepagent_middleware,
+        response_format=response_format,
         context_schema=context_schema,
         checkpointer=checkpointer,
         store=store,
-        use_longterm_memory=use_longterm_memory,
-        tool_configs=tool_configs,
-        is_async=True,
-    )
+        debug=debug,
+        name=name,
+        cache=cache,
+    )

deepagents/middleware/__init__.py

@@ -0,0 +1,6 @@
+"""Middleware for the DeepAgent."""
+
+from deepagents.middleware.filesystem import FilesystemMiddleware
+from deepagents.middleware.subagents import CompiledSubAgent, SubAgent, SubAgentMiddleware
+
+__all__ = ["CompiledSubAgent", "FilesystemMiddleware", "SubAgent", "SubAgentMiddleware"]