Update agent_langchain.py

agent_langchain.py

@@ -5,7 +5,6 @@ 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 time
@@ -29,25 +28,18 @@ GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
 ROUTING_URL = os.environ.get("ROUTING_URL")
 SPACE_URL = os.environ.get("SPACE_URL", "http://localhost:7860")
 FIREBASE_CREDS_PATH = os.environ.get("FIREBASE_CREDS_PATH")
-firebase_creds_json = os.getenv("FIREBASE_CREDS_JSON")
 
 # Initialize Firebase
 db = None
-if firebase_creds_json:
+if FIREBASE_CREDS_PATH and os.path.exists(FIREBASE_CREDS_PATH):
     try:
-        creds_dict = json.loads(firebase_creds_json)
-        cred = credentials.Certificate(creds_dict)
-
         if not firebase_admin._apps:
+            cred = credentials.Certificate(FIREBASE_CREDS_PATH)
             firebase_admin.initialize_app(cred)
         db = firestore.client()
-        print("✅ Firebase initialized from FIREBASE_CREDS_JSON")
+        print("✅ Firebase initialized")
     except Exception as e:
-        import traceback
         print(f"⚠️ Firebase init failed: {e}")
-        traceback.print_exc()
-else:
-    print("⚠️ FIREBASE_CREDS_JSON not found in environment variables")
 
 # Label Dictionary
 LABEL_DICTIONARY = {
@@ -189,6 +181,45 @@ def escalation_tool(reason: str) -> str:
     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
 tools = [
     Tool(
@@ -206,10 +237,20 @@ tools = [
         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."
+    ),
     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."
+        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."
     )
 ]
 
@@ -224,32 +265,70 @@ 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
-4. **Escalate wisely** - Only escalate when truly necessary (low KB confidence, complex issues, or failed solutions)
-5. **Maintain context** - Remember previous conversation history when handling follow-ups
-6. **Be empathetic** - Users are frustrated when things break; be professional and supportive
-
-DECISION FRAMEWORK:
-- For a NEW ticket: You might need to classify, route, search KB - but decide based on what's needed
-- For FOLLOW-UPS: If user says solution worked → close positively. If it failed → search KB again or escalate
-- For SIMPLE questions: You may not need all tools - use your judgment
-- For COMPLEX issues: Use multiple tools to gather information before providing solution
+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
 
 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 tool's output
+Observation: the result of the action
 ... (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
-- Ask clarifying questions if needed
+- 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!
 
@@ -322,16 +401,25 @@ def process_with_agent(
         status = "in_progress"
         should_save = False
         
-        # Check for resolution indicators
-        if any(phrase in agent_response.lower() for phrase in ["resolved", "you're all set", "should work now", "problem solved"]):
+        # Check for escalation FIRST (higher priority)
+        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"]):
             status = "resolved"
             should_save = True
-        elif "ESCALATED" in agent_response or "TKT-" in agent_response:
+        # 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
+            should_save = True  # ✅ FIX: Save when forwarded to team
         
         # 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
+        
         for action, observation in intermediate_steps:
             if action.tool == "ClassifyTicket":
                 # Parse classification
@@ -343,10 +431,47 @@ 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:
+                    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
+                    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 = []