Update agent.py

agent.py

@@ -1,4 +1,4 @@
-# agent_v41.py — Agent analizujący każde pytanie krok po kroku i szukający odpowiedzi zewnętrznie
+# agent_v42.py — Wersja stabilna z obsługą błędów, filtrowaniem i lepszym parsingiem
 import os
 import re
 import io
@@ -25,17 +25,10 @@ class GaiaAgent:
             return None, None
 
     def get_step_by_step_plan(self, question):
-        steps_prompt = f"""
-You are an expert planner. Break down the question into a clear plan with 2–5 steps.
-
-Question: {question}
-
-Steps:
-"""
         try:
             response = self.client.chat.completions.create(
                 model="gpt-4-turbo",
-                messages=[{"role": "user", "content": steps_prompt}],
+                messages=[{"role": "user", "content": f"Break down this question into 2–5 logical steps:\n{question}"}],
                 temperature=0,
                 timeout=15
             )
@@ -44,76 +37,84 @@ Steps:
             return "Step 1: Try to understand the question."
 
     def search_with_steps(self, question, steps):
-        combined_prompt = f"""
-You are a knowledgeable assistant. Given the following plan:
-
-{steps}
-
-Answer the original question using verified and precise information.
-Return only the final answer, nothing else.
-
-Question: {question}
-"""
         try:
-            web_context = self.search_tool.run(question)[:2000]
+            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 web data:\n{web_context}"},
-                    {"role": "user", "content": combined_prompt}
+                    {"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()
         except:
-            return ""
+            return "[ERROR: step execution failed]"
 
     def handle_file(self, content, ctype, question):
         if not content:
-            return ""
-        if "image" in ctype:
-            b64 = base64.b64encode(content).decode("utf-8")
-            messages = [
-                {"role": "system", "content": "You're a chess analyst. Return only the best move for Black that guarantees a win. Use algebraic notation."},
-                {"role": "user", "content": [
-                    {"type": "text", "text": question},
-                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
-                ]}
-            ]
-            result = self.client.chat.completions.create(model="gpt-4o", messages=messages)
-            return result.choices[0].message.content.strip()
-        if "audio" in ctype:
-            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]
-        if "excel" in ctype:
-            try:
+            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": "user", "content": [
+                            {"type": "text", "text": question},
+                            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
+                        ]}
+                    ]
+                )
+                return result.choices[0].message.content.strip()
+            if "audio" in ctype:
+                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]
+            if "excel" in ctype:
                 df = pd.read_excel(io.BytesIO(content), engine="openpyxl")
                 df.columns = [c.strip().lower() for c in df.columns]
-                df = df.dropna(subset=['category', 'sales'])
-                df = df[df['category'].str.strip().str.lower() == 'food']
-                df['sales'] = pd.to_numeric(df['sales'], errors='coerce')
-                return f"${df['sales'].sum():.2f}"
-            except:
-                return "$0.00"
-        return content.decode("utf-8", errors="ignore")[:3000]
+                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['sales'] = pd.to_numeric(df['sales'], errors='coerce')
+                    return f"${df['sales'].sum():.2f}"
+                return "[NO FOOD SALES DATA]"
+            return content.decode("utf-8", errors="ignore")[:3000]
+        except Exception as e:
+            return f"[FILE ERROR: {e}]"
+
+    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])
+        except:
+            return text[:200]
 
     def format_answer(self, raw, question):
+        if not raw:
+            return "[NO ANSWER]"
         raw = raw.strip().strip("\"'")
         q = question.lower()
+        if "ingredients" 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
+            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
         if "usd" in q:
-            m = re.search(r"\d+(\.\d{2})", raw)
+            m = re.search(r"\$?\d+(\.\d{2})", raw)
             return f"${m.group()}" if m else "$0.00"
         if "first name" in q:
-            return raw.split()[0]
+            return raw.split()[0] if " " in raw else raw
         try:
             return str(w2n.word_to_num(raw))
         except:
@@ -121,12 +122,13 @@ Question: {question}
             return m.group(0) if m else raw
 
     def __call__(self, question, task_id=None):
-        file, ctype = self.fetch_file(task_id) if task_id else (None, None)
-
-        if file:
-            context = self.handle_file(file, ctype, question)
+        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)
-
-        steps = self.get_step_by_step_plan(question)
-        raw = self.search_with_steps(question, steps)
-        return self.format_answer(raw, question)
+        except Exception as e:
+            return f"[AGENT ERROR: {e}]"