deepagents 0.0.6rc1__py3-none-any.whl → 0.0.6rc3__py3-none-any.whl

deepagents/interrupt.py

@@ -1,122 +0,0 @@
-"""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, Union[HumanInterruptConfig, bool]]
-
-
-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 or boolean values.
-                     If True, uses default HumanInterruptConfig. If False, no interrupt.
-        message_prefix: Optional message prefix for interrupt descriptions
-    """
-    # Right now we don't properly handle `ignore`
-    for tool, interrupt_config in tool_configs.items():
-        if isinstance(interrupt_config, dict):
-            if "allow_ignore" in interrupt_config and interrupt_config["allow_ignore"]:
-                raise ValueError(
-                    f"For {tool} we get `allow_ignore = True` - we currently don't support `ignore`."
-                )
-
-    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 and tool_configs[tool_name]:
-                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
-
-        # Right now, no easy handling for when multiple tools need interrupt
-        if len(interrupt_tool_calls) > 1:
-            raise ValueError(
-                "Right now, interrupt hook only works when one tool requires interrupts"
-            )
-        tool_call = interrupt_tool_calls[0]
-
-        approved_tool_calls = auto_approved_tool_calls.copy()
-
-        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]
-        default_tool_config: HumanInterruptConfig = {
-            "allow_accept": True,
-            "allow_edit": True,
-            "allow_respond": True,
-            "allow_ignore": False,
-        }
-
-        request: HumanInterrupt = {
-            "action_request": ActionRequest(
-                action=tool_name,
-                args=tool_args,
-            ),
-            "config": tool_config
-            if isinstance(tool_config, dict)
-            else default_tool_config,
-            "description": description,
-        }
-
-        responses: List[HumanResponse] = interrupt([request])
-
-        if len(responses) != 1:
-            raise ValueError(f"Expected a list of one response, got {responses}")
-        response = responses[0]
-
-        if response["type"] == "accept":
-            approved_tool_calls.append(tool_call)
-        elif response["type"] == "edit":
-            edited: ActionRequest = response["args"]
-            new_tool_call = {
-                "type": "tool_call",
-                "name": edited["action"],
-                "args": edited["args"],
-                "id": tool_call["id"],
-            }
-            approved_tool_calls.append(new_tool_call)
-        elif response["type"] == "response":
-            response_message = {
-                "type": "tool",
-                "tool_call_id": tool_call["id"],
-                "content": response["args"],
-            }
-            return {"messages": [response_message]}
-        else:
-            raise ValueError(f"Unknown response type: {response['type']}")
-
-        last_message.tool_calls = approved_tool_calls
-
-        return {"messages": [last_message]}
-
-    return interrupt_hook

deepagents/sub_agent.py

@@ -1,169 +0,0 @@
-from deepagents.prompts import TASK_TOOL_DESCRIPTION
-from deepagents.state import DeepAgentState
-from langgraph.prebuilt import create_react_agent
-from langchain_core.tools import BaseTool
-from typing_extensions import TypedDict
-from langchain_core.tools import tool, InjectedToolCallId
-from langchain_core.messages import ToolMessage
-from langchain_core.language_models import LanguageModelLike
-from langchain.chat_models import init_chat_model
-from typing import Annotated, NotRequired, Any, Union, Optional, Callable
-from langgraph.types import Command
-from langchain_core.runnables import Runnable
-
-from langgraph.prebuilt import InjectedState
-
-
-class SubAgent(TypedDict):
-    name: str
-    description: str
-    prompt: str
-    tools: NotRequired[list[str]]
-    # Optional per-subagent model: can be either a model instance OR dict settings
-    model: NotRequired[Union[LanguageModelLike, dict[str, Any]]]
-
-
-class CustomSubAgent(TypedDict):
-    name: str
-    description: str
-    graph: Runnable
-
-
-def _get_agents(
-    tools,
-    instructions,
-    subagents: list[SubAgent | CustomSubAgent],
-    model,
-    state_schema,
-    post_model_hook: Optional[Callable] = None,
-):
-    agents = {
-        "general-purpose": create_react_agent(
-            model,
-            prompt=instructions,
-            tools=tools,
-            checkpointer=False,
-            post_model_hook=post_model_hook,
-            state_schema=state_schema,
-        )
-    }
-    tools_by_name = {}
-    for tool_ in tools:
-        if not isinstance(tool_, BaseTool):
-            tool_ = tool(tool_)
-        tools_by_name[tool_.name] = tool_
-    for _agent in subagents:
-        if "graph" in _agent:
-            agents[_agent["name"]] = _agent["graph"]
-            continue
-        if "tools" in _agent:
-            _tools = [tools_by_name[t] for t in _agent["tools"]]
-        else:
-            _tools = tools
-        # Resolve per-subagent model: can be instance or dict
-        if "model" in _agent:
-            agent_model = _agent["model"]
-            if isinstance(agent_model, dict):
-                # Dictionary settings - create model from config
-                sub_model = init_chat_model(**agent_model)
-            else:
-                # Model instance - use directly
-                sub_model = agent_model
-        else:
-            # Fallback to main model
-            sub_model = model
-        agents[_agent["name"]] = create_react_agent(
-            sub_model,
-            prompt=_agent["prompt"],
-            tools=_tools,
-            state_schema=state_schema,
-            checkpointer=False,
-            post_model_hook=post_model_hook,
-        )
-    return agents
-
-
-def _get_subagent_description(subagents: list[SubAgent | CustomSubAgent]):
-    return [f"- {_agent['name']}: {_agent['description']}" for _agent in subagents]
-
-
-def _create_task_tool(
-    tools,
-    instructions,
-    subagents: list[SubAgent | CustomSubAgent],
-    model,
-    state_schema,
-    post_model_hook: Optional[Callable] = None,
-):
-    agents = _get_agents(
-        tools, instructions, subagents, model, state_schema, post_model_hook
-    )
-    other_agents_string = _get_subagent_description(subagents)
-
-    @tool(
-        description=TASK_TOOL_DESCRIPTION.format(other_agents=other_agents_string)
-    )
-    async def task(
-        description: str,
-        subagent_type: str,
-        state: Annotated[DeepAgentState, InjectedState],
-        tool_call_id: Annotated[str, InjectedToolCallId],
-    ):
-        if subagent_type not in agents:
-            return f"Error: invoked agent of type {subagent_type}, the only allowed types are {[f'`{k}`' for k in agents]}"
-        sub_agent = agents[subagent_type]
-        state["messages"] = [{"role": "user", "content": description}]
-        result = await sub_agent.ainvoke(state)
-        return Command(
-            update={
-                "files": result.get("files", {}),
-                "messages": [
-                    ToolMessage(
-                        result["messages"][-1].content, tool_call_id=tool_call_id
-                    )
-                ],
-            }
-        )
-
-    return task
-
-
-def _create_sync_task_tool(
-    tools,
-    instructions,
-    subagents: list[SubAgent | CustomSubAgent],
-    model,
-    state_schema,
-    post_model_hook: Optional[Callable] = None,
-):
-    agents = _get_agents(
-        tools, instructions, subagents, model, state_schema, post_model_hook
-    )
-    other_agents_string = _get_subagent_description(subagents)
-
-    @tool(
-        description=TASK_TOOL_DESCRIPTION.format(other_agents=other_agents_string)
-    )
-    def task(
-        description: str,
-        subagent_type: str,
-        state: Annotated[DeepAgentState, InjectedState],
-        tool_call_id: Annotated[str, InjectedToolCallId],
-    ):
-        if subagent_type not in agents:
-            return f"Error: invoked agent of type {subagent_type}, the only allowed types are {[f'`{k}`' for k in agents]}"
-        sub_agent = agents[subagent_type]
-        state["messages"] = [{"role": "user", "content": description}]
-        result = sub_agent.invoke(state)
-        return Command(
-            update={
-                "files": result.get("files", {}),
-                "messages": [
-                    ToolMessage(
-                        result["messages"][-1].content, tool_call_id=tool_call_id
-                    )
-                ],
-            }
-        )
-
-    return task

deepagents-0.0.6rc1.dist-info/RECORD

@@ -1,14 +0,0 @@
-deepagents/__init__.py,sha256=_u6fBfAwHlIeMsu5n95nMHz0WPhEglVlZ3ulm31WlwY,361
-deepagents/builder.py,sha256=CTjEZpkubpGr2pippATsQaENxHGZgzddrUrsattU-QU,2794
-deepagents/graph.py,sha256=tEdZ4WQHN0tsnXr60Lv9LIp55s6LYq0R-v2czAbmHlg,8035
-deepagents/interrupt.py,sha256=08W7Zjk6S8HBoNepBvzSAXvpywM5sCDl0oGNim8YCJA,4449
-deepagents/model.py,sha256=VyRIkdeXJH8HqLrudTKucHpBTtrwMFTQGRlXBj0kUyo,155
-deepagents/prompts.py,sha256=PzHgIwy4gzHyiKHR3fCS7RtJR15NyGshCtPKuOS7XTQ,24743
-deepagents/state.py,sha256=sCihH_OgYKibf6zGc2MdORFJqBqKNO60bWVjAenQ_xc,567
-deepagents/sub_agent.py,sha256=4Q84OxoAznXKVVLbd6Y2RYDOnTF7THdYwtOLvCxaED4,5404
-deepagents/tools.py,sha256=LFu6T1qP0DDtUBBKZUiZJt4O1rfpZ69BbdV1jx7IrK8,4765
-deepagents-0.0.6rc1.dist-info/licenses/LICENSE,sha256=c__BaxUCK69leo2yEKynf8lWndu8iwYwge1CbyqAe-E,1071
-deepagents-0.0.6rc1.dist-info/METADATA,sha256=9t_eBM4TTKxVCGXdz1M9v86rSSGeSOQ15-Yc7PJZxz0,17180
-deepagents-0.0.6rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-deepagents-0.0.6rc1.dist-info/top_level.txt,sha256=drAzchOzPNePwpb3_pbPuvLuayXkN7SNqeIKMBWJoAo,11
-deepagents-0.0.6rc1.dist-info/RECORD,,