fix and add secrets

add_secrets.ipynb

@@ -40,7 +40,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Uploaded 77 secrets to Cyberlgl/CyberLegalAIendpoint.\n"
+      "Uploaded 80 secrets to Cyberlgl/CyberLegalAIendpoint.\n"
      ]
     }
    ],

agent_api.py

@@ -27,6 +27,7 @@ from pdf_analyzer import PDFAnalyzerAgent
 from langchain_openai import ChatOpenAI
 from mistralai import Mistral
 import logging
+import traceback
 import base64
 import tempfile
 import os as pathlib
@@ -153,15 +154,14 @@ class CyberLegalAPI:
         self.agent_lawyer = CyberLegalAgent(llm=llm, system_prompt=SYSTEM_PROMPT_LAWYER, tools=tools.tools_for_lawyer)
         self.pdf_analyzer = PDFAnalyzerAgent(llm=llm, mistral_client=mistral_client)
         self.conversation_manager = ConversationManager()
-        self.base_lawyer_prompt = SYSTEM_PROMPT_LAWYER
         logger.info(f"🔧 CyberLegalAPI initialized with {llm_provider.upper()} provider")
     
     def _build_lawyer_prompt(self, document_analyses: Optional[List[DocumentAnalysis]], jurisdiction: str) -> str:
         """Build lawyer prompt with optional document context"""
         if not document_analyses:
-            return self.base_lawyer_prompt.format(jurisdiction=jurisdiction)
+            return SYSTEM_PROMPT_LAWYER.format(jurisdiction=jurisdiction)
         
-        docs_text = "\n\n### Available Document Analyses in Your Workspace\n"
+        docs_text = "\n\n### Documents parsed in the lawyer profile\n"
         for i, doc in enumerate(document_analyses, 1):
             docs_text += f"[Doc {i}] {doc.file_name}\n"
             if doc.summary: docs_text += f"Summary: {doc.summary}\n"
@@ -169,7 +169,8 @@ class CyberLegalAPI:
             if doc.key_details: docs_text += f"Key Details: {doc.key_details}\n"
             docs_text += "\n"
         
-        return self.base_lawyer_prompt.format(jurisdiction=jurisdiction) + docs_text + "Consider these documents when relevant.\n"
+        docs_text += "Use these documents if the user's question is related to their content.\n"
+        return SYSTEM_PROMPT_LAWYER.format(jurisdiction=jurisdiction) + docs_text
     
     async def process_request(self, request: ChatRequest) -> ChatResponse:
         """
@@ -199,14 +200,23 @@ class CyberLegalAPI:
                 "content": msg.content
             })
         
+        logger.info(f"🚀 Starting request processing - user_type: {request.userType}, jurisdiction: {request.jurisdiction}")
+        logger.info(f"💬 User query: {request.message}")
+        
         try:
             # Build dynamic system prompt for lawyers with document analyses
-            system_prompt = None
             if request.userType == "lawyer" and request.documentAnalyses:
                 system_prompt = self._build_lawyer_prompt(request.documentAnalyses, request.jurisdiction)
                 logger.info(f"📚 Using lawyer prompt with {len(request.documentAnalyses)} document analyses")
+            elif request.userType == "lawyer":
+                system_prompt = SYSTEM_PROMPT_LAWYER.format(jurisdiction=request.jurisdiction)
+                logger.info(f"📝 Using default lawyer prompt with jurisdiction: {request.jurisdiction}")
+            else:
+                system_prompt = SYSTEM_PROMPT_CLIENT.format(jurisdiction=request.jurisdiction)
+                logger.info(f"👤 Using client prompt with jurisdiction: {request.jurisdiction}")
             
             # Process through selected agent with raw message and conversation history
+            logger.info(f"🤖 Calling agent.process_query with jurisdiction: {request.jurisdiction}")
             result = await agent.process_query(
                 user_query=request.message,
                 conversation_history=conversation_history,
@@ -214,6 +224,8 @@ class CyberLegalAPI:
                 system_prompt=system_prompt
             )
             
+            logger.info(f"✅ Agent processing completed successfully")
+            
             # Create response
             response = ChatResponse(
                 response=result["response"],
@@ -223,12 +235,22 @@ class CyberLegalAPI:
                 error=result.get("error")
             )
             
+            logger.info(f"📤 Returning response to user")
             return response
             
         except Exception as e:
+            # Log full traceback for debugging
+            error_traceback = traceback.format_exc()
+            logger.error(f"❌ Request processing failed: {str(e)}")
+            logger.error(f"🔍 Full traceback:\n{error_traceback}")
             raise HTTPException(
                 status_code=500, 
-                detail=f"Processing failed: {str(e)}"
+                detail={
+                    "error": "Processing failed",
+                    "message": str(e),
+                    "traceback": error_traceback,
+                    "timestamp": datetime.now().isoformat()
+                }
             )
     
     async def health_check(self) -> HealthResponse:
@@ -300,10 +322,17 @@ class CyberLegalAPI:
                     logger.debug(f"🗑️ Cleaned up temporary file: {tmp_file_path}")
                     
         except Exception as e:
+            error_traceback = traceback.format_exc()
             logger.error(f"❌ PDF analysis failed: {str(e)}")
+            logger.error(f"🔍 Full traceback:\n{error_traceback}")
             raise HTTPException(
                 status_code=500,
-                detail=f"PDF analysis failed: {str(e)}"
+                detail={
+                    "error": "PDF analysis failed",
+                    "message": str(e),
+                    "traceback": error_traceback,
+                    "timestamp": datetime.now().isoformat()
+                }
             )
 
 # Initialize API instance
@@ -405,13 +434,18 @@ async def root():
 @app.exception_handler(Exception)
 async def global_exception_handler(request, exc):
     """
