Outcome Classification Errors

class OutcomeClassifier:
    """Classify call outcomes with validation"""
    
    OUTCOME_REQUIREMENTS = {
        "qualified": {
            "required_fields": ["permission_to_send_playbook", 
                               "whatsapp_number"],
            "field_values": {
                "permission_to_send_playbook": ["yes"],
                "whatsapp_number": lambda x: x and x != ""
            }
        },
        "callback": {
            "required_fields": ["callback_time"],
            "field_values": {
                "callback_time": lambda x: x and x != ""
            }
        },
        "not_interested": {
            "required_fields": [],
            "must_not_have": ["do_not_contact"]  # DNC is different
        },
        "do_not_contact": {
            "required_fields": ["do_not_contact"],
            "field_values": {
                "do_not_contact": ["Y", "yes", True]
            }
        }
    }
    
    def validate_outcome(self, proposed_outcome: str, 
                         captured_data: dict) -> dict:
        """Validate proposed outcome against captured data"""
        requirements = self.OUTCOME_REQUIREMENTS.get(proposed_outcome)
        if not requirements:
            return {"valid": False, "error": "Unknown outcome"}
        
        issues = []
        
        # Check required fields
        for field in requirements.get("required_fields", []):
            if field not in captured_data or not captured_data[field]:
                issues.append({
                    "type": "missing_required",
                    "field": field,
                    "message": f"'{proposed_outcome}' requires '{field}'"
                })
        
        # Check field values
        for field, validator in requirements.get("field_values", {}).items():
            value = captured_data.get(field)
            if callable(validator):
                if not validator(value):
                    issues.append({
                        "type": "invalid_value",
                        "field": field,
                        "value": value
                    })
            elif value not in validator:
                issues.append({
                    "type": "invalid_value",
                    "field": field,
                    "value": value,
                    "expected": validator
                })
        
        return {
            "valid": len(issues) == 0,
            "issues": issues,
            "proposed": proposed_outcome
        }
    
    def derive_outcome(self, captured_data: dict) -> str:
        """Derive outcome from captured data"""
        # Check in priority order
        
        # DNC takes priority
        if captured_data.get("do_not_contact") in ["Y", "yes", True]:
            return "do_not_contact"
        
        # Check for qualification
        has_permission = captured_data.get(
            "permission_to_send_playbook") == "yes"
        has_number = bool(captured_data.get("whatsapp_number"))
        
        if has_permission and has_number:
            return "qualified"
        
        # Check for callback
        if captured_data.get("callback_time"):
            return "callback"
        
        # Check for interest without completion
        interest = captured_data.get("interest_expressed")
        if interest and not has_permission:
            return "interested_incomplete"
        
        # Default to not interested
        return "not_interested"
    
    def check_consistency(self, outcome: str, 
                          captured_data: dict) -> list:
        """Check for data-outcome contradictions"""
        contradictions = []
        
        # Qualified but missing permission
        if outcome == "qualified":
            if captured_data.get("permission_to_send_playbook") != "yes":
                contradictions.append(
                    "Qualified but permission not 'yes'"
                )
        
        # Not interested but has permission
        if outcome == "not_interested":
            if captured_data.get("permission_to_send_playbook") == "yes":
                contradictions.append(
                    "Not interested but permission is 'yes'"
                )
        
        # Callback but no time
        if outcome == "callback":
            if not captured_data.get("callback_time"):
                contradictions.append(
                    "Callback but no callback_time captured"
                )
        
        return contradictions


class PreCloseValidator:
    """Validate before routing to close"""
    
    def __init__(self):
        self.classifier = OutcomeClassifier()
    
    def can_close(self, target_outcome: str, 
                  captured_data: dict) -> dict:
        """Check if we can close with target outcome"""
        validation = self.classifier.validate_outcome(
            target_outcome, captured_data
        )
        
        if not validation["valid"]:
            # Determine what's missing
            missing = [i["field"] for i in validation["issues"]
                      if i["type"] == "missing_required"]
            
            return {
                "can_close": False,
                "missing_fields": missing,
                "suggested_action": f"Capture: {', '.join(missing)}",
                "alternative_outcome": self.get_alternative(
                    target_outcome, captured_data
                )
            }
        
        # Check consistency
        contradictions = self.classifier.check_consistency(
            target_outcome, captured_data
        )
        
        if contradictions:
            return {
                "can_close": False,
                "contradictions": contradictions,
                "suggested_outcome": self.classifier.derive_outcome(
                    captured_data
                )
            }
        
        return {"can_close": True, "outcome": target_outcome}

instructions: |
  ## OUTCOME CLASSIFICATION RULES
  
  QUALIFIED requires ALL of:
  - Interest expressed (yes or open)
  - WhatsApp permission: "yes"
  - WhatsApp number: confirmed (same or different)
  
  CALLBACK requires:
  - Caller said busy/call later
  - Callback time captured (evening/weekend/specific)
  
  NOT INTERESTED:
  - Caller declined the offer
  - Did NOT request no-contact
  
  DO NOT CONTACT:
  - Caller explicitly said "don't call", "remove me", 
    "no WhatsApp", "don't contact"
  
  BEFORE routing to close, check:
  1. Do I have all required fields for this outcome?
  2. Does my data match the outcome I'm routing to?
  3. If "Qualified"—do I have permission AND number?
  4. If "Callback"—do I have the callback time?
  
  COMMON ERRORS to avoid:
  - "Qualified" without WhatsApp permission
  - "Not Interested" when caller just said "busy"
  - "Callback" without capturing when
  - "DNC" for simple "no thanks"