Update agent.py

agent.py

@@ -1,12 +1,11 @@
-# agent_v44.py — Poprawiona obsługa: YouTube, commutativity, web fallback, Excel
 import os
 import re
 import io
 import base64
 import requests
 import pandas as pd
-from word2number import w2n
 from openai import OpenAI
+from word2number import w2n
 from langchain_community.tools import DuckDuckGoSearchRun
 
 class GaiaAgent:
@@ -21,7 +20,7 @@ class GaiaAgent:
             r = requests.get(url, timeout=10)
             r.raise_for_status()
             return r.content, r.headers.get("Content-Type", "")
-        except Exception:
+        except:
             return None, None
 
     def ask(self, prompt):
@@ -29,20 +28,12 @@ class GaiaAgent:
             r = self.client.chat.completions.create(
                 model="gpt-4-turbo",
                 messages=[{"role": "user", "content": prompt}],
-                temperature=0,
-                timeout=40
+                temperature=0
             )
             return r.choices[0].message.content.strip()
-        except Exception:
+        except:
             return "[ERROR: ask failed]"
 
-    def search_context(self, query):
-        try:
-            result = self.search_tool.run(query)
-            return result[:2000] if result else "[NO WEB RESULT]"
-        except Exception:
-            return "[WEB ERROR]"
-
     def handle_file(self, content, ctype, question):
         try:
             if "image" in ctype:
@@ -50,7 +41,7 @@ class GaiaAgent:
                 result = self.client.chat.completions.create(
                     model="gpt-4o",
                     messages=[
-                        {"role": "system", "content": "You're a chess assistant. Reply only with the best move in algebraic notation (e.g., Qd1#)."},
+                        {"role": "system", "content": "You're a chess assistant. Answer only with the best move in algebraic notation (e.g., Qd1#)."},
                         {"role": "user", "content": [
                             {"type": "text", "text": question},
                             {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
@@ -66,44 +57,25 @@ class GaiaAgent:
             if "excel" in ctype:
                 df = pd.read_excel(io.BytesIO(content), engine="openpyxl")
                 df.columns = [c.lower().strip() for c in df.columns]
-                food = df[df['category'].str.lower() == 'food'] if 'category' in df.columns else df
-                food['sales'] = pd.to_numeric(food.get('sales'), errors='coerce')
-                return f"${food['sales'].sum():.2f}"
+                df = df[df['category'].str.lower() == 'food']
+                df['sales'] = pd.to_numeric(df['sales'], errors='coerce')
+                return f"${df['sales'].sum():.2f}"
             return content.decode("utf-8", errors="ignore")[:3000]
-        except Exception as e:
-            return f"[FILE ERROR: {e}]"
-
-    def extract_commutativity_set(self, table_txt):
-        try:
-            rows = [r for r in table_txt.splitlines() if r.strip().startswith("|")]
-            head = rows[0].split("|")[2:-1]
-            table = {}
-            for row in rows[1:]:
-                parts = row.split("|")[1:-1]
-                table[parts[0]] = parts[1:]
-            s = set()
-            for a in head:
-                for b in head:
-                    if table[a][head.index(b)] != table[b][head.index(a)]:
-                        s |= {a, b}
-            return ", ".join(sorted(s))
-        except Exception:
-            return "[COMMUTATIVE ERROR]"
+        except:
+            return "[FILE ERROR]"
 
     def extract_ingredients(self, text):
         try:
             tokens = re.findall(r"[a-zA-Z]+(?:\s[a-zA-Z]+)?", text)
-            noise = {"add", "combine", "cook", "mixture", "until", "dash", "medium", "heat", "remove", "stir"}
-            filtered = [t.lower() for t in tokens if t.lower() not in noise and len(t.split()) <= 3]
+            blocked = {"add", "combine", "cook", "stir", "remove", "cool", "mixture", "saucepan", "until", "heat", "dash"}
+            filtered = [t.lower() for t in tokens if t.lower() not in blocked and len(t.split()) <= 3]
             return ", ".join(sorted(set(filtered)))
-        except Exception:
-            return text[:80]
+        except:
+            return text[:100]
 
     def format_answer(self, answer, question):
         q = question.lower()
         raw = answer.strip().strip("\"'")
-        if "commutative" in q:
-            return self.extract_commutativity_set(question)
         if "ingredient" in q:
             return self.extract_ingredients(raw)
         if "algebraic notation" in q:
@@ -115,9 +87,6 @@ class GaiaAgent:
         if "award number" in q:
             m = re.search(r"80NSSC[0-9A-Z]+", raw)
             return m.group(0) if m else raw
-        if "ioc" in q:
-            m = re.search(r"\b[A-Z]{3}\b", raw)
-            return m.group(0) if m else raw
         if "first name" in q:
             return raw.split()[0]
         try:
@@ -126,27 +95,18 @@ class GaiaAgent:
             m = re.search(r"\d+", raw)
             return m.group(0) if m else raw
 
-    def retry_fallback(self, question):
-        context = self.search_context(question)
-        prompt = f"""Answer concisely and factually:
-Context: {context}
-Question: {question}"""
-        return self.ask(prompt)
-
     def __call__(self, question, task_id=None):
         try:
             content, ctype = self.fetch_file(task_id) if task_id else (None, None)
-            context = self.handle_file(content, ctype, question) if content else self.search_context(question)
-            prompt = f"""Use this context to answer:
+            context = self.handle_file(content, ctype, question) if content else ""
+            prompt = f"Use this context to answer the question below.
+Context:
 {context}
 
 Question:
 {question}
-Answer:"""
+Answer:"
             raw = self.ask(prompt)
-            if not raw or "[ERROR" in raw or "step execution failed" in raw:
-                retry = self.retry_fallback(question)
-                return self.format_answer(retry, question)
             return self.format_answer(raw, question)
         except Exception as e:
             return f"[AGENT ERROR: {e}]"