# BAD: Agent receives full user profile for a simple query task
def run_customer_agent_bad(user_id: str, query: str):
    # Fetches entire user record including sensitive fields
    user_profile = db.get_full_profile(user_id)
    # user_profile now in context: SSN, medical history, payment info, etc.
    return agent.run(query=query, context=user_profile)

# GOOD: Agent receives only fields required for the specific task
def run_customer_agent_gdpr(user_id: str, query: str, task_type: str):
    # Determine what fields are needed for this specific task type
    required_fields = get_required_fields_for_task(task_type)
    # {order_status: ["order_id", "status", "estimated_delivery"]}
    # {billing_inquiry: ["account_name", "last_4_digits", "billing_period"]}

    scoped_context = db.get_user_fields(user_id, fields=required_fields[task_type])
    return agent.run(query=query, context=scoped_context)

import json
from dataclasses import dataclass, field
from typing import Any


@dataclass
class ExplainableAgentDecision:
    decision: Any
    reasoning_steps: list[str]
    factors_considered: list[str]
    data_accessed: list[str]
    confidence_level: str
    human_review_available: bool = True

    def generate_explanation(self) -> str:
        """Generate a GDPR-compliant explanation for the automated decision."""
        return (
            f"This decision was made by an automated AI system based on the following factors:\n\n"
            + "\n".join(f"- {factor}" for factor in self.factors_considered)
            + f"\n\nData sources consulted: {', '.join(self.data_accessed)}\n"
            + f"Confidence level: {self.confidence_level}\n\n"
            + "You have the right to request human review of this decision. "
            + "To exercise this right, contact privacy@company.com."
        )


async def make_explainable_decision(agent, request: str, user_id: str):
    """Run agent with explanation tracking for GDPR compliance."""
    # Track what data was accessed during this agent run
    data_access_log = []
    reasoning_trace = []

    result = await agent.run_with_tracing(
        request=request,
        on_data_access=lambda source: data_access_log.append(source),
        on_reasoning_step=lambda step: reasoning_trace.append(step),
    )

    decision = ExplainableAgentDecision(
        decision=result.output,
        reasoning_steps=reasoning_trace,
        factors_considered=extract_key_factors(reasoning_trace),
        data_accessed=data_access_log,
        confidence_level=result.confidence,
    )

    # Store explanation for potential GDPR requests (retain per data retention policy)
    await store_decision_record(user_id=user_id, decision=decision)

    return result.output, decision

from datetime import datetime, timedelta, timezone


class AgentConversationRetentionManager:
    """Manages retention and deletion of agent conversation data."""

    # Retention periods by data sensitivity
    RETENTION_POLICIES = {
        "general_conversation": timedelta(days=90),
        "support_ticket": timedelta(days=365),
        "healthcare_interaction": timedelta(days=2555),  # 7 years HIPAA
        "financial_transaction": timedelta(days=2555),   # 7 years SOX
        "gdpr_consent_record": timedelta(days=3650),     # 10 years
    }

    async def schedule_deletion(self, conversation_id: str, category: str):
        retention = self.RETENTION_POLICIES.get(category, timedelta(days=90))
        delete_at = datetime.now(timezone.utc) + retention

        await db.schedule_deletion(
            record_id=conversation_id,
            record_type="agent_conversation",
            delete_at=delete_at,
        )

    async def handle_erasure_request(self, user_id: str) -> dict:
        """Handle GDPR Article 17 right to erasure request."""
        deleted_records = []

        # Find all agent conversations for this user
        conversations = await db.get_user_conversations(user_id)

        for conv in conversations:
            if not has_legal_hold(conv):  # Legal hold overrides erasure
                await db.delete_conversation(conv.id)
                deleted_records.append(conv.id)

        # Delete from vector databases (RAG memory)
        await vector_store.delete_by_user(user_id)

        # Delete fine-tuning data if applicable
        await training_data_store.delete_by_user(user_id)

        return {
            "user_id": user_id,
            "deleted_conversations": len(deleted_records),
            "erasure_date": datetime.now(timezone.utc).isoformat(),
        }

PHI_IDENTIFIERS = [
    "name", "geographic_data", "dates", "phone_numbers",
    "fax_numbers", "email_addresses", "ssn", "mrn",  # Medical record number
    "health_plan_beneficiary_number", "account_numbers",
    "certificate_license_numbers", "vehicle_identifiers",
    "device_identifiers", "urls", "ip_addresses",
    "biometric_identifiers", "full_face_photographs",
    "any_other_unique_identifying_number"
]


class HIPAACompliantAgentContext:
    """Manages PHI-containing contexts for HIPAA-compliant agent operations."""

    def __init__(self, baa_verified: bool, encryption_key: str):
        if not baa_verified:
            raise ValueError("Business Associate Agreement must be verified before handling PHI")
        self.baa_verified = baa_verified
        self.key = encryption_key

    def prepare_context(self, patient_data: dict) -> dict:
        """Prepare patient context with minimum necessary PHI principle."""
        # HIPAA's minimum necessary rule: only include what's needed for the task
        # Never include the full patient record

        safe_context = {
            "patient_age_range": get_age_range(patient_data.get("dob")),  # Not exact DOB
            "relevant_conditions": patient_data.get("active_conditions", []),
            "current_medications": patient_data.get("medications", []),
            # NOT: name, address, SSN, full DOB, MRN
        }
        return safe_context

    def log_phi_access(self, accessor_id: str, patient_id: str, purpose: str):
        """HIPAA requires audit logging of all PHI access."""
        audit_entry = {
            "timestamp": datetime.now(timezone.utc).isoformat(),
            "accessor": accessor_id,
            "patient_id": patient_id,  # Hashed in actual implementation
            "purpose": purpose,
            "action": "read",
            "system": "ai-agent",
        }
        # Write to immutable audit log (CloudTrail, Splunk, etc.)
        hipaa_audit_log.write(audit_entry)

