added ag

app/agents/context_agent.py

@@ -0,0 +1,22 @@
+from langchain.agents import create_agent
+from langchain.agents.middleware import ToolCallLimitMiddleware
+from langchain_groq import ChatGroq
+from app.prompts.context_agent_prompt import context_agent_template
+from app.tools.context_agent_tools import context_agent_tools
+from typing import Any
+
+context_agent = create_agent(
+    model=ChatGroq(
+        model="openai/gpt-oss-20b",
+        temperature=0.1,
+    ),
+    tools=context_agent_tools,
+    store=p_store,  
+    middleware=[
+        ToolCallLimitMiddleware[Any,None](
+           tool_name="search_memory",
+           run_limit=7,
+         thread_limit=10,
+        )
+   ] ,
+)

app/agents/email_writing_agent.py

@@ -0,0 +1,8 @@
+from langchain_groq import ChatGroq
+from app.tools.email_writing_agent_tools import create_gmail_draft, send_draft_by_id
+base_llm = ChatGroq(
+    model="qwen/qwen3-32b",
+    temperature=0.1,       
+)
+tools = [create_gmail_draft, send_draft_by_id]
+email_agent = base_llm.bind_tools(tools)

app/agents/memory_manager_agent.py

@@ -0,0 +1,56 @@
+import types
+from langchain_groq import ChatGroq
+from langmem import create_memory_store_manager
+from app.schemas.memory_agent_schema import EmailMemory
+import os
+from app.core.config import settings
+
+if "GROQ_API_KEY" not in os.environ:
+    os.environ["GROQ_API_KEY"] = settings.GROQ_API_KEY
+
+def patch_groq_for_extractions(model: ChatGroq):
+    # Capture the original method
+    original_bind_tools = model.bind_tools
+
+    def fixed_bind_tools(self, tools, **kwargs):
+        fixed_tools = []
+        for tool in tools:
+            # 1. Handle dictionary-style tools (JSON Schema)
+            if isinstance(tool, dict):
+                # Ensure nested description is present
+                if "function" in tool and not tool["function"].get("description"):
+                    tool["function"]["description"] = "Extract information based on the schema."
+                elif not tool.get("description"):
+                    tool["description"] = "Extract information based on the schema."
+                fixed_tools.append(tool)
+            # 2. Handle Class-style tools (Pydantic)
+            else:
+                if not getattr(tool, "__doc__", None):
+                    # This fixes the internal 'Done' class from langmem/trustcall
+                    tool.__doc__ = "Signal that extraction is finished."
+                fixed_tools.append(tool)
+        
+        return original_bind_tools(fixed_tools, **kwargs)
+
+    object.__setattr__(
+        model, 
+        "bind_tools", 
+        types.MethodType(fixed_bind_tools, model)
+    )
+    return model
+
+# Apply the patch
+
+
+model=ChatGroq(model="openai/gpt-oss-20b", temperature=0.2)
+model = patch_groq_for_extractions(model)
+
+memory_manager_agent = create_memory_store_manager(
+    model, 
+    schemas=[EmailMemory],
+    namespace=namespace,
+    store=p_store,
+    instructions="Extract required info from incoming mail and its reply .",
+    enable_inserts=True,
+    enable_deletes=True,
+)

app/agents/{agents.py → triage_agent.py}

@@ -1,13 +1,29 @@
 from langchain_groq import ChatGroq
-from app.schemas.pydanticschema import ResumeExtract,JobDescriptionExtract,SkillGapAnalysis
+from app.schemas.triage_agent_schema import TriageOutput
 from app.core.config import settings
-from app.tools.tools import roadmap_planner_agent_tools
-from app.prompts.roadmap_planner_agent_prompt import roadmap_planner_agent_prompt
+from app.prompts.triage_agent_prompt import triage_agent_template
 from typing import Any
 from langchain.agents import create_agent
 from langchain.agents.middleware import ToolCallLimitMiddleware
 import os
 
