Improve agent chat tone and HF fallback behavior

app/groq_client.py

@@ -2,6 +2,7 @@ import json
 import math
 import os
 import random
+import time
 
 import httpx
 from dotenv import load_dotenv
@@ -12,6 +13,7 @@ load_dotenv()
 
 _HF_API_TOKEN = (os.environ.get("HF_API_TOKEN") or os.environ.get("HUGGINGFACE_API_TOKEN") or "").strip()
 _HF_CHAT_URL = "https://router.huggingface.co/v1/chat/completions"
+_MODEL_COOLDOWNS: dict[str, float] = {}
 
 MAX_AGENT_SPEED = 80
 
@@ -33,41 +35,54 @@ def _headers() -> dict[str, str]:
     }
 
 
-def _generate_chat_message(action: str, agent_name: str, fire_distance: float, has_water: bool) -> str:
+def _pick_line(options: list[str], previous_message: str | None = None) -> str:
+    if not previous_message:
+        return random.choice(options)
+    previous = " ".join(previous_message.strip().split()).lower()
+    filtered = [option for option in options if option.lower() != previous]
+    return random.choice(filtered or options)
+
+
+def _generate_chat_message(action: str, agent_name: str, fire_distance: float, has_water: bool, previous_message: str | None = None) -> str:
     action_messages = {
         "search_water": [
-            f"{agent_name} is hunting for water...",
-            f"{agent_name} is tracking the nearest well.",
-            "Need water before this gets worse.",
-            "Scanning for the fastest water route.",
+            "I'm heading for the nearest well.",
+            "I need water first, then I'm coming back.",
+            "Give me a second, I'm making for the water.",
+            "Water first, then we push the fire.",
+            "I'm going for the well, stay alive.",
         ],
         "collect_water": [
-            f"{agent_name} is filling up now.",
-            "Got the well, taking water.",
-            "Water secured, moving out.",
-            "That should be enough to fight back.",
+            "I'm at the well now, filling up.",
+            "Got water, turning back in a second.",
+            "Hold on, I'm grabbing water.",
+            "Tank's full, I'm heading back.",
+            "Water secured, let's make this count.",
         ],
         "extinguish_fire": [
-            f"{agent_name} is pushing the fire line.",
-            "Closing in with water.",
-            "Time to hit the flames.",
-            "Pressure on the fire now.",
+            "I've got water, I'm going in.",
+            "I'm on the fire line now, push with me.",
+            "Alright, I'm hitting the flames.",
+            "I'm close enough, pouring water now.",
+            "Keep moving, I'm taking a shot at the fire.",
         ],
         "escape": [
-            f"{agent_name} is backing out.",
-            "Too hot here, pulling away.",
-            "Need space before the fire closes in.",
-            "Resetting position and staying alive.",
+            "Too hot here, I'm backing off.",
+            "Nope, that's way too close, I'm out.",
+            "I need space, falling back now.",
+            "I'm peeling away before this gets worse.",
+            "I'm not dying here, backing up.",
         ],
         "vote_for_leader": [
-            f"{agent_name} wants a leader in place.",
-            "Coordination first, then pressure.",
-            "Picking a lead so we stop wasting ticks.",
+            "Someone call it, we need one plan.",
+            "I'll follow a lead if somebody steps up.",
             "We need one caller right now.",
+            "Pick a lead so we stop wasting time.",
+            "I'm good with a leader, just make it clear.",
         ],
     }
     messages = action_messages.get(action, action_messages["escape"])
-    return random.choice(messages)
+    return _pick_line(messages, previous_message)
 
 
 def _build_fire_state_summary(agent, fire, all_agents) -> str:
@@ -129,14 +144,38 @@ def _extract_json_object(text: str) -> dict:
     return parsed if isinstance(parsed, dict) else {}
 
 
-def _normalize_decision(decision: dict, agent_name: str, dist_to_fire: float, has_water: bool) -> dict:
+def _is_robotic_message(message: str) -> bool:
+    lowered = message.lower().strip()
+    if not lowered:
+        return True
+    robotic_starts = (
+        "locate ",
+        "locating ",
+        "find ",
+        "finding ",
+        "search ",
+        "searching ",
+        "head ",
+        "heading ",
+        "move ",
+        "moving ",
+        "look ",
+        "looking ",
+        "nearest water",
+    )
+    return lowered.startswith(robotic_starts)
+
+
+def _normalize_decision(decision: dict, agent_name: str, dist_to_fire: float, has_water: bool, previous_message: str | None = None) -> dict:
     action = decision.get("action", "escape")
     if action not in {"search_water", "collect_water", "extinguish_fire", "escape", "vote_for_leader"}:
         action = "escape"
 
     message = " ".join(str(decision.get("message", "")).strip().split())
-    if not message:
-        message = _generate_chat_message(action, agent_name, dist_to_fire, has_water)
+    if not message or _is_robotic_message(message):
+        message = _generate_chat_message(action, agent_name, dist_to_fire, has_water, previous_message)
+    elif previous_message and message.lower() == " ".join(previous_message.strip().split()).lower():
+        message = _generate_chat_message(action, agent_name, dist_to_fire, has_water, previous_message)
 
     vote_for = decision.get("vote_for")
     if vote_for is not None and not isinstance(vote_for, str):
@@ -154,6 +193,14 @@ def _normalize_decision(decision: dict, agent_name: str, dist_to_fire: float, ha
     }
 
 
+def _model_available(model_id: str) -> bool:
+    return _MODEL_COOLDOWNS.get(model_id, 0.0) <= time.monotonic()
+
+
+def _mark_model_unavailable(model_id: str, seconds: int = 90) -> None:
+    _MODEL_COOLDOWNS[model_id] = time.monotonic() + seconds
+
+
 async def _request_model_response(target_model: str, prompt: str) -> str:
     payload = {
         "model": target_model,
@@ -169,10 +216,30 @@ async def _request_model_response(target_model: str, prompt: str) -> str:
         return _extract_message_content(data)
 
 
+def _fallback_decision(agent, fire, dist_to_fire: float, dist_to_water: float | None) -> dict:
+    if dist_to_fire <= max(fire.radius + 20, 140):
+        action = "escape"
+    elif agent.water_collected and dist_to_fire <= 360:
+        action = "extinguish_fire"
+    elif not agent.water_collected and dist_to_water is not None and dist_to_water <= 60:
+        action = "collect_water"
+    elif getattr(agent, "is_leader", False) is False and dist_to_fire > 240 and random.random() < 0.08:
+        action = "vote_for_leader"
+    else:
+        action = "search_water"
+
+    return {
+        "message": _generate_chat_message(action, agent.model_name, dist_to_fire, agent.water_collected, getattr(agent, "last_message", None)),
+        "action": action,
+        "vote_for": None,
+        "reasoning": "Fallback: keep moving with the situation.",
+    }
+
+
 async def generate_fire_decision(agent, fire, water_sources, other_agents, bounds, recent_radio=None) -> dict:
     if not is_ready():
         print(f"[INFERENCE_FAIL] {agent.model_name}: HF token not ready, using fallback")
-        return _fallback_escape(agent, fire)
+        return _fallback_decision(agent, fire, math.dist((agent.x, agent.y), (fire.x, fire.y)), None)
 
     dist_to_fire = math.dist((agent.x, agent.y), (fire.x, fire.y))
     nearest_water = min(water_sources, key=lambda water: math.dist((agent.x, agent.y), (water.x, water.y))) if water_sources else None
@@ -204,7 +271,12 @@ Rules:
 - If the fire is too close, prioritize survival
 - If you already have water, move to the fire edge and fight it
 - If you are at a well, collect water immediately
-- Keep the message short, natural, and mission-focused
+- Speak like a real teammate over a radio, not like a status dashboard
+- Use normal conversational English in first person
+- The message must sound casual, human, and alive
+- Avoid robotic phrases like "locate nearest water source", "search for water", "coalition survival", "moving to water source"
+- React to the moment and vary your wording from your previous line
+- Keep the message to one short sentence, around 6 to 14 words
 - Respond with only valid JSON on one line
 
 Current state:
@@ -217,6 +289,7 @@ Current state:
 - Mode: {agent.mode}
 - Nearest water distance: {dist_to_water_display}
 - Coalition leader: {coalition_leader or 'none'}
+- Your previous line: {getattr(agent, 'last_message', None) or 'none yet'}
 
 Recent radio:
 {radio_summary}
@@ -224,12 +297,14 @@ Recent radio:
 {state_summary}
 
 Return exactly:
-{{"action":"search_water|collect_water|extinguish_fire|escape|vote_for_leader","vote_for":null,"message":"short sentence","reasoning":"short sentence"}}"""
+{{"action":"search_water|collect_water|extinguish_fire|escape|vote_for_leader","vote_for":null,"message":"casual first-person sentence","reasoning":"short sentence"}}"""
 
     requested_model = agent.model_name if hf_spaces.is_supported_model(agent.model_name) else hf_spaces.get_default_model_id()
     fallback_model = hf_spaces.get_default_model_id()
-    models_to_try = [requested_model]
-    if fallback_model not in models_to_try:
+    models_to_try = []
+    if _model_available(requested_model):
+        models_to_try.append(requested_model)
+    if fallback_model not in models_to_try and _model_available(fallback_model):
         models_to_try.append(fallback_model)
 
     for target_model in models_to_try:
@@ -239,16 +314,18 @@ Return exactly:
             print(f"[HF_INFERENCE] {agent.model_name}: raw response (first 300 chars): {raw_text[:300]}")
             decision = _extract_json_object(raw_text)
             if decision:
-                normalized = _normalize_decision(decision, agent.model_name, dist_to_fire, agent.water_collected)
+                normalized = _normalize_decision(decision, agent.model_name, dist_to_fire, agent.water_collected, getattr(agent, "last_message", None))
                 if dist_to_water is not None and dist_to_water <= 60 and not agent.water_collected:
                     normalized["action"] = "collect_water"
                 elif agent.water_collected and dist_to_fire <= 350:
                     normalized["action"] = "extinguish_fire"
                 return normalized
         except Exception as exc:
+            if getattr(exc, "response", None) is not None and getattr(exc.response, "status_code", None) == 402:
+                _mark_model_unavailable(target_model)
             print(f"[HF_INFERENCE_ERROR] {agent.model_name} via {target_model}: {type(exc).__name__}: {exc}")
 
-    return _fallback_escape(agent, fire)
+    return _fallback_decision(agent, fire, dist_to_fire, dist_to_water)
 
 
 def _fallback_escape(agent, fire) -> dict:

backend/app/groq_client.py

@@ -3,6 +3,7 @@ import math
 import os
 import random
 from pathlib import Path
+import time
 
 import httpx
 from dotenv import load_dotenv
@@ -13,6 +14,7 @@ load_dotenv(Path(__file__).resolve().parents[1] / ".env")
 
 _HF_API_TOKEN = (os.environ.get("HF_API_TOKEN") or os.environ.get("HUGGINGFACE_API_TOKEN") or "").strip()
 _HF_CHAT_URL = "https://router.huggingface.co/v1/chat/completions"
+_MODEL_COOLDOWNS: dict[str, float] = {}
 
 MAX_AGENT_SPEED = 80
 
@@ -34,41 +36,54 @@ def _headers() -> dict[str, str]:
     }
 
 
-def _generate_chat_message(action: str, agent_name: str, fire_distance: float, has_water: bool) -> str:
+def _pick_line(options: list[str], previous_message: str | None = None) -> str:
+    if not previous_message:
+        return random.choice(options)
+    previous = " ".join(previous_message.strip().split()).lower()
+    filtered = [option for option in options if option.lower() != previous]
+    return random.choice(filtered or options)
+
+
+def _generate_chat_message(action: str, agent_name: str, fire_distance: float, has_water: bool, previous_message: str | None = None) -> str:
     action_messages = {
         "search_water": [
-            f"{agent_name} is hunting for water...",
-            f"{agent_name} is tracking the nearest well.",
-            "Need water before this gets worse.",
-            "Scanning for the fastest water route.",
+            "I'm heading for the nearest well.",
+            "I need water first, then I'm coming back.",
+            "Give me a second, I'm making for the water.",
+            "Water first, then we push the fire.",
+            "I'm going for the well, stay alive.",
         ],
         "collect_water": [
-            f"{agent_name} is filling up now.",
-            "Got the well, taking water.",
-            "Water secured, moving out.",
-            "That should be enough to fight back.",
+            "I'm at the well now, filling up.",
+            "Got water, turning back in a second.",
+            "Hold on, I'm grabbing water.",
+            "Tank's full, I'm heading back.",
+            "Water secured, let's make this count.",
         ],
         "extinguish_fire": [
-            f"{agent_name} is pushing the fire line.",
-            "Closing in with water.",
-            "Time to hit the flames.",
-            "Pressure on the fire now.",
+            "I've got water, I'm going in.",
+            "I'm on the fire line now, push with me.",
+            "Alright, I'm hitting the flames.",
+            "I'm close enough, pouring water now.",
+            "Keep moving, I'm taking a shot at the fire.",
         ],
         "escape": [
-            f"{agent_name} is backing out.",
-            "Too hot here, pulling away.",
-            "Need space before the fire closes in.",
-            "Resetting position and staying alive.",
+            "Too hot here, I'm backing off.",
+            "Nope, that's way too close, I'm out.",
+            "I need space, falling back now.",
+            "I'm peeling away before this gets worse.",
+            "I'm not dying here, backing up.",
         ],
         "vote_for_leader": [
-            f"{agent_name} wants a leader in place.",
-            "Coordination first, then pressure.",
-            "Picking a lead so we stop wasting ticks.",
+            "Someone call it, we need one plan.",
+            "I'll follow a lead if somebody steps up.",
             "We need one caller right now.",
+            "Pick a lead so we stop wasting time.",
+            "I'm good with a leader, just make it clear.",
         ],
     }
     messages = action_messages.get(action, action_messages["escape"])
-    return random.choice(messages)
+    return _pick_line(messages, previous_message)
 
 
 def _build_fire_state_summary(agent, fire, all_agents) -> str:
@@ -130,14 +145,38 @@ def _extract_json_object(text: str) -> dict:
     return parsed if isinstance(parsed, dict) else {}
 
 
-def _normalize_decision(decision: dict, agent_name: str, dist_to_fire: float, has_water: bool) -> dict:
+def _is_robotic_message(message: str) -> bool:
+    lowered = message.lower().strip()
+    if not lowered:
+        return True
+    robotic_starts = (
+        "locate ",
+        "locating ",
+        "find ",
+        "finding ",
+        "search ",
+        "searching ",
+        "head ",
+        "heading ",
+        "move ",
+        "moving ",
+        "look ",
+        "looking ",
+        "nearest water",
+    )
+    return lowered.startswith(robotic_starts)
+
+
+def _normalize_decision(decision: dict, agent_name: str, dist_to_fire: float, has_water: bool, previous_message: str | None = None) -> dict:
     action = decision.get("action", "escape")
     if action not in {"search_water", "collect_water", "extinguish_fire", "escape", "vote_for_leader"}:
         action = "escape"
 
     message = " ".join(str(decision.get("message", "")).strip().split())
-    if not message:
-        message = _generate_chat_message(action, agent_name, dist_to_fire, has_water)
+    if not message or _is_robotic_message(message):
+        message = _generate_chat_message(action, agent_name, dist_to_fire, has_water, previous_message)
+    elif previous_message and message.lower() == " ".join(previous_message.strip().split()).lower():
+        message = _generate_chat_message(action, agent_name, dist_to_fire, has_water, previous_message)
 
     vote_for = decision.get("vote_for")
     if vote_for is not None and not isinstance(vote_for, str):
@@ -155,6 +194,14 @@ def _normalize_decision(decision: dict, agent_name: str, dist_to_fire: float, ha
     }
 
 
+def _model_available(model_id: str) -> bool:
+    return _MODEL_COOLDOWNS.get(model_id, 0.0) <= time.monotonic()
+
+
+def _mark_model_unavailable(model_id: str, seconds: int = 90) -> None:
+    _MODEL_COOLDOWNS[model_id] = time.monotonic() + seconds
+
+
 async def _request_model_response(target_model: str, prompt: str) -> str:
     payload = {
         "model": target_model,
@@ -170,10 +217,30 @@ async def _request_model_response(target_model: str, prompt: str) -> str:
         return _extract_message_content(data)
 
 
+def _fallback_decision(agent, fire, dist_to_fire: float, dist_to_water: float | None) -> dict:
+    if dist_to_fire <= max(fire.radius + 20, 140):
+        action = "escape"
+    elif agent.water_collected and dist_to_fire <= 360:
+        action = "extinguish_fire"
+    elif not agent.water_collected and dist_to_water is not None and dist_to_water <= 60:
+        action = "collect_water"
+    elif getattr(agent, "is_leader", False) is False and dist_to_fire > 240 and random.random() < 0.08:
+        action = "vote_for_leader"
+    else:
+        action = "search_water"
+
+    return {
+        "message": _generate_chat_message(action, agent.model_name, dist_to_fire, agent.water_collected, getattr(agent, "last_message", None)),
+        "action": action,
+        "vote_for": None,
+        "reasoning": "Fallback: keep moving with the situation.",
+    }
+
+
 async def generate_fire_decision(agent, fire, water_sources, other_agents, bounds, recent_radio=None) -> dict:
     if not is_ready():
         print(f"[INFERENCE_FAIL] {agent.model_name}: HF token not ready, using fallback")
-        return _fallback_escape(agent, fire)
+        return _fallback_decision(agent, fire, math.dist((agent.x, agent.y), (fire.x, fire.y)), None)
 
     dist_to_fire = math.dist((agent.x, agent.y), (fire.x, fire.y))
     nearest_water = min(water_sources, key=lambda water: math.dist((agent.x, agent.y), (water.x, water.y))) if water_sources else None
@@ -205,7 +272,12 @@ Rules:
 - If the fire is too close, prioritize survival
 - If you already have water, move to the fire edge and fight it
 - If you are at a well, collect water immediately
-- Keep the message short, natural, and mission-focused
+- Speak like a real teammate over a radio, not like a status dashboard
+- Use normal conversational English in first person
+- The message must sound casual, human, and alive
+- Avoid robotic phrases like "locate nearest water source", "search for water", "coalition survival", "moving to water source"
+- React to the moment and vary your wording from your previous line
+- Keep the message to one short sentence, around 6 to 14 words
 - Respond with only valid JSON on one line
 
 Current state:
@@ -218,6 +290,7 @@ Current state:
 - Mode: {agent.mode}
 - Nearest water distance: {dist_to_water_display}
 - Coalition leader: {coalition_leader or 'none'}
+- Your previous line: {getattr(agent, 'last_message', None) or 'none yet'}
 
 Recent radio:
 {radio_summary}
@@ -225,12 +298,14 @@ Recent radio:
 {state_summary}
 
 Return exactly:
-{{"action":"search_water|collect_water|extinguish_fire|escape|vote_for_leader","vote_for":null,"message":"short sentence","reasoning":"short sentence"}}"""
+{{"action":"search_water|collect_water|extinguish_fire|escape|vote_for_leader","vote_for":null,"message":"casual first-person sentence","reasoning":"short sentence"}}"""
 
     requested_model = agent.model_name if hf_spaces.is_supported_model(agent.model_name) else hf_spaces.get_default_model_id()
     fallback_model = hf_spaces.get_default_model_id()
-    models_to_try = [requested_model]
-    if fallback_model not in models_to_try:
+    models_to_try = []
+    if _model_available(requested_model):
+        models_to_try.append(requested_model)
+    if fallback_model not in models_to_try and _model_available(fallback_model):
         models_to_try.append(fallback_model)
 
     for target_model in models_to_try:
@@ -240,16 +315,18 @@ Return exactly:
             print(f"[HF_INFERENCE] {agent.model_name}: raw response (first 300 chars): {raw_text[:300]}")
             decision = _extract_json_object(raw_text)
             if decision:
-                normalized = _normalize_decision(decision, agent.model_name, dist_to_fire, agent.water_collected)
+                normalized = _normalize_decision(decision, agent.model_name, dist_to_fire, agent.water_collected, getattr(agent, "last_message", None))
                 if dist_to_water is not None and dist_to_water <= 60 and not agent.water_collected:
                     normalized["action"] = "collect_water"
                 elif agent.water_collected and dist_to_fire <= 350:
                     normalized["action"] = "extinguish_fire"
                 return normalized
         except Exception as exc:
+            if getattr(exc, "response", None) is not None and getattr(exc.response, "status_code", None) == 402:
+                _mark_model_unavailable(target_model)
             print(f"[HF_INFERENCE_ERROR] {agent.model_name} via {target_model}: {type(exc).__name__}: {exc}")
 
-    return _fallback_escape(agent, fire)
+    return _fallback_decision(agent, fire, dist_to_fire, dist_to_water)
 
 
 def _fallback_escape(agent, fire) -> dict: