def etapa_processar_contatos(ctx: dict, mensagem: str) -> dict:
    """Processa as opções 1, 2 ou 3 da confirmação de contatos."""
    opcao = mensagem.strip().lower()
    
    # Palavras de cancelamento/voltar
    palavras_cancelar = ["cancelar", "voltar", "sair", "menu", "cancel", "back", "exit"]

    # ============================================
    # FUNÇÃO AUXILIAR PARA RECARREGAR DADOS DO CLIENTE (USANDO CPF)
    # ============================================
    def recarregar_dados_cliente(ctx: dict, id_cliente: int) -> dict:
        """Reconsulta a API usando CPF para obter dados atualizados do cliente (inclui e-mails e telefones)."""
        cpf = ctx.get("cpf_cliente")
        if not cpf:
            log("[CONTATOS] CPF não encontrado no contexto para recarregar dados", "ERROR")
            return ctx
        
        log(f"[CONTATOS] Recarregando dados do cliente via CPF: {cpf}", "INFO")
        
        # Usa o mesmo endpoint da consulta inicial
        resultado = chamar_api_radiusnet("consultar_cliente_por_cpf", cpf=cpf)
        
        if not resultado.get("success"):
            log(f"[CONTATOS] Erro ao recarregar dados: {resultado.get('error')}", "ERROR")
            return ctx
        
        cadastros = resultado.get("data", [])
        
        # Encontrar o cadastro específico pelo ID
        for cad in cadastros:
            if cad.get("id_cliente") == id_cliente:
                # Atualizar os cadastros no contexto
                ctx["ultima_consulta_cpf"] = cadastros
                
                # Atualizar contatos_cadastro
                emails = [e["email"] for e in cad.get("emails", [])]
                telefones = [f"({t['ddd']}) {t['telefone']}" for t in cad.get("telefones", [])]
                ctx["contatos_cadastro"] = {"emails": emails, "telefones": telefones}
                
                log(f"[CONTATOS] Dados recarregados: {len(emails)} e-mails, {len(telefones)} telefones", "INFO")
                break
        
        return ctx

    # ============================================
    # FUNÇÃO AUXILIAR PARA VALIDAR E CLASSIFICAR TELEFONE
    # ============================================
    def validar_telefone(ddd: str, numero: str) -> dict:
        """Valida telefone e retorna o tipo (1=Residencial, 2=Celular, 3=Comercial)"""
        # Limpar número (remover não dígitos)
        numero_limpo = re.sub(r'\D', '', numero)
        ddd_limpo = re.sub(r'\D', '', ddd)
        
        # Validar DDD (deve ter 2 dígitos)
        if len(ddd_limpo) != 2:
            return {"valido": False, "erro": "DDD inválido. Use 2 dígitos (ex: 32)"}
        
        # Verificar tamanho do número
        if len(numero_limpo) == 8:
            # Telefone fixo (8 dígitos)
            return {"valido": True, "tipo": None, "fixo": True, "ddd": ddd_limpo, "numero": numero_limpo}
        elif len(numero_limpo) == 9 and numero_limpo[0] == '9':
            # Celular (9 dígitos começando com 9)
            return {"valido": True, "tipo": 2, "fixo": False, "ddd": ddd_limpo, "numero": numero_limpo}
        else:
            return {"valido": False, "erro": "Número inválido. Celular: 9 dígitos começando com 9. Fixo: 8 dígitos."}

    # ============================================
    # Sub-etapa: aguardando novo e-mail
    # ============================================
    if ctx.get("aguardando_email"):
        log("[CONTATOS] Processando novo e-mail", "DEBUG")
        
        # Verificar cancelamento
        if opcao in palavras_cancelar:
            log("[CONTATOS] Usuário cancelou adição de e-mail", "INFO")
            ctx["aguardando_email"] = False
            # Recarregar dados para garantir lista atualizada
            ctx = recarregar_dados_cliente(ctx, ctx.get("id_cliente"))
            return etapa_exibir_contatos(ctx)
        
        email = mensagem.strip()
        
        # Validação básica de e-mail
        if "@" in email and "." in email:
            id_cliente = ctx.get("id_cliente")
            log(f"[CONTATOS] Adicionando e-mail: {email} para IDCLI={id_cliente}", "INFO")
            
            resultado = chamar_api_radiusnet("atualizar_email", IDCLI=id_cliente, EMAIL=email)
            
            log(f"[CONTATOS] Resultado API: success={resultado.get('success')}, error={resultado.get('error')}", "DEBUG")
            
            if resultado.get("success"):
                log(f"[CONTATOS] E-mail {email} adicionado com sucesso", "INFO")
                ctx["aguardando_email"] = False
                # Recarregar dados do cliente para obter a lista atualizada
                ctx = recarregar_dados_cliente(ctx, id_cliente)
                return etapa_exibir_contatos(ctx)
            else:
                erro = resultado.get('error', 'Tente novamente.')
                log(f"[CONTATOS] ERRO ao adicionar e-mail: {erro}", "ERROR")
                return {
                    "resposta": f"❌ Erro ao adicionar e-mail: {erro}\n\n"
                               f"Digite 1 para tentar outro e-mail, 2 para adicionar telefone ou 3 para prosseguir."
                }
        else:
            log("[CONTATOS] E-mail inválido - formato incorreto", "WARNING")
            return {"resposta": "❌ E-mail inválido. Por favor, informe um e-mail válido (ex: nome@provedor.com) ou digite 'cancelar' para voltar."}

    # ============================================
    # Sub-etapa: aguardando novo telefone (primeira etapa - receber DDD e número)
    # ============================================
    if ctx.get("aguardando_telefone"):
        log("[CONTATOS] Processando novo telefone", "DEBUG")
        
        # Verificar cancelamento
        if opcao in palavras_cancelar:
            log("[CONTATOS] Usuário cancelou adição de telefone", "INFO")
            ctx["aguardando_telefone"] = False
            ctx.pop("telefone_temporario", None)
            ctx.pop("aguardando_tipo_telefone", None)
            # Recarregar dados para garantir lista atualizada
            ctx = recarregar_dados_cliente(ctx, ctx.get("id_cliente"))
            return etapa_exibir_contatos(ctx)
        
        partes = mensagem.strip().split()
        if len(partes) >= 2:
            ddd = partes[0]
            telefone = "".join(partes[1:])
            
            # Validar telefone
            validacao = validar_telefone(ddd, telefone)
            
            if not validacao.get("valido"):
                return {"resposta": f"❌ {validacao.get('erro')}\n\nUse o formato: DDD NÚMERO (ex: 32 999970216 para celular ou 32 32211234 para fixo)"}
            
            # Salvar telefone temporariamente
            ctx["telefone_temporario"] = {
                "ddd": validacao["ddd"],
                "numero": validacao["numero"],
                "fixo": validacao["fixo"]
            }
            
            # Se for celular, já tem tipo definido (2)
            if not validacao.get("fixo") and validacao.get("tipo") == 2:
                ctx["aguardando_telefone"] = False
                id_cliente = ctx.get("id_cliente")
                ddd_telefone = validacao["ddd"]
                numero_telefone = validacao["numero"]
                
                log(f"[CONTATOS] Adicionando telefone celular: ({ddd_telefone}) {numero_telefone} para IDCLI={id_cliente}", "INFO")
                
                resultado = chamar_api_radiusnet("atualizar_telefone", IDCLI=id_cliente, DDD=ddd_telefone, TEL=numero_telefone, TT=2)
                
                if resultado.get("success"):
                    log(f"[CONTATOS] Telefone celular adicionado com sucesso", "INFO")
                    ctx.pop("telefone_temporario", None)
                    # Recarregar dados do cliente
                    ctx = recarregar_dados_cliente(ctx, id_cliente)
                    return etapa_exibir_contatos(ctx)
                else:
                    erro = resultado.get('error', 'Tente novamente.')
                    log(f"[CONTATOS] ERRO ao adicionar telefone: {erro}", "ERROR")
                    ctx.pop("telefone_temporario", None)
                    return {
                        "resposta": f"❌ Erro ao adicionar telefone: {erro}\n\n"
                                   f"Digite 1 para adicionar e-mail, 2 para tentar novamente ou 3 para prosseguir."
                    }
            else:
                # Telefone fixo - perguntar o tipo
                ctx["aguardando_tipo_telefone"] = True
                ctx["aguardando_telefone"] = False
                return {
                    "resposta": "📞 Telefone fixo identificado.\n\n"
                               "Qual o tipo deste telefone?\n"
                               "1 - Residencial\n"
                               "2 - Comercial\n\n"
                               "Digite 1 ou 2:"
                }
        else:
            return {"resposta": "❌ Formato inválido. Use: DDD NÚMERO (ex: 32 999970216 para celular ou 32 32211234 para fixo) ou digite 'cancelar' para voltar."}

    # ============================================
    # Sub-etapa: aguardando tipo do telefone (fixo: residencial ou comercial)
    # ============================================
    if ctx.get("aguardando_tipo_telefone"):
        tipo_opcao = mensagem.strip()
        telefone_temp = ctx.get("telefone_temporario")
        
        if not telefone_temp:
            ctx["aguardando_tipo_telefone"] = False
            return {"resposta": "❌ Erro: dados do telefone não encontrados. Tente novamente."}
        
        tipo_map = {
            "1": 1,  # Residencial
            "2": 3,  # Comercial
        }
        
        if tipo_opcao in tipo_map:
            tipo_telefone = tipo_map[tipo_opcao]
            tipo_nome = "Residencial" if tipo_opcao == "1" else "Comercial"
            id_cliente = ctx.get("id_cliente")
            ddd_telefone = telefone_temp["ddd"]
            numero_telefone = telefone_temp["numero"]
            
            log(f"[CONTATOS] Adicionando telefone fixo {tipo_nome}: ({ddd_telefone}) {numero_telefone} para IDCLI={id_cliente}", "INFO")
            
            resultado = chamar_api_radiusnet("atualizar_telefone", IDCLI=id_cliente, DDD=ddd_telefone, TEL=numero_telefone, TT=tipo_telefone)
            
            ctx["aguardando_tipo_telefone"] = False
            ctx.pop("telefone_temporario", None)
            
            if resultado.get("success"):
                log(f"[CONTATOS] Telefone fixo {tipo_nome} adicionado com sucesso", "INFO")
                # Recarregar dados do cliente
                ctx = recarregar_dados_cliente(ctx, id_cliente)
                return etapa_exibir_contatos(ctx)
            else:
                erro = resultado.get('error', 'Tente novamente.')
                log(f"[CONTATOS] ERRO ao adicionar telefone: {erro}", "ERROR")
                return {
                    "resposta": f"❌ Erro ao adicionar telefone: {erro}\n\n"
                               f"Digite 1 para adicionar e-mail, 2 para tentar novamente ou 3 para prosseguir."
                }
        else:
            return {"resposta": "❌ Opção inválida. Digite 1 para Residencial ou 2 para Comercial."}

    # ============================================
    # Processar opções principais (1, 2, 3)
    # ============================================
    log(f"[CONTATOS] Processando opção principal: {opcao}", "DEBUG")
    
    if opcao == "1":
        log("[CONTATOS] Usuário escolheu adicionar e-mail", "INFO")
        ctx["aguardando_email"] = True
        return {"resposta": "📧 Por favor, informe o novo e-mail que deseja adicionar (ou digite 'cancelar' para voltar)."}

    if opcao == "2":
        log("[CONTATOS] Usuário escolheu adicionar telefone", "INFO")
        ctx["aguardando_telefone"] = True
        return {"resposta": "📱 Por favor, informe o DDD e o número do telefone.\n\n"
                           "Celular: 32 999970216 (9 dígitos começando com 9)\n"
                           "Fixo: 32 32211234 (8 dígitos)\n\n"
                           "Ou digite 'cancelar' para voltar."}

    # Aceita "3" ou palavras de confirmação
    if opcao == "3" or opcao in ["sim", "s", "yes", "y", "ok", "certo", "correto", "prosseguir"]:
        log("[CONTATOS] Usuário confirmou contatos, prosseguindo", "INFO")
        ctx["contatos_confirmados"] = True
        ctx["aguardando_opcao_contatos"] = False
        # Limpar qualquer flag residual
        ctx["aguardando_email"] = False
        ctx["aguardando_telefone"] = False
        ctx["aguardando_tipo_telefone"] = False
        ctx.pop("telefone_temporario", None)
        return {"resposta": "✅ Perfeito! Em que posso ajudá-lo hoje?", "proxima_etapa": "aguardar_intencao"}

    # Resposta padrão para opção inválida
    return {"resposta": "❌ Opção inválida. Escolha:\n1 - Adicionar e-mail\n2 - Adicionar telefone\n3 - Prosseguir (contatos corretos)"}