Fix some issues before sendng the request

main.py

@@ -599,10 +599,59 @@ class HealthcareChatbot:
                     }
                 
                 time.sleep(self.retry_delay)
+    def parse_relative_date(self, text, detected_language):
+        """
+        Parse relative dates from text using a combination of methods
+        """
+        today = datetime.now()
+        
+        # Handle common relative date patterns in English and Arabic
+        tomorrow_patterns = {
+            'english': [r'\btomorrow\b', r'\bnext day\b'],
+            'arabic': [r'\bغدا\b', r'\bبكرة\b', r'\bغدًا\b', r'\bالغد\b']
+        }
+        
+        next_week_patterns = {
+            'english': [r'\bnext week\b'],
+            'arabic': [r'\bالأسبوع القادم\b', r'\bالأسبوع المقبل\b', r'\bالاسبوع الجاي\b']
+        }
+        
+        # Check for "tomorrow" patterns
+        for pattern in tomorrow_patterns.get(detected_language, []) + tomorrow_patterns.get('english', []):
+            if re.search(pattern, text, re.IGNORECASE):
+                return (today + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')
+        
+        # Check for "next week" patterns
+        for pattern in next_week_patterns.get(detected_language, []) + next_week_patterns.get('english', []):
+            if re.search(pattern, text, re.IGNORECASE):
+                return (today + timedelta(days=7)).strftime('%Y-%m-%dT%H:%M:%S')
+        
+        # If NER model is available, use it to extract date entities
+        if self.date_parser and detected_language == 'english':
+            try:
+                date_entities = self.date_parser(text)
+                for entity in date_entities:
+                    if entity['entity_group'] == 'DATE':
+                        # Here you would need more complex date parsing logic
+                        # This is just a placeholder
+                        print(f"Found date entity: {entity['word']}")
+                        # For now, just default to tomorrow if we detect any date
+                        return (today + timedelta(days=1)).strftime('%Y-%m-%dT%H:%M:%S')
+            except Exception as e:
+                print(f"Error in date parsing: {e}")
+        
+        # Default return None if no date pattern is recognized
+        return None
+
 
     def handle_api_action(self, user_query, detected_language, sentiment_result, keywords):
         """Handle API-based actions"""
         try:
+            
+            parsed_date = self.parse_relative_date(user_query, detected_language)
+            if parsed_date:
+                print(f"Parsed relative date: {parsed_date}")
+            
             # Route the query to determine API endpoint
             router_result = self.router_chain.invoke({
                 "endpoints_documentation": json.dumps(self.endpoints_documentation, indent=2),
@@ -615,20 +664,72 @@ class HealthcareChatbot:
             
             # Parse router response
             route_text = router_result["text"]
-            cleaned_response = re.sub(r'//.*?$', '', route_text, flags=re.MULTILINE)
+            # cleaned_response = re.sub(r'//.*?$', '', route_text, flags=re.MULTILINE)
+            # cleaned_response = re.sub(r'/\*.*?\*/', '', cleaned_response, flags=re.DOTALL)
+            # cleaned_response = re.sub(r',(\s*[}\]])', r'\1', cleaned_response)
+            
+            # try:
+            #     parsed_route = json.loads(cleaned_response)
+            # except json.JSONDecodeError:
+            #     json_match = re.search(r'\{.*?\}', cleaned_response, re.DOTALL)
+            #     if json_match:
+            #         parsed_route = json.loads(json_match.group(0))
+            #     else:
+            #         raise ValueError("Could not parse routing response")
+            
+            # print(f"🔍 Parsed route: {parsed_route}")
+            cleaned_response = route_text
+            
+            # Remove any comments (both single-line and multi-line)
+            cleaned_response = re.sub(r'//.*?$', '', cleaned_response, flags=re.MULTILINE)
             cleaned_response = re.sub(r'/\*.*?\*/', '', cleaned_response, flags=re.DOTALL)
+            
+            # Remove any trailing commas
             cleaned_response = re.sub(r',(\s*[}\]])', r'\1', cleaned_response)
             
+            # Try different methods to parse the JSON response
             try:
+                # First attempt: direct JSON parsing of cleaned response
                 parsed_route = json.loads(cleaned_response)
             except json.JSONDecodeError:
-                json_match = re.search(r'\{.*?\}', cleaned_response, re.DOTALL)
-                if json_match:
-                    parsed_route = json.loads(json_match.group(0))
-                else:
-                    raise ValueError("Could not parse routing response")
+                try:
+                    # Second attempt: extract JSON from markdown code block
+                    json_match = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', cleaned_response, re.DOTALL)
+                    if json_match:
+                        parsed_route = json.loads(json_match.group(1))
+                except (json.JSONDecodeError, AttributeError):
+                    try:
+                        # Third attempt: find JSON-like content using regex
+                        json_pattern = r'\{\s*"endpoint"\s*:.*?\}'
+                        json_match = re.search(json_pattern, cleaned_response, re.DOTALL)
+                        if json_match:
+                            json_str = json_match.group(0)
+                            # Additional cleaning for the extracted JSON
+                            json_str = re.sub(r'//.*?$', '', json_str, flags=re.MULTILINE)
+                            json_str = re.sub(r',(\s*[}\]])', r'\1', json_str)
+                            parsed_route = json.loads(json_str)
+                    except (json.JSONDecodeError, AttributeError):
+                        print(f"Failed to parse JSON. Raw response: {route_text}")
+                        print(f"Cleaned response: {cleaned_response}")
+                        raise ValueError("Could not extract valid JSON from LLM response")
+            
+            if not parsed_route:
+                raise ValueError("Failed to parse LLM response into valid JSON")
+            
+            # Replace any placeholder values and inject parsed dates if available
+            if 'params' in parsed_route:
+                if 'patient_id' in parsed_route['params']:
+                    parsed_route['params']['patient_id'] = self.user_id
+                
+                # Inject parsed date if available and a date parameter exists
+                date_params = ['appointment_date', 'date', 'schedule_date', 'date_time', 'new_date_time']
+                if parsed_date:
+                    for param in date_params:
+                        if param in parsed_route['params']:
+                            parsed_route['params'][param] = parsed_date
+            
+            print('Parsed route: ', parsed_route)
             
-            print(f"🔍 Parsed route: {parsed_route}")
             # Make backend API call
             api_response = self.backend_call(parsed_route)