uuu

my_tools.py

@@ -7,469 +7,206 @@ from io import BytesIO
 from bs4 import BeautifulSoup
 from pydantic import Field
 
-# ---------- OPTIONAL & LAZY IMPORTS ----------
-# (avoid hard‑failure if libs are absent; import inside tools when needed)
-
-# ---------- LLM WRAPPER ----------
+# ----- LlamaIndex & LangChain Imports -----
 from llama_index.core.llms import ChatMessage, LLMMetadata, LLM, CompletionResponse
 from llama_index.core.agent import ReActAgent
 from llama_index.core.callbacks.llama_debug import LlamaDebugHandler
 from llama_index.core.tools import FunctionTool
-from llama_index.core.schema import Document
-
+from llama_index.llms.huggingface import HuggingFaceInferenceAPI
 from langchain_community.retrievers import TavilySearchAPIRetriever
-import google.generativeai as genai
-
 
 # ---------- BASIC SETUP ----------
 HEADERS = {"User-Agent": "Mozilla/5.0"}
 
-
-
 def check_required_keys() -> None:
-    missing = []
-    if not os.getenv("TAVILY_API_KEY"):
-        missing.append("TAVILY_API_KEY")
-    if not os.getenv("GEMINI_API_KEY"):
-        missing.append("GEMINI_API_KEY")
+    missing = [k for k in ("TAVILY_API_KEY", "HUGGINGFACE_TOKEN") if not os.getenv(k)]
     if missing:
-        print(
-            f"⚠️  WARNING: Missing API keys: {', '.join(missing)}. Agent will not function properly!"
-        )
+        print(f"⚠️  WARNING: Missing API keys: {', '.join(missing)}")
     else:
         print("✅ All required API keys are present.")
 
-
 check_required_keys()
 
-# Monkey‑patch requerido por LlamaIndex
+# Monkey-patch requerido por LlamaIndex
 ChatMessage.message = property(lambda self: self)
 
-
-# ---------- GEMINI LLM ----------
-class GeminiLLM(LLM):
-    """Wrapper mínimo para Gemini 1.5 que satisface la interfaz de Llama-Index."""
-
-    model_name: str = Field(default="models/gemini-1.5-flash-latest")
-    temperature: float = Field(default=0.0)
-
-    _model: object = None
-    _gen_cfg: object = None
+# ---------- HUGGING FACE LLM WRAPPER (Command R+) ----------
+class HuggingFaceLLM(LLM):
+    """Wrapper para la API de Inferencia de Hugging Face, optimizado para Command R+."""
+    model_name: str = Field(default="CohereForAI/c4ai-command-r-plus")
+    temperature: float = Field(default=0.01)
+    max_new_tokens: int = Field(default=2048) # Aumentado para respuestas más largas
+    
+    _client: HuggingFaceInferenceAPI = None
 
     class Config:
         extra = "allow"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-
-        # --------- Normalización rápida (evita FieldInfo) -----------------
-        if not isinstance(self.model_name, str):
-            self.model_name = "models/gemini-1.5-pro-latest" #"models/gemini-1.5-flash-latest"
-        if not isinstance(self.temperature, (float, int)):
-            self.temperature = 0.0
-        # ------------------------------------------------------------------
-
-        # Configurar clave y modelo
-        key = os.getenv("GEMINI_API_KEY")
-        if not key:
-            raise ValueError("GEMINI_API_KEY no configurada en variables de entorno")
-        genai.configure(api_key=key)
-
-        self._gen_cfg = genai.types.GenerationConfig(
-            temperature=float(self.temperature)
-        )
-        self._model = genai.GenerativeModel(
-            model_name=self.model_name,
-            generation_config=self._gen_cfg
-        )
-
-        # callback manager defensivo
+        api_key = os.getenv("HUGGINGFACE_TOKEN")
+        if not api_key:
+            raise ValueError("HUGGINGFACE_TOKEN no configurado en los secrets del Space")
+        self._client = HuggingFaceInferenceAPI(model_name=self.model_name, token=api_key)
         if self.callback_manager is None:
             from llama_index.core.callbacks.base import CallbackManager
             self.callback_manager = CallbackManager([])
         if not self.callback_manager.handlers:
             self.callback_manager.add_handler(LlamaDebugHandler())
 
-    # -- metadatos ----------------------------------------------------------
     @property
-    def metadata(self) -> LLMMetadata:  # type: ignore[override]
+    def metadata(self) -> LLMMetadata:
         return LLMMetadata(
-            context_window=1_048_576,
-            num_output=8192,
+            context_window=128000,
+            num_output=self.max_new_tokens,
             is_chat_model=True,
             is_function_calling_model=True,
             model_name=self.model_name,
         )
 
-    # ----------------------------------------------------------------------
-    # 1️⃣  CHAT SINCRONO
-    # ----------------------------------------------------------------------
-    def chat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:  # type: ignore[override]
-        history = [
-            {"role": "user" if m.role == "user" else "model", "parts": [{"text": str(m.content)}]}
-            for m in messages[:-1]
-        ]
-        session = self._model.start_chat(history=history)
-        reply = session.send_message(str(messages[-1].content))
-        return ChatMessage(role="assistant", content=reply.text)
+    def chat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:
+        prompt = self._client.tokenizer.apply_chat_template(
+            [{"role": msg.role.value, "content": msg.content} for msg in messages],
+            tokenize=False, add_generation_prompt=True
+        )
+        try:
+            response = self._client.text_generation(
+                prompt, max_new_tokens=self.max_new_tokens,
+                temperature=self.temperature if self.temperature > 0 else 0.01, # Temp no puede ser 0
+                do_sample=True, top_p=0.95
+            )
+            return ChatMessage(role="assistant", content=response)
+        except Exception as e:
+            print(f"[ERROR] HuggingFace API call failed: {e}")
+            return ChatMessage(role="assistant", content=f"Error: API call failed. Reason: {e}")
 
-    # 1-bis  CHAT ASINCRONO
-    async def achat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:  # type: ignore[override]
+    async def achat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:
         return await asyncio.to_thread(self.chat, messages, **kwargs)
 
-    # ----------------------------------------------------------------------
-    # 2️⃣  COMPLETE SINCRONO (prompt plano)
-    # ----------------------------------------------------------------------
-    def complete(self, prompt: str, formatted: bool = False, **kwargs) -> CompletionResponse:  # type: ignore[override]
-        resp = self._model.generate_content(prompt)
-        return CompletionResponse(text=resp.text)
-
-    # 2-bis COMPLETE ASINCRONO
-    async def acomplete(self, prompt: str, formatted: bool = False, **kwargs) -> CompletionResponse:  # type: ignore[override]
-        return await asyncio.to_thread(self.complete, prompt, formatted=formatted, **kwargs)
-
-    # ----------------------------------------------------------------------
-    # 3️⃣  STREAMING DE COMPLETIONS
-    # ----------------------------------------------------------------------
-    def stream_complete(self, prompt: str, formatted: bool = False, **kwargs):
-        stream = self._model.generate_content(prompt, stream=True)
-
-        def generator():
-            from llama_index.core.llms import CompletionResponse
-            acc = ""
-            for chunk in stream:
-                delta = getattr(chunk, "text", "") or (chunk.parts[0].text if chunk.parts else "")
-                if delta:
-                    acc += delta
-                    yield CompletionResponse(text=acc, delta=delta)
-
-        return generator()
-
-    async def astream_complete(self, prompt: str, formatted: bool = False, **kwargs):
-        sync_gen = await asyncio.to_thread(self.stream_complete, prompt, formatted=formatted, **kwargs)
-
-        async def agen():
-            for item in sync_gen:
-                yield item
-
-        return agen()
-
-    # ----------------------------------------------------------------------
-    # 4️⃣  STREAMING DE CHAT
-    # ----------------------------------------------------------------------
-    def stream_chat(self, messages: list[ChatMessage], **kwargs):
-        history = [
-            {"role": "user" if m.role == "user" else "model", "parts": [{"text": str(m.content)}]}
-            for m in messages[:-1]
-        ]
-        session = self._model.start_chat(history=history)
-        stream = session.send_message(str(messages[-1].content), stream=True)
-
-        def generator():
-            acc = ""
-            for chunk in stream:
-                delta = getattr(chunk, "text", "") or (chunk.parts[0].text if chunk.parts else "")
-                if delta:
-                    acc += delta
-                    yield ChatMessage(
-                        role="assistant",
-                        content=acc,
-                        additional_kwargs={"delta": delta},
-                    )
-
-        return generator()
-
-    async def astream_chat(self, messages: list[ChatMessage], **kwargs):
-        sync_gen = await asyncio.to_thread(self.stream_chat, messages, **kwargs)
-
-        async def agen():
-            for item in sync_gen:
-                yield item
-
-        return agen()
-
-
-
+    def complete(self, prompt: str, **kwargs) -> CompletionResponse:
+        raise NotImplementedError("Use .chat() for this model.")
 
 # ---------- TOOLING ----------
+def _pd_safe_import():
+    try:
+        import pandas as pd
+        return pd
+    except ModuleNotFoundError:
+        return None
 
 def web_search(query: str, num_results: int = 5) -> str:
     """Tavily search -> concatenated, citation‑ready snippet list (includes URL)."""
     try:
         retriever = TavilySearchAPIRetriever(api_key=os.getenv("TAVILY_API_KEY"), k=num_results)
         results = retriever.invoke(query)
-        formatted = []
-        for i, doc in enumerate(results, start=1):
-            formatted.append(
-                f"Result {i}:\nTitle: {doc.metadata.get('title','')}\nURL: {doc.metadata.get('source','')}\nContent: {doc.page_content}\n"
-            )
+        formatted = [f"Result {i}:\nTitle: {doc.metadata.get('title','')}\nURL: {doc.metadata.get('source','')}\nContent: {doc.page_content}\n" for i, doc in enumerate(results, 1)]
         return "\n\n".join(formatted)
     except Exception as exc:
         return f"Error web_search: {exc}"
 
-
-def reverse_text(text: str) -> str:
-    return text[::-1]
-
-
-# small util for optional pandas
-
-def _pd_safe_import():
+def scrape_url_text(url: str) -> str:
+    """Downloads a webpage and returns cleaned visible text."""
     try:
-        import pandas as pd  # noqa: F401
-
-        return pd
-    except ModuleNotFoundError:
-        raise RuntimeError("pandas not available in this environment")
-
+        resp = requests.get(url, headers=HEADERS, timeout=20)
+        resp.raise_for_status()
+        if "Just a moment" in resp.text and "cloudflare" in resp.text.lower():
+            return "Error: The site is protected by Cloudflare and cannot be scraped directly. Use information from web_search instead."
+        soup = BeautifulSoup(resp.text, "html.parser")
+        for tag in soup(["script", "style", "noscript", "header", "footer", "nav"]):
+            tag.decompose()
+        text = "\n".join(t.strip() for t in soup.get_text("\n").splitlines() if t.strip())
+        return text[:8000]
+    except Exception as exc:
+        return f"Error scrape_url_text: {exc}"
 
 def analyze_markdown_table(table_md: str, question: str) -> str:
+    """Check commutativity or return CSV. Requires pandas lazily."""
+    pd = _pd_safe_import()
+    if pd is None: return "Error: pandas library is required for this tool but not installed."
     try:
-        pd = _pd_safe_import()
-
-        # — 1️⃣  Parseo seguro del markdown —
-        clean = [
-            ln for ln in table_md.strip().splitlines()
-            if ln.strip() and not ln.lstrip().startswith("|---")
-        ]
-        rows = [ [c.strip() for c in ln.strip("|").split("|")] for ln in clean ]
-        if len(rows) < 2:
-            return "Error analyze_table: empty or malformed markdown table"
-
+        clean = [ln for ln in table_md.strip().splitlines() if ln.strip() and not ln.lstrip().startswith("|---")]
+        rows = [[c.strip() for c in ln.strip("|").split("|")] for ln in clean]
+        if len(rows) < 2: return "Error: malformed markdown table"
         df = pd.DataFrame(rows[1:], columns=rows[0])