+
 if "GROQ_API_KEY" not in os.environ:
     os.environ["GROQ_API_KEY"] = settings.GROQ_API_KEY
 
+
+triage_agent=ChatGroq(
+    model="meta-llama/llama-4-scout-17b-16e-instruct",
+    temperature=0.1,
+)
+
+
+triage_agent=triage_agent.with_structured_output(
+
+    TriageOutput,
+    method="json_schema",
+    include_raw=True,
+    strict=True
+)
+
+

app/graph.py

@@ -1,7 +1,7 @@
 from app.state.state import 
-from app.nodes.graphnodes import *
+from app.nodes.triage_node import *
 from langgraph.prebuilt import ToolNode ,tools_condition
-from app.agents.agents import 
+from app.agents.triage_agent import 
 from langgraph.graph import StateGraph,END,START
 
 

app/memory_store/embeddings.py

@@ -0,0 +1,30 @@
+import requests
+from typing import List
+from langchain_core.embeddings import Embeddings
+
+class RemoteAPIEmbeddings(Embeddings):
+    def __init__(self, base_url: str):
+        self.base_url = base_url.rstrip("/")
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Call the /embed_docs endpoint."""
+        response = requests.post(
+            f"{self.base_url}/embed_docs",
+            json={"texts": texts}
+        )
+        response.raise_for_status()
+        return response.json()["embeddings"]
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call the /embed_query endpoint."""
+        response = requests.post(
+            f"{self.base_url}/embed_query",
+            json={"text": text}
+        )
+        response.raise_for_status()
+        return response.json()["embedding"]
+    
+
+API_BASE_URL = "https://gaykar-generalembeddings.hf.space"
+
+remote_embeddings = RemoteAPIEmbeddings(base_url=API_BASE_URL)

app/memory_store/memory_store.py

@@ -0,0 +1,14 @@
+from psycopg_pool import ConnectionPool
+from langgraph.store.postgres import PostgresStore
+from langgraph.checkpoint.postgres import PostgresSaver
+from app.memory_store.embeddings import remote_embeddings
+
+
+pool = ConnectionPool(
+    conninfo=DB_URI, 
+    min_size=1, 
+    max_size=10,
+    kwargs={"autocommit": True} 
+)
+
+memory_store = PostgresStore(pool, index={"dims": 384, "embed": remote_embeddings})

app/nodes/archive_node.py

@@ -0,0 +1,17 @@
+from app.state.state import EmailAgentState
+from langchain_core.runnables.config import RunnableConfig
+
+def archive_node(state: EmailAgentState,config: RunnableConfig) -> dict:
+
+    print(f"[ARCHIVE] {state['triage_label']} — {state['sender_subject']}")
+
+    
+    session=get_session()
+
+    user_id=state['user_id']
+
+    thread_id = config.get("configurable", {}).get("thread_id")
+
+    save_received_email(session, user_id, thread_id,state) 
+
+    return {}

app/nodes/context_node.py

@@ -0,0 +1,43 @@
+from langchain_core.messages import AIMessage
+from app.agents.context_agent import context_agent
+from app.prompts.context_agent_prompt import context_agent_template
+from app.state.state import EmailAgentState
+from langgraph.types import RunnableConfig
+
+def prepare_context_node(state: EmailAgentState,config: RunnableConfig):
+
+    """This node retrieves past context and prepares the prompt for the drafting agent."""
+    print("DEBUG: Executing prepare_context_node...")
+
+    prompt_value = context_agent_template.invoke({
+        "user_name":      state["user_name"],
+        "user_email_id": state["user_email_id"], 
+        "senders_email": state["sender_email_id"],
+        "subject":       state["sender_subject"],
+        "body":          state["sender_email_body"],
+        "triage_label":  state["triage_label"],
+        "priority_score":state["priority_score"],
+    })
+
+    prompt = prompt_value.to_messages()
+
+    
+    context_agent_response = context_agent.invoke({"messages": prompt},config=config)
+
+    draft_context = ""
+    
+    for msg in context_agent_response["messages"]:
+       
+        if msg.type == "tool" and msg.name == "give_previous_context":
+            draft_context = msg.content
+            break
+        
+        elif isinstance(msg, AIMessage) and not msg.tool_calls and not draft_context:
+            draft_context = msg.content
+
+    print(f"DEBUG: draft_context = {draft_context[:100] if draft_context else 'NOT FOUND'}")
+
+    return {
+        "context_agent_messages":      context_agent_response["messages"],
+        "draft_context": draft_context,
+    }

