5.2 Escalation and Ambiguity Resolution

def handle_ambiguous_request(user_input, context):
    # Detect ambiguity
    interpretation = client.messages.create(
        system="""You are an ambiguity detector. 
        If the request has multiple valid interpretations, list them.
        If clear, respond with "CLEAR".""",
        messages=[{"role": "user", "content": user_input}]
    )
    
    if "CLEAR" not in interpretation.content[0].text:
        # Escalate — ask user to clarify
        return {
            "action": "clarify",
            "message": f"I found multiple interpretations:\n{interpretation.content[0].text}\nWhich did you mean?",
            "options": extract_options(interpretation)
        }
    
    return {"action": "proceed"}

def should_escalate(confidence, action_type):
    thresholds = {
        "read_only": 0.3,      # Low bar — safe to try
        "reversible_write": 0.6,  # Medium bar
        "irreversible": 0.9,    # High bar — almost certain before acting
        "destructive": 0.99,    # Nearly certain
    }
    
    threshold = thresholds.get(action_type, 0.8)
    
    if confidence < threshold:
        return True, f"Confidence {confidence:.0%} below threshold {threshold:.0%} for {action_type}"
    return False, None

class EscalationTier:
    SELF_RESOLVE = 1      # Try harder, use more tools
    PEER_AGENT = 2        # Ask another agent for opinion  
    SUPERVISOR_AGENT = 3  # Escalate to orchestrator
    HUMAN = 4             # Ask the human

def escalate(issue, current_tier=1):
    if current_tier == EscalationTier.SELF_RESOLVE:
        result = try_alternative_approach(issue)
        if result.success:
            return result
        return escalate(issue, EscalationTier.PEER_AGENT)
    
    elif current_tier == EscalationTier.PEER_AGENT:
        opinion = ask_peer_agent(issue)
        if opinion.confidence > 0.8:
            return execute_with_opinion(opinion)
        return escalate(issue, EscalationTier.SUPERVISOR_AGENT)
    
    elif current_tier == EscalationTier.SUPERVISOR_AGENT:
        decision = ask_supervisor(issue)
        if decision.resolved:
            return execute_decision(decision)
        return escalate(issue, EscalationTier.HUMAN)
    
    elif current_tier == EscalationTier.HUMAN:
        return pause_and_ask_human(issue)

def ask_clarification(ambiguity):
    return {
        "question": ambiguity.description,
        "options": [
            {"label": "A", "description": ambiguity.interpretation_1},
            {"label": "B", "description": ambiguity.interpretation_2},
            {"label": "C", "description": "Something else (please specify)"}
        ],
        "context": ambiguity.why_it_matters
    }

def act_with_default(ambiguous_param, safe_default, reason):
    result = execute_with(safe_default)
    return {
        "result": result,
        "note": f"I assumed '{safe_default}' for '{ambiguous_param}' because {reason}. Let me know if you'd prefer something different."
    }