fixed error api key

agents.py

@@ -1,62 +1,55 @@
 # agents.py
 from langgraph.prebuilt import create_react_agent
 import os
-import uuid
-from typing import Dict
+import logging
 
-# Secure session-based API key storage
-_session_keys: Dict[str, str] = {}
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-def generate_session_id() -> str:
-    """Generate a unique session ID"""
-    return str(uuid.uuid4())
+# Simple global API key storage
+_api_key = None
 
-def set_api_key(api_key: str, session_id: str = None) -> str:
-    """Securely set the API key for a specific session"""
-    if not session_id:
-        session_id = generate_session_id()
-    
-    # Basic validation
-    if not api_key or len(api_key.strip()) < 10:
-        return None
-    
-    # Store securely per session
-    _session_keys[session_id] = api_key.strip()
-    return session_id
-
-def get_api_key(session_id: str) -> str:
-    """Retrieve API key for session"""
-    return _session_keys.get(session_id, None)
-
-def clear_session(session_id: str):
-    """Clear session data"""
-    if session_id in _session_keys:
-        del _session_keys[session_id]
+def set_api_key(api_key: str) -> bool:
+    """Set the API key for Claude"""
+    global _api_key
+    if api_key and api_key.strip():
+        _api_key = api_key.strip()
+        os.environ["ANTHROPIC_API_KEY"] = _api_key
+        logger.info("API key set successfully")
+        return True
+    else:
+        logger.error("Invalid API key provided")
+        return False
 
-def create_agent_response(prompt: str, user_input: str, session_id: str, model: str = "anthropic/claude-3-haiku-20240307") -> str:
+def create_agent_response(prompt: str, user_input: str, model: str = "anthropic:claude-3-haiku-20240307") -> str:
     """Generic function to create and invoke any agent"""
     global _api_key
     
     if not _api_key:
-        return "Error: API key not set. Please set your Claude API key first."
+        error_msg = "API key not set. Please set your Claude API key first."
+        logger.error(error_msg)
+        return f"Error: {error_msg}"
     
     try:
+        logger.info(f"Creating agent with model: {model}")
         agent = create_react_agent(
             model=model,
             tools=[],
             prompt=prompt
         )
         
+        logger.info("Invoking agent with user input")
         result = agent.invoke({
             "messages": [{"role": "user", "content": user_input}]
         })
         
         # Handle different possible return types from LangGraph
         if hasattr(result, 'content'):
-            # AIMessage object
+            logger.info("Received AIMessage response")
             return str(result.content)
         elif isinstance(result, dict):
-            # Dictionary format
+            logger.info("Received dict response")
             if 'content' in result:
                 return str(result['content'])
             elif 'messages' in result and len(result['messages']) > 0:
@@ -66,19 +59,23 @@ def create_agent_response(prompt: str, user_input: str, session_id: str, model:
                 elif isinstance(last_msg, dict) and 'content' in last_msg:
                     return str(last_msg['content'])
         elif isinstance(result, str):
-            # Direct string response
+            logger.info("Received string response")
             return result
         
         # Fallback: convert whatever we got to string
+        logger.warning("Using fallback response conversion")
         return str(result)
             
     except Exception as e:
-        return f"Error: Unable to process request - {str(e)}"
+        error_msg = f"Unable to process request - {str(e)}"
+        logger.error(f"Agent error: {error_msg}", exc_info=True)
+        return f"Error: {error_msg}"
 
 # ==================== CORE AGENT FUNCTIONS ====================
 
-def judge_agent(student_arg: str, opponent_arg: str = "", documents: str = "", session_id: str = "") -> str:
+def judge_agent(student_arg: str, opponent_arg: str = "", documents: str = "") -> str:
     """Judge agent for evaluating legal arguments"""
+    logger.info("Judge agent called")
     prompt = """You are an experienced federal judge presiding over a courtroom.
     
 Your role is to:
@@ -93,10 +90,11 @@ ALWAYS respond in this exact format: Judge: [your response]
 Keep responses 2-4 sentences, focusing on legal analysis."""
 
     user_input = f"Student Argument: {student_arg}\nOpponent Argument: {opponent_arg}\nCase Documents: {documents}"
-    return create_agent_response(prompt, user_input, session_id)
+    return create_agent_response(prompt, user_input)
 
-def opponent_agent(student_arg: str, case_context: str = "", session_id: str = "") -> str:
+def opponent_agent(student_arg: str, case_context: str = "") -> str:
     """Opponent agent for counter-arguments"""
+    logger.info("Opponent agent called")
     prompt = """You are a skilled attorney arguing the opposing side in this case.
     
 Your role is to:
@@ -111,10 +109,11 @@ ALWAYS respond in this exact format: Opponent: [your response]
 Keep responses 2-4 sentences, focused on strong legal counter-arguments."""
 
     user_input = f"Student's Argument: {student_arg}\nCase Context: {case_context}"
-    return create_agent_response(prompt, user_input, session_id)
+    return create_agent_response(prompt, user_input)
 
-def narrator_agent(context: str, student_arg: str = "", opponent_arg: str = "", session_id: str = "") -> str:
+def narrator_agent(context: str, student_arg: str = "", opponent_arg: str = "") -> str:
     """Enhanced narrator agent that handles courtroom atmosphere AND side character arguments"""
+    logger.info("Narrator agent called")
     prompt = """You are a courtroom narrator who describes the scene and occasionally voices side characters.
     
 Your roles include:
@@ -136,10 +135,9 @@ Otherwise format as: "Narrator: [your narration]"
 Keep responses 2-4 sentences, atmospheric and engaging."""
 
     user_input = f"Context: {context}\nStudent Argument: {student_arg}\nOpponent Argument: {opponent_arg}"
-    return create_agent_response(prompt, user_input, session_id)
+    return create_agent_response(prompt, user_input)
 
 # ==================== AGENT REGISTRY ====================
-# Simplified registry with only the three core agents
 AVAILABLE_AGENTS = {
     'judge': judge_agent,
     'opponent': opponent_agent,
@@ -151,4 +149,6 @@ def get_agent_response(agent_type: str, *args, **kwargs) -> str:
     if agent_type in AVAILABLE_AGENTS:
         return AVAILABLE_AGENTS[agent_type](*args, **kwargs)
     else:
-        return f"Error: Unknown agent type '{agent_type}'. Available agents: {list(AVAILABLE_AGENTS.keys())}"
+        error_msg = f"Unknown agent type '{agent_type}'. Available agents: {list(AVAILABLE_AGENTS.keys())}"
+        logger.error(error_msg)
+        return f"Error: {error_msg}"

app.py

@@ -1,10 +1,15 @@
 import gradio as gr
 import time
+import logging
 from typing import Dict, List, Tuple, Optional
-from agents import judge_agent, opponent_agent, narrator_agent, set_api_key, generate_session_id, clear_session
+from agents import judge_agent, opponent_agent, narrator_agent, set_api_key
 from dotenv import load_dotenv
 import os
 
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # Load environment variables
 load_dotenv()
 
@@ -16,32 +21,41 @@ class LawTrainingSystem:
         self.student_side = None
         self.conversation_history = []
         self.processing_lock = False
-        self.session_id = None
+        self.api_key_set = False
         
     def set_api_key(self, api_key: str):
         """Set the API key for the agents"""
-        if api_key and api_key.strip():
-            self.session_id = set_api_key(api_key)
-            if self.session_id:
-                return "✅ API Key set successfully!"
+        try:
+            if api_key and api_key.strip():
+                success = set_api_key(api_key)
+                if success:
+                    self.api_key_set = True
+                    logger.info("API key set successfully in system")
+                    return "✅ API Key set successfully!"
+                else:
+                    self.api_key_set = False
+                    logger.error("Failed to set API key")
+                    return "❌ Invalid API key format"
             else:
-                return "❌ Invalid API key format"
-        else:
-            return "❌ Please enter a valid API key"
+                self.api_key_set = False
+                logger.error("Empty API key provided")
+                return "❌ Please enter a valid API key"
+        except Exception as e:
+            logger.error(f"Error setting API key: {e}", exc_info=True)
+            return f"❌ Error setting API key: {str(e)}"
     
-    def clear_session(self):
-        """Clear session data when done"""
-        if self.session_id:
-            clear_session(self.session_id)
-            self.session_id = None
-        
     def initialize_session(self, case_title: str, case_description: str, student_side: str):
         """Initialize a new training session"""
-        self.session_active = True
-        self.current_case = {"title": case_title, "description": case_description}
-        self.student_side = student_side
-        self.conversation_history = []
-        return f"Session initialized: {case_title} - You are the {student_side}"
+        try:
+            self.session_active = True
+            self.current_case = {"title": case_title, "description": case_description}
+            self.student_side = student_side
+            self.conversation_history = []
+            logger.info(f"Session initialized: {case_title} - Student side: {student_side}")
+            return f"Session initialized: {case_title} - You are the {student_side}"
+        except Exception as e:
+            logger.error(f"Error initializing session: {e}", exc_info=True)
+            raise
     
     def is_processing(self) -> bool:
         """Check if system is currently processing a response"""
@@ -50,6 +64,7 @@ class LawTrainingSystem:
     def set_processing(self, status: bool):
         """Set processing lock status"""
         self.processing_lock = status
+        logger.info(f"Processing lock set to: {status}")
 
 # Global system instance
 system = LawTrainingSystem()
@@ -58,55 +73,72 @@ system = LawTrainingSystem()
 def generate_judge_response(student_message: str, opponent_message: str = "", documents: str = "") -> str:
     """Generate Judge AI response"""
     try:
-        return judge_agent(student_message, opponent_message, documents, system.session_id)
+        logger.info("Generating judge response")
+        return judge_agent(student_message, opponent_message, documents)
     except Exception as e:
-        return f"Judge: I'm having trouble processing your argument. Could you please rephrase it?"
+        logger.error(f"Error in judge response: {e}", exc_info=True)
+        return f"Judge: I'm having trouble processing your argument. Error: {str(e)}"
 
 def generate_opponent_response(student_message: str) -> str:
     """Generate Opponent AI response"""
     try:
+        logger.info("Generating opponent response")
         case_context = f"Case: {system.current_case['title']} - {system.current_case['description']}" if system.current_case else ""
-        return opponent_agent(student_message, case_context, system.session_id)
+        return opponent_agent(student_message, case_context)
     except Exception as e:
-        return f"Opponent: I'm experiencing technical difficulties. Please try again."
+        logger.error(f"Error in opponent response: {e}", exc_info=True)
+        return f"Opponent: I'm experiencing technical difficulties. Error: {str(e)}"
 
 def generate_narrator_response(context: str, student_message: str = "", opponent_message: str = "") -> str:
     """Generate Narrator AI response - handles side character arguments too"""
     try:
-        return narrator_agent(context, student_message, opponent_message, system.session_id)
+        logger.info("Generating narrator response")
+        return narrator_agent(context, student_message, opponent_message)
     except Exception as e:
-        return f"Narrator: The courtroom atmosphere is tense as technical difficulties arise..."
+        logger.error(f"Error in narrator response: {e}", exc_info=True)
+        return f"Narrator: The courtroom atmosphere is tense as technical difficulties arise. Error: {str(e)}"
 
 # ==================== UI RESPONSE HANDLERS ====================
 def handle_student_response(student_message: str, judge_history: List, opponent_history: List, narrator_history: List) -> Tuple:
     """Process student message and generate AI responses"""
     
-    # Initialize histories if they are None
-    if judge_history is None:
-        judge_history = []
-    if opponent_history is None:
-        opponent_history = []
-    if narrator_history is None:
-        narrator_history = []
-    
-    # Prevent multiple simultaneous processing
-    if system.is_processing():
-        return student_message, judge_history, opponent_history, narrator_history, gr.update(interactive=False)
-    
-    if not system.session_active:
-        return student_message, judge_history, opponent_history, narrator_history, gr.update(interactive=True)
-    
-    # Set processing lock
-    system.set_processing(True)
-    
     try:
+        logger.info(f"Processing student response: {student_message[:50]}...")
+        
+        # Initialize histories if they are None
+        if judge_history is None:
+            judge_history = []
+        if opponent_history is None:
+            opponent_history = []
+        if narrator_history is None:
+            narrator_history = []
+        
+        # Prevent multiple simultaneous processing
+        if system.is_processing():
+            logger.warning("System is already processing, skipping request")
+            return student_message, judge_history, opponent_history, narrator_history, gr.update(interactive=False)
+        
+        if not system.session_active:
+            logger.warning("No active session")
+            return student_message, judge_history, opponent_history, narrator_history, gr.update(interactive=True)
+        
+        if not system.api_key_set:
+            logger.warning("API key not set")
+            return student_message, judge_history, opponent_history, narrator_history, gr.update(interactive=True)
+        
+        # Set processing lock
+        system.set_processing(True)
+        
         # Generate opponent response first
+        logger.info("Generating opponent response")
         opponent_response = generate_opponent_response(student_message)
         
         # Generate judge response (evaluating both student and opponent)
+        logger.info("Generating judge response")
         judge_response = generate_judge_response(student_message, opponent_response)
         
         # Generate narrator response (describing the courtroom scene)
+        logger.info("Generating narrator response")
         narrator_response = generate_narrator_response("Arguments presented", student_message, opponent_response)
         
         # Update chat histories
@@ -114,49 +146,72 @@ def handle_student_response(student_message: str, judge_history: List, opponent_
         opponent_history.append({"role": "assistant", "content": opponent_response})
         narrator_history.append({"role": "assistant", "content": narrator_response})
         
+        logger.info("All responses generated successfully")
+        
         # Clear student input and re-enable
         return "", judge_history, opponent_history, narrator_history, gr.update(interactive=True)
         
+    except Exception as e:
+        logger.error(f"Error in handle_student_response: {e}", exc_info=True)
+        return student_message, judge_history, opponent_history, narrator_history, gr.update(interactive=True)
     finally:
         # Always release processing lock
         system.set_processing(False)
 
 def start_case_session(case_title: str, case_description: str, student_side: str) -> Tuple:
     """Initialize a new case session"""
-    if not system.session_id:
-        return gr.update(), gr.update(), gr.update(), gr.update(), gr.update(interactive=False)
-    
-    if not case_title or not case_description:
+    try:
+        logger.info(f"Starting case session: {case_title}")
+        
+        if not system.api_key_set:
+            logger.warning("Cannot start session - API key not set")
+            return gr.update(), gr.update(), gr.update(), gr.update(), gr.update(interactive=False)
+        
+        if not case_title or not case_description:
+            logger.warning("Cannot start session - missing case details")
+            return gr.update(), gr.update(), gr.update(), gr.update(), gr.update(interactive=False)
+        
+        # Initialize system
+        init_message = system.initialize_session(case_title, case_description, student_side)
+        
+        # Generate initial context from Narrator
+        logger.info("Generating initial narrator context")
+        initial_context = generate_narrator_response(f"Case session begins: {case_title}")
+        
+        # Create initial chat histories
+        judge_history = [{"role": "assistant", "content": "Judge: I am ready to evaluate your arguments based on legal precedent and constitutional law."}]
+        opponent_side = 'prosecution' if student_side == 'defense' else 'defense'
+        opponent_history = [{"role": "assistant", "content": f"Opponent: I will argue for the {opponent_side} side. Present your case."}]
+        narrator_history = [{"role": "assistant", "content": initial_context}]
+        
+        logger.info("Case session started successfully")
+        
+        return (
+            judge_history,
+            opponent_history,
+            narrator_history,
+            gr.update(visible=True),
+            gr.update(interactive=True)
+        )
+        
+    except Exception as e:
+        logger.error(f"Error starting case session: {e}", exc_info=True)
         return gr.update(), gr.update(), gr.update(), gr.update(), gr.update(interactive=False)
-    
-    # Initialize system
-    init_message = system.initialize_session(case_title, case_description, student_side)
-    
-    # Generate initial context from Narrator
-    initial_context = generate_narrator_response(f"Case session begins: {case_title}")
-    
-    # Create initial chat histories
-    judge_history = [{"role": "assistant", "content": "Judge: I am ready to evaluate your arguments based on legal precedent and constitutional law."}]
-    opponent_side = 'prosecution' if student_side == 'defense' else 'defense'
-    opponent_history = [{"role": "assistant", "content": f"Opponent: I will argue for the {opponent_side} side. Present your case."}]
-    narrator_history = [{"role": "assistant", "content": initial_context}]
-    
-    return (
-        judge_history,
-        opponent_history,
-        narrator_history,
-        gr.update(visible=True),
-        gr.update(interactive=True)
-    )
 
 def upload_case_documents(files) -> str:
     """Handle case document uploads"""
-    if not files:
-        return "No documents uploaded"
-    
-    # TODO: Process uploaded documents with document parsing
-    file_names = [f.name for f in files]
-    return f"Uploaded {len(files)} documents: {', '.join(file_names)}"
+    try:
+        if not files:
+            return "No documents uploaded"
+        
+        # TODO: Process uploaded documents with document parsing
+        file_names = [f.name for f in files]
+        logger.info(f"Uploaded {len(files)} documents: {file_names}")
+        return f"Uploaded {len(files)} documents: {', '.join(file_names)}"
+        
+    except Exception as e:
+        logger.error(f"Error uploading documents: {e}", exc_info=True)
+        return f"Error uploading documents: {str(e)}"
 
 # ==================== GRADIO INTERFACE ====================
 def create_law_training_interface():
@@ -322,13 +377,18 @@ def create_law_training_interface():
 
 # ==================== MAIN EXECUTION ====================
 if __name__ == "__main__":
-    # Create and launch the interface
-    app = create_law_training_interface()
-    
-    # Launch configuration
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        debug=True
-    )
+    try:
+        logger.info("Starting Law Training System")
+        # Create and launch the interface
+        app = create_law_training_interface()
+        
+        # Launch configuration
+        app.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            debug=True
+        )
+    except Exception as e:
+        logger.error(f"Failed to start application: {e}", exc_info=True)
+        raise