Update agent_langchain.py

agent_langchain.py

@@ -5,9 +5,9 @@ os.environ["HF_HOME"] = "/tmp/huggingface"
 os.environ["SENTENCE_TRANSFORMERS_HOME"] = "/tmp/sentence_transformers"
 os.environ["TORCH_HOME"] = "/tmp/torch"
 
+import json
 import requests
 import torch
-import json
 import time
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import numpy as np
@@ -39,7 +39,6 @@ if firebase_creds_json:
         cred = credentials.Certificate(creds_dict)
 
         if not firebase_admin._apps:
-
             firebase_admin.initialize_app(cred)
         db = firestore.client()
         print("✅ Firebase initialized from FIREBASE_CREDS_JSON")
@@ -167,7 +166,7 @@ llm = ChatGoogleGenerativeAI(
 # Global conversation storage
 conversations = {}
 
-# Tool Functions for Agent (TRULY AUTONOMOUS NOW)
+# Tool Functions for Agent
 def classify_tool(query: str) -> str:
     """Analyzes ticket severity, impact, urgency, and type. Use when you need to understand ticket priority."""
     result = classify_ticket(query)
@@ -186,50 +185,11 @@ def kb_tool(query: str) -> str:
     return f"[KB Confidence: {result['confidence']}] No relevant solution found in knowledge base."
 
 def escalation_tool(reason: str) -> str:
-    """Creates escalation ticket for human agent. Use when: KB confidence is low, issue is complex, or user reports solution failed."""
+    """Creates escalation ticket for human agent. Use ONLY when KB confidence is below 0.6 AND issue is truly complex. Always try KB first!"""
     ticket_id = f"TKT-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
     return f"ESCALATED: Ticket {ticket_id} created. Reason: {reason}. Human agent will respond in 2-4 hours."
 
-def clarifying_questions_tool(issue_summary: str) -> str:
-    """Generates clarifying questions when more information needed. Use when: User description is vague, Need to diagnose issue better, Before searching KB."""
-    prompt = f"""You are an IT helpdesk expert. Based on this issue, generate 2-3 specific clarifying questions to better diagnose the problem.
-
-Issue: {issue_summary}
-
-Generate focused questions that would help identify:
-- Specific symptoms or error messages
-- When the issue started
-- What the user has already tried
-- Environment details (OS, browser, device)
-
-Questions (numbered list):"""
-    
-    try:
-        response = llm.invoke(prompt)
-        return f"CLARIFYING QUESTIONS:\n{response.content.strip()}"
-    except Exception as e:
-        return "Please provide more details: 1) What specific error do you see? 2) When did this start? 3) Have you tried any solutions yet?"
-
-def check_solution_tool(user_feedback: str) -> str:
-    """Analyzes user feedback to determine if provided solution worked. Use after: Giving a solution, User responds with feedback."""
-    feedback_lower = user_feedback.lower()
-    
-    # Success indicators
-    success_keywords = ["worked", "fixed", "solved", "resolved", "success", "thank", "thanks", "great", "perfect", "awesome"]
-    # Failure indicators  
-    failure_keywords = ["didn't work", "not working", "still", "failed", "broken", "issue persists", "same problem", "no luck", "doesn't work"]
-    
-    success_count = sum(1 for kw in success_keywords if kw in feedback_lower)
-    failure_count = sum(1 for kw in failure_keywords if kw in feedback_lower)
-    
-    if success_count > failure_count and success_count > 0:
-        return "SOLUTION_WORKED: User confirmed the solution resolved their issue. You can close this ticket positively."
-    elif failure_count > success_count and failure_count > 0:
-        return "SOLUTION_FAILED: User confirmed the solution did NOT work. You should try alternative solutions or escalate."
-    else:
-        return "UNCLEAR: Cannot determine if solution worked. Ask the user directly: 'Did that solution work for you?'"
-
-# Define Tools with better descriptions
+# Define Tools
 tools = [
     Tool(
         name="ClassifyTicket",
@@ -244,101 +204,58 @@ tools = [
     Tool(
         name="SearchKnowledgeBase",
         func=kb_tool,
-        description="Searches internal knowledge base for solutions. Returns answer with confidence score (0-1). Use this when you need to find technical solutions or troubleshooting steps."
-    ),
-    Tool(
-        name="AskClarifyingQuestions",
-        func=clarifying_questions_tool,
-        description="Generates 2-3 specific questions to better understand the user's problem. Use when: user's description is vague, you need more details to diagnose, or before searching KB with unclear symptoms."
-    ),
-    Tool(
-        name="CheckSolutionEffectiveness",
-        func=check_solution_tool,
-        description="Analyzes user's feedback to determine if the provided solution worked. Use AFTER giving a solution and user responds. Returns SOLUTION_WORKED, SOLUTION_FAILED, or UNCLEAR."
+        description="Searches internal knowledge base for solutions. Returns answer with confidence score (0-1). ALWAYS USE THIS FIRST before escalating. Use this when you need to find technical solutions or troubleshooting steps."
     ),
     Tool(
         name="EscalateToHuman",
         func=escalation_tool,
-        description="Creates an escalation ticket for human agent review. Use this ONLY when: 1) KB confidence score is below 0.75, 2) Issue is highly complex or unusual, 3) User confirms solution didn't work, 4) User explicitly requests human help."
+        description="Creates an escalation ticket for human agent review. CRITICAL: Use this ONLY as a LAST RESORT when: 1) KB confidence score is below 0.6 AND you've already tried KB, 2) Issue is extremely complex and unusual, 3) User explicitly confirms the KB solution failed after trying it. DO NOT escalate if KB has a reasonable solution (confidence > 0.6)."
     )
 ]
 
-# IMPROVED Agent Prompt - More Autonomous
-AGENT_PROMPT = """You are an intelligent IT Helpdesk AI Agent. Your goal is to efficiently resolve IT support tickets using the tools available to you.
+# IMPROVED Agent Prompt
+AGENT_PROMPT = """You are an intelligent IT Helpdesk AI Agent. Your PRIMARY goal is to resolve tickets using the Knowledge Base. Escalation is a LAST RESORT.
 
 AVAILABLE TOOLS:
 {tools}
 
 TOOL NAMES: {tool_names}
 
-GUIDING PRINCIPLES:
-1. **Think autonomously** - Decide which tools you need based on the situation, not a fixed sequence
-2. **Be efficient** - Only use tools when they add value to solving the user's problem
-3. **Trust high-confidence solutions** - If KB returns confidence >= 0.75, provide that solution directly
-4. **Exhaust KB options first** - Try searching KB before escalating. Only escalate if KB truly cannot help
-5. **Escalate wisely** - Only escalate when truly necessary (low KB confidence, complex issues, or failed solutions)
-6. **Maintain context** - Remember previous conversation history when handling follow-ups
-7. **Be empathetic** - Users are frustrated when things break; be professional and supportive
-8. **Be Useful** - If low KB confidence, try answering using general knowledge and escalate
-
-CRITICAL DECISION FRAMEWORK FOR KB CONFIDENCE:
-
-**KB Confidence >= 0.75 (HIGH):**
-- ✅ PROVIDE THE SOLUTION IMMEDIATELY
-- ❌ DO NOT escalate
-- ❌ DO NOT use EscalateToHuman tool
-- This is a good solution - trust it!
-
-**KB Confidence 0.5-0.74 (MEDIUM):**
-- Consider the issue complexity
-- For common issues (password, printer, etc): Provide the solution
-- For critical issues: Provide solution + mention you can escalate if it doesn't work
-- DO NOT immediately escalate - give the solution a chance first
-
-**KB Confidence < 0.5 (LOW) OR No KB Match:**
-- Try to help with general IT knowledge if possible
-- If you cannot help OR issue is highly complex → Then escalate
-- Use EscalateToHuman tool only as last resort
-
-WORKFLOW FOR NEW TICKETS:
-1. Understand the issue (classify if needed)
-2. Search KB for solutions
-3. Evaluate KB confidence:
-   - High (≥0.75): Provide solution, DON'T escalate
-   - Medium (0.5-0.74): Provide solution, offer escalation as backup
-   - Low (<0.5): Try general knowledge OR escalate
-4. Only use EscalateToHuman if KB has no solution AND you can't help
-
-WORKFLOW FOR FOLLOW-UPS:
-- If user says solution worked → Close positively, NO escalation needed
-- If user says solution failed → Try searching KB with different query OR escalate
-- For clarification questions → Answer directly
+CRITICAL RULES:
+1. **ALWAYS search Knowledge Base FIRST** - This is your primary tool for resolution
+2. **Trust KB solutions with confidence >= 0.6** - These are reliable solutions, provide them to users
+3. **ONLY escalate when ABSOLUTELY necessary**:
+   - KB confidence is below 0.6 AND no solution found
+   - Issue is extremely unusual or complex beyond KB scope
+   - User explicitly tried your KB solution and reports it failed
+4. **Be thorough with KB** - If first search doesn't work, try rephrasing the query
+5. **Maintain context** - Remember conversation history for follow-ups
+
+DECISION WORKFLOW:
+NEW TICKET → Search KB → If confidence >= 0.6 → Provide solution → Mark RESOLVED
+         ↓
+   If confidence < 0.6 → Try rephrasing search → Still low? → Classify & Route → THEN escalate
+
+FOLLOW-UP → Check if user tried solution → Worked? → Mark RESOLVED
+                                      ↓
+                              Failed? → Search KB again with different query → Still failing? → THEN escalate
+
+IMPORTANT: 
+- Don't mention tool names or confidence scores to users
+- Provide clear, step-by-step instructions from KB
+- Be conversational and helpful
+- Escalation means you couldn't solve it - avoid this outcome!
 
 FORMAT:
 Question: the user's input
 Thought: your reasoning about what to do next
 Action: the tool to use (must be one of [{tool_names}])
 Action Input: the input for that tool
-Observation: the result of the action
+Observation: the tool's output
 ... (repeat Thought/Action/Observation as needed)
 Thought: I now have enough information to respond
 Final Answer: your complete response to the user
 
-CRITICAL: When you have enough information to answer the user, you MUST use this EXACT format:
-
-Thought: I now have enough information to respond
-Final Answer: [your complete response to the user]
-
-Do NOT add any additional "Action:" or "Thought:" after "Final Answer:". The conversation ends with "Final Answer:".
-
-IMPORTANT: 
-- Don't mention tool names or technical process to users
-- Provide clear, step-by-step instructions
-- Don't escalate if you have a working solution (confidence ≥ 0.75)
-- Trust high-confidence KB solutions - they are tested and verified
-- Be conversational and helpful
-- STOP after "Final Answer:" - do not continue the loop
-
 Begin!
 
 Question: {input}
@@ -346,16 +263,16 @@ Thought: {agent_scratchpad}"""
 
 prompt = PromptTemplate.from_template(AGENT_PROMPT)
 
-# Create Agent with more flexibility
+# Create Agent
 agent = create_react_agent(llm=llm, tools=tools, prompt=prompt)
 agent_executor = AgentExecutor(
     agent=agent,
     tools=tools,
     verbose=True,
-    max_iterations=6,  # Reduced to prevent loops
+    max_iterations=6,
     handle_parsing_errors="Check your output and make sure it conforms to the format instructions!",
     return_intermediate_steps=True,
-    early_stopping_method="force"  # Force stop if max iterations reached
+    early_stopping_method="force"
 )
 
 # Main Processing Function
@@ -363,7 +280,7 @@ def process_with_agent(
     user_message: str, 
     conversation_id: str = None,
     user_email: str = None,
-    callback=None  # For streaming updates via WebSocket
+    callback=None
 ):
     """Process user message through autonomous AI agent."""
     
@@ -393,7 +310,7 @@ def process_with_agent(
     # Build context for follow-ups
     if len(conv["messages"]) > 1:
         context = f"CONVERSATION HISTORY:\n"
-        for msg in conv["messages"][-6:-1]:  # Last 5 messages for context
+        for msg in conv["messages"][-6:-1]:
             context += f"{msg['role'].upper()}: {msg['content']}\n"
         context += f"\nCURRENT MESSAGE: {user_message}"
         agent_input = context
@@ -406,32 +323,29 @@ def process_with_agent(
         agent_response = result.get("output", "I apologize, I encountered an error.")
         intermediate_steps = result.get("intermediate_steps", [])
         
-        # Determine status and handle Firestore
+        # Determine status based on agent's response
         status = "in_progress"
         should_save = False
+        escalated = False
         
-        # Check for escalation FIRST (higher priority)
+        # Check for escalation FIRST (most important)
         if "ESCALATED" in agent_response or "TKT-" in agent_response:
             status = "escalated"
-            should_save = True  # ✅ FIX: Save escalated tickets too!
-        # Then check for resolution indicators
-        elif any(phrase in agent_response.lower() for phrase in ["resolved", "you're all set", "should work now", "problem solved", "glad that worked"]):
+            should_save = True
+            escalated = True
+            print("🔴 Ticket ESCALATED - Saving to Firebase")
+        # Then check for resolution
+        elif any(phrase in agent_response.lower() for phrase in ["resolved", "you're all set", "should work now", "problem solved", "this should fix", "try these steps"]):
             status = "resolved"
             should_save = True
-        # If agent explicitly mentions escalation/forwarding to team
-        elif any(phrase in agent_response.lower() for phrase in ["sent your request to", "forwarded to", "escalated to", "will be in touch", "team will contact"]):
-            status = "escalated"
-            should_save = True  # ✅ FIX: Save when forwarded to team
+            print("✅ Ticket RESOLVED - Saving to Firebase")
         
         # Extract ticket info from tools
         ticket_info = conv.get("ticket_info", {})
-        used_escalation_tool = False  # Track if escalation tool was used
-        kb_confidence = 0.0  # Track KB confidence
-        kb_was_searched = False  # Track if KB was searched
+        kb_confidence = None
         
         for action, observation in intermediate_steps:
             if action.tool == "ClassifyTicket":
-                # Parse classification
                 parts = str(observation).split(", ")
                 for part in parts:
                     if "Impact:" in part:
@@ -440,47 +354,19 @@ def process_with_agent(
                         ticket_info["urgency"] = part.split(": ")[1]
                     elif "Type:" in part:
                         ticket_info["type"] = part.split(": ")[1]
-            
             elif action.tool == "RouteTicket":
                 ticket_info["department"] = str(observation).replace("Department: ", "")
-            
             elif action.tool == "SearchKnowledgeBase":
-                # ✅ Track KB search
-                kb_was_searched = True
-                obs_str = str(observation)
-                if "[KB Confidence:" in obs_str:
+                # Extract confidence from KB response
+                if "[KB Confidence:" in str(observation):
                     try:
-                        # Extract confidence score
-                        import re
-                        match = re.search(r'\[KB Confidence: ([\d.]+)\]', obs_str)
-                        if match:
-                            kb_confidence = float(match.group(1))
-                            ticket_info["kb_confidence"] = kb_confidence
+                        conf_str = str(observation).split("[KB Confidence: ")[1].split("]")[0]
+                        kb_confidence = float(conf_str)
+                        ticket_info["kb_confidence"] = kb_confidence
                     except:
                         pass
-            
-            elif action.tool == "EscalateToHuman":
-                # ✅ SAFEGUARD: Check if escalation was premature
-                if kb_was_searched and kb_confidence >= 0.75:
-                    print(f"⚠️ WARNING: Agent escalated despite high KB confidence ({kb_confidence})")
-                    # Don't set used_escalation_tool = True
-                    # This prevents premature escalation from being treated as valid
-                else:
-                    used_escalation_tool = True
-                    # Extract ticket ID from observation
-                    if "TKT-" in str(observation):
-                        import re
-                        ticket_match = re.search(r'TKT-\d{8}-\d{6}', str(observation))
-                        if ticket_match:
-                            ticket_info["escalation_ticket_id"] = ticket_match.group(0)
         
         conv["ticket_info"] = ticket_info
-        
-        # ✅ FIX: If escalation tool was used, force status to escalated
-        if used_escalation_tool:
-            status = "escalated"
-            should_save = True
-        
         conv["status"] = status
         
         reasoning_trace = []
@@ -505,7 +391,7 @@ def process_with_agent(
             "reasoning": reasoning_trace
         })
         
-        # Save to Firestore if resolved/escalated
+        # Save to Firestore if resolved OR escalated
         firestore_id = None
         if should_save:
             firestore_data = {
@@ -515,14 +401,28 @@ def process_with_agent(
                 "ticket_info": ticket_info,
                 "messages": conv["messages"],
                 "resolution": agent_response,
-                "created_at_iso": conv["created_at"]
+                "created_at_iso": conv["created_at"],
+                "escalated": escalated
             }
+            
+            # Add escalation reason if escalated
+            if escalated:
+                escalation_reason = "Low KB confidence" if kb_confidence and kb_confidence < 0.6 else "Complex issue requiring human intervention"
+                firestore_data["escalation_reason"] = escalation_reason
+                print(f"📤 Saving escalated ticket to Firebase - Reason: {escalation_reason}")
+            
             firestore_id = save_ticket_to_firestore(firestore_data)
             
+            if firestore_id:
+                print(f"✅ Successfully saved to Firestore with ID: {firestore_id}")
+            else:
+                print("❌ Failed to save to Firestore")
+            
             if callback:
                 callback({
                     "type": "saved",
-                    "firestore_id": firestore_id
+                    "firestore_id": firestore_id,
+                    "status": status
                 })
         
         return {