app/nodes/email_writing_node.py

@@ -0,0 +1,58 @@
+import json
+from langchain_core.runnables import RunnableConfig
+from app.state.state import EmailAgentState
+from app.agents.email_writing_agent import email_agent
+from app.prompts.email_writing_agent_prompt import email_agent_template
+from langchain_core.messages import ToolMessage
+
+
+def email_writing_agent_node(state: EmailAgentState) -> dict:
+    print("--- DEBUG: ENTERING EMAIL_NODE ---")
+
+
+    messages= state["messages"]
+
+    if len(messages) <= 1:
+        
+        final_prompt = email_agent_template.invoke({
+        "user_name":         state.get("user_name"),
+        "sender_email_id":   state.get("sender_email_id"),
+        "sender_subject":    state.get("sender_subject"),
+        "sender_email_body": state.get("sender_email_body"),
+        "draft_context":     state.get("draft_context") or "No relevant past context found.",
+        })
+
+        final_prompt = final_prompt.to_messages()
+
+    else:
+        
+        final_prompt = messages
+
+    
+    response = email_agent.invoke(final_prompt)
+
+
+
+    return {"messages": [response]}
+
+
+def route_after_tools(state: EmailAgentState):
+    # Iterate backwards to find the latest ToolMessage
+    # This handles cases where the LLM might have sent a text follow-up
+    last_tool_msg = next((m for m in reversed(state["messages"]) 
+                         if isinstance(m, ToolMessage)), None)
+
+    if not last_tool_msg:
+        return "email_writing_agent"
+
+    content_upper = last_tool_msg.content.upper()
+    
+    # logic 1: If we just successfully SENT the email, go to Parser -> Memory
+    if last_tool_msg.name == "send_draft_by_id" and "SUCCESS" in content_upper:
+        print("--- ROUTER: Send successful. Moving to Parse/Memory. ---")
+        return "parse_node"
+    
+    # logic 2: If we just created a DRAFT (or the send failed)
+    # Go back to agent to talk to the user
+    print("--- ROUTER: Draft created or Tool failed. Returning to Agent. ---")
+    return "email_writing_agent"

app/nodes/graphnodes.py

@@ -1,13 +0,0 @@
-from app.state.state import OnboardingState
-from langchain_core.messages import SystemMessage, HumanMessage,ToolMessage,AIMessage
-from app.prompts.
-from app.prompts.
-from app.prompts.
-from app.agents.agents import 
-from app.prompts.gap_analysis_agent_prompt import gap_analysis_agent_prompt
-from app.schemas.pydanticschema import ResumeExtract,JobDescriptionExtract,SkillGapAnalysis
-import json
-from app.tools.tools import *
-from langchain_community.document_loaders import PyMuPDFLoader
-from langgraph.prebuilt import ToolNode ,tools_condition
-

app/nodes/parse_node.py

