Update app.py

app.py

@@ -256,12 +256,14 @@ def perform_duckduckgo_search(query: str, max_results: int = 5): # Reduced max_r
 # Define the new semantic date/time detection and calculation function using dateparser
 def perform_date_calculation(query: str) -> str or None:
     """
-    Analyzes query for date/time information using dateparser.
-    If dateparser finds a date, it returns a human-friendly response string.
-    Otherwise, it returns None.
-    It is designed to handle multiple languages and provide the time for East Africa (Tanzania).
+    Analyzes query for explicit date/time calculation requests and performs the calculation.
+    Returns a human-friendly response string if a calculation is clearly requested,
+    otherwise returns None to indicate the LLM should handle the query.
+    Uses dateparser.search_dates but is more selective about returning a result.
+    It is also designed to handle multiple languages and provide the time for East Africa (Tanzania).
     """
     print(f"Executing Tool: perform_date_calculation with query='{query}') using dateparser.search_dates")
+    query_lower = query.lower()
 
     try:
         eafrica_tz = pytz.timezone('Africa/Dar_es_Salaam')
@@ -270,35 +272,68 @@ def perform_date_calculation(query: str) -> str or None:
         print("Error: Unknown timezone 'Africa/Dar_es_Salaam'. Using default system time.")
         now = datetime.now()
 
+    calculation_phrases = [
+        r"\b(what is|what'?s|tell me|do you know|can you tell me)?\s*the\s*date\s+(of|for)?\s*(today|today'?s)?\b", # "what is today's date" (English)
+        r'\b(\d+)\s+(days?|weeks?|months?|years?)\s+(ago|from now)\b', # "3 days ago", "2 weeks from now" (English)
+        r'\bwhat day is it\b', # "what day is it" (English)
+        r'\bwhat is the time\b', # "what is the time" (English)
+        r'\bwhen is\s+', # "when is..." (English)
+        r'\bon\s+what\s+date\s+did\s+', # "on what date did..." (English)
+        r'\btarehe\s+ya\s+leo\b', # "date of today" (Swahili)
+        r'\bsaa\s+ngapi\b', # "what time" (Swahili)
+        r'\bmuda\s+gani\b', # "what time" (Swahili)
+        r'\btarehe\s+gani\b', # "what date" (Swahili)
+        r'\bni\s+saa\s+ngapi\b', # "it is what time" (Swahili)
+        r'\bni\s+tarehe\s+gani\b', # "it is what date" (Swahili)
+        r'\btarehe\s+ya\s+kesho\b', # "date of tomorrow" (Swahili)
+        r'\btarehe\s+ya\s+jana\b', # "date of yesterday" (Swahili)
+        r'\bsiku\s+ya\s+leo\b', # "day of today" (Swahili)
+        r'\bsiku\s+gani\b', # "what day" (Swahili)
+        r'\bmwezi\s+gani\b', # "what month" (Swahili)
+        r'\b(mwaka|mwaka\s+gani)\b', # "year" or "what year" (Swahili)
+        r'\bsaa\s+za\s+sasa\b', # "current time" (Swahili)
+        r'\btarehe\s+ngapi\s+leo\b', # "date how much today" (Swahili - common phrasing)
+        r'\bni\s+tarehe\s+ngapi\s+leo\b', # "it is date how much today" (Swahili - common phrasing)
+        r'\bsiku\s+ngapi\s+leo\b', # "day how much today" (Swahili - common phrasing)
+        r'\bni\s+siku\s+ngapi\s+leo\b', # "it is day how much today" (Swahili - common phrasing)
+        r'\b(leo|leo\s+hii)\b.*?\b(tarehe|siku|saa|muda)\b', # "today" followed by date/day/time (Swahili)
+    ]
+
+    is_calculation_query = False
+    for phrase in calculation_phrases:
+        if re.search(phrase, query_lower):
+            is_calculation_query = True
+            break
+
+    if not is_calculation_query:
+        print("Query does not contain explicit date/time calculation phrases. Returning None.")
+        return None
+
     try:
-        # Try parsing with Swahili first, then English
         found = search_dates(
             query,
             settings={
                 "PREFER_DATES_FROM": "future",
                 "RELATIVE_BASE": now
             },
-            languages=['sw', 'en'] # Prioritize Swahili
+            languages=['en', 'sw']
         )
 
         if not found:
-            print("dateparser.search_dates could not parse any date/time.")
-            return None
+            print("Explicit date/time phrase found, but dateparser.search_dates could not parse it.")
+            return "Sorry, I couldn’t understand that date/time. Could you rephrase?"
 
         text_snippet, parsed = found[0]
         print(f"dateparser.search_dates found: text='{text_snippet}', parsed='{parsed}'")
 
-        is_swahili = any(swahili_phrase in query.lower() for swahili_phrase in ['tarehe', 'siku', 'saa', 'muda', 'leo', 'kesho', 'jana', 'ngapi', 'gani', 'mwezi', 'mwaka'])
+        is_swahili = any(swahili_phrase in query_lower for swahili_phrase in ['tarehe', 'siku', 'saa', 'muda', 'leo', 'kesho', 'jana', 'ngapi', 'gani', 'mwezi', 'mwaka'])
 
-        # Handle timezone information
         if now.tzinfo is not None and parsed.tzinfo is None:
             parsed = now.tzinfo.localize(parsed)
         elif now.tzinfo is None and parsed.tzinfo is not None:
              parsed = parsed.replace(tzinfo=None)
 
-        # Check if the parsed date is today and time is close to now or midnight
         if parsed.date() == now.date():
-             # Consider it "now" if within a small time window or if no specific time was parsed (midnight)
              if abs((parsed - now).total_seconds()) < 60 or parsed.time() == datetime.min.time():
                  print("Query parsed to today's date and time is close to 'now' or midnight, returning current time/date.")
                  if is_swahili:
@@ -336,43 +371,15 @@ def perform_date_calculation(query: str) -> str or None:
 def determine_tool_usage(query: str) -> str:
     """
     Analyzes the query to determine if a specific tool is needed.
-    Returns the name of the tool ('duckduckgo_search', 'business_info_retrieval',
-    'date_calculation') or 'none' if no specific tool is clearly indicated.
-    Prioritizes specific tools based on keywords and LLM judgment, then business info.
+    Returns the name of the tool ('duckduckgo_search', 'business_info_retrieval')
+    or 'none' if no specific tool is clearly indicated or if it's a date/time query
+    (as date/time is handled by semantic detection first).
     """
     query_lower = query.lower()
 
-    # 1. Check for Date Calculation first, as it's a specific function call
-    date_time_check_result = perform_date_calculation(query)
-    if date_time_check_result is not None:
-        print(f"Detected as date/time calculation query based on dateparser result for: '{query}'")
-        return "date_calculation"
-
-    # 2. Use LLM to determine if DuckDuckGo search is needed
-    messages_tool_determination_search = [{"role": "user", "content": f"Does the following query require searching the web for current or general knowledge information (e.g., news, facts, definitions, current events)? Respond ONLY with 'duckduckgo_search' or 'none'. Query: {query}"}]
-    try:
-        search_determination_response = client.chat_completion(
-            messages=messages_tool_determination_search,
-            max_tokens=20,
-            temperature=0.1,
-            top_p=0.9
-        ).choices[0].message.content or ""
-        response_lower = search_determination_response.strip().lower()
-
-        if "duckduckgo_search" in response_lower:
-            print(f"Model-determined tool for '{query}': 'duckduckgo_search'")
-            return "duckduckgo_search"
-        else:
-            print(f"Model-determined tool for '{query}': 'none' (for search)")
-
-    except Exception as e:
-        print(f"Error during LLM call for search tool determination for query '{query}': {e}")
-        print(traceback.format_exc())
-        print(f"Proceeding without search tool check for query '{query}' due to error.")
-
-
-    # 3. If neither date calculation nor DuckDuckGo search, check for Business Info Retrieval if RAG is available
+    # 1. Prioritize Business Info Retrieval if RAG is available
     if business_info_available:
+         # Use a more direct prompt to encourage "yes" for relevant queries
          messages_business_check = [{"role": "user", "content": f"Does the following query ask about a specific person, service, offering, or description that would likely be found in a business's knowledge base? Answer only 'yes' or 'no'. Query: {query}"}]
          try:
              business_check_response = client.chat_completion(
@@ -380,8 +387,7 @@ def determine_tool_usage(query: str) -> str:
                  max_tokens=10,
                  temperature=0.1
              ).choices[0].message.content.strip().lower()
-             # Ensure the response explicitly contains "yes" and is not just a substring match
-             if business_check_response == "yes":
+             if "yes" in business_check_response:
                  print(f"Detected as business info query based on LLM check: '{query}'")
                  return "business_info_retrieval"
              else:
@@ -391,9 +397,40 @@ def determine_tool_usage(query: str) -> str:
              print(traceback.format_exc())
              print(f"Proceeding without business info check for query '{query}' due to error.")
 
-    # 4. If none of the specific tools are determined, default to 'none'
-    print(f"No specific tool determined for '{query}'. Defaulting to 'none'.")
-    return "none"
+    # 2. If not a business info query, check for date calculation
+    date_time_check_result = perform_date_calculation(query)
+    if date_time_check_result is not None and "Sorry, I couldn’t understand" not in date_time_check_result:
+        print(f"Detected as date/time calculation query: '{query}'")
+        return "date_calculation"
+
+    # 3. If neither business info nor date calculation, use LLM for other tool determination (DuckDuckGo or none)
+    messages_tool_determination = [{"role": "user", "content": f"Determine the most suitable tool for the following query from the options: 'duckduckgo_search', or 'none'. Respond ONLY with the tool name. Query: {query}"}]
+    try:
+        initial_response = client.chat_completion(
+            messages=messages_tool_determination,
+            max_tokens=20,
+            temperature=0.1,
+            top_p=0.9
+        ).choices[0].message.content or ""
+        response_lower = initial_response.strip().lower()
+
+        if "duckduckgo_search" in response_lower:
+            determined_tool = "duckduckgo_search"
+        elif "none" in response_lower:
+             # Allow the LLM to answer simple questions like "who are you" internally
+             # without a tool if it determines 'none'.
+             determined_tool = "none"
+        else:
+            print(f"Warning: LLM returned unexpected tool determination '{initial_response.strip()}'. Defaulting to 'none'.")
+            determined_tool = "none"
+        print(f"Model-determined tool: {determined_tool}")
+        return determined_tool
+
+    except Exception as e:
+        print(f"Error during LLM call for tool determination for query '{query}': {e}")
+        print(traceback.format_exc())
+        print(f"Defaulting to 'none' tool due to error for query '{query}'.")
+        return "none"
 
 
 # Function to generate text using the LLM, incorporating tool results if available
@@ -432,8 +469,7 @@ def generate_text(prompt: str, tool_results: dict = None) -> str:
                 else:
                      full_prompt_builder.append(f"{results}\n\n") # Handle single string results (like date calculation)
 
-        full_prompt_builder.append("Based on the provided tool results, answer the user's original query. If a question was answered by a tool, use the tool's result directly in your response.")
-        print("Added tool results and instruction to final prompt.")
+        print("Added tool results to final prompt.")
     else:
         print("No tool results to add to final prompt.")
 
@@ -590,6 +626,5 @@ if __name__ == "__main__":
         iface.launch(debug=True)
     except Exception as e:
         print(f"Error launching Gradio interface: {e}")
-        print(traceback. format_exc())
-        print("Please check the console output for more details on the error.")
-
+        print(traceback. обзоr)
+        print("Please check the console output for more details on the error.")