Upload 2 files

core/hf_inference.py

@@ -328,24 +328,19 @@ class HFInferenceClient:
     
     def __init__(self):
         self.settings = get_settings()
-        self.token = self.settings.hf.hf_token
-        
+        # Read token fresh from env — the Settings singleton may have been
+        # created before the user entered their token via the Gradio UI.
+        self.token = os.getenv("HF_TOKEN", "") or self.settings.hf.hf_token
+
         if not self.token:
             raise ValueError("HF_TOKEN is required for inference")
-        
-        # New HuggingFace router URL (api-inference is deprecated)
-        # The huggingface_hub library should handle this automatically with newer versions,
-        # but we set it explicitly for compatibility
-        router_url = "https://router.huggingface.co"
-        
-        # Create clients with explicit base_url for new router
-        try:
-            self.sync_client = InferenceClient(token=self.token, base_url=router_url)
-            self.async_client = AsyncInferenceClient(token=self.token, base_url=router_url)
-        except TypeError:
-            # Fallback for older huggingface_hub versions that don't support base_url
-            self.sync_client = InferenceClient(token=self.token)
-            self.async_client = AsyncInferenceClient(token=self.token)
+
+        # Do NOT set base_url — the huggingface_hub library routes requests
+        # to the correct endpoint automatically based on the model parameter.
+        # Setting base_url overrides per-model routing and causes API errors
+        # when different models are used across agents.
+        self.sync_client = InferenceClient(token=self.token)
+        self.async_client = AsyncInferenceClient(token=self.token)
     
     def get_model_for_agent(self, agent_name: str) -> str:
         """Get the appropriate model for an agent."""
@@ -424,19 +419,24 @@ class HFInferenceClient:
                 temperature=temperature,
             )
             return response.choices[0].message.content
-            
+
         except Exception as e:
-            # Try fallback model
+            error_msg = str(e)
+            print(f"[HF] Primary model {model} failed: {error_msg[:120]}")
             fallback = self.settings.models.fallback_model
-            if fallback != model:
-                print(f"Primary model {model} failed, trying fallback: {fallback}")
-                response = self.sync_client.chat_completion(
-                    model=fallback,
-                    messages=messages,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                )
-                return response.choices[0].message.content
+            if fallback and fallback != model:
+                print(f"[HF] Trying fallback: {fallback}")
+                try:
+                    response = self.sync_client.chat_completion(
+                        model=fallback,
+                        messages=messages,
+                        max_tokens=max_tokens,
+                        temperature=temperature,
+                    )
+                    return response.choices[0].message.content
+                except Exception as fallback_err:
+                    print(f"[HF] Fallback {fallback} also failed: {str(fallback_err)[:120]}")
+                    raise fallback_err
             raise e
     
     async def complete_async(
@@ -471,18 +471,24 @@ class HFInferenceClient:
                 temperature=temperature,
             )
             return response.choices[0].message.content
-            
+
         except Exception as e:
+            error_msg = str(e)
+            print(f"[HF] Primary model {model} failed: {error_msg[:120]}")
             fallback = self.settings.models.fallback_model
-            if fallback != model:
-                print(f"Primary model {model} failed, trying fallback: {fallback}")
-                response = await self.async_client.chat_completion(
-                    model=fallback,
-                    messages=messages,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                )
-                return response.choices[0].message.content
+            if fallback and fallback != model:
+                print(f"[HF] Trying fallback: {fallback}")
+                try:
+                    response = await self.async_client.chat_completion(
+                        model=fallback,
+                        messages=messages,
+                        max_tokens=max_tokens,
+                        temperature=temperature,
+                    )
+                    return response.choices[0].message.content
+                except Exception as fallback_err:
+                    print(f"[HF] Fallback {fallback} also failed: {str(fallback_err)[:120]}")
+                    raise fallback_err
             raise e
     
     async def stream_async(
@@ -523,9 +529,14 @@ _client: Optional[HFInferenceClient] = None
 
 
 def get_inference_client() -> HFInferenceClient:
-    """Get or create the inference client singleton."""
+    """Get or create the inference client singleton.
+
+    Re-creates the client if the token has changed (e.g. user entered it
+    via the Gradio UI after initial startup).
+    """
     global _client
-    if _client is None:
+    current_token = os.getenv("HF_TOKEN", "")
+    if _client is None or (_client.token != current_token and current_token):
         _client = HFInferenceClient()
     return _client
 

core/rule_engine.py

@@ -280,37 +280,58 @@ def find_aa_compliant_color(hex_color: str, background: str = "#ffffff", target_
     a darkened/lightened version that passes.
     """
     current_contrast = get_contrast_ratio(hex_color, background)
-    
+
     if current_contrast >= target_contrast:
         return hex_color
-    
-    # Determine if we need to darken or lighten
+
+    # Determine direction: move fg *away* from bg in luminance.
+    # If fg is lighter than bg → darken fg to increase gap.
+    # If fg is darker than bg → lighten fg to increase gap.
     bg_luminance = get_relative_luminance(background)
     color_luminance = get_relative_luminance(hex_color)
-    
-    # If background is light, darken the color; if dark, lighten it
-    should_darken = bg_luminance > 0.5
-    
+
+    should_darken = color_luminance >= bg_luminance
+
     best_color = hex_color
     best_contrast = current_contrast
-    
+
     for i in range(1, 101):
         factor = i / 100
-        
+
         if should_darken:
             new_color = darken_color(hex_color, factor)
         else:
             new_color = lighten_color(hex_color, factor)
-        
+
         new_contrast = get_contrast_ratio(new_color, background)
-        
+
         if new_contrast >= target_contrast:
             return new_color
-        
+
         if new_contrast > best_contrast:
             best_contrast = new_contrast
             best_color = new_color
-    
+
+    # If first direction didn't reach target, try the opposite direction
+    # (e.g., very similar luminances where either direction could work)
+    should_darken = not should_darken
+    for i in range(1, 101):
+        factor = i / 100
+
+        if should_darken:
+            new_color = darken_color(hex_color, factor)
+        else:
+            new_color = lighten_color(hex_color, factor)
+
+        new_contrast = get_contrast_ratio(new_color, background)
+
+        if new_contrast >= target_contrast:
+            return new_color
+
+        if new_contrast > best_contrast:
+            best_contrast = new_contrast
+            best_color = new_color
+
     return best_color
 
 
@@ -536,20 +557,26 @@ def analyze_accessibility(color_tokens: dict, fg_bg_pairs: list[dict] = None) ->
     # --- Real foreground-background pair checks ---
     if fg_bg_pairs:
         for pair in fg_bg_pairs:
-            fg = pair.get("foreground", "")
-            bg = pair.get("background", "")
+            fg = pair.get("foreground", "").lower()
+            bg = pair.get("background", "").lower()
             element = pair.get("element", "")
             if not (fg.startswith("#") and bg.startswith("#")):
                 continue
+            # Skip same-color pairs (invisible/placeholder text — not real failures)
+            if fg == bg:
+                continue
             try:
                 ratio = get_contrast_ratio(fg, bg)
+                # Skip near-identical pairs (ratio < 1.1) — likely decorative/hidden
+                if ratio < 1.1:
+                    continue
                 if ratio < 4.5:
                     # This pair fails AA — record it
                     fix = find_aa_compliant_color(fg, bg, 4.5)
                     fix_contrast = get_contrast_ratio(fix, bg)
                     results.append(ColorAccessibility(
                         hex_color=fg,
-                        name=f"fg:{fg} on bg:{bg} ({element})",
+                        name=f"fg:{fg} on bg:{bg} ({element}) [{ratio:.1f}:1]",
                         contrast_on_white=get_contrast_ratio(fg, "#ffffff"),
                         contrast_on_black=get_contrast_ratio(fg, "#000000"),
                         passes_aa_normal=False,