add human in the loop functions

.gitignore

@@ -9,3 +9,4 @@ wheels/
 
 # Virtual environments
 .venv
+.env

main.py

@@ -10,7 +10,7 @@ from langgraph.prebuilt import ToolNode
 from langgraph.graph import MessagesState, END, StateGraph
 from langchain_core.messages import HumanMessage
 from langgraph.checkpoint.memory import MemorySaver
-from langgraph.types import Command, interrupt
+from langgraph.types import Command
 
 
 from pmcp.agents.executor import ExecutorAgent
@@ -18,6 +18,9 @@ from pmcp.agents.trello_agent import TrelloAgent
 from pmcp.agents.github_agent import GithubAgent
 from pmcp.agents.planner import PlannerAgent
 
+from pmcp.nodes.human_interrupt_node import HumanInterruptNode
+from pmcp.nodes.human_resume_node import HumanResumeNode
+
 from pmcp.models.state import PlanningState
 
 load_dotenv()
@@ -28,36 +31,6 @@ async def call_llm(llm_with_tools: ChatOpenAI, state: MessagesState):
     return {"messages": [response]}
 
 
-def human_review_node(state) -> Command[Literal["PLANNER_AGENT", "tool"]]:
-    last_message = state["messages"][-1]
-    tool_call = last_message.tool_calls[-1]
-    if tool_call.get("name", "").startswith("get_"):
-        return Command(goto="tool")
-
-    human_review = interrupt(
-        {
-            "question": "Is this correct?",
-            # Surface tool calls for review
-            "tool_call": tool_call,
-        }
-    )
-
-    review_action = human_review["action"]
-    review_data = human_review.get("data")
-
-    if review_action == "continue":
-        return Command(goto="tool")
-
-    else:
-        tool_message = {
-            "role": "tool",
-            "content": review_data,
-            "name": tool_call["name"],
-            "tool_call_id": tool_call["id"],
-        }
-        return Command(goto="PLANNER_AGENT", update={"messages": [tool_message]})
-
-
 async def main():
     mcp_client_trello = MultiServerMCPClient(
         {
@@ -104,25 +77,30 @@ async def main():
     )
     executor_agent = ExecutorAgent(llm=llm)
 
+    human_interrupt_node = HumanInterruptNode(
+        llm=llm,
+    )
+    human_resume_node = HumanResumeNode(llm=llm)
+
     graph = StateGraph(MessagesState)
     graph.add_node(planner_agent.agent.agent_name, planner_agent.acall_planner_agent)
     graph.add_node(trello_agent.agent.agent_name, trello_agent.acall_trello_agent)
     graph.add_node(github_agent.agent.agent_name, github_agent.acall_github_agent)
     graph.add_node(executor_agent.agent.agent_name, executor_agent.acall_executor_agent)
     graph.add_node("tool", tool_node)
-    graph.add_node("human_review", human_review_node)
+    graph.add_node("human_interrupt", human_interrupt_node.call_human_interrupt_agent)
     graph.set_entry_point(planner_agent.agent.agent_name)
 
     def should_continue(state: PlanningState):
         last_message = state.messages[-1]
         if last_message.tool_calls:
-            return "human_review"
+            return "human_interrupt"
         return executor_agent.agent.agent_name
 
     def execute_agent(state: PlanningState):
         if state.current_step:
             return state.current_step.agent
-        
+
         return END
 
     graph.add_conditional_edges(trello_agent.agent.agent_name, should_continue)
@@ -136,24 +114,36 @@ async def main():
     app = graph.compile(checkpointer=memory)
     app.get_graph(xray=True).draw_mermaid()
 
-
     user_input = input("user >")
     config = {
         "configurable": {"thread_id": f"{str(uuid.uuid4())}"},
         "recursion_limit": 100,
     }
 
+    is_message_command = False
     while user_input.lower() != "q":
-        async for res in app.astream(
-            {
+
+        if is_message_command:
+            app_input = human_resume_node.call_human_interrupt_agent(
+                user_input
+            )
+            is_message_command = False
+        else:
+            app_input = {
                 "messages": [
                     HumanMessage(content=user_input),
                 ]
-            },
+            }
+        async for res in app.astream(
+            app_input,
             config=config,
             stream_mode="values",
         ):
-            pprint.pprint(res["messages"][-1])
+            if "messages" in res:
+                pprint.pprint(res["messages"][-1])
+            else:
+                pprint.pprint(res["__interrupt__"][0])
+                is_message_command = True
             pprint.pprint("-------------------------------------")
         user_input = input("user >")
 

pmcp/models/resume_trigger.py

@@ -0,0 +1,9 @@
+
+from typing import Optional
+from pydantic import BaseModel
+from typing_extensions import Literal
+
+
+class ResumeTrigger(BaseModel):
+    action: Literal["continue", "edit"] 
+    changes: Optional[str] = None

pmcp/nodes/human_interrupt_node.py

@@ -0,0 +1,58 @@
+from typing import List, Optional
+
+from pmcp.agents.agent_base import AgentBlueprint
+from langchain_core.tools import BaseTool
+from langchain_core.messages import SystemMessage, AIMessage
+from langchain_openai import ChatOpenAI
+from langgraph.types import Command, interrupt
+
+from pmcp.models.state import PlanningState
+
+SYSTEM_PROMPT = """
+You are a Human Reviewer Agent responsible for confirming the execution of tasks planned by the Planner Agent. Your role is to:
+- Ask the user for confirmation before an tool calling is performed.
+"""
+
+
+class HumanInterruptNode:
+    def __init__(self, llm: ChatOpenAI, tools: Optional[List[BaseTool]] = None):
+        self.agent = AgentBlueprint(
+            agent_name="HUMAN_REVIEWER_AGENT",
+            description="The agent asks for human confirmation",
+            tools=tools,
+            system_prompt=SYSTEM_PROMPT.strip(),
+            llm=llm,
+        )
+
+    def call_human_interrupt_agent(self, state: PlanningState):
+        last_message = state.messages[-1]
+    
+        try:
+            tool_call = last_message.tool_calls[-1]
+        except Exception:
+            last_message = state.messages[-2]
+            tool_call = last_message.tool_calls[-1]
+
+
+
+        if tool_call.get("name", "").startswith("get_"):
+            return Command(goto="tool")            
+        
+        response = self.agent.call_agent(
+            messages=[SystemMessage(content=self.agent.system_prompt), AIMessage(content= str(tool_call))],
+        )
+        human_review = interrupt(response.content)
+
+        review_action = human_review.action
+        review_changes = human_review.changes
+        if review_action == "continue":
+            return Command(goto="tool")
+
+        else:
+            tool_message = {
+                "role": "tool",
+                "content": review_changes,
+                "name": tool_call["name"],
+                "tool_call_id": tool_call["id"],
+            }
+            return Command(goto="PLANNER_AGENT", update={"messages": [tool_message]})

pmcp/nodes/human_resume_node.py

@@ -0,0 +1,33 @@
+from typing import List, Optional
+
+from pmcp.agents.agent_base import AgentBlueprint
+from langchain_core.tools import BaseTool
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_openai import ChatOpenAI
+from langgraph.types import Command
+
+from pmcp.models.resume_trigger import ResumeTrigger
+
+
+SYSTEM_PROMPT = """
+You are a Human Resumer Agent responsible for understading the user indication on whethere procede or not with an action.
+"""
+
+
+class HumanResumeNode:
+    def __init__(self, llm: ChatOpenAI, tools: Optional[List[BaseTool]] = None):
+        self.agent = AgentBlueprint(
+            agent_name="HUMAN_REVIEWER_AGENT",
+            description="The agent asks for human confirmation",
+            tools=tools,
+            system_prompt=SYSTEM_PROMPT.strip(),
+            llm=llm,
+        )
+
+    def call_human_interrupt_agent(self, user_message: str):
+        response = self.agent.call_agent_structured(
+            [SystemMessage(content=self.agent.system_prompt), HumanMessage(content= user_message)],
+            clazz=ResumeTrigger,
+        )
+
+        return Command(resume=response)