Good enough for now

app.py

@@ -39,7 +39,10 @@ COUNTRIES = [
 
 def get_system_message_with_country():
     """Generate a system message with a randomly selected country"""
+    global selected_country
     selected_country = random.choice(COUNTRIES)
+    COUNTRIES.remove(selected_country)  # Ensure the same country isn't picked again
+    print(selected_country)
     return f"""You are a friendly geography game host playing 20 questions with students. You are thinking of the country: {selected_country}
 
 RULES:
@@ -49,26 +52,26 @@ RULES:
 4. When they correctly guess {selected_country}, respond with: 'Congratulations! The country was <<{selected_country}>>'
 5. If they reach 20 questions without guessing correctly, respond with: 'Game over! The country was <<{selected_country}>>'
 6. Be encouraging and give helpful hints through your yes/no answers
-7. If they want to play again tell them they need to reload the page."""
+7. If they want to play again tell them they need to reload the page.
+8. IMPORTANT: Only accept the country name "{selected_country}" as correct, but Spelling is not important and they can ask a question like it is? Do NOT accept neighboring countries, similar countries, or regions that contain this country.
+9. If they guess a neighboring country or similar country, respond with "No" and continue the game.
+10. Be very strict about the exact country match - only "{selected_country}" is the correct answer."""
 
-
-def extract_country_name(response):
-    """Extract country name from response using the <<COUNTRY_NAME>> format"""
-    match = re.search(r'<<(.+?)>>', response)
-    if match:
-        return match.group(1)
-    return None
+current_system = get_system_message_with_country()
 
 def format_game_result(response):
     """Format the game result with proper styling"""
-    country = extract_country_name(response)
-    if not country:
-        return response
-    
+    if "The country was" in response:
+        print(f"🔍 DEBUG - Game end detected! Country extracted: {selected_country}")
+    else:
+        print("🔍 DEBUG - Regular response (no game end)")
+
     if "Congratulations" in response:
-        return f"🎉 **Congratulations!** You correctly guessed **{country}**! Well done! 🎉\n\nWould you like to play another round?"
+        return f"🎉 **Congratulations!** You correctly guessed **{selected_country}**! Well done! 🎉\n\nWould you like to play another round?"
     elif "Game over" in response:
-        return f"😔 **Game Over!** You've used all 20 questions. The country I was thinking of was **{country}**. 😔\n\nBetter luck next time! Would you like to try again?"
+        return f"😔 **Game Over!** You've used all 20 questions. The country I was thinking of was **{selected_country}**. 😔\n\nBetter luck next time! Would you like to try again?"
+    global current_system  # Ensure we're using the global variable
+    current_system = get_system_message_with_country()
     
     return response
 
@@ -85,14 +88,31 @@ def respond(
     """
     For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
     """
-    # Generate a new system message with random country for new conversations
-    if not history:
-        system_message = get_system_message_with_country()
 
-    messages = [{"role": "system", "content": system_message}]
+
+    messages = [{"role": "system", "content": current_system}]
     messages.extend(history)
     messages.append({"role": "user", "content": message})
 
+    # Debug: Calculate approximate input token count
+    total_input_chars = sum(len(str(msg.get("content", ""))) for msg in messages)
+    estimated_input_tokens = total_input_chars // 4  # Rough approximation: 4 chars per token
+    print(f"🔍 DEBUG - Estimated input tokens: {estimated_input_tokens}")
+    print(f"🔍 DEBUG - Messages count: {len(messages)}")
+    print(f"🔍 DEBUG - Max tokens setting: {max_tokens}")
+    
+    # Debug: Show each message type and length
+    for i, msg in enumerate(messages):
+        role = msg.get("role", "unknown")
+        content = str(msg.get("content", ""))
+        print(f"🔍 DEBUG - Message {i+1} ({role}): {len(content)} chars")
+        if role == "system":
+            print(f"🔍 DEBUG - System message preview: {content[:100]}...")
+        elif role == "user":
+            print(f"🔍 DEBUG - User message: {content}")
+        elif role == "assistant":
+            print(f"🔍 DEBUG - Assistant message: {content[:50]}...")
+
     # Choose client based on whether we're running locally or in the cloud
     if LOCAL_MODE:
         # Running locally with custom model settings
@@ -109,6 +129,7 @@ def respond(
         client = InferenceClient(token=hf_token.token, model=MODEL_NAME)
 
     response = ""
+    output_token_count = 0
 
     try:
         for message_chunk in client.chat_completion(
@@ -123,13 +144,23 @@ def respond(
             token = ""
             if len(choices) and choices[0].delta.content:
                 token = choices[0].delta.content
+                output_token_count += 1
 
             response += token
 
+        # Debug: Show output token statistics
+        estimated_output_tokens = len(response) // 4  # Rough approximation
+        print(f"🔍 DEBUG - Output token chunks received: {output_token_count}")
+        print(f"🔍 DEBUG - Estimated output tokens (by chars): {estimated_output_tokens}")
+        print(f"🔍 DEBUG - Response length: {len(response)} characters")
+        print(f"🔍 DEBUG - Raw response: {response}")
+
         # Check if this is a game end response and format it nicely
-        if "<<" in response and ">>" in response:
+        if "The country was" in response:
+            print(f"🔍 DEBUG - Game end detected! Country extracted: {selected_country}")
             return format_game_result(response)
         else:
+            print("🔍 DEBUG - Regular response (no game end)")
             return response
     except Exception as e:
         return f"Error during inference: {str(e)}"
@@ -159,31 +190,22 @@ examples = [
     ["Is the currency the Euro?"],
 ]
 
-additional_inputs = [
-    gr.Textbox(visible=False, value="Geography game placeholder - will be replaced with random country", label="System message"),
-    gr.Slider(visible=False, minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-    gr.Slider(visible=False, minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-    gr.Slider(
-        visible=False,
-        minimum=0.1,
-        maximum=1.0,
-        value=0.95,
-        step=0.05,
-        label="Top-p (nucleus sampling)",
-    ),
-]
-
 # Create wrapper function for local mode that doesn't expect OAuth token
-def respond_local(message, history, system_message, max_tokens, temperature, top_p):
-    return respond(message, history, system_message, max_tokens, temperature, top_p, None)
+def custom_respond(message, history):
+    # Hardcoded values - no additional inputs needed
+    system_message = ""
+    max_tokens = 2048
+    temperature = 0.3  # Lower temperature for more consistent responses
+    top_p = 0.7  # Lower top_p for more deterministic behavior
+    return respond(message, history, system_message, max_tokens, temperature, top_p, None if LOCAL_MODE else hf_token)
 
 chatbot = gr.ChatInterface(
-    (respond_local if LOCAL_MODE else respond),
+    custom_respond,
     type="messages",
     description=description,
     examples=examples,
     cache_examples=False,
-    additional_inputs=additional_inputs,
+    # No additional_inputs - values are hardcoded in wrapper functions
 )
 
 with gr.Blocks() as demo: