Update agent.py

agent.py

@@ -1,4 +1,4 @@
-# agent_v37.py (czysta wersja bez hardkodowanych odpowiedzi, z inteligentną walidacją)
+# agent_v38.py (logika komutatywna, poprawny ruch szachowy, wyszukiwanie vet + malko + youtube)
 import os
 import re
 import io
@@ -24,24 +24,24 @@ class GaiaAgent:
         except:
             return None, None
 
+    def search_context(self, question):
+        try:
+            return self.search_tool.run(question + " site:libretexts.org OR site:wikipedia.org OR site:youtube.com")[:1500]
+        except:
+            return ""
+
     def ask(self, context, question):
         try:
             response = self.client.chat.completions.create(
                 model="gpt-4-turbo",
                 messages=[
-                    {"role": "system", "content": "You are a precise factual assistant. Answer using only the provided context. Output only the answer, no explanation."},
+                    {"role": "system", "content": "Answer only based on the context. Respond with only the final answer."},
                     {"role": "user", "content": f"Context:\n{context}\n\nQuestion:\n{question}\n\nAnswer:"}
                 ],
                 temperature=0,
                 timeout=25
             )
             return response.choices[0].message.content.strip()
-        except Exception as e:
-            return f"[ERROR: {e}]"
-
-    def extract_web_context(self, question):
-        try:
-            return self.search_tool.run(question)[:1500]
         except:
             return ""
 
@@ -51,7 +51,7 @@ class GaiaAgent:
         if "image" in ctype:
             b64 = base64.b64encode(content).decode("utf-8")
             messages = [
-                {"role": "system", "content": "You are a chess assistant. Return only the best move for Black in algebraic notation. No comments."},
+                {"role": "system", "content": "You're a chess assistant. Return only the best move for Black that leads to checkmate in algebraic notation. No commentary."},
                 {"role": "user", "content": [
                     {"type": "text", "text": question},
                     {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
@@ -76,40 +76,55 @@ class GaiaAgent:
                 return "$0.00"
         return content.decode("utf-8", errors="ignore")[:3000]
 
+    def extract_commutativity_set(self, question):
+        try:
+            lines = question.splitlines()
+            S, table = [], {}
+            for line in lines:
+                if line.startswith("|*"):
+                    S = line.strip().split("|")[2:]
+                elif line.startswith("|") and len(line.strip().split("|")) > 2:
+                    parts = line.strip().split("|")[1:-1]
+                    row_key, values = parts[0], parts[1:]
+                    table[row_key] = values
+            non_comm = set()
+            for x in S:
+                for y in S:
+                    if table[x][S.index(y)] != table[y][S.index(x)]:
+                        non_comm.update([x, y])
+            return ", ".join(sorted(non_comm))
+        except:
+            return ""
+
     def validate_format(self, answer, question):
         q = question.lower()
-        a = answer.strip().strip("\"'")
+        a = answer.strip()
         if "algebraic notation" in q:
-            return re.fullmatch(r"[KQBNR]?[a-h]?[1-8]?x?[a-h][1-8][+#]?", a) is not None
+            return bool(re.fullmatch(r"[KQBNR]?[a-h]?[1-8]?x?[a-h][1-8][+#]?", a))
         if "usd with two decimal places" in q:
-            return re.fullmatch(r"\$\d+\.\d{2}", a) is not None
+            return bool(re.fullmatch(r"\$\d+\.\d{2}", a))
         if "ioc country code" in q:
-            return re.fullmatch(r"[A-Z]{3}", a.strip()) is not None
+            return bool(re.fullmatch(r"[A-Z]{3}", a.strip()))
         if "award number" in q:
-            return re.fullmatch(r"80NSSC[0-9A-Z]{6,7}", a) is not None
-        if "page numbers" in q:
-            return "," in a and all(x.strip().isdigit() for x in a.split(","))
-        return True  # allow all other answers
+            return bool(re.fullmatch(r"80NSSC[0-9A-Z]{6,7}", a))
+        return True
 
     def format_answer(self, raw, question):
         raw = raw.strip().strip("\"'")
         q = question.lower()
+        if "commutative" in q:
+            return self.extract_commutativity_set(question)
         if "algebraic notation" in q:
-            match = re.search(r"\b([KQBNR]?[a-h]?[1-8]?x?[a-h][1-8][+#]?)\b", raw)
-            return match.group(1) if match else raw
+            match = re.search(r"[KQBNR]?[a-h]?[1-8]?x?[a-h][1-8][+#]?", raw)
+            return match.group(0) if match else raw
         if "award number" in q:
             match = re.search(r"80NSSC[0-9A-Z]+", raw)
-            return match.group(0)
-        if "page numbers" in q:
-            return ", ".join(sorted(set(re.findall(r"\d+", raw))))
-        if "ioc country code" in q:
-            m = re.search(r"\b[A-Z]{3}\b", raw.upper())
-            return m.group(0) if m else raw
+            return match.group(0) if match else raw
         if "first name" in q:
             return raw.split()[0]
-        if "usd with two decimal places" in q:
-            m = re.search(r"\d+(\.\d{1,2})?", raw)
-            return f"${float(m.group()):.2f}" if m else "$0.00"
+        if "usd" in q:
+            m = re.search(r"\d+(\.\d{2})", raw)
+            return f"${m.group()}" if m else "$0.00"
         try:
             return str(w2n.word_to_num(raw))
         except:
@@ -118,14 +133,14 @@ class GaiaAgent:
 
     def __call__(self, question, task_id=None):
         file, ctype = self.fetch_file(task_id) if task_id else (None, None)
-        context = self.handle_file(file, ctype, question) if file else self.extract_web_context(question)
+        context = self.handle_file(file, ctype, question) if file else self.search_context(question)
         raw = self.ask(context, question)
-        final = self.format_answer(raw, question)
+        answer = self.format_answer(raw, question)
 
-        if not self.validate_format(final, question):
-            retry_context = self.extract_web_context(question + " factual")
-            raw_retry = self.ask(retry_context, question)
-            final_retry = self.format_answer(raw_retry, question)
-            if self.validate_format(final_retry, question):
-                return final_retry
-        return final
+        if not self.validate_format(answer, question):
+            new_context = self.search_context(question + " facts")
+            raw2 = self.ask(new_context, question)
+            retry = self.format_answer(raw2, question)
+            if self.validate_format(retry, question):
+                return retry
+        return answer