made chnages in the nodes and prompts

app/core/config.py

@@ -7,22 +7,22 @@ class Settings(BaseSettings):
     PROJECT_NAME: str = "Email Assistant Project"
  
     GROQ_API_KEY: str
-    PINECONE_API_KEY: str
+    # PINECONE_API_KEY: str
 
-    CLOUDINARY_CLOUD_NAME: str
-    CLOUDINARY_API_KEY: str
-    CLOUDINARY_API_SECRET: str
+    # CLOUDINARY_CLOUD_NAME: str
+    # CLOUDINARY_API_KEY: str
+    # CLOUDINARY_API_SECRET: str
 
     
-    DB_URL_FOR_CHECKPOINTER_STORE: str
+    # DB_URL_FOR_CHECKPOINTER_STORE: str
 
-    DB_URL_FOR_SQL_AL:str
+    # DB_URL_FOR_SQL_AL:str
  
-    model_config = SettingsConfigDict(
-        env_file=str(BASE_DIR / ".env"),
-        env_file_encoding="utf-8",
-        extra="ignore"
-    )
+    # model_config = SettingsConfigDict(
+    #     env_file=str(BASE_DIR / ".env"),
+    #     env_file_encoding="utf-8",
+    #     extra="ignore"
+    # )
  
 settings = Settings()
 

app/graph.py

@@ -11,25 +11,38 @@ from app.nodes.parse_node import parse_response_node
 from app.nodes.context_node import prepare_context_node
 from app.nodes.store_memory_data_node import store_memory_and_data_node
 from app.nodes.unsafe_email_node import unsafe_emails_node
+from app.nodes.check_email_exist_node import *
 from langgraph.types import RetryPolicy
 from psycopg import OperationalError # Or sqlalchemy.exc.OperationalError depending on your driver
+# imoprt display
+from IPython.display import Image, display
+
 
 # Define a standard retry policy for database-heavy nodes
 db_retry_policy = RetryPolicy(
     retry_on=OperationalError,
-    max_attempts=3,
-    backoff_factor=2 # Waits 2s, then 4s, then 8s between retries
+    max_attempts=4,
+    backoff_factor=1 # Waits 2s, then 4s, then 8s between retries
+)
+
+tool_node_retry_policy = RetryPolicy(
+    max_attempts=4,
+    initial_interval=1.0,
+    backoff_factor=2.0,
+    jitter=True
 )
 
+
 builder = StateGraph(EmailAgentState)
 
 # Nodes
 builder.add_node("safety_check_node", safety_classifier_node)  
+builder.add_node("check_previous_email_exist_node", check_previous_email_exist_node)
 builder.add_node("triage_node", triage_node)
 builder.add_node("prepare_context_node", prepare_context_node)
 builder.add_node("email_writing_agent", email_writing_agent_node)
 