-    Global exception handler
+    Global exception handler with full traceback for debugging
     """
+    error_traceback = traceback.format_exc()
+    logger.error(f"❌ Unhandled exception: {str(exc)}")
+    logger.error(f"🔍 Full traceback:\n{error_traceback}")
+    
     return JSONResponse(
         status_code=500,
         content={
             "error": "Internal server error",
             "detail": str(exc),
+            "traceback": error_traceback,
             "timestamp": datetime.now().isoformat()
         }
     )

langraph_agent.py

@@ -5,6 +5,7 @@ Agent can call tools, process results, and decide to continue or answer
 """
 
 import os
+import copy
 import logging
 from typing import Dict, Any, List, Optional
 from datetime import datetime
@@ -23,7 +24,6 @@ from tools import tools, tools_for_client, tools_for_lawyer
 class CyberLegalAgent:
     def __init__(self, llm, system_prompt: str = SYSTEM_PROMPT_CLIENT, tools: List[Any] = tools):
         self.tools = tools
-        self.system_prompt = system_prompt
         self.llm = llm
         self.performance_monitor = PerformanceMonitor()
         self.llm_with_tools = self.llm.bind_tools(self.tools)
@@ -54,8 +54,14 @@ class CyberLegalAgent:
         
         if not intermediate_steps:
             history = state.get("conversation_history", [])
-            # Use provided system prompt if available, otherwise use the default
-            system_prompt_to_use = state.get("system_prompt", self.system_prompt)
+            # Use provided system prompt if available (not None), otherwise use the default
+            system_prompt_to_use = state.get("system_prompt")
+            jurisdiction = state.get("jurisdiction", "unknown")
+            # Deepcopy to avoid modifying the original prompt string
+            system_prompt_to_use = copy.deepcopy(system_prompt_to_use)
+            system_prompt_to_use = system_prompt_to_use.format(jurisdiction=jurisdiction)
+            logger.info(f"📍 Formatted system prompt with jurisdiction: {jurisdiction}")
+            
             intermediate_steps.append(SystemMessage(content=system_prompt_to_use))
             for msg in history:
                 if isinstance(msg, dict):