Update app.py

app.py

@@ -140,8 +140,8 @@ class AppModelStatus:
 class OptionalHFInferenceClient:
     """Small adapter around huggingface_hub.InferenceClient.
 
-    This adapter is optional. If a model id is not configured, the app still
-    works through WorldSmithAI's deterministic fallback generator.
+    This adapter tries both chat-completion and text-generation APIs and raises
+    detailed errors instead of hiding provider/model failures.
     """
 
     def __init__(self, model_id: str, token: str | None = None) -> None:
@@ -149,8 +149,8 @@ class OptionalHFInferenceClient:
 
         from huggingface_hub import InferenceClient
 
-        self.model_id = model_id
-        self.client = InferenceClient(model=model_id, token=token)
+        self.model_id = model_id.strip().strip('"').strip("'").strip()
+        self.client = InferenceClient(model=self.model_id, token=token)
 
     def generate(
         self,
@@ -160,27 +160,45 @@ class OptionalHFInferenceClient:
         temperature: float = 0.2,
         **_: Any,
     ) -> str:
-        """Generate text using common InferenceClient methods."""
+        """Generate text using Hugging Face chat or text-generation APIs."""
+
+        errors: list[str] = []
 
         if messages:
-            chat_text = self._try_chat_completion(
+            text = self._try_chat_completion(
+                messages,
+                max_new_tokens=max_new_tokens,
+                temperature=temperature,
+                errors=errors,
+            )
+            if text:
+                return text
+
+            text = self._try_openai_compatible_chat(
                 messages,
                 max_new_tokens=max_new_tokens,
                 temperature=temperature,
+                errors=errors,
             )
-            if chat_text:
-                return chat_text
+            if text:
+                return text
 
         if prompt:
-            text_generation = self._try_text_generation(
+            text = self._try_text_generation(
                 prompt,
                 max_new_tokens=max_new_tokens,
                 temperature=temperature,
+                errors=errors,
             )
-            if text_generation:
-                return text_generation
-
-        raise RuntimeError("InferenceClient did not return generated text")
+            if text:
+                return text
+
+        error_text = "\n".join(errors) if errors else "No inference method was attempted."
+        raise RuntimeError(
+            "InferenceClient did not return generated text.\n\n"
+            f"Model id: {self.model_id}\n\n"
+            f"Attempted methods and errors:\n{error_text}"
+        )
 
     def _try_chat_completion(
         self,
@@ -188,34 +206,85 @@ class OptionalHFInferenceClient:
         *,
         max_new_tokens: int,
         temperature: float,
+        errors: list[str],
     ) -> str | None:
-        """Try chat-style generation methods."""
+        """Try InferenceClient.chat_completion()."""
 
-        try:
-            chat_completion = getattr(self.client, "chat_completion", None)
-            if callable(chat_completion):
-                response = chat_completion(
-                    messages=messages,
-                    max_tokens=max_new_tokens,
-                    temperature=temperature,
-                )
-                return _extract_model_text(response)
-        except Exception:
-            logger.debug("InferenceClient.chat_completion failed", exc_info=True)
+        chat_completion = getattr(self.client, "chat_completion", None)
+        if not callable(chat_completion):
+            errors.append("chat_completion: method not available on InferenceClient")
+            return None
 
         try:
-            chat = getattr(self.client, "chat", None)
-            completions = getattr(chat, "completions", None)
-            create = getattr(completions, "create", None)
-            if callable(create):
-                response = create(
-                    messages=messages,
-                    max_tokens=max_new_tokens,
-                    temperature=temperature,
+            response = chat_completion(
+                messages=messages,
+                max_tokens=max_new_tokens,
+                temperature=temperature,
+            )
+            text = _extract_model_text(response)
+            if text:
+                return text
+
+            errors.append(
+                "chat_completion: response had no extractable text. "
+                f"response_type={response.__class__.__name__}, response={_short_repr(response)}"
+            )
+            return None
+        except Exception as exc:
+            errors.append(f"chat_completion: {exc.__class__.__name__}: {exc}")
+            return None
+
+    def _try_openai_compatible_chat(
+        self,
+        messages: list[dict[str, str]],
+        *,
+        max_new_tokens: int,
+        temperature: float,
+        errors: list[str],
+    ) -> str | None:
+        """Try InferenceClient.chat.completions.create()."""
+
+        chat = getattr(self.client, "chat", None)
+        completions = getattr(chat, "completions", None)
+        create = getattr(completions, "create", None)
+
+        if not callable(create):
+            errors.append("chat.completions.create: method not available on InferenceClient")
+            return None
+
+        call_variants = (
+            {
+                "model": self.model_id,
+                "messages": messages,
+                "max_tokens": max_new_tokens,
+                "temperature": temperature,
+            },
+            {
+                "messages": messages,
+                "max_tokens": max_new_tokens,
+                "temperature": temperature,
+            },
+        )
+
+        for kwargs in call_variants:
+            try:
+                response = create(**kwargs)
+                text = _extract_model_text(response)
+                if text:
+                    return text
+
+                errors.append(
+                    "chat.completions.create: response had no extractable text. "
+                    f"kwargs_keys={list(kwargs.keys())}, "
+                    f"response_type={response.__class__.__name__}, "
+                    f"response={_short_repr(response)}"
+                )
+            except Exception as exc:
+                errors.append(
+                    "chat.completions.create: "
+                    f"kwargs_keys={list(kwargs.keys())}, "
+                    f"{exc.__class__.__name__}: {exc}"
                 )
-                return _extract_model_text(response)
-        except Exception:
-            logger.debug("InferenceClient.chat.completions.create failed", exc_info=True)
 
         return None
 
@@ -225,21 +294,52 @@ class OptionalHFInferenceClient:
         *,
         max_new_tokens: int,
         temperature: float,
+        errors: list[str],
     ) -> str | None:
-        """Try text-generation style methods."""
+        """Try InferenceClient.text_generation()."""
 
-        try:
-            text_generation = getattr(self.client, "text_generation", None)
-            if callable(text_generation):
-                response = text_generation(
-                    prompt,
-                    max_new_tokens=max_new_tokens,
-                    temperature=temperature,
-                    return_full_text=False,
+        text_generation = getattr(self.client, "text_generation", None)
+        if not callable(text_generation):
+            errors.append("text_generation: method not available on InferenceClient")
+            return None
+
+        call_variants = (
+            {
+                "prompt": prompt,
+                "max_new_tokens": max_new_tokens,
+                "temperature": temperature,
+                "return_full_text": False,
+            },
+            {
+                "prompt": prompt,
+                "max_new_tokens": max_new_tokens,
+                "return_full_text": False,
+            },
+            {
+                "prompt": prompt,
+                "max_new_tokens": max_new_tokens,
+            },
+        )
+
+        for kwargs in call_variants:
+            try:
+                response = text_generation(**kwargs)
+                text = _extract_model_text(response)
+                if text:
+                    return text
+
+                errors.append(
+                    "text_generation: response had no extractable text. "
+                    f"kwargs_keys={list(kwargs.keys())}, "
+                    f"response_type={response.__class__.__name__}, "
+                    f"response={_short_repr(response)}"
+                )
+            except Exception as exc:
+                errors.append(
+                    "text_generation: "
+                    f"kwargs_keys={list(kwargs.keys())}, "
+                    f"{exc.__class__.__name__}: {exc}"
                 )
-                return _extract_model_text(response)
-        except Exception:
-            logger.debug("InferenceClient.text_generation failed", exc_info=True)
 
         return None
 
@@ -326,17 +426,17 @@ def model_health_check_ui() -> str:
         )
 
         return (
-            f"Model client is configured.\n\n"
+            "Model client is configured and returned text.\n\n"
             f"Model id: {MODEL_STATUS.model_id}\n\n"
-            f"Raw response:\n{response}"
+            f"Response:\n{response}"
         )
     except Exception as exc:
         logger.exception("Model health check failed")
         return (
-            f"Model client is configured but inference failed.\n\n"
+            "Model client is configured but inference failed.\n\n"
             f"Model id: {MODEL_STATUS.model_id}\n\n"
             f"Error type: {exc.__class__.__name__}\n"
-            f"Error: {exc}"
+            f"Error:\n{exc}"
         )
 
 
@@ -978,6 +1078,14 @@ examples/
 
     return demo
 
+def _short_repr(value: Any, *, max_chars: int = 1200) -> str:
+    """Return a bounded repr for diagnostics."""
+
+    text = repr(value)
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 3] + "..."
+
 
 def _extract_model_text(response: Any) -> str | None:
     """Extract text from common model response shapes."""