feat: add local tools

Author: Palashio

src/deepagents/__init__.py

@@ -1,3 +1,5 @@
 from deepagents.graph import create_deep_agent
+from deepagents.interrupt import ToolInterruptConfig
 from deepagents.state import DeepAgentState
 from deepagents.sub_agent import SubAgent
+from deepagents.model import get_default_model

src/deepagents/graph.py

@@ -2,10 +2,20 @@
 from deepagents.model import get_default_model
 from deepagents.tools import write_todos, write_file, read_file, ls, edit_file
 from deepagents.state import DeepAgentState
-from typing import Sequence, Union, Callable, Any, TypeVar, Type, Optional
+from typing import Sequence, Union, Callable, Any, TypeVar, Type, Optional, Dict
 from langchain_core.tools import BaseTool
 from langchain_core.language_models import LanguageModelLike
 
+from deepagents.local_tools import (
+    write_file as local_write_file,
+    read_file as local_read_file,
+    ls as local_ls,
+    glob as local_glob,
+    grep as local_grep,
+    str_replace_based_edit_tool,
+)
+from deepagents.interrupt import create_interrupt_hook, ToolInterruptConfig
+from langgraph.types import Checkpointer
 from langgraph.prebuilt import create_react_agent
 
 StateSchema = TypeVar("StateSchema", bound=DeepAgentState)
@@ -30,11 +40,16 @@ def create_deep_agent(
     model: Optional[Union[str, LanguageModelLike]] = None,
     subagents: list[SubAgent] = None,
     state_schema: Optional[StateSchemaType] = None,
+    interrupt_config: Optional[ToolInterruptConfig] = None,
+    config_schema: Optional[Type[Any]] = None,
+    checkpointer: Optional[Checkpointer] = None,
+    post_model_hook: Optional[Callable] = None,
+    local_filesystem: bool = False,
 ):
     """Create a deep agent.
 
     This agent will by default have access to a tool to write todos (write_todos),
-    and then four file editing tools: write_file, ls, read_file, edit_file.
+    and then four file editing tools: write_file, ls, read_file, str_replace_based_edit_tool.
 
     Args:
         tools: The additional tools the agent should have access to.
@@ -48,9 +63,18 @@ def create_deep_agent(
                 - `prompt` (used as the system prompt in the subagent)
                 - (optional) `tools`
         state_schema: The schema of the deep agent. Should subclass from DeepAgentState
+        interrupt_config: Optional Dict[str, HumanInterruptConfig] mapping tool names to interrupt configs.
+
+        config_schema: The schema of the deep agent.
+        checkpointer: Optional checkpointer for persisting agent state between runs.
     """
+    
     prompt = instructions + base_prompt
-    built_in_tools = [write_todos, write_file, read_file, ls, edit_file]
+    if local_filesystem:
+        built_in_tools = [write_todos, local_write_file, local_read_file, local_ls, local_glob, local_grep, str_replace_based_edit_tool]
+    else:
+        built_in_tools = [write_todos, write_file, read_file, ls, edit_file]
+
     if model is None:
         model = get_default_model()
     state_schema = state_schema or DeepAgentState
@@ -62,9 +86,26 @@ def create_deep_agent(
         state_schema
     )
     all_tools = built_in_tools + list(tools) + [task_tool]
+    
+    # Should never be the case that both are specified
+    if post_model_hook and interrupt_config:
+        raise ValueError(
+            "Cannot specify both post_model_hook and interrupt_config together. "
+            "Use either interrupt_config for tool interrupts or post_model_hook for custom post-processing."
+        )
+    elif post_model_hook is not None:
+        selected_post_model_hook = post_model_hook
+    elif interrupt_config is not None:
+        selected_post_model_hook = create_interrupt_hook(interrupt_config)
+    else:
+        selected_post_model_hook = None
+    
     return create_react_agent(
         model,
         prompt=prompt,
         tools=all_tools,
         state_schema=state_schema,
+        post_model_hook=selected_post_model_hook,
+        config_schema=config_schema,
+        checkpointer=checkpointer,
     )

src/deepagents/interrupt.py

@@ -0,0 +1,96 @@
+"""Interrupt configuration functionality for deep agents using LangGraph prebuilts."""
+
+from typing import Dict, Any, List, Optional, Union
+from langgraph.types import interrupt
+from langgraph.prebuilt.interrupt import (
+    HumanInterruptConfig,
+    ActionRequest,
+    HumanInterrupt,
+    HumanResponse,
+)
+
+ToolInterruptConfig = Dict[str, HumanInterruptConfig]
+
+def create_interrupt_hook(
+    tool_configs: ToolInterruptConfig,
+    message_prefix: str = "Tool execution requires approval",
+) -> callable:
+    """Create a post model hook that handles interrupts using native LangGraph schemas.
+    
+    Args:
+        tool_configs: Dict mapping tool names to HumanInterruptConfig objects
+        message_prefix: Optional message prefix for interrupt descriptions
+    """
+    
+    def interrupt_hook(state: Dict[str, Any]) -> Dict[str, Any]:
+        """Post model hook that checks for tool calls and triggers interrupts if needed."""
+        messages = state.get("messages", [])
+        if not messages:
+            return
+
+        last_message = messages[-1]
+
+        if not hasattr(last_message, "tool_calls") or not last_message.tool_calls:
+            return
+
+        # Separate tool calls that need interrupts from those that don't
+        interrupt_tool_calls = []
+        auto_approved_tool_calls = []
+        
+        for tool_call in last_message.tool_calls:
+            tool_name = tool_call["name"]
+            if tool_name in tool_configs:
+                interrupt_tool_calls.append(tool_call)
+            else:
+                auto_approved_tool_calls.append(tool_call)
+
+        # If no interrupts needed, return early
+        if not interrupt_tool_calls:
+            return
+
+        approved_tool_calls = auto_approved_tool_calls.copy()
+
+        # Process all tool calls that need interrupts in parallel
+        requests = []
+        
+        for tool_call in interrupt_tool_calls:
+            tool_name = tool_call["name"]
+            tool_args = tool_call["args"]
+            description = f"{message_prefix}\n\nTool: {tool_name}\nArgs: {tool_args}"
+            tool_config = tool_configs[tool_name]
+
+            request: HumanInterrupt = {
+                "action_request": ActionRequest(
+                    action=tool_name,
+                    args=tool_args,
+                ),
+                "config": tool_config,
+                "description": description,
+            }
+            requests.append(request)
+
+        responses: List[HumanResponse] = interrupt(requests)
+        
+        for i, response in enumerate(responses):
+            tool_call = interrupt_tool_calls[i]
+            
+            if response["type"] == "accept":
+                approved_tool_calls.append(tool_call)
+            elif response["type"] == "edit":
+                edited: ActionRequest = response["args"]
+                new_tool_call = {
+                    "name": tool_call["name"],
+                    "args": edited["args"],
+                    "id": tool_call["id"],
+                }
+                approved_tool_calls.append(new_tool_call)
+            else:
+                raise ValueError(f"Unknown response type: {response['type']}")
+
+        last_message.tool_calls = approved_tool_calls
+
+        return {"messages": [last_message]}
+
+    return interrupt_hook
+
+