Update app.py

app.py

@@ -10,6 +10,13 @@ from transformers import pipeline
 from newspaper import Article
 import hashlib, datetime
 
+import hashlib
+import datetime
+from newspaper import Article
+from duckduckgo_search import DDGS
+from transformers import pipeline
+import logging
+
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -32,58 +39,86 @@ class BasicAgent:
 
 class SmartResearchAgent:
     def __init__(self):
-        print("SmartResearchAgent initialized.")
+        logging.info("Initializing SmartResearchAgent")
+        self.summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
 
     def search_web(self, query: str) -> str:
-        results_text = ""
-        with DDGS() as ddgs:
-            results = ddgs.text(query, max_results=3)
-            for i, r in enumerate(results):
-                results_text += f"{i+1}. {r['title']}: {r['href']}\n"
-        return results_text or "No results found."
-
-    def summarize(self, input_text: str) -> str:
-        if input_text.startswith("http"):
-            try:
-                article = Article(input_text)
+        try:
+            with DDGS() as ddgs:
+                results = ddgs.text(query, max_results=3)
+                top = [f"{i+1}. {r['title']}: {r['href']}" for i, r in enumerate(results)]
+                return "\n".join(top) if top else "No results found."
+        except Exception as e:
+            logging.error(f"Search error: {e}")
+            return "Error during web search."
+
+    def summarize(self, input_text_or_url: str) -> str:
+        try:
+            if input_text_or_url.startswith("http"):
+                article = Article(input_text_or_url)
                 article.download()
                 article.parse()
-                input_text = article.text
-            except Exception as e:
-                return f"Error processing article: {e}"
-        summary = summarizer(input_text, max_length=130, min_length=30, do_sample=False)
-        return summary[0]['summary_text']
+                input_text_or_url = article.text
+            if not input_text_or_url.strip():
+                return "No content to summarize."
+            summary = self.summarizer(input_text_or_url, max_length=160, min_length=40, do_sample=False)
+            return summary[0]['summary_text'].strip()
+        except Exception as e:
+            logging.error(f"Summarization error: {e}")
+            return "Error during summarization."
 
-    def generate_citation(self, source: str) -> str:
-        citation_id = hashlib.md5(source.encode()).hexdigest()[:6]
-        year = datetime.datetime.now().year
-        return f"@article{{cite{citation_id}, title={{\"Research Article\"}}, author={{Unknown}}, journal={{Online Source}}, year={{ {year} }}, url={{ {source} }} }}"
+    def generate_citation(self, url: str) -> str:
+        try:
+            citation_id = hashlib.md5(url.encode()).hexdigest()[:6]
+            year = datetime.datetime.now().year
+            citation = (
+                f"@article{{cite{citation_id},\n"
+                f"  title={{Generated Reference}},\n"
+                f"  author={{Unknown}},\n"
+                f"  journal={{Online}},\n"
+                f"  year={{ {year} }},\n"
+                f"  url={{ {url} }}\n"
+                f"}}"
+            )
+            return citation
+        except Exception as e:
+            logging.error(f"Citation error: {e}")
+            return "Error during citation generation."
 
     def __call__(self, question: str) -> str:
-        print(f"Received question: {question}")
-
-        if "summarize" in question.lower():
-            return self.summarize(question.replace("summarize", "", 1).strip())
-
-        elif "cite" in question.lower() or "citation" in question.lower():
-            return self.generate_citation(question.split()[-1])
-
-        elif "search" in question.lower():
-            return self.search_web(question.replace("search", "", 1).strip())
+        logging.info(f"Received question: {question}")
+        q_lower = question.lower().strip()
 
-        else:
-            # Default: web search + summarization
-            web_result = self.search_web(question)
-            if "http" in web_result:
-                first_url = next((line.split(": ", 1)[-1] for line in web_result.splitlines() if line.startswith("1.")), None)
+        try:
+            if q_lower.startswith("search:"):
+                query = question.split(":", 1)[1].strip()
+                result = self.search_web(query)
+            elif q_lower.startswith("summarize:"):
+                target = question.split(":", 1)[1].strip()
+                result = self.summarize(target)
+            elif q_lower.startswith("generate citation:") or q_lower.startswith("cite:"):
+                url = question.split(":", 1)[1].strip()
+                result = self.generate_citation(url)
+            else:
+                # Default: search + summarize first link
+                search_result = self.search_web(question)
+                logging.debug(f"Search result:\n{search_result}")
+                first_url = next((line.split(": ", 1)[-1] for line in search_result.splitlines() if "http" in line), None)
                 if first_url:
                     summary = self.summarize(first_url)
-                    citation = self.generate_citation(first_url)
-                    return f"Summary:\n{summary}\n\nCitation:\n{citation}"
-            return web_result
+                    result = f"{summary}\n\nSource: {first_url}"
+                else:
+                    result = "Sorry, I couldn't find relevant information."
+
+            logging.info(f"Agent answer: {result}")
+            return result
 
+        except Exception as e:
+            logging.exception("Unhandled error in agent call")
+            return f"Agent error: {e}"
             
 
+
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,