Update app.py

app.py

@@ -44,9 +44,10 @@ class Config(object):
         self.temperature = 0.1
         self.DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
         self.model_name = "mistralai/Mistral-7B-Instruct-v0.2"
+        # self.model_name = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"
         # self.reasoning_model_name = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"
         # self.reasoning_model_name = "Qwen/Qwen2.5-7B-Instruct"
-        self.reasoning_model_name = "mistralai/Mistral-7B-Instruct-v0.2"
+        # self.reasoning_model_name = "mistralai/Mistral-7B-Instruct-v0.2"
 
 
 config = Config()
@@ -193,6 +194,149 @@ def visit_webpage(url: str) -> str:
     return (text[:1000], )
 
 
+def visit_webpage(url: str) -> str:
+    headers = {
+        "User-Agent": "Mozilla/5.0"
+    }
+
+    response = requests.get(url, headers=headers, timeout=10)
+    response.raise_for_status()
+
+    soup = BeautifulSoup(response.text, "html.parser")
+
+    # Remove scripts/styles
+    for tag in soup(["script", "style"]):
+        tag.extract()
+
+    content = soup.find("div", {"id": "mw-content-text"})
+
+    texts = []
+
+    # 1. Paragraphs
+    for p in content.find_all("p"):
+        texts.append(p.get_text(strip=False))
+
+    # 2. Definition lists
+    for dd in content.find_all("dd"):
+        texts.append(dd.get_text(strip=False))
+
+    # 3. Tables (IMPORTANT)
+    for table in content.find_all("table", {"class": "wikitable"}):
+        for row in table.find_all("tr"):
+            cols = [c.get_text(strip=True) for c in row.find_all(["td", "th"])]
+            if cols:
+                texts.append(" | ".join(cols))
+
+    return (" \n ".join(texts)[:1000], )
+
+
+def visit_webpage(url: str) -> str:
+    headers = {
+        "User-Agent": "Mozilla/5.0"
+    }
+
+    response = requests.get(url, headers=headers, timeout=10)
+    response.raise_for_status()
+
+    soup = BeautifulSoup(response.text, "html.parser")
+
+    # Remove scripts/styles
+    for tag in soup(["script", "style"]):
+        tag.extract()
+
+    content = soup.find("div", {"id": "mw-content-text"})
+
+    # Extract more elements (not just <p>)
+    elements = soup.find_all(["p", "dd"])
+
+    main_text = " \n ".join(el.get_text(strip=False) for el in elements)
+
+    # 3. Tables (IMPORTANT)
+    table_texts = []
+    for table in content.find_all("table", {"class": "wikitable"}):
+        for row in table.find_all("tr"):
+            cols = [c.get_text(strip=True) for c in row.find_all(["td", "th"])]
+            if cols:
+                table_texts.append(" | ".join(cols))
+
+    if len(table_texts) > 0:
+        return [main_text[:1000], " \n ".join(table_texts),]
+    else:
+        return [main_text[:1000],]
+
+
+def visit_webpage(url: str) -> str:
+    headers = {
+        "User-Agent": "Mozilla/5.0"
+    }
+
+    response = requests.get(url, headers=headers, timeout=10)
+    response.raise_for_status()
+
+    soup = BeautifulSoup(response.text, "html.parser")
+
+    # Remove scripts/styles
+    for tag in soup(["script", "style"]):
+        tag.extract()
+
+    content = soup.find("div", {"id": "mw-content-text"})
+
+    # Extract more elements (not just <p>)
+    elements = soup.find_all(["p", "dd"])
+
+    main_text = " \n ".join(el.get_text(strip=False) for el in elements)
+
+    # 3. Tables (IMPORTANT)
+    table_texts = []
+    if content is not None:
+        for table in content.find_all("table", {"class": "wikitable"}):
+            for row in table.find_all("tr"):
+                cols = [c.get_text(strip=True) for c in row.find_all(["td", "th"])]
+                if cols:
+                    table_texts.append(" | ".join(cols))
+
+    if len(table_texts) > 0:
+        return [main_text[:1000], " \n ".join(table_texts),]
+    else:
+        return [main_text[:1000],]
+
+
+def visit_webpage(url: str) -> str:
+    headers = {
+        "User-Agent": "Mozilla/5.0"
+    }
+
+    response = requests.get(url, headers=headers, timeout=10)
+    response.raise_for_status()
+
+    soup = BeautifulSoup(response.text, "html.parser")
+
+    # Remove scripts/styles
+    for tag in soup(["script", "style"]):
+        tag.extract()
+
+    content = soup.find("div", {"id": "mw-content-text"})
+
+    # Extract more elements (not just <p>)
+    elements = soup.find_all(["p", "dd"])
+
+    main_text = " \n ".join(el.get_text(strip=False) for el in elements)
+
+    # 3. Tables (IMPORTANT)
+    table_texts = []
+    if content is not None:
+        for table in content.find_all("table", {"class": "wikitable"}):
+            for row in table.find_all("tr"):
+                cols = [c.get_text(strip=True) for c in row.find_all(["td", "th"])]
+                if cols:
+                    table_texts.append(" | ".join(cols))
+
+    if len(table_texts) > 0:
+        return [main_text[:1000], " \n ".join(table_texts)[:5000],]
+    else:
+        return [main_text[:1000],]
+
+
 def web_search(query: str, num_results: int = 10):
     """
     Search the internet for the query provided
@@ -212,6 +356,107 @@ def web_search(query: str, num_results: int = 10):
     soup = BeautifulSoup(response.text, "html.parser")
     return [a.get("href") for a in soup.select(".result__a")[:num_results]]
 
+
+def planner_node(state: AgentState):
+    """
+    Planning node for a tool-using LLM agent.
+
+    The planner enforces:
+    - Strict JSON-only output
+    - Tool selection constrained to predefined tools
+    - Argument generation limited to user-provided information
+
+    Parameters
+    ----------
+    state : dict
+        Agent state dictionary containing:
+        - "messages" (str): The user's natural language request.
+
+    Returns
+    -------
+    dict
+        Updated state dictionary with additional keys:
+        - "proposed_action" (dict): Parsed JSON tool call in the form:
+              {
+                  "tool": "<tool_name>",
+                  "args": {...}
+              }
+        - "risk_score" (float): Initialized risk score (default 0.0).
+        - "decision" (str): Initial decision ("allow" by default).
+
+    Behavior
+    --------
+    1. Constructs a planning prompt including:
+       - Available tools and allowed arguments
+       - Strict JSON formatting requirements
+       - Example of valid output
+    2. Calls the language model via `generate()`.
+    3. Attempts to extract valid JSON from the model output.
+    4. Repairs malformed JSON using `repair_json`.
+    5. Stores the parsed action into the agent state.
+
+    Security Notes
+    --------------
+    - This node does not enforce tool-level authorization.
+    - It does not validate hallucinated tools.
+    - It does not perform risk scoring beyond initializing values.
+    - Downstream nodes must implement:
+        * Tool whitelist validation
+        * Argument validation
+        * Risk scoring and mitigation
+        * Execution authorization
+
+    Intended Usage
+    --------------
+    Designed for multi-agent or LangGraph-style workflows where:
+        Planner → Risk Assessment → Tool Executor → Logger
+
+    This node represents the *planning layer* of the agent architecture.
+    """
+
+    user_input = state["messages"][-1].content
+
+    prompt = f"""
+You are a planning agent.
+
+You MUST return ONLY valid JSON as per the tools specs below ONLY.
+No extra text.
+DO NOT invent anything additional beyond the user request provided. Keep it strict to the user request information provided. The question and the query should be fully relevant to the user request provided, no deviation and hallucination. If possible and makes sense then the query should be exactly the user request.
+
+The available tools and their respective arguments are: {{
+    "web_search": ["query"],
+    "visit_webpage": ["url"],
+}}
+
+Return exactly the following format:
+Response:
+{{
+  "tool": "...",
+  "args": {{...}}
+}}
+
+User request: Who nominated the only Featured Article on English Wikipedia about a dinosaur that was promoted in November 2016?. Example of valid JSON expected:
+Response:
+{{"tool": "web_search",
+ "args": {{"query": "Who nominated the only Featured Article on English Wikipedia about a dinosaur that was promoted in November 2016?",
+  }}
+}}
+
+Return only one Response!
+
+User request:
+{user_input}
+"""
+
+    output = generate(prompt)
+
+    state["proposed_action"] = output.split("Response:")[-1]
+    fixed = repair_json(state["proposed_action"])
+    data = json.loads(fixed)
+    state["proposed_action"] = data
+
+    return state
+
 def planner_node(state: AgentState):
     """
     Planning node for a tool-using LLM agent.
