Update app.py

app.py

@@ -146,12 +146,25 @@ def create_model_with_api_key(hf_token: str, model_id: str = None) -> InferenceC
     if not model_id:
         model_id = "Qwen/Qwen2.5-Coder-32B-Instruct"
     
-    return InferenceClientModel(
-        model_id=model_id,
-        hf_token=hf_token,
-        temperature=0.1,
-        max_tokens=4000,
-    )
+    # Store original token
+    original_token = os.environ.get("HF_TOKEN")
+    
+    try:
+        # Set the token in environment for this session
+        os.environ["HF_TOKEN"] = hf_token
+        
+        # Create model without explicit token parameter
+        model = InferenceClientModel(
+            model_id=model_id,
+        )
+        
+        return model
+    finally:
+        # Restore original token
+        if original_token:
+            os.environ["HF_TOKEN"] = original_token
+        elif "HF_TOKEN" in os.environ:
+            del os.environ["HF_TOKEN"]
 
 def create_tools_with_model(model: InferenceClientModel):
     """Create tools with the provided model."""
@@ -224,16 +237,69 @@ def get_user_session(request: gr.Request) -> str:
 def get_stable_session_id(request: gr.Request) -> str:
     """Get a stable session ID that persists across requests."""
     if not request:
-        return "default_session"
+        logger.warning("No request object, using random session ID")
+        return f"random_{str(uuid.uuid4())[:8]}"
     
     # Use a combination of client info for more stable sessions
     client_ip = getattr(request.client, 'host', 'unknown') if request.client else 'unknown'
     user_agent = request.headers.get("user-agent", "unknown")
     
-    # Create a stable session ID
+    # Add additional uniqueness factors
+    accept_language = request.headers.get("accept-language", "unknown")
+    accept_encoding = request.headers.get("accept-encoding", "unknown")
+    
+    # Create a more unique session ID
     import hashlib
-    session_hash = hashlib.md5(f"{client_ip}:{user_agent}".encode()).hexdigest()
-    return f"user_{session_hash[:12]}"
+    session_data = f"{client_ip}:{user_agent}:{accept_language}:{accept_encoding}"
+    session_hash = hashlib.md5(session_data.encode()).hexdigest()
+    session_id = f"user_{session_hash[:16]}"
+    
+    logger.info(f"Generated session ID: {session_id}")
+    logger.info(f"Session data: {session_data}")
+    
+    return session_id
+
+def get_unique_session_id(request: gr.Request) -> str:
+    """Get a truly unique session ID for each request."""
+    if not request:
+        return f"unique_{str(uuid.uuid4())[:8]}"
+    
+    # Use timestamp + client info for uniqueness
+    import time
+    timestamp = int(time.time() * 1000)  # milliseconds
+    client_ip = getattr(request.client, 'host', 'unknown') if request.client else 'unknown'
+    user_agent = request.headers.get("user-agent", "unknown")
+    
+    # Create a unique session ID
+    import hashlib
+    session_data = f"{timestamp}:{client_ip}:{user_agent}"
+    session_hash = hashlib.md5(session_data.encode()).hexdigest()
+    session_id = f"unique_{session_hash[:16]}"
+    
+    logger.info(f"Generated unique session ID: {session_id}")
+    
+    return session_id
+
+def get_persistent_session_id(request: gr.Request) -> str:
+    """Get a persistent session ID that stays the same for the same client."""
+    if not request:
+        return f"persistent_{str(uuid.uuid4())[:8]}"
+    
+    # Use only client info for persistence (no timestamp)
+    client_ip = getattr(request.client, 'host', 'unknown') if request.client else 'unknown'
+    user_agent = request.headers.get("user-agent", "unknown")
+    accept_language = request.headers.get("accept-language", "unknown")
+    
+    # Create a persistent session ID
+    import hashlib
+    session_data = f"{client_ip}:{user_agent}:{accept_language}"
+    session_hash = hashlib.md5(session_data.encode()).hexdigest()
+    session_id = f"persistent_{session_hash[:16]}"
+    
+    logger.info(f"Generated persistent session ID: {session_id}")
+    logger.info(f"Session data: {session_data}")
+    
+    return session_id
 
 def get_session_data(session_id: str) -> dict:
     """Get session data for a specific user."""
@@ -318,12 +384,14 @@ class GradioUI:
     def interact_with_agent(self, prompt, messages, request: gr.Request):
         """Handle agent interaction with proper session management."""
         # Get unique session ID for this user
-        session_id = get_stable_session_id(request)
+        session_id = get_persistent_session_id(request)
         session_data = get_session_data(session_id)
         
         logger.info(f"Processing request for session {session_id}...")
         logger.info(f"Request client: {request.client.host if request and request.client else 'unknown'}")
         logger.info(f"Request user-agent: {request.headers.get('user-agent', 'unknown')[:50] if request else 'unknown'}")
+        logger.info(f"All active sessions: {list(user_sessions.keys())}")
+        logger.info(f"Session data for {session_id}: {session_data}")
         
         # Check if we have a valid agent for this session
         if not session_data.get("agent"):
@@ -467,12 +535,14 @@ User Query: """
     def setup_api_key(self, api_key: str, max_steps: int, request: gr.Request) -> str:
         """Setup API key for the user's session."""
         # Get unique session ID for this user
-        session_id = get_stable_session_id(request)
+        session_id = get_persistent_session_id(request)
         session_data = get_session_data(session_id)
         
         logger.info(f"Setting up API key for session {session_id}...")
         logger.info(f"Setup request client: {request.client.host if request and request.client else 'unknown'}")
         logger.info(f"Setup request user-agent: {request.headers.get('user-agent', 'unknown')[:50] if request else 'unknown'}")
+        logger.info(f"All active sessions before setup: {list(user_sessions.keys())}")
+        logger.info(f"Session data before setup: {session_data}")
         
         # Check if API key is provided from interface
         if api_key and api_key.strip():