@@ -0,0 +1,40 @@
+import re
+from langchain_core.messages import ToolMessage
+from app.state.state import EmailAgentState
+
+
+def parse_response_node(state: EmailAgentState) -> dict:
+    messages = state["messages"]
+    updates = {}
+    
+    # 1. Find the successful SEND message to get the ID
+    # We scan backwards for the first ToolMessage from 'send_draft_by_id'
+    send_tool_msg = next((m for m in reversed(messages) 
+                         if isinstance(m, ToolMessage) and m.name == "send_draft_by_id"), None)
+    
+    if send_tool_msg and "SUCCESS" in send_tool_msg.content.upper():
+        id_match = re.search(r'<id>(.*?)</id>', send_tool_msg.content)
+        if id_match:
+            updates["sent_message_id"] = id_match.group(1)
+
+    # 2. Find the most recent successful DRAFT creation
+    # This is the "lookback" that ignores all the rejections and rewrites
+    draft_tool_msg = next((m for m in reversed(messages) 
+                          if isinstance(m, ToolMessage) and m.name == "create_gmail_draft" 
+                          and "Successfully" in m.content), None)
+
+    if draft_tool_msg:
+        # Extract the content from the tags you defined in the tool
+        subject_match = re.search(r'<subject>(.*?)</subject>', draft_tool_msg.content)
+        body_match = re.search(r'<body>(.*?)</body>', draft_tool_msg.content, re.DOTALL)
+        
+        if subject_match:
+            updates["reply_subject"] = subject_match.group(1)
+        if body_match:
+            updates["reply_email_body"] = body_match.group(1)
+
+    # 3. Final Safety: If we still don't have a body, don't return 'None'
+    if not updates.get("reply_email_body"):
+        updates["reply_email_body"] = "Content could not be retrieved from history."
+
+    return updates

app/nodes/safety_classifier_node.py

@@ -0,0 +1,41 @@
+import httpx
+from typing import Any
+from app.state.state import EmailAgentState
+
+
+SAFETY_API_URL = "https://gaykar-classifyemail.hf.space/predict"
+
+def safety_classifier_node(state: EmailAgentState) -> dict:
+    payload = {
+        "subject": state["sender_subject"],
+        "body":    state["sender_email_body"],
+    }
+    try:
+        with httpx.Client(timeout=10.0) as client:
+            response = client.post(SAFETY_API_URL, json=payload)
+            response.raise_for_status()
+            result = response.json()
+
+        prediction    = result.get("prediction", "UNSAFE").upper()
+        confidence    = result.get("confidence", "0.00%")
+        url_count     = result.get("url_count", 0)
+        is_safe       = prediction == "SAFE"
+        safety_reason = None
+        if not is_safe:
+            safety_reason = (
+                f"Classified as {prediction} "
+                f"(confidence: {confidence}, urls found: {url_count})"
+            )
+        return {"is_safe": is_safe, "safety_reason": safety_reason}
+
+    except httpx.TimeoutException:
+        return {"is_safe": False, "safety_reason": "Safety API timed out"}
+    except httpx.HTTPStatusError as e:
+        return {"is_safe": False, "safety_reason": f"API error {e.response.status_code}"}
+    
+
+
+def after_safety(state: EmailAgentState) -> str:
+    if not state["is_safe"]:
+        return "unsafe_emails_node"
+    return "triage_node"

app/nodes/store_memory_data_node.py

@@ -0,0 +1,45 @@
+from langchain_core.messages import AIMessage
+from langchain_core.runnables.config import RunnableConfig
+from app.agents.memory_manager_agent import memory_manager_agent
+from app.prompts.memory_manager_agent_prompt import memory_agent_template
+from app.state.state import EmailAgentState
+from app.agents.memory_manager_agent import memory_manager_agent 
+
+def store_memory_and_data_node(state: EmailAgentState, config: RunnableConfig):
+    """
+    Synchronous LangGraph node to persist email interaction with robust session handling.
+    """
+    print("--- Memory Node: Persisting interaction to DB ---")
+
+    # 1. Prepare the memory summary
+    prompt = memory_agent_template.invoke({
+        "user_name": state["user_name"],
+        "senders_email_id": state["sender_email_id"],
+        "user_email_id": state["user_email_id"],
+        "sent_email_body": state.get("reply_email_body", "No response found"), # Use .get() for safety
+        "incoming_email_body": state["sender_email_body"],
+    })
+
+    # 2. Invoke memory agent logic
+    memory_manager_agent.invoke(
+        {"messages": prompt.to_messages()},
+        config=config
+    )
+
+    # 3. Robust Database Operations
+    sender_id = state['user_id']
+    thread_id = config.get("configurable", {}).get("thread_id")
+
+    # Using 'with' handles opening/closing even if an error occurs
+    with get_session() as session:
+        try:
+            save_sent_email(session, sender_id, thread_id, state)
+            save_received_email(session, sender_id, thread_id, state)
+            session.commit()
+            print("--- Memory Node: DB Save Successful ---")
+        except Exception as e:
+            session.rollback()
+            print(f"--- Memory Node Error: {e} ---")
+            raise e
+
+    return {"memory_agent_messages": [AIMessage(content="Memory successfully persisted.")]}

app/nodes/triage_node.py

@@ -0,0 +1,31 @@
+from app.agents.triage_agent import triage_agent
+from app.prompts.triage_agent_prompt import triage_agent_template
+from app.schemas.triage_agent_schema import TriageOutput
+from app.state.state import EmailAgentState
+def triage_node(state: dict) -> dict:
+   
+    triage_agent_prompt =triage_agent_template.invoke(
+        {
+            "sender_subject": state["sender_subject"],
+            "sender_body": state["sender_email_body"],
+            "user_name": state["user_name"],
+        }
+    )
+    result = triage_agent.invoke(triage_agent_prompt.to_messages())
+    parsed: TriageOutput = result["parsed"]
+    return {
+        "triage_label":   parsed.triage_label,
+        "requires_reply": parsed.requires_reply,
+        "triage_notes":   parsed.triage_notes,
+        "priority_score": parsed.priority_score,
+    }
+
+
+def route_after_triage(state: EmailAgentState):
+    # This is a ROUTER, so it returns a STRING name of the next node
+    label = state["triage_label"]
+     # Go to the node that formats the prompt
+    if label == "FOLLOW_UP_REQUIRED":
+        return "prepare_context_node"
+    
+    return "archive_node"

app/nodes/unsafe_email_nodes.py

@@ -0,0 +1,14 @@
+from app.state.state import EmailAgentState
+from langchain_core.runnables.config import RunnableConfig
+
+def unsafe_emails_node(state: EmailAgentState,config: RunnableConfig) -> dict:
+    print(f"[QUARANTINE] {state['sender_subject']} — reason: {state['safety_reason']}")
+
+    session=get_session()
+
+    user_id=state['user_id']
+
+    thread_id = config.get("configurable", {}).get("thread_id")
+
+    save_received_email(session, user_id, thread_id,state) 
+    return {}

app/prompts/email_writing_agent_prompt.py

@@ -0,0 +1,42 @@
+from langchain_core.prompts import ChatPromptTemplate
+
+email_agent_template = ChatPromptTemplate([
+    ("system", """
+<role>
+You are {user_name}'s email assistant. MUST use tools for every action.
+</role>
+
+<memory_context>
+{draft_context}
+</memory_context>
+
+<one_shot_example>
+User: "Reply to client."
+Agent Tool: create_gmail_draft_tool(...)
+Output: "Success! ID: draft_999"
+User: "Send it."
+Agent Tool: send_draft_by_id_tool(draft_id="draft_999")
+Output: "SUCCESS: Sent! Message ID: msg_123"
+Output: "Stored."
+</one_shot_example>
+
+<rules>
+1. NEW DRAFT: Call `create_gmail_draft_tool` first.
+2. REJECTION: If "DRAFT REJECTED", rewrite and call `create_gmail_draft_tool` again.
+3. SENDING: Only call `send_draft_by_id_tool` when user explicitly orders. 
+4. ARCHIVING: After `send_draft_by_id_tool` returns a Message ID.
+important:You are not allowed to send until the user explicitly orders to send.
+5.Use **{sender_email_id}** as the recipient not the name.
+</rules>
+
+"""),
+    ("human", """
+<incoming_email>
+Subject  : {sender_subject}
+Sender   : {sender_email_id}
+Body     : {sender_email_body}
+</incoming_email>
+
+
+""")
+])

app/prompts/memory_manager_agent_prompt.py

@@ -0,0 +1,20 @@
+from langchain_core.prompts import ChatPromptTemplate
+
+memory_agent_template = ChatPromptTemplate([
+    ("system", """<username>{user_name}</username>.<user_email_id>{user_email_id}</user_email_id>
+
+"""),
+
+    ("human", """
+<incoming_email>
+From: {senders_email_id}
+To:User
+Body: {incoming_email_body}
+</incoming_email>
+<reply_email>
+From:User
+To: {senders_email_id}
+Body: {sent_email_body}  
+</reply_email>    
+"""),
+])

app/schemas/email_writing_agent_tools_schema.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+class CreateDraftSchema(BaseModel):
+    to: str = Field(description="Recipient email address,must be a plain string email, NOT a list/array.")
+    subject: str = Field(description="Email subject.")
+    body: str = Field(description="Email body content.")
+
+
+class SendDraftSchema(BaseModel):
+    draft_id: str = Field(description="The ID of the draft to send.")

app/schemas/triage_agent_schema.py

@@ -0,0 +1,49 @@
+from typing import Literal
+from pydantic import BaseModel, Field
+from typing import Literal, Optional
+
+TriageLabel = Literal[
+    "FOLLOW_UP_REQUIRED",
+    "READ_LATER",
+    "CHECK_LATER",
+    "PROMOTIONAL",
+    "FYI_NOTIFICATION",
+]
+
+class TriageOutput(BaseModel):
+    """
+    Structured output from the triage agent.
+    Classifies an incoming email into a productivity label.
+    """
+
+    triage_label: TriageLabel = Field(
+        description=(
+            "Productivity label assigned to the email. "
+            "FOLLOW_UP_REQUIRED = Action or reply needed (High Urgency & Standard Follow-ups), "
+            "READ_LATER = Informational only, no action required, "
+            "CHECK_LATER = Unknown sender or cold outreach, "
+            "PROMOTIONAL = Marketing or sales emails, "
+            "FYI_NOTIFICATION = Automated alerts or confirmations."
+        )
+    )
+
+    requires_reply: bool = Field(
+        description="True ONLY when triage_label is FOLLOW_UP_REQUIRED. False for all others."
+    )
+
+    triage_notes: Optional[str] = Field(
+        default=None,
+        description="One concise sentence explaining why this label and priority were chosen."
+    )
+
+    priority_score: int = Field(
+        ge=1,
+        le=5,
+        description=(
+            "Urgency score: 5 = Critical/Urgent (Reply NOW), "
+            "4 = High priority (Reply today), "
+            "3 = Standard follow-up (this week), "
+            "2 = Low priority read, "
+            "1 = Ignore/Archive."
+        )
+    )

app/state/state.py

@@ -1,22 +1,65 @@
 from typing import Any, Dict, List, Optional, Tuple,TypedDict,Literal
 from typing import Annotated, Sequence
-import os
-from langchain_core.messages import SystemMessage, HumanMessage,ToolMessage,AIMessage
-from langchain_core.tools import Tool
 from langgraph.graph import StateGraph,END,START
 from langgraph.types import interrupt  
 from langchain_core.prompts import ChatPromptTemplate,MessagesPlaceholder
-from langchain_community.document_loaders import  PyMuPDFLoader
 from pydantic import BaseModel, Field
 from typing import List, Optional
-from pprint import pprint
 from langchain_core.messages import BaseMessage
 from langgraph.graph import add_messages
-from app.schemas.pydanticschema import *
+from app.schemas.triage_agent_schema import TriageLabel
 
 
 
+class EmailAgentState(TypedDict):
 
 
+    user_email_id:  str
+    user_id:        int 
+    
+    sender_email_body:      str
 
+    sender_email_id:         str
 
+    sender_subject:        str     
+    
+    user_name:      str                  
+
+    # Safety node output
+    is_safe:        Optional[bool]
+    safety_reason:  Optional[str]
+
+    # Triage node output
+    triage_label:   Optional[TriageLabel]
+
+    requires_reply: Optional[bool]
+
+    triage_notes:   Optional[str]
+
+    priority_score: Optional[int] 
+
+    draft_id: Optional[str]
+    
+    sent_message_id: Optional[str]  
+    
+    draft_context:Optional[str]     
+
+    memory_agent_messages:Annotated[Sequence[BaseMessage],add_messages]   
+
+
+    reply_subject:  Optional[str] 
+
+    draft_email:    Optional[str]
+
+    draft_reason:   Optional[str]
+
+
+    context_agent_messages:Annotated[Sequence[BaseMessage],add_messages]
+
+   
+    human_approved: Optional[bool]
+    reply_email_body:Optional[str]  
+
+    messages:Annotated[Sequence[BaseMessage],add_messages]
+    
+           

app/tools/context_agent_tools.py

@@ -0,0 +1,22 @@
+from langmem import create_search_memory_tool
+from langchain.tools import tool
+
+search_memory_tool = create_search_memory_tool(
+    namespace=(
+        "email",
+        "{langgraph_user_id}",
+        "collection"
+    )
+)
+
+@tool
+def give_previous_context(memory_summary: str) -> str:
+    """
+   Args:
+        memory_summary: Structured summary containing sender identity,
+                        past context, new facts stored, and suggested tone.
+                        
+    """
+    return memory_summary
+
+context_agent_tools=[search_memory_tool,give_previous_context]

app/tools/email_writing_agent_tools.py

@@ -0,0 +1,54 @@
+from langgraph.types import interrupt
+from googleapiclient.errors import HttpError
+from app.schemas.email_writing_agent_tools_schema import CreateDraftSchema, SendDraftSchema
+from langchain.tools import tool
+from langchain_google_community import GmailToolkit
+
+
+@tool(args_schema=CreateDraftSchema)
+def create_gmail_draft(to: str, subject: str, body: str):
+    """Creates a new Gmail draft after human approval."""
+    
+    # 1. Pause and ask for review
+    response = interrupt({
+        "action": "review_draft",
+        "data": {"to": to, "subject": subject, "body": body}
+    })
+
+    toolkit = GmailToolkit() 
+    draft_tool = [t for t in toolkit.get_tools() if t.name == "create_gmail_draft"][0]
+
+    # 2. Handle the response
+    if response.get("status") == "approved":
+        reply = draft_tool.invoke({
+            "message": body,
+            "to": [to],
+            "subject": subject
+        })
+
+        draft_id=reply.split(":")[1].strip()
+        return f"Successfully created draft : <id>{draft_id}</id> <subject>{subject}</subject> <body>{body}</body>"
+    
+    else:
+        # Get the feedback from the user response
+        feedback = response.get("feedback", "User rejected without specific notes.")
+        
+        # We return this to the AGENT so it can read it and rewrite the draft
+        return f"DRAFT REJECTED BY USER. Feedback: {feedback}. Please rewrite the draft based on this feedback and try again."
+    
+
+
+
+@tool(args_schema=SendDraftSchema)
+def send_draft_by_id(draft_id: str):
+    """Sends a finalized Gmail draft by its ID."""
+    try:
+        toolkit = GmailToolkit()
+        result = toolkit.api_resource.users().drafts().send(
+            userId="me", body={"id": draft_id}
+        ).execute()
+        return f"SUCCESS: Sent! a Gmail with  ID: <id>{result['id']}</id>"
+    except HttpError as error:
+        if error.resp.status == 404:
+            return f"ERROR: Draft ID {draft_id} was not found. Please verify the ID or check if it was already sent."
+        return f"ERROR: An unexpected error occurred: {error}"

requirements.txt

@@ -6,3 +6,6 @@ fastapi==0.118.1
 uvicorn
 langmem
 SQLAlchemy==2.0.41
+google-auth==2.49.1
+langgraph-checkpoint-postgres
+psycopg[binary,pool]