# Implement RBAC for agent configuration and monitoring
class AgentAccessControl:
    AGENT_ROLES = {
        "agent_user": ["submit_tasks", "view_own_history"],
        "agent_operator": ["submit_tasks", "view_all_history", "view_metrics"],
        "agent_admin": ["submit_tasks", "view_all_history", "configure_agent",
                        "view_metrics", "view_audit_logs"],
        "agent_auditor": ["view_all_history", "view_metrics", "view_audit_logs"],
    }

    def check_permission(self, user_id: str, action: str) -> bool:
        user_role = db.get_user_role(user_id)
        allowed_actions = self.AGENT_ROLES.get(user_role, [])
        return action in allowed_actions

class AgentChangeRecord:
    def __init__(self):
        pass

    async def request_change(
        self,
        change_type: str,  # "system_prompt", "tool_addition", "model_update"
        proposed_change: dict,
        requestor_id: str,
        justification: str,
    ) -> str:
        change_id = generate_change_id()

        record = {
            "change_id": change_id,
            "type": change_type,
            "proposed": proposed_change,
            "current": await get_current_config(change_type),
            "requestor": requestor_id,
            "justification": justification,
            "status": "pending_review",
            "created_at": datetime.now(timezone.utc).isoformat(),
        }

        await db.save_change_record(record)
        await notify_approvers(change_id)
        return change_id

class AgentIncidentResponse:
    SEVERITY_LEVELS = {
        "critical": ["prompt_injection_detected", "data_exfiltration_attempt", "unauthorized_tool_call"],
        "high": ["authentication_failure_spike", "unusual_query_patterns", "output_pii_detected"],
        "medium": ["rate_limit_exceeded", "tool_permission_violation"],
        "low": ["input_validation_failure", "output_truncation_applied"],
    }

    async def handle_incident(self, event_type: str, event_data: dict):
        severity = self.get_severity(event_type)

        incident = {
            "incident_id": generate_incident_id(),
            "event_type": event_type,
            "severity": severity,
            "detected_at": datetime.now(timezone.utc).isoformat(),
            "event_data": event_data,
            "status": "open",
        }

        await db.save_incident(incident)

        if severity == "critical":
            await self.disable_agent_immediately()
            await notify_security_team_immediately(incident)
            await notify_executive_team(incident)
        elif severity == "high":
            await notify_security_team(incident)

Unacceptable Risk (PROHIBITED — cannot deploy):
- Social scoring systems
- Real-time biometric surveillance in public spaces
- Manipulation of vulnerable groups

High Risk (Strict obligations before deployment):
- Medical diagnosis or treatment recommendations
- Credit scoring and financial risk assessment
- CV/resume screening and employment decisions
- Critical infrastructure management
- Law enforcement decisions
- Education assessment and grading

Limited Risk (Transparency obligations):
- Chatbots and conversational AI (must disclose AI)
- Deepfake generation (must label synthetic content)

Minimal Risk (No specific obligations):
- Spam filters, general productivity agents
- AI in video games, recommendation systems

from dataclasses import dataclass


@dataclass
class EUAIActTechnicalDocumentation:
    """Required documentation for high-risk AI systems under EU AI Act Annex IV."""

    # 1. General description
    system_name: str
    system_version: str
    intended_purpose: str
    intended_users: str
    geographic_markets: list[str]

    # 2. Design and development
    model_architecture_description: str
    training_data_description: str
    training_methodology: str
    data_governance_measures: str

    # 3. Information on training, validation, and testing
    training_datasets: list[dict]
    validation_methodology: str
    testing_results: dict
    known_limitations: list[str]

    # 4. Monitoring, functioning, and control
    human_oversight_measures: str
    logging_capabilities: str
    performance_metrics: dict
    accuracy_metrics: dict

    # 5. Risk management
    risk_management_system: str
    identified_risks: list[str]
    mitigation_measures: dict

    # 6. Changes and versions
    change_log: list[dict]
    conformity_assessment_date: str

class EUAIActOversightManager:
    """Implements human oversight requirements for high-risk AI systems."""

    async def create_decision_with_oversight(
        self,
        agent_decision: dict,
        affected_individual_id: str,
        decision_type: str,
    ) -> dict:
        # All high-stakes decisions require human review queue
        review_item = {
            "decision_id": generate_id(),
            "agent_decision": agent_decision,
            "ai_explanation": agent_decision.get("explanation"),
            "affected_individual": affected_individual_id,
            "decision_type": decision_type,
            "queued_at": datetime.now(timezone.utc).isoformat(),
            "status": "pending_human_review",
        }

        await human_review_queue.add(review_item)

        # Do not act on the decision until a human has reviewed
        human_decision = await human_review_queue.wait_for_review(
            review_item["decision_id"],
            timeout_seconds=86400,  # 24-hour review window
        )

        return {
            "final_decision": human_decision.decision,
            "ai_recommendation": agent_decision,
            "reviewer_id": human_decision.reviewer_id,
            "review_timestamp": human_decision.timestamp,
        }