solves review comments

Author: Josephrp

radioshaq/radioshaq/llm/client.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+import os
 from typing import Any
 
 from loguru import logger
@@ -44,6 +45,23 @@ class ChatResponseWithTools(ChatResponse):
 class LLMClient:
     """LLM client using LiteLLM (supports Mistral, OpenAI, Anthropic, etc.)."""
 
+    _PROVIDER_ENV_KEYS: dict[str, tuple[str, ...]] = {
+        "mistral": ("MISTRAL_API_KEY",),
+        "openai": ("OPENAI_API_KEY",),
+        "anthropic": ("ANTHROPIC_API_KEY",),
+        "huggingface": ("HF_TOKEN", "HUGGINGFACE_API_KEY"),
+        "gemini": ("GEMINI_API_KEY",),
+    }
+
+    _FALLBACK_ENV_CHAIN: tuple[str, ...] = (
+        "MISTRAL_API_KEY",
+        "OPENAI_API_KEY",
+        "ANTHROPIC_API_KEY",
+        "HF_TOKEN",
+        "HUGGINGFACE_API_KEY",
+        "GEMINI_API_KEY",
+    )
+
     def __init__(
         self,
         model: str = "mistral/mistral-large-latest",
@@ -62,30 +80,45 @@ def __init__(
         self.temperature = temperature
         self.max_tokens = max_tokens
 
+    def _provider_from_model(self) -> str:
+        if "/" not in self.model:
+            return ""
+        return self.model.split("/", 1)[0].lower().strip()
+
+    def _resolve_api_key(self) -> str | None:
+        """Resolve API key by explicit value, then provider-matched env vars, then generic fallback."""
+        if self.api_key:
+            return self.api_key
+
+        provider = self._provider_from_model()
+        if self.api_base and "huggingface.co" in self.api_base:
+            provider = "huggingface"
+
+        provider_keys = self._PROVIDER_ENV_KEYS.get(provider, ())
+        for env_name in provider_keys:
+            value = os.environ.get(env_name)
+            if value:
+                return value
+
+        for env_name in self._FALLBACK_ENV_CHAIN:
+            value = os.environ.get(env_name)
+            if value:
+                return value
+
+        return None
+
     async def chat(
         self,
         messages: list[dict[str, str]],
         temperature: float | None = None,
         max_tokens: int | None = None,
     ) -> ChatResponse:
         """Send chat messages and return response."""
-        import os
-
         import litellm
 
         temp = temperature if temperature is not None else self.temperature
         max_tok = max_tokens if max_tokens is not None else self.max_tokens
-        # Fallback order: explicit then Mistral/OpenAI/Anthropic/HF/Gemini. Consider
-        # making this model-aware (e.g. prefer OPENAI_API_KEY when model starts with openai/).
-        api_key = (
-            self.api_key
-            or os.environ.get("MISTRAL_API_KEY")
-            or os.environ.get("OPENAI_API_KEY")
-            or os.environ.get("ANTHROPIC_API_KEY")
-            or os.environ.get("HF_TOKEN")
-            or os.environ.get("HUGGINGFACE_API_KEY")
-            or os.environ.get("GEMINI_API_KEY")
-        )
+        api_key = self._resolve_api_key()
 
         kwargs: dict[str, Any] = {
             "model": self.model,
@@ -125,22 +158,11 @@ async def chat_with_tools(
         Send messages with tool definitions; return content and tool_calls.
         Does not loop; caller must execute tools, append results, and call again until no tool_calls.
         """
-        import os
-
         import litellm
 
         temp = temperature if temperature is not None else self.temperature
         max_tok = max_tokens if max_tokens is not None else self.max_tokens
-        # Same fallback order as chat() (see comment there).
-        api_key = (
-            self.api_key
-            or os.environ.get("MISTRAL_API_KEY")
-            or os.environ.get("OPENAI_API_KEY")
-            or os.environ.get("ANTHROPIC_API_KEY")
-            or os.environ.get("HF_TOKEN")
-            or os.environ.get("HUGGINGFACE_API_KEY")
-            or os.environ.get("GEMINI_API_KEY")
-        )
+        api_key = self._resolve_api_key()
 
         kwargs_tools: dict[str, Any] = {
             "model": self.model,

radioshaq/web-interface/src/components/maps/OperatorMap.tsx

@@ -51,6 +51,8 @@ function OperatorMapGoogle({
   const mapRef = useRef<google.maps.Map | null>(null);
   const markersRef = useRef<google.maps.Marker[]>([]);
   const infoWindowRef = useRef<google.maps.InfoWindow | null>(null);
+  const centerRef = useRef(center);
+  const zoomRef = useRef(zoom);
   const [mapError, setMapError] = useState<string | null>(null);
   const [mapReady, setMapReady] = useState(false);
 
@@ -62,6 +64,11 @@ function OperatorMapGoogle({
     }
   }, []);
 
+  useEffect(() => {
+    centerRef.current = center;
+    zoomRef.current = zoom;
+  }, [center, zoom]);
+
   useEffect(() => {
     if (!containerRef.current) return;
     setMapError(null);
@@ -71,9 +78,11 @@ function OperatorMapGoogle({
       .then((google) => {
         if (cancelled || !containerRef.current) return;
         try {
+          const latestCenter = centerRef.current;
+          const latestZoom = zoomRef.current;
           const map = new google.maps.Map(containerRef.current, {
-            center: { lat: center.lat, lng: center.lng },
-            zoom,
+            center: { lat: latestCenter.lat, lng: latestCenter.lng },
+            zoom: latestZoom,
             mapTypeControl: true,
             fullscreenControl: true,
             streetViewControl: true,
@@ -105,10 +114,10 @@ function OperatorMapGoogle({
 
   useEffect(() => {
     const map = mapRef.current;
-    if (!map) return;
+    if (!map || !mapReady) return;
     map.setCenter({ lat: center.lat, lng: center.lng });
     map.setZoom(zoom);
-  }, [center.lat, center.lng, zoom]);
+  }, [center.lat, center.lng, zoom, mapReady]);
 
   useEffect(() => {
     const map = mapRef.current;

radioshaq/web-interface/src/maps/googleMapsLoader.ts

@@ -18,7 +18,13 @@ export function loadGoogleMaps(): Promise<typeof google> {
     return Promise.reject(new Error('VITE_GOOGLE_MAPS_API_KEY is not set. Set it in .env or .env.local for map features.'));
   }
   setOptions({ key: API_KEY, v: 'weekly' });
-  loadPromise = importLibrary('maps').then(() => (globalThis as unknown as { google: typeof google }).google);
+  loadPromise = importLibrary('maps')
+    .then(() => (globalThis as unknown as { google: typeof google }).google)
+    .catch((err) => {
+      // Allow retry after transient failures instead of caching a rejected promise forever.
+      loadPromise = null;
+      throw err;
+    });
   return loadPromise;
 }