-# --- APPLY RETRY POLICIES HERE ---
+
 builder.add_node(
     "store_memory_and_data_node", 
     store_memory_and_data_node, 
@@ -41,9 +54,9 @@ builder.add_node(
     retry=db_retry_policy
 )
 
-builder.add_node("archive_node", archive_node)   
+builder.add_node("archive_node", archive_node,retry=db_retry_policy)   
 builder.add_node("parse_node", parse_response_node)
-builder.add_node("tools", ToolNode(email_writing_agent_tools))
+builder.add_node("tools", ToolNode(email_writing_agent_tools), retry_policy=tool_node_retry_policy)
 
 # Edges (Same as your original logic)
 builder.add_edge(START, "safety_check_node")
@@ -54,12 +67,21 @@ builder.add_conditional_edges("safety_check_node", after_safety, {
 })
 
 builder.add_conditional_edges("triage_node", route_after_triage, {
-    "prepare_context_node": "prepare_context_node",
+    "check_previous_email_exist_node": "check_previous_email_exist_node", 
     "archive_node": "archive_node",
 })
 
+builder.add_conditional_edges(
+    "check_previous_email_exist_node",
+    after_mail_check,
+    {
+        "email_writing_agent": "email_writing_agent", 
+        "prepare_context_node": "prepare_context_node" 
+    }
+)
 builder.add_edge("prepare_context_node", "email_writing_agent")
 
+
 builder.add_conditional_edges(
     "email_writing_agent",
     tools_condition,
@@ -81,4 +103,10 @@ builder.add_conditional_edges(
 builder.add_edge("parse_node", "store_memory_and_data_node")
 builder.add_edge("store_memory_and_data_node", END)
 builder.add_edge("unsafe_emails_node", END)
-builder.add_edge("archive_node", END)
+builder.add_edge("archive_node", END)
+
+
+
+graph = builder.compile() 
+
+display(graph)

app/nodes/archive_node.py

@@ -1,5 +1,8 @@
 from app.state.state import EmailAgentState
 from langchain_core.runnables.config import RunnableConfig
+from app.database.connection import get_session
+from app.database.utils import save_received_email
+
 
 def archive_node(state: EmailAgentState,config: RunnableConfig) -> dict:
 
@@ -12,6 +15,20 @@ def archive_node(state: EmailAgentState,config: RunnableConfig) -> dict:
 
     thread_id = config.get("configurable", {}).get("thread_id")
 
-    save_received_email(session, user_id, thread_id,state) 
+    with get_session() as session:
+        try:
+            # 2. Persist the received email even if it's unsafe (for records/logging)
+            save_received_email(session, user_id, thread_id, state)
+
+            session.commit()
+            print("--- [QUARANTINE] Data persisted successfully ---")
+            
+        except Exception as e:
+            # 4. Rollback in case of an OperationalError or SSL timeout
+            session.rollback()
+            print(f"--- [QUARANTINE ERROR] Failed to persist unsafe email: {e} ---")
+         
+            raise e
 
+    
     return {}

app/nodes/check_email_exist_node.py

@@ -0,0 +1,19 @@
+
+from app.state.state import EmailAgentState
+from langchain_google_community import GmailToolkit
+
+def check_previous_email_exist_node(state: EmailAgentState):
+    # Search for previous interactions with this sender
+    toolkit = GmailToolkit()
+    search_tool = [t for t in toolkit.get_tools() if t.name == "search_gmail"][0]
+    results = search_tool.invoke(f"from:{state['sender_email_id']}")
+
+    if len(results) == 0:
+        # No history found - flag this for the conditional edge
+        return {"draft_context": "No relevant past context found."}
+
+def after_mail_check(state: EmailAgentState):
+    # Check the actual state value
+    if state.get("draft_context") == "No relevant past context found.":
+        return "email_writing_agent"
+    return "prepare_context_node"

app/nodes/email_writing_node.py

@@ -2,40 +2,44 @@ 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 app.prompts.email_writing_agent_prompt import *
 from langchain_core.messages import ToolMessage
 
-
 def email_writing_agent_node(state: EmailAgentState) -> dict:
     print("--- DEBUG: ENTERING EMAIL_NODE ---")
+    messages = state.get("messages", [])
 
+    # 1. Prepare Prompts (Your Style)
+    # .to_messages() converts the template into a list: [SystemMessage(...)]
+    system_prompt = system_prompt_email_agent_template.invoke({
+        "user_name":       state.get("user_name"),
+        "draft_context":   state.get("draft_context") or "No relevant past context found.",
+        "sender_email_id": state.get("sender_email_id"),
+    }).to_messages()
 
-    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"),
+    human_prompt = human_prompt_email_agent_template.invoke({
         "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()
+        "sender_email_id":   state.get("sender_email_id"),
+    }).to_messages()
 
-    else:
+  
+    if len(messages) == 0:
         
-        final_prompt = messages
+        final_prompt = system_prompt + human_prompt
+        
+    else:
+      
+        final_prompt = system_prompt + messages
 
-    
+    # 3. Invoke
     response = email_agent.invoke(final_prompt)
 
-
-
+    # 4. Return
     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

app/nodes/store_memory_data_node.py

@@ -44,4 +44,4 @@ def store_memory_and_data_node(state: EmailAgentState, config: RunnableConfig):
             print(f"--- Memory Node Error: {e} ---")
             raise e
 
-    return {"memory_agent_messages": [AIMessage(content="Memory successfully persisted.")]}
+    return {"memory_agent_messages": [AIMessage(content="Memory successfully persisted.")],"email_sent": True}

app/nodes/triage_node.py

@@ -26,6 +26,6 @@ def route_after_triage(state: EmailAgentState):
     label = state["triage_label"]
      # Go to the node that formats the prompt
     if label == "FOLLOW_UP_REQUIRED":
-        return "prepare_context_node"
+        return "check_previous_email_exist_node"
     
     return "archive_node"

app/prompts/email_writing_agent_prompt.py

@@ -1,6 +1,7 @@
 from langchain_core.prompts import ChatPromptTemplate
 
-email_agent_template = ChatPromptTemplate([
+
+system_prompt_email_agent_template = ChatPromptTemplate([
     ("system", """
 <role>
 You are {user_name}'s email assistant. MUST use tools for every action.
@@ -12,24 +13,30 @@ You are {user_name}'s email assistant. MUST use tools for every action.
 
 <one_shot_example>
 User: "Reply to client."
-Agent Tool: create_gmail_draft_tool(...)
+Agent Tool: create_gmail_draft(...)
 Output: "Success! ID: draft_999"
 User: "Send it."
-Agent Tool: send_draft_by_id_tool(draft_id="draft_999")
+Agent Tool: send_draft_by_id(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.
+1. NEW DRAFT: Call `create_gmail_draft` 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.
+3. SENDING: Only call `send_draft_by_id` when user explicitly orders to send. **dont call send_draft_by_id until user  allows you to send the draft**
+4. ARCHIVING: After `send_draft_by_id` 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_prompt_email_agent_template = ChatPromptTemplate([
+
     ("human", """
 <incoming_email>
 Subject  : {sender_subject}
@@ -40,3 +47,6 @@ Body     : {sender_email_body}
 
 """)
 ])
+
+
+

app/schemas/memory_agent_schema.py

@@ -14,7 +14,7 @@ class EmailMemory(BaseModel):
         description="The email address of the person with whom user is communicating."
     )
     
-    content: str = Field(
+    summary: str = Field(
         ..., 
         description="A concise summary of the key information, intent, and decisions found in the emails.The content should be stored using user name"
     )

app/state/state.py

@@ -56,6 +56,8 @@ class EmailAgentState(TypedDict):
 
     context_agent_messages:Annotated[Sequence[BaseMessage],add_messages]
 
+    email_sent: Optional[bool]
+
    
     human_approved: Optional[bool]
     reply_email_body:Optional[str]  

app/tools/email_writing_agent_tools.py

@@ -8,6 +8,12 @@ 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."""
+
+    if isinstance(to, list):
+        if len(to) > 0:
+            to = str(to[0])
+        else:
+            return "ERROR: 'to' parameter is an empty list. Please provide a valid email string."
     
     # 1. Pause and ask for review
     response = interrupt({