@@ -312,6 +557,7 @@ User request:
 
     return state
 
+
 def planner_node(state: AgentState):
     """
     Planning node for a tool-using LLM agent.
@@ -411,6 +657,7 @@ User request:
     state["proposed_action"] = data
 
     return state
+    
 
 def safety_node(state: AgentState):
     """
@@ -423,8 +670,8 @@ def safety_node(state: AgentState):
     prompt = f"""
 You are a response agent.
 
-You must reason over the user request and the provided information and output the answer to the user's request. 
-    
+You must reason over the user request and the provided information and output the answer to the user's request. Reason well over the information provided, if any, and output the answer that satisfies the user's question exactly.
+
 You MUST return EXACTLY one line in the following format:
 Response: <answer>
 
@@ -614,7 +861,7 @@ def tool_executor(state: AgentState):
     responsible for translating structured LLM intent into real system actions.
     """
 
-    web_page_result = ""
+    webpage_result = ""
     action = Action.model_validate(state["proposed_action"])
 
     best_query_webpage_information_similarity_score = -1.0
@@ -639,36 +886,40 @@ def tool_executor(state: AgentState):
 
         for result in results:
             try:
-                web_page_results = visit_webpage(result)
+                webpage_results = visit_webpage(result)
+                webpage_result = " \n ".join(webpage_results)
 
