Why is everything being falsified!!!

controllers/log_controller.py

@@ -176,77 +176,103 @@ def process_log_sync(log_id):
 
 def classify_activity(activity, workflow_info):
     """
-    Classify an activity against available workflows
-    Returns workflow_id if matched, None otherwise
+    Classify an activity against available workflows using an LLM.
+    Returns workflow_id if matched, None otherwise.
+    Includes enhanced logging and asks for justification from the LLM.
     """
     try:
-        # Check if OpenAI API key is set
         api_key = os.environ.get('OPENAI_API_KEY')
         if not api_key:
-            logger.error("OPENAI_API_KEY environment variable is not set")
+            logger.error("OPENAI_API_KEY not found for classify_activity.")
             return None
             
-        # Create OpenAI client with correct parameters for the current version
         client = openai.OpenAI(api_key=api_key)
             
-        # Prepare prompt for OpenAI
         workflows_text = "\n".join([
-            f"Workflow {i+1}: {w['title']} - {w['description']}"
-            for i, w in enumerate(workflow_info)
+            f"Workflow ID: {w['id']} | Title: {w['title']} | Description: {w['description']}"
+            for w in workflow_info
         ])
         
         prompt = f"""
-        I need to classify a law enforcement activity into one of our defined workflows, 
-        or determine if it's a routine/mundane activity that doesn't match any workflow.
-        
-        Here are the available workflows:
+        Analyze the following law enforcement activity and decide if it matches one of the provided workflows or if it is a mundane activity.
+
+        Available Workflows:
         {workflows_text}
-        
-        Here is the activity:
-        Activity: {activity['activity']}
-        Full Text: {activity['text']}
+
+        Activity Details:
+        Activity Description: {activity.get('activity', 'N/A')}
+        Full Text: {activity.get('text', 'N/A')}
         Time: {activity.get('time', 'Not specified')}
         Location: {activity.get('location', 'Not specified')}
-        
-        Please classify this activity into one of the workflows, or indicate it's mundane.
-        Respond with just the workflow ID if it matches, or "mundane" if it doesn't match any workflow.
+
+        Your Task:
+        1. Determine if the activity clearly matches one of the workflow descriptions.
+        2. If it matches, provide the corresponding Workflow ID.
+        3. If it does not match any workflow, classify it as "mundane".
+        4. Provide a brief justification for your decision (1-2 sentences).
+
+        Output Format:
+        Return a JSON object with two keys: "decision" and "justification".
+        - "decision": Should be the matching Workflow ID (string) or the string "mundane".
+        - "justification": Should be a brief string explaining your reasoning.
+
+        Example Match Response:
+        {{"decision": "60d21b4967d0d8992e610c87", "justification": "The activity describes a traffic stop, which matches the Traffic Violation workflow."}}
+
+        Example Mundane Response:
+        {{"decision": "mundane", "justification": "The activity describes routine patrol or administrative tasks not covered by any workflow."}}
         """
         
-        # Call OpenAI API
+        # Log the prompt being sent (use debug level for potentially sensitive info)
+        logger.debug(f"Sending classification prompt to OpenAI: \n{prompt}")
+        
         response = client.chat.completions.create(
             model="gpt-4o-mini",
             messages=[
-                {"role": "system", "content": "You are a law enforcement activity classifier that matches activities to defined workflows."},
+                {"role": "system", "content": "You are an AI assistant helping classify law enforcement activities into predefined workflows. Respond ONLY in the requested JSON format."},
                 {"role": "user", "content": prompt}
-            ]
+            ],
+            response_format={"type": "json_object"} # Ensure JSON output
         )
         
-        # Get classification result
-        result = response.choices[0].message.content.strip()
-        
-        # Check if result is a workflow ID or "mundane"
-        if result == "mundane":
-            return None
-            
-        # Find the workflow by ID or index
-        for workflow in workflow_info:
-            if workflow['id'] in result:
-                return workflow['id']
-            if workflow['title'] in result:
-                return workflow['id']
-        
-        # If we got a number, try to use it as an index
+        # Parse the JSON response
         try:
-            index = int(result) - 1
-            if 0 <= index < len(workflow_info):
-                return workflow_info[index]['id']
-        except ValueError:
-            pass
+            content = response.choices[0].message.content
+            logger.debug(f"Received OpenAI classification response content: {content}")
+            result_json = json.loads(content)
+            decision = result_json.get("decision")
+            justification = result_json.get("justification", "No justification provided.")
+            
+            logger.info(f"LLM Classification - Decision: {decision}, Justification: {justification}")
+
+            if decision == "mundane":
+                return None
+            
+            # Check if the decision is a valid ObjectId and matches a known workflow ID
+            valid_workflow_ids = {w['id'] for w in workflow_info}
+            if decision in valid_workflow_ids:
+                 try:
+                    # Validate it's a proper ObjectId format, though it's already a string match
+                    ObjectId(decision)
+                    return decision # Return the matched workflow ID string
+                 except Exception:
+                    logger.warning(f"LLM returned a decision '{decision}' matching a workflow ID, but it's not a valid ObjectId format. Treating as unclassified.")
+                    return None
+            else:
+                logger.warning(f"LLM returned a decision '{decision}' which is not 'mundane' and does not match any known workflow ID. Treating as unclassified.")
+                return None
+
+        except json.JSONDecodeError:
+            logger.error(f"Failed to decode JSON response from OpenAI: {content}")
+            return None
+        except Exception as parse_err:
+            logger.error(f"Error parsing OpenAI classification response: {parse_err}")
+            return None
             
-        return None
-        
     except Exception as e:
-        logger.error(f"Error classifying activity: {str(e)}")
+        logger.error(f"Error in classify_activity function: {str(e)}")
+        import traceback
+        logger.error(traceback.format_exc())
         return None
 
 def get_log(current_user, log_id):