Update app.py

app.py

@@ -1,3 +1,4 @@
+# app.py — robust starter (fallback model + safe proxy + web tools)
 from smolagents import CodeAgent, HfApiModel, tool
 from duckduckgo_search import DDGS
 import requests
@@ -8,15 +9,15 @@ import yaml
 from tools.final_answer import FinalAnswerTool
 from Gradio_UI import GradioUI
 import json
+import sys
+import traceback
 
-#---------------------------------------------------------------------------#
-#--------------------------------- Tools ----------------------------------#
-#---------------------------------------------------------------------------#
+# ---------------------- Tools (Google-style docstrings) --------------------
 
 @tool
 def web_search(query: str, max_results: int = 5) -> str:
     """
-    Recherche des informations sur internet via DuckDuckGo et retourne une liste de résultats JSON.
+    Recherche des informations sur internet via DuckDuckGo et retourne une liste JSON.
 
     Args:
         query (str): La requête de recherche.
@@ -30,25 +31,40 @@ def web_search(query: str, max_results: int = 5) -> str:
             results = list(ddgs.text(query, max_results=max_results))
         return json.dumps(results, ensure_ascii=False, indent=2)
     except Exception as e:
-        return json.dumps({"error": str(e)})
+        return json.dumps({"error": f"web_search failed: {str(e)}"})
 
 @tool
-def get_current_time_in_timezone(timezone: str) -> str:
+def extract_first_url(search_results_json: str) -> str:
     """
-    Retourne l’heure locale actuelle dans un fuseau horaire donné.
+    Extrait la première URL HTTP de la sortie JSON de web_search.
 
     Args:
-        timezone (str): Un fuseau horaire valide (ex: 'America/New_York').
+        search_results_json (str): JSON string retourné par web_search.
 
     Returns:
-        str: Heure locale formatée ou message d’erreur.
+        str: la première URL trouvée, ou un message d'erreur.
     """
     try:
-        tz = pytz.timezone(timezone)
-        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-        return f"L’heure locale à {timezone} est {local_time}"
+        results = json.loads(search_results_json)
+        if not results:
+            return "Aucun résultat trouvé"
+        first = results[0]
+        if isinstance(first, dict):
+            for k in ("href", "link", "url", "result"):
+                v = first.get(k)
+                if isinstance(v, str) and v.startswith("http"):
+                    return v
+            for v in first.values():
+                if isinstance(v, str) and v.startswith("http"):
+                    return v
+        text = json.dumps(results)
+        import re
+        m = re.search(r"https?://[^\s'\"<>()]+", text)
+        if m:
+            return m.group(0)
+        return "Aucune URL trouvée"
     except Exception as e:
-        return f"Erreur pour le fuseau horaire '{timezone}': {str(e)}"
+        return f"Erreur extraction URL: {str(e)}"
 
 @tool
 def visit_webpage(url: str) -> str:
@@ -59,7 +75,7 @@ def visit_webpage(url: str) -> str:
         url (str): URL de la page web.
 
     Returns:
-        str: Contenu HTML de la page.
+        str: Contenu HTML de la page ou message d'erreur.
     """
     headers = {
         "User-Agent": (
@@ -68,65 +84,226 @@ def visit_webpage(url: str) -> str:
             "Chrome/122.0.0.0 Safari/537.36"
         )
     }
-    resp = requests.get(url, headers=headers, timeout=10)
-    resp.raise_for_status()
-    return resp.text
+    try:
+        resp = requests.get(url, headers=headers, timeout=12)
+        resp.raise_for_status()
+        return resp.text
+    except Exception as e:
+        return f"Erreur téléchargement page: {str(e)}"
 
 @tool
-def parse_html(html: str, css_selector: str) -> list:
+def parse_html(html: str, css_selector: str) -> str:
     """
-    Extrait du texte d’éléments HTML via un sélecteur CSS.
+    Extrait des textes du HTML via un sélecteur CSS et retourne une liste JSON.
 
     Args:
         html (str): Code HTML complet.
-        css_selector (str): Sélecteur CSS (ex: 'table tr td:last-child').
+        css_selector (str): Sélecteur CSS (ex: 'table.wikitable tr').
 
     Returns:
-        list: Liste de textes extraits des éléments correspondant au sélecteur.
+        str: JSON list (string) des textes extraits ou message d'erreur.
     """
-    soup = BeautifulSoup(html, "html.parser")
-    elements = soup.select(css_selector)
-    return [el.get_text(strip=True) for el in elements]
+    try:
+        soup = BeautifulSoup(html, "html.parser")
+        items = soup.select(css_selector)
+        texts = [el.get_text(" ", strip=True) for el in items]
+        return json.dumps(texts, ensure_ascii=False, indent=2)
+    except Exception as e:
+        return json.dumps({"error": f"Parse failed: {str(e)}"})
 
-#---------------------------------------------------------------------------#
-#------------------------------- Agent Init -------------------------------#
-#---------------------------------------------------------------------------#
+@tool
+def get_current_time_in_timezone(timezone: str) -> str:
+    """
+    Retourne l'heure locale actuelle dans un fuseau horaire donné.
 
-final_answer = FinalAnswerTool()
+    Args:
+        timezone (str): Nom du fuseau horaire (ex: 'Europe/Paris').
 
-# Utiliser un modèle gratuit
-model = HfApiModel(
-    max_tokens=1024,
-    temperature=0.5,
-    model_id='Qwen/Qwen2.5-small-Instruct',
-    custom_role_conversions=None,
-)
+    Returns:
+        str: JSON avec timezone et local_time.
+    """
+    try:
+        tz = pytz.timezone(timezone)
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        return json.dumps({"timezone": timezone, "local_time": local_time}, ensure_ascii=False)
+    except Exception as e:
+        return json.dumps({"error": f"Timezone error: {str(e)}"})
+
+
+# ---------------------- Safe model proxy & fallback ------------------------
+
+class SafeModelProxy:
+    """
+    Wrap a model-like object and ensure token counters never return None.
+    Delegates attribute access and 'run' to the wrapped model when present.
+    """
+    def __init__(self, model_obj):
+        self._m = model_obj
+        # ensure attributes exist
+        if not hasattr(self._m, "last_input_token_count"):
+            self._m.last_input_token_count = 0
+        if not hasattr(self._m, "last_output_token_count"):
+            self._m.last_output_token_count = 0
+
+    def __getattr__(self, name):
+        # return attributes from underlying model
+        return getattr(self._m, name)
+
+    @property
+    def last_input_token_count(self):
+        v = getattr(self._m, "last_input_token_count", 0)
+        return v if isinstance(v, int) else 0
+
+    @property
+    def last_output_token_count(self):
+        v = getattr(self._m, "last_output_token_count", 0)
+        return v if isinstance(v, int) else 0
+
+    def run(self, *args, **kwargs):
+        # call underlying run/generate/chat if available
+        try:
+            if hasattr(self._m, "run"):
+                out = self._m.run(*args, **kwargs)
+            elif hasattr(self._m, "generate"):
+                out = self._m.generate(*args, **kwargs)
+            else:
+                # fallback echo
+                prompt = args[0] if args else kwargs.get("prompt", "")
+                out = f"[FALLBACK] model not available to generate answer. Prompt was: {prompt}"
+            # keep token counters non-None (best-effort)
+            if not isinstance(getattr(self._m, "last_input_token_count", 0), int):
+                try:
+                    self._m.last_input_token_count = len(args[0].split()) if args else 0
+                except Exception:
+                    self._m.last_input_token_count = 0
+            if not isinstance(getattr(self._m, "last_output_token_count", 0), int):
+                try:
+                    self._m.last_output_token_count = len(str(out).split())
+                except Exception:
+                    self._m.last_output_token_count = 0
+            return out
+        except Exception as e:
+            # never raise: return an informative string
+            return f"[MODEL ERROR] {str(e)}"
+
+
+def create_safe_hf_model(preferred_model_ids=None):
+    """
+    Try to instantiate HfApiModel with several model_ids.
+    If all fail, return a local fallback model wrapped in SafeModelProxy.
+    """
+    if preferred_model_ids is None:
+        preferred_model_ids = [
+            "google/flan-t5-small",
+            "gpt2",
+            "facebook/opt-125m"
+        ]
+    last_exc = None
+    for mid in preferred_model_ids:
+        try:
+            print(f"[model] trying HfApiModel({mid})", file=sys.stderr)
+            m = HfApiModel(model_id=mid, max_tokens=1024, temperature=0.5)
+            # wrap and return
+            proxy = SafeModelProxy(m)
+            print(f"[model] loaded {mid}", file=sys.stderr)
+            return proxy
+        except Exception as e:
+            last_exc = e
+            print(f"[model] cannot load {mid}: {repr(e)}", file=sys.stderr)
+            # continue to next
+    # fallback local simple model with run()
+    print("[model] all remote models failed -> using fallback local model", file=sys.stderr)
+
+    class FallbackLocal:
+        def __init__(self):
+            self.model_id = "fallback-local"
+            self.last_input_token_count = 0
+            self.last_output_token_count = 0
+        def run(self, prompt: str):
+            # Return a safe, instructive reply and keep token counters integer
+            reply = (
+                "MODE DÉGRADÉ: le modèle distant n'a pas pu être chargé.\n"
+                "Je peux cependant effectuer une recherche web et extraire des pages.\n"
+                "Demande par exemple : 'Who nominated the Giganotosaurus featured article?'"
+            )
+            try:
+                self.last_input_token_count = len(prompt.split()) if prompt else 0
+            except Exception:
+                self.last_input_token_count = 0
+            try:
+                self.last_output_token_count = len(reply.split())
+            except Exception:
+                self.last_output_token_count = 0
+            return reply
 
-# Charger les templates de prompt
-with open("prompts.yaml", 'r') as stream:
-    prompt_templates = yaml.safe_load(stream)
+    return SafeModelProxy(FallbackLocal())
+
+
+# ---------------------- Create model (safe) -------------------------------
+
+model = create_safe_hf_model()
+
+# ensure attributes exist and are ints
+if not hasattr(model, "last_input_token_count") or model.last_input_token_count is None:
+    try:
+        model._m.last_input_token_count = 0
+    except Exception:
+        # fallback attribute on proxy
+        pass
+if not hasattr(model, "last_output_token_count") or model.last_output_token_count is None:
+    try:
+        model._m.last_output_token_count = 0
+    except Exception:
+        pass
+
+# ---------------------- Agent init ---------------------------------------
+
+final_answer = FinalAnswerTool()
+
+# load prompts.yaml safely
+try:
+    with open("prompts.yaml", "r") as fh:
+        prompt_templates = yaml.safe_load(fh) or {}
+except Exception:
+    prompt_templates = {}
 
-# Créer l’agent avec les outils
 agent = CodeAgent(
     model=model,
     tools=[
         final_answer,
         web_search,
-        get_current_time_in_timezone,
+        extract_first_url,
         visit_webpage,
-        parse_html
+        parse_html,
+        get_current_time_in_timezone
     ],
     max_steps=6,
     verbosity_level=1,
-    grammar=None,
-    planning_interval=None,
+    prompt_templates=prompt_templates,
     name="InfoAgent",
-    description="Un agent capable de donner l’heure, rechercher sur internet et analyser des pages web",
-    prompt_templates=prompt_templates
+    description="Agent minimal : recherche web + parsing HTML"
 )
 
-#---------------------------------------------------------------------------#
-#------------------------------- Launch UI --------------------------------#
-#---------------------------------------------------------------------------#
+# final safety: make sure token counters available and ints
+try:
+    if getattr(agent.model, "last_input_token_count", None) is None:
+        agent.model._m.last_input_token_count = 0
+except Exception:
+    pass
+try:
+    if getattr(agent.model, "last_output_token_count", None) is None:
+        agent.model._m.last_output_token_count = 0
+except Exception:
+    pass
+
+# ---------------------- Launch UI ----------------------------------------
 
-GradioUI(agent).launch()
+if __name__ == "__main__":
+    # extra guard for Gradio_UI usage (no TypeError)
+    # Gradio_UI will read agent.model.last_input_token_count — guarantee int
+    if getattr(agent.model, "last_input_token_count", None) is None:
+        try:
+            agent.model._m.last_input_token_count = 0
+        except Exception:
+            pass
+    GradioUI(agent).launch()