Update agent.py

agent.py

@@ -1,4 +1,4 @@
-# agent_v42.py — Wersja stabilna z obsługą błędów, filtrowaniem i lepszym parsingiem
+# agent_v43.py — Najlepsze cechy z V18–V34: precyzja, retry fallback, stabilność
 import os
 import re
 import io
@@ -18,50 +18,39 @@ class GaiaAgent:
     def fetch_file(self, task_id):
         try:
             url = f"{self.api_url}/files/{task_id}"
-            response = requests.get(url, timeout=10)
-            response.raise_for_status()
-            return response.content, response.headers.get("Content-Type", "")
+            r = requests.get(url, timeout=10)
+            r.raise_for_status()
+            return r.content, r.headers.get("Content-Type", "")
         except:
             return None, None
 
-    def get_step_by_step_plan(self, question):
+    def ask(self, prompt):
         try:
-            response = self.client.chat.completions.create(
+            r = self.client.chat.completions.create(
                 model="gpt-4-turbo",
-                messages=[{"role": "user", "content": f"Break down this question into 2–5 logical steps:\n{question}"}],
+                messages=[{"role": "user", "content": prompt}],
                 temperature=0,
-                timeout=15
+                timeout=30
             )
-            return response.choices[0].message.content.strip()
+            return r.choices[0].message.content.strip()
         except:
-            return "Step 1: Try to understand the question."
+            return "[ERROR: ask failed]"
 
-    def search_with_steps(self, question, steps):
+    def search_context(self, query):
         try:
-            web_context = self.search_tool.run(question)[:2000] or "No useful info found."
-            response = self.client.chat.completions.create(
-                model="gpt-4-turbo",
-                messages=[
-                    {"role": "system", "content": f"Use only this data:\n{web_context}"},
-                    {"role": "user", "content": f"Follow this plan:\n{steps}\n\nAnswer this question concisely:\n{question}"}
-                ],
-                temperature=0,
-                timeout=30
-            )
-            return response.choices[0].message.content.strip()
+            result = self.search_tool.run(query)
+            return result[:2000] if result else "[NO WEB RESULT]"
         except:
-            return "[ERROR: step execution failed]"
+            return "[WEB ERROR]"
 
     def handle_file(self, content, ctype, question):
-        if not content:
-            return "[NO FILE DATA]"
         try:
             if "image" in ctype:
                 b64 = base64.b64encode(content).decode("utf-8")
                 result = self.client.chat.completions.create(
                     model="gpt-4o",
                     messages=[
-                        {"role": "system", "content": "You're a chess assistant. Respond with only the best move in algebraic notation."},
+                        {"role": "system", "content": "You're a chess assistant. Reply 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}"}}
@@ -73,13 +62,13 @@ class GaiaAgent:
                 with open("/tmp/audio.mp3", "wb") as f:
                     f.write(content)
                 result = self.client.audio.transcriptions.create(model="whisper-1", file=open("/tmp/audio.mp3", "rb"))
-                return result.text[:2000]
+                return result.text
             if "excel" in ctype:
                 df = pd.read_excel(io.BytesIO(content), engine="openpyxl")
-                df.columns = [c.strip().lower() for c in df.columns]
+                df.columns = [c.lower().strip() for c in df.columns]
                 if 'category' in df.columns and 'sales' in df.columns:
                     df = df.dropna(subset=['category', 'sales'])
-                    df = df[df['category'].str.lower().str.strip() == 'food']
+                    df = df[df['category'].str.lower() == 'food']
                     df['sales'] = pd.to_numeric(df['sales'], errors='coerce')
                     return f"${df['sales'].sum():.2f}"
                 return "[NO FOOD SALES DATA]"
@@ -87,48 +76,79 @@ class GaiaAgent:
         except Exception as e:
             return f"[FILE ERROR: {e}]"
 
+    def extract_commutativity_set(self, table_txt):
+        try:
+            lines = table_txt.splitlines()
+            S, table = [], {}
+            for l in lines:
+                if l.startswith("|*"):
+                    S = l.strip().split("|")[2:]
+                elif l.startswith("|"):
+                    parts = l.strip().split("|")[1:-1]
+                    table[parts[0]] = parts[1:]
+            fail = set()
+            for x in S:
+                for y in S:
+                    if table[x][S.index(y)] != table[y][S.index(x)]:
+                        fail |= {x, y}
+            return ", ".join(sorted(fail))
+        except:
+            return "[COMMUTATIVE ERROR]"
+
     def extract_ingredients(self, text):
         try:
-            items = re.findall(r"[a-zA-Z]+(?:\s[a-zA-Z]+)*", text.lower())
-            blacklist = {'add', 'mix', 'cook', 'remove', 'combine', 'heat', 'stir', 'dash', 'before', 'cool', 'saucepan', 'until', 'mixture'}
-            filtered = [w for w in items if w not in blacklist and len(w.split()) <= 3]
-            unique = sorted(set(filtered))
-            return ", ".join(unique[:15])
+            candidates = re.findall(r"[a-zA-Z]+(?:\s[a-zA-Z]+)?", text)
+            blocked = {"add", "combine", "cook", "stir", "remove", "cool", "mixture", "saucepan", "until", "heat", "dash"}
+            clean = [c.lower() for c in candidates if c.lower() not in blocked and len(c.split()) <= 3]
+            return ", ".join(sorted(set(clean)))
         except:
-            return text[:200]
+            return text[:100]
 
-    def format_answer(self, raw, question):
-        if not raw:
-            return "[NO ANSWER]"
-        raw = raw.strip().strip("\"'")
+    def format_answer(self, answer, question):
         q = question.lower()
-        if "ingredients" in q:
+        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:
-            match = re.search(r"[KQBNR]?[a-h]?[1-8]?x?[a-h][1-8][+#]?", raw)
-            return match.group(0) if match else raw[:30]
-        if "award number" in q:
-            match = re.search(r"80NSSC[0-9A-Z]+", raw)
-            return match.group(0) if match else raw
+            m = re.search(r"[KQBNR]?[a-h]?[1-8]?x?[a-h][1-8][+#]?", raw)
+            return m.group(0) if m else raw
         if "usd" in q:
             m = re.search(r"\$?\d+(\.\d{2})", raw)
             return f"${m.group()}" if m else "$0.00"
+        if "award number" in q:
+            m = re.search(r"80NSSC[0-9A-Z]+", raw)
+            return m.group(0) if m else raw
         if "first name" in q:
-            return raw.split()[0] if " " in raw else raw
+            return raw.split()[0]
         try:
             return str(w2n.word_to_num(raw))
         except:
             m = re.search(r"\d+", raw)
             return m.group(0) if m else raw
 
+    def retry_fallback(self, question):
+        try:
+            prompt = f"Answer concisely and factually:
+Question: {question}"
+            return self.ask(prompt)
+        except:
+            return "[RETRY FAILED]"
+
     def __call__(self, question, task_id=None):
         try:
-            file, ctype = self.fetch_file(task_id) if task_id else (None, None)
-            if file:
-                context = self.handle_file(file, ctype, question)
-            else:
-                steps = self.get_step_by_step_plan(question)
-                context = self.search_with_steps(question, steps)
-            return self.format_answer(context, question)
+            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)
+            raw = self.ask(f"Use this context to answer:
+{context}
+
+Question:
+{question}
+Answer:")
+            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}]"