-                for web_page_result in web_page_results:
-                    query_embeddings = sentence_transformer_model.encode_query(state["messages"][-1].content).reshape(1, -1)
-                    webpage_information_embeddings = sentence_transformer_model.encode_query(web_page_result).reshape(1, -1)
-                    query_webpage_information_similarity_score = float(cosine_similarity(query_embeddings, webpage_information_embeddings)[0][0])
-        
-                    # logger.info(f"Webpage Information and Similarity Score: {web_page_result} - {query_webpage_information_similarity_score}")
-        
-                    if query_webpage_information_similarity_score > 0.60:
-                        webpage_information_complete += web_page_result
-                        webpage_information_complete += " \n "
-                        webpage_information_complete += " \n "
-        
-                    if query_webpage_information_similarity_score > best_query_webpage_information_similarity_score:
-                        best_query_webpage_information_similarity_score = query_webpage_information_similarity_score
-                        best_webpage_information = web_page_result
+                # for webpage_result in webpage_results:
+                query_embeddings = sentence_transformer_model.encode_query(state["messages"][-1].content).reshape(1, -1)
+                webpage_information_embeddings = sentence_transformer_model.encode_query(webpage_result).reshape(1, -1)
+                query_webpage_information_similarity_score = float(cosine_similarity(query_embeddings, webpage_information_embeddings)[0][0])
+    
+                # logger.info(f"Webpage Information and Similarity Score: {result} - {webpage_result} - {query_webpage_information_similarity_score}")
+    
+                if query_webpage_information_similarity_score > 0.65:
+                    webpage_information_complete += webpage_result
+                    webpage_information_complete += " \n "
+                    webpage_information_complete += " \n "
+    
+                if query_webpage_information_similarity_score > best_query_webpage_information_similarity_score:
+                    best_query_webpage_information_similarity_score = query_webpage_information_similarity_score
+                    best_webpage_information = webpage_result
 
             except Exception as e:
                 logger.info(f"Tool Executor - Exception: {e}")
                 
     elif action.tool == "visit_webpage":
         try:
-            web_page_result = visit_webpage(**action.args)
+            webpage_result = visit_webpage(**action.args)
         except:
             pass
     else:
         result = "Unknown tool"
 
-    state["information"] = webpage_information_complete
+    if webpage_information_complete == "":
+        webpage_information_complete = best_webpage_information
+    
+    state["information"] = webpage_information_complete[:3000]
     state["best_query_webpage_information_similarity_score"] = best_query_webpage_information_similarity_score
 
     logger.info(f"Information: {state['information']}")
@@ -719,8 +970,8 @@ class BasicAgent:
 
 
         # if question == "Given this table defining * on the set S = {a, b, c, d, e}\n\n|*|a|b|c|d|e|\n|---|---|---|---|---|---|\n|a|a|b|c|b|d|\n|b|b|c|a|e|c|\n|c|c|a|b|b|a|\n|d|b|e|b|e|d|\n|e|d|b|a|d|c|\n\nprovide the subset of S involved in any possible counter-examples that prove * is not commutative. Provide your answer as a comma separated list of the elements in the set in alphabetical order.":
-        if " image " not in question and " video " not in question:
-        # if question == "Who nominated the only Featured Article on English Wikipedia about a dinosaur that was promoted in November 2016?":
+        # if " image " not in question and " video " not in question:
+        if question == "Who nominated the only Featured Article on English Wikipedia about a dinosaur that was promoted in November 2016?":
             state = {
                 "messages": question,
             }