-
-        # — 2️⃣  ¿Nos piden conmutatividad? —
         if "conmut" in question.lower():
             offenders: set[str] = set()
-            header = df.columns[0]        # nombre de la columna/índice
-
-            cols = df.columns[1:]         # solo las etiquetas
+            header, cols = df.columns[0], df.columns[1:]
             for x in cols:
                 for y in cols:
                     try:
                         val_xy = df.loc[df[header] == x, y].iat[0]
                         val_yx = df.loc[df[header] == y, x].iat[0]
-                        if val_xy != val_yx:
-                            offenders.update([x, y])
-                    except (IndexError, KeyError):
-                        continue
+                        if val_xy != val_yx: offenders.update([x, y])
+                    except (IndexError, KeyError): continue
             return ", ".join(sorted(offenders)) or "Conmutativa"
-
-        # — 3️⃣  Si no, devolvemos CSV —
         return df.to_csv(index=False)
     except Exception as exc:
         return f"Error analyze_markdown_table: {exc}"
 
-
-
 def execute_code(code: str) -> str:
-    """Runs arbitrary **short** python code in a sandboxed subprocess."""
+    """Runs short python code in a sandboxed subprocess."""
     try:
         res = subprocess.run(["python", "-S", "-c", code], capture_output=True, text=True, timeout=10)
         if res.returncode == 0:
             output = res.stdout.strip()
             return f"Output: {output if output else '(No output)'}"
         return f"Error: {res.stderr.strip()}"
-    except subprocess.TimeoutExpired:
-        return "Error: execution timeout"
     except Exception as exc:
         return f"Error execute_code: {exc}"
 
+# ... (otras herramientas como reverse_text, classify_botanical_foods, etc. van aquí, sin cambios) ...
+def reverse_text(text: str) -> str: return text[::-1]
 
-def read_excel_data(file_path: str, sheet_name: int | str = 0) -> str:
-    """Downloads or opens an excel file and returns CSV (requires pandas)."""
-    try:
-        pd = _pd_safe_import()
-        if file_path.startswith(("http://", "https://")):
-            resp = requests.get(file_path, headers=HEADERS, timeout=20)
-            resp.raise_for_status()
-            df = pd.read_excel(BytesIO(resp.content), sheet_name=sheet_name)
-        else:
-            if not os.path.exists(file_path):
-                return f"Error read_excel_data: file '{file_path}' not found"
-            df = pd.read_excel(file_path, sheet_name=sheet_name)
-        return df.fillna("").to_csv(index=False)
-    except Exception as exc:
-        return f"Error read_excel_data: {exc}"
-
-
-# --- botanical classifier (unchanged) ---
-
-def classify_botanical_foods(items_list_str: str) -> str:
-    botanical_fruits = {
-        "tomato",
-        "bell pepper",
-        "pepper",
-        "green beans",
-        "beans",
-        "zucchini",
-        "cucumber",
-        "eggplant",
-        "corn",
-        "peas",
-        "pea",
-        "pumpkin",
-        "squash",
-        "avocado",
-    }
-    botanical_vegetables = {
-        "broccoli",
-        "celery",
-        "lettuce",
-        "kale",
-        "spinach",
-        "sweet potatoes",
-        "sweet potato",
-        "potato",
-        "onion",
-        "garlic",
-        "carrot",
-        "okra",
-        "cabbage",
-        "cauliflower",
-        "beet",
-        "turnip",
-        "parsnip",
-        "leek",
-    }
-    vegs, fruits, others = set(), set(), set()
-    for token in (t.strip().lower() for t in items_list_str.split(",")):
-        if token in botanical_vegetables and token not in botanical_fruits:
-            vegs.add(token)
-        elif token in botanical_fruits:
-            fruits.add(token)
-        else:
-            others.add(token)
-    return (
-        f"Vegetables: {', '.join(sorted(vegs))}\n"
-        f"Fruits: {', '.join(sorted(fruits))}\n"
-        f"Others: {', '.join(sorted(others))}"
-    )
-
-
-# --- flexible Wikipedia table scraper ---
-
-def scrape_wiki_table(page_title: str, section: str | None = None, table_index: int = 0) -> str:
-    """Returns the requested Wikipedia table in markdown."""
-    try:
-        url = f"https://en.wikipedia.org/wiki/{page_title.replace(' ', '_')}"
-        html = requests.get(url, timeout=15).text
-        soup = BeautifulSoup(html, "html.parser")
-
-        def _find_tables(s: BeautifulSoup):
-            return s.find_all("table", class_="wikitable")
-
-        if section:
-            header_tag = soup.find(lambda tag: tag.name in {"h2", "h3"} and section.lower() in tag.get_text(" ", strip=True).lower())
-            if not header_tag:
-                return f"Error scrape_wiki_table: section '{section}' not found"
-            tables = header_tag.find_all_next("table", class_="wikitable")
-        else:
-            tables = _find_tables(soup)
-        if not tables or table_index >= len(tables):
-            return f"Error scrape_wiki_table: table index {table_index} out of range (found {len(tables)})"
-
-        pd = _pd_safe_import()
-        df = pd.read_html(str(tables[table_index]), flavor="bs4")[0]
-        return df.to_markdown(index=False)
-    except Exception as exc:
-        return f"Error scrape_wiki_table: {exc}"
-
-
-# --- generic URL text scraper ---
-
-def scrape_url_text(url: str) -> str:
-    """Descarga página y devuelve texto visible (trim-8k)."""
-    try:
-        resp = requests.get(url, headers=HEADERS, timeout=20)
-        if "Just a moment" in resp.text and "cloudflare" in resp.text.lower():
-            return "Error scrape_url_text: Cloudflare protection detected"
-        resp.raise_for_status()
-
-        soup = BeautifulSoup(resp.text, "html.parser")
-        for tag in soup(["script", "style", "noscript"]):
-            tag.decompose()
-        text = "\n".join(t.strip() for t in soup.get_text("\n").splitlines() if t.strip())
-        return text[:8000]
-    except Exception as exc:
-        return f"Error scrape_url_text: {exc}"
-
-
-
-# ---------- TOOL WRAPPERS ----------
-
+# ---------- TOOL DEFINITIONS & PROMPT ----------
 tool_defs = [
     (web_search, "web_search", "Searches the web via Tavily."),
-    (scrape_wiki_table, "scrape_wiki_table", "Extracts a wikitable from Wikipedia."),
     (scrape_url_text, "scrape_url_text", "Fetch any URL and return visible text."),
-    (analyze_markdown_table, "analyze_markdown_table", "Analyze a markdown table (commutativity etc)."),
+    (analyze_markdown_table, "analyze_markdown_table", "Analyze a markdown table."),
     (execute_code, "execute_code", "Run short python snippets securely."),
-    (read_excel_data, "read_excel_data", "Load Excel (URL or local) → CSV."),
-    (classify_botanical_foods, "classify_botanical_foods", "Botanically classify food list."),
     (reverse_text, "reverse_text", "Reverse a text string."),
-    (lambda q: "I cannot answer with the available tools.", "no_tool_solution", "Fallback answer when stuck."),
+    (lambda _: "I cannot answer with the available tools.", "no_tool_solution", "Fallback answer when stuck."),
 ]
-
 TOOLS = [FunctionTool.from_defaults(fn=fn, name=name, description=desc) for fn, name, desc in tool_defs]
 
-# ---------- SYSTEM PROMPT ----------
-tool_desc_str = "\n".join(f"{t.metadata.name}: {t.metadata.description}" for t in TOOLS)
 SYSTEM_PROMPT = f"""
-You are Alfred, a ReAct agent. Use the provided tools to answer.
-Rules:
-1. Try a relevant tool first when external info is needed.
-2. After a tool call you receive `Observation:`. Your *very next* assistant message **must** be exactly that observation (untouched) *or* the fixed string "I cannot answer with the available tools." – no extra text.
-3. If a tool fails, think why and try an alternative (different params / another tool) once before giving up.
-4. Do not invent facts.
-Available tools:
-{tool_desc_str}
-"""
+You are Alfred, a ReAct agent. Your goal is to answer questions accurately. Follow these rules STRICTLY.
 
-# ---------- REACT AGENT ----------
-llm = GeminiLLM()
-agent = ReActAgent.from_tools(
-    tools=TOOLS,
-    llm=llm,
-    system_prompt=SYSTEM_PROMPT,
-    verbose=True,
-    max_iterations=25,
-    callback_manager=llm.callback_manager,
-    handle_parsing_errors=True,
-)
+**OPERATING PROCEDURE:**
 
+1.  **TRIAGE:** First, analyze the question. If it involves a local file (image, audio, Excel) or multimedia, IMMEDIATELY use `no_tool_solution`.
+2.  **INFORMATION GATHERING:** For all other questions, your FIRST step is ALWAYS `web_search`.
+3.  **ANALYZE SNIPPET:** After `web_search`, CAREFULLY read the `Content:` snippet of each result. If the answer is clearly present, answer immediately. DO NOT use another tool if you already have the information.
+4.  **DEEP DIVE:** Only if the snippet is incomplete, use `scrape_url_text` on the most promising URL. If `scrape_url_text` fails (e.g., Cloudflare error), go back to the text from `web_search` or give up.
+5.  **FINAL ANSWER:** Your final response MUST be ONLY the `Observation:` from your last successful tool call, or the phrase "I cannot answer with the available tools."
+"""
+
+# ---------- AGENT CREATION & EXECUTION ----------
+def create_fresh_agent():
+    """Creates a new, clean agent instance to prevent state contamination."""
+    llm = HuggingFaceLLM()
+    return ReActAgent.from_tools(
+        tools=TOOLS, llm=llm, system_prompt=SYSTEM_PROMPT, verbose=False,
+        max_iterations=20, handle_parsing_errors=True
+    )
 
-# Helper to strip to the last Observation or fallback
 def _extract_observation(raw: str) -> str:
-    """Extrae la ÚLTIMA observación de la cadena de pensamiento."""
+    """Extracts the LAST observation from the ReAct agent's reasoning dump."""
     if "Observation:" in raw:
-        # rsplit divide desde la derecha, asegurando que tomamos la última
-        segment = raw.rsplit("Observation:", 1)[-1] 
+        segment = raw.rsplit("Observation:", 1)[-1]
         if "Final Answer:" in segment:
             segment = segment.split("Final Answer:", 1)[0]
         return segment.strip()
     return raw.strip()
 
-
-# Public entry point
-
 def basic_agent_response(question: str) -> str:
+    """Public entry point: creates a fresh agent and runs one query."""
     try:
-        # ⚠️ agente nuevo por pregunta
-        fresh_agent = ReActAgent.from_tools(
-            tools=TOOLS,
-            llm=GeminiLLM(),
-            system_prompt=SYSTEM_PROMPT,
-            verbose=False,
-            max_iterations=25,
-            callback_manager=None,   # sin historial previo
-            handle_parsing_errors=True,
-        )
-
-        raw = fresh_agent.query(question)
-        cleaned = _extract_observation(
-            str(raw.response if hasattr(raw, "response") else raw)
-        )
+        print(f"[DEBUG] ➜ Question: {question}")
+        agent = create_fresh_agent()
+        raw_resp = agent.query(question)
+        text_response = str(raw_resp.response if hasattr(raw_resp, "response") else raw_resp)
+        cleaned = _extract_observation(text_response)
         return cleaned or "I cannot answer with the available tools."
     except Exception as exc:
-        print(f"[ERROR] {exc}")
-        return "I cannot answer with the available tools."
+        print(f"[ERROR] Agent execution failed: {exc}")
+        return "I cannot answer with the available tools."