def processar_mensagem(ctx: dict, mensagem: str, historico: list, atendimento_id: int = None) -> dict:
    """Função principal de processamento - versão melhorada com logs e IA"""
    
    import re
    import requests
    import json
    from datetime import datetime
    
    # LOG da mensagem recebida
    log(f"[PROCESSAR] Mensagem: {mensagem[:100]}", "DEBUG")
    
    # ============================================
    # PRIORIDADE 0: Verificar se cliente quer encerrar (qualquer estado)
    # ============================================
    msg_lower = mensagem.lower().strip()
    palavras_encerrar = ["encerrar", "terminar", "finalizar", "sair", "tchau", "adeus", "obrigado", "nada mais", "é só", "só isso"]
    
    if any(p in msg_lower for p in palavras_encerrar):
        log("[PROCESSAR] Cliente solicitou encerramento", "INFO")
        horario = "bom dia" if datetime.now().hour < 12 else "boa tarde" if datetime.now().hour < 18 else "boa noite"
        despedida = MENSAGEM_DESPEDIDA_PADRAO.replace("{horario}", horario) if 'MENSAGEM_DESPEDIDA_PADRAO' in dir() else f"Obrigado por entrar em contato! Tenha um {horario}! 😊"
        # Limpar todos os estados
        for key in list(ctx.keys()):
            if key not in ['historico', 'cpf_cliente', 'id_cliente', 'protocolo']:
                del ctx[key]
        ctx["intencao_definida"] = None
        return {"resposta": despedida, "acao": "encerrar"}
    
    # ============================================
    # COMANDOS ESPECIAIS (prioridade máxima)
    # ============================================
    if 'verificar_comandos_especiais' in dir():
        resultado = verificar_comandos_especiais(ctx, mensagem)
        if resultado:
            log(f"[PROCESSAR] Comando especial detectado: {resultado}", "DEBUG")
            acao = resultado.get("acao")
            
            if acao == "resetar_contexto":
                for key in list(ctx.keys()):
                    if key not in ['historico', 'cpf_cliente', 'id_cliente', 'protocolo']:
                        del ctx[key]
                ctx["intencao_definida"] = None
                ctx["aguardando_formato_boleto"] = False
                ctx["contatos_confirmados"] = False
                return resultado
                
            elif acao == "trocar_plano":
                # Limpar apenas o plano e a cobrança atual, manter o resto
                ctx.pop("plano_escolhido_id", None)
                ctx.pop("ultima_cobranca", None)
                ctx["aguardando_formato_boleto"] = False
                ctx["intencao_definida"] = "emitir_boleto"
                # Executa o fluxo de boleto imediatamente
                return executar_fluxo_boleto(ctx, mensagem, atendimento_id)
                
            else:
                # Para outras ações (ex: "encerrar"), retorna o resultado original
                return resultado

    # ============================================
    # TRATAMENTO DE ESCOLHA DE COBRANÇA DE TODOS OS PLANOS
    # ============================================
    if ctx.get("aguardando_escolha_cobranca_todos"):
        try:
            escolha = int(mensagem.strip())
            cobrancas = ctx.get("lista_cobrancas_todos_planos", [])
            if 1 <= escolha <= len(cobrancas):
                cob = cobrancas[escolha - 1]
                ctx["ultima_cobranca"] = cob
                ctx["aguardando_escolha_cobranca_todos"] = False
                ctx["aguardando_formato_boleto"] = True
                vencimento = formatar_data(cob.get("data_vencimento"))
                valor = formatar_valor(cob.get("valor_total_a_pagar"))
                plano_nome = cob.get("plano") or "Plano não identificado"
                return {
                    "resposta": f"""*Dados da fatura selecionada:*\n📌 Plano: {plano_nome}
📅 Vencimento: {vencimento}
💰 Valor: {valor}

Como deseja receber?

1 - Pix (copia e cola)
2 - Código de barras
3 - Boleto em PDF"""
                }
            else:
                return {"resposta": f"Opção inválida. Escolha entre 1 e {len(cobrancas)}."}
        except ValueError:
            # Não é um número – classificar intenção
            log(f"[PROCESSAR] Opção inválida na lista de cobranças: {mensagem}. Classificando intenção...", "DEBUG")
            intencao = classificar_intencao_global(mensagem)
            log(f"[PROCESSAR] Intenção classificada: {intencao}", "DEBUG")
            
            if intencao == "encerrar":
                from datetime import datetime
                horario = "bom dia" if datetime.now().hour < 12 else "boa tarde" if datetime.now().hour < 18 else "boa noite"
                despedida = MENSAGEM_DESPEDIDA_PADRAO.replace("{horario}", horario) if 'MENSAGEM_DESPEDIDA_PADRAO' in dir() else f"Obrigado por entrar em contato! Tenha um {horario}! 😊"
                ctx["intencao_definida"] = None
                ctx["aguardando_escolha_cobranca_todos"] = False
                return {"resposta": despedida, "acao": "encerrar"}
            elif intencao == "recomecar":
                for key in list(ctx.keys()):
                    if key not in ['historico', 'protocolo']:
                        del ctx[key]
                ctx["intencao_definida"] = None
                ctx["contatos_confirmados"] = False
                ctx["aguardando_formato_boleto"] = False
                ctx["aguardando_escolha_cobranca_todos"] = False
                return {"resposta": "Entendido! Vamos recomeçar o atendimento. Por favor, informe seu CPF para continuarmos."}
            elif intencao == "trocar_plano":
                ctx.pop("plano_escolhido_id", None)
                ctx.pop("ultima_cobranca", None)
                ctx["aguardando_formato_boleto"] = False
                ctx["aguardando_escolha_cobranca_todos"] = False
                ctx["intencao_definida"] = "emitir_boleto"
                return executar_fluxo_boleto(ctx, mensagem, atendimento_id)
            else:
                return {"resposta": "Digite apenas o número da cobrança que deseja pagar."}

    # ============================================
    # TRATAMENTO DE CONFIRMAÇÃO FINANCEIRO OU TODOS OS PLANOS
    # ============================================
    if ctx.get("aguardando_confirmacao_financeiro_ou_todos"):
        opcao = mensagem.strip()
        log(f"[PROCESSAR] Processando opção de lista de todos os planos: {opcao}", "DEBUG")
        
        if opcao == "1":
            ctx["aguardando_confirmacao_financeiro_ou_todos"] = False
            return executar_fluxo_boleto_todos_planos(ctx, atendimento_id)
        elif opcao == "2":
            ctx["aguardando_confirmacao_financeiro_ou_todos"] = False
            adicionar_fila_humana(atendimento_id, 1)
            conn = get_db()
            cur = conn.cursor()
            cur.execute("UPDATE atendimentos SET status = 'fila', setor_id = 1 WHERE id = %s", (atendimento_id,))
            cur.execute("DELETE FROM fila_robot WHERE atendimento_id = %s", (atendimento_id,))
            conn.commit()
            cur.close()
            conn.close()
            template = MENSAGEM_ENCAMINHAMENTO_HUMANO if 'MENSAGEM_ENCAMINHAMENTO_HUMANO' in dir() else "✅ Entendido! Vou encaminhar seu atendimento para o setor {setor}."
            resposta = template.replace("{setor}", "Financeiro").replace("{protocolo}", ctx.get("protocolo", "N/A"))
            return {"resposta": resposta, "acao": "transferir", "setor_id": 1}
        else:
            # Opção inválida – classificar intenção
            log(f"[PROCESSAR] Opção inválida no menu de todos os planos: {opcao}. Classificando intenção...", "DEBUG")
            intencao = classificar_intencao_global(mensagem)
            log(f"[PROCESSAR] Intenção classificada: {intencao}", "DEBUG")
            
            if intencao == "encerrar":
                from datetime import datetime
                horario = "bom dia" if datetime.now().hour < 12 else "boa tarde" if datetime.now().hour < 18 else "boa noite"
                despedida = MENSAGEM_DESPEDIDA_PADRAO.replace("{horario}", horario) if 'MENSAGEM_DESPEDIDA_PADRAO' in dir() else f"Obrigado por entrar em contato! Tenha um {horario}! 😊"
                ctx["intencao_definida"] = None
                ctx["aguardando_confirmacao_financeiro_ou_todos"] = False
                return {"resposta": despedida, "acao": "encerrar"}
            elif intencao == "recomecar":
                for key in list(ctx.keys()):
                    if key not in ['historico', 'protocolo']:
                        del ctx[key]
                ctx["intencao_definida"] = None
                ctx["contatos_confirmados"] = False
                ctx["aguardando_formato_boleto"] = False
                ctx["aguardando_confirmacao_financeiro_ou_todos"] = False
                return {"resposta": "Entendido! Vamos recomeçar o atendimento. Por favor, informe seu CPF para continuarmos."}
            elif intencao == "trocar_plano":
                ctx.pop("plano_escolhido_id", None)
                ctx.pop("ultima_cobranca", None)
                ctx["aguardando_formato_boleto"] = False
                ctx["aguardando_confirmacao_financeiro_ou_todos"] = False
                ctx["intencao_definida"] = "emitir_boleto"
                return executar_fluxo_boleto(ctx, mensagem, atendimento_id)
            else:
                return {"resposta": "Opção inválida. Digite 1 para ver boletos de todos os planos ou 2 para falar com o Financeiro."}

    # ============================================
    # TRATAMENTO DE CONFIRMAÇÃO FINANCEIRO (responder SIM/NÃO)
    # ============================================
    if ctx.get("aguardando_confirmacao_financeiro"):
        log(f"[PROCESSAR] Processando confirmação financeiro: {mensagem}", "DEBUG")
        
        if mensagem.lower().strip() in ["sim", "s", "yes"]:
            # Transferir para financeiro
            adicionar_fila_humana(atendimento_id, 1)
            conn = get_db()
            cur = conn.cursor()
            cur.execute("UPDATE atendimentos SET status = 'fila', setor_id = 1 WHERE id = %s", (atendimento_id,))
            cur.execute("DELETE FROM fila_robot WHERE atendimento_id = %s", (atendimento_id,))
            conn.commit()
            cur.close()
            conn.close()
            ctx["aguardando_confirmacao_financeiro"] = False
            ctx["intencao_definida"] = None
            template = MENSAGEM_ENCAMINHAMENTO_HUMANO if 'MENSAGEM_ENCAMINHAMENTO_HUMANO' in dir() else "✅ Entendido! Vou encaminhar seu atendimento para o setor {setor}."
            resposta = template.replace("{setor}", "Financeiro").replace("{protocolo}", ctx.get("protocolo", "N/A"))
            return {"resposta": resposta, "acao": "transferir", "setor_id": 1}
        else:
            # Resposta "nao" - limpa o estado e volta ao menu
            ctx["aguardando_confirmacao_financeiro"] = False
            ctx["intencao_definida"] = None
            return {"resposta": "OK. Em que mais posso ajudá-lo hoje?"}
    
    # ============================================
    # TRATAMENTO DE BOLETO EM ANDAMENTO (emitir_boleto)
    # ============================================
    if ctx.get("aguardando_formato_boleto"):
        opcao = mensagem.strip()
        cob = ctx.get("ultima_cobranca", {})
        
        log(f"[PROCESSAR] Processando escolha de formato do boleto: opcao={opcao}", "DEBUG")
        
        if opcao == "1":  # Pix
            pix = cob.get('qrcode_copy_paste')
            if not pix:
                return {"resposta": "Desculpe, não consegui recuperar o código Pix. Tente novamente."}
            ctx["aguardando_formato_boleto"] = False
            ctx["intencao_definida"] = None
            return {
                "resposta": "Segue o Pix copia e cola do boleto:",
                "conteudo_adicional": pix,
                "mensagem_followup": "Deseja mais alguma ajuda?",
                "acao": "enviar_texto_adicional"
            }
        elif opcao == "2":  # Código de barras
            cod_barras = cob.get('linha_digitavel')
            if not cod_barras:
                return {"resposta": "Desculpe, não consegui recuperar o código de barras. Tente novamente."}
            ctx["aguardando_formato_boleto"] = False
            ctx["intencao_definida"] = None
            return {
                "resposta": "Segue o código de barras do boleto:",
                "conteudo_adicional": cod_barras,
                "mensagem_followup": "Deseja mais alguma ajuda?",
                "acao": "enviar_texto_adicional"
            }
        elif opcao == "3":  # PDF
            id_cobranca = cob.get("id_cobranca")
            if not id_cobranca:
                return {"resposta": "Desculpe, não consegui identificar a cobrança. Tente novamente."}
            
            resultado = chamar_api_radiusnet("gerar_boleto", id_cobranca=id_cobranca)
            if resultado.get("success"):
                url_pdf = resultado.get("data")
                if url_pdf:
                    ctx["aguardando_formato_boleto"] = False
                    ctx["intencao_definida"] = None
                    return {
                        "resposta": "Segue o arquivo PDF do boleto.",
                        "acao": "enviar_documento",
                        "url": url_pdf,
                        "nome": f"boleto_{id_cobranca}.pdf",
                        "mensagem_followup": "Deseja mais alguma ajuda?"
                    }
            return {"resposta": "Não foi possível gerar o PDF. Tente novamente mais tarde."}
        else:
            return {"resposta": "Opção inválida. Digite 1, 2 ou 3."}
    
    # ============================================
    # TRATAMENTO DE ESCOLHA DE COBRANÇA (para verificar_pendencias)
    # ============================================
    if ctx.get("aguardando_escolha_cobranca_pendencias"):
        try:
            escolha = int(mensagem.strip())
            cobrancas = ctx.get("lista_cobrancas_atraso", [])
            if 1 <= escolha <= len(cobrancas):
                cob = cobrancas[escolha - 1]
                ctx["ultima_cobranca"] = cob
                ctx["aguardando_escolha_cobranca_pendencias"] = False
                ctx["aguardando_acao_cobranca"] = True
                
                vencimento = formatar_data(cob.get("data_vencimento"))
                valor = formatar_valor(cob.get("valor_total_a_pagar"))
                
                return {
                    "resposta": f"""*Cobrança em atraso selecionada:*
📅 Vencimento: {vencimento}
💰 Valor: {valor}

O que deseja fazer?

1 - Gerar Pix (copia e cola)
2 - Gerar código de barras
3 - Gerar boleto em PDF
4 - Falar com o setor Financeiro"""
                }
            else:
                return {"resposta": f"Opção inválida. Escolha entre 1 e {len(cobrancas)}."}
        except ValueError:
            return {"resposta": "Digite apenas o número da cobrança."}
    
    # ============================================
    # TRATAMENTO DE AÇÃO SOBRE COBRANÇA (Pix, código, PDF ou transferir)
    # ============================================
    if ctx.get("aguardando_acao_cobranca"):
        opcao = mensagem.strip()
        cob = ctx.get("ultima_cobranca", {})
        
        if opcao == "1":  # Pix
            pix = cob.get('qrcode_copy_paste')
            if not pix:
                return {"resposta": "Desculpe, não consegui recuperar o código Pix. Tente novamente."}
            ctx["aguardando_acao_cobranca"] = False
            ctx["intencao_definida"] = None
            return {
                "resposta": "Segue o Pix copia e cola da cobrança:",
                "conteudo_adicional": pix,
                "mensagem_followup": "Deseja mais alguma ajuda?",
                "acao": "enviar_texto_adicional"
            }
        elif opcao == "2":  # Código de barras
            cod_barras = cob.get('linha_digitavel')
            if not cod_barras:
                return {"resposta": "Desculpe, não consegui recuperar o código de barras. Tente novamente."}
            ctx["aguardando_acao_cobranca"] = False
            ctx["intencao_definida"] = None
            return {
                "resposta": "Segue o código de barras da cobrança:",
                "conteudo_adicional": cod_barras,
                "mensagem_followup": "Deseja mais alguma ajuda?",
                "acao": "enviar_texto_adicional"
            }
        elif opcao == "3":  # PDF
            id_cobranca = cob.get("id_cobranca")
            if not id_cobranca:
                return {"resposta": "Desculpe, não consegui identificar a cobrança. Tente novamente."}
            
            resultado = chamar_api_radiusnet("gerar_boleto", id_cobranca=id_cobranca)
            if resultado.get("success"):
                url_pdf = resultado.get("data")
                if url_pdf:
                    ctx["aguardando_acao_cobranca"] = False
                    ctx["intencao_definida"] = None
                    return {
                        "resposta": "Segue o arquivo PDF do boleto.",
                        "acao": "enviar_documento",
                        "url": url_pdf,
                        "nome": f"boleto_{id_cobranca}.pdf",
                        "mensagem_followup": "Deseja mais alguma ajuda?"
                    }
            return {"resposta": "Não foi possível gerar o PDF. Tente novamente mais tarde."}
        elif opcao == "4":  # Falar com Financeiro
            adicionar_fila_humana(atendimento_id, 1)
            conn = get_db()
            cur = conn.cursor()
            cur.execute("UPDATE atendimentos SET status = 'fila', setor_id = 1 WHERE id = %s", (atendimento_id,))
            cur.execute("DELETE FROM fila_robot WHERE atendimento_id = %s", (atendimento_id,))
            conn.commit()
            cur.close()
            conn.close()
            ctx["aguardando_acao_cobranca"] = False
            ctx["intencao_definida"] = None
            return {
                "resposta": "✅ Transferindo você para o setor Financeiro. Um atendente irá te ajudar em breve.",
                "acao": "transferir",
                "setor_id": 1
            }
        else:
            return {"resposta": "Opção inválida. Digite 1, 2, 3 ou 4."}
    
    # ============================================
    # TRATAMENTO DE CONFIRMAÇÃO DE TRANSFERÊNCIA (para vendas)
    # ============================================
    if ctx.get("aguardando_confirmacao_transferencia"):
        setor_id = ctx.get("transferencia_setor_id", 4)
        setor_nome = ctx.get("transferencia_setor_nome", "Atendimento Geral")
        
        if mensagem.lower().strip() in ["sim", "s", "yes"]:
            adicionar_fila_humana(atendimento_id, setor_id)
            conn = get_db()
            cur = conn.cursor()
            cur.execute("UPDATE atendimentos SET status = 'fila', setor_id = %s WHERE id = %s", (setor_id, atendimento_id))
            cur.execute("DELETE FROM fila_robot WHERE atendimento_id = %s", (atendimento_id,))
            conn.commit()
            cur.close()
            conn.close()
            ctx["aguardando_confirmacao_transferencia"] = False
            ctx["intencao_definida"] = None
            template = MENSAGEM_ENCAMINHAMENTO_HUMANO if 'MENSAGEM_ENCAMINHAMENTO_HUMANO' in dir() else "✅ Entendido! Vou encaminhar seu atendimento para o setor {setor}."
            resposta = template.replace("{setor}", setor_nome).replace("{protocolo}", ctx.get("protocolo", "N/A"))
            return {"resposta": resposta, "acao": "transferir", "setor_id": setor_id}
        else:
            ctx["aguardando_confirmacao_transferencia"] = False
            ctx["intencao_definida"] = None
            return {"resposta": "OK. Em que mais posso ajudá-lo hoje?"}

    # ============================================
    # TRATAMENTO DE ESCOLHA DE PLANO (após listagem de planos)
    # ============================================
    if ctx.get("aguardando_escolha_plano"):
        log("[PROCESSAR] Processando escolha de plano", "DEBUG")
        return etapa_confirmar_escolha_cadastro(ctx, mensagem)
    
    # ============================================
    # ETAPA 1: IDENTIFICAÇÃO DO CLIENTE (CPF)
    # ============================================
    if not ctx.get("cpf_cliente"):
        log("[PROCESSAR] Cliente sem CPF. Verificando mensagem...", "DEBUG")
        
        cpf_match = re.search(r"\b(\d{3}\.?\d{3}\.?\d{3}-?\d{2}|\d{11})\b", mensagem)
        if cpf_match:
            cpf_limpo = re.sub(r"\D", "", cpf_match.group(1))
            if len(cpf_limpo) == 11:
                log(f"[PROCESSAR] CPF detectado: {cpf_limpo}", "INFO")
                ctx["cpf_cliente"] = cpf_limpo
                return etapa_consultar_cadastros(ctx, cpf_limpo)
        
        return {"resposta": "Para melhor atendê-lo, preciso que informe seu CPF (apenas números)."}
    
    # ============================================
    # ETAPA 2: ESCOLHA DO CADASTRO
    # ============================================
    if ctx.get("cpf_cliente") and not ctx.get("id_cliente"):
        log("[PROCESSAR] Aguardando escolha do cadastro...", "DEBUG")
        
        if ctx.get("aguardando_confirmacao") or ctx.get("aguardando_escolha"):
            return etapa_confirmar_escolha_cadastro(ctx, mensagem)
        
        if ctx.get("ultima_consulta_cpf"):
            cadastros = ctx["ultima_consulta_cpf"]
            if len(cadastros) == 1:
                log("[PROCESSAR] Único cadastro encontrado, selecionando automaticamente", "DEBUG")
                ctx["id_cliente"] = cadastros[0].get("id_cliente")
                return etapa_exibir_contatos(ctx)
            else:
                log(f"[PROCESSAR] Múltiplos cadastros ({len(cadastros)}), solicitando escolha", "DEBUG")
                return etapa_consultar_cadastros(ctx, ctx["cpf_cliente"])
        
        return etapa_consultar_cadastros(ctx, ctx["cpf_cliente"])
    
    # ============================================
    # ETAPA 3: CONFIRMAÇÃO DE CONTATOS
    # ============================================
    if ctx.get("id_cliente") and not ctx.get("contatos_confirmados"):
        log("[PROCESSAR] Aguardando confirmação de contatos...", "DEBUG")
        
        if ctx.get("aguardando_opcao_contatos") or ctx.get("aguardando_email") or ctx.get("aguardando_telefone"):
            return etapa_processar_contatos(ctx, mensagem)
        
        return etapa_exibir_contatos(ctx)

    
    # ============================================
    # ETAPA 4: CLASSIFICAR INTENÇÃO (com IA e fallback)
    # ============================================
    if not ctx.get("intencao_definida"):
        msg_lower = mensagem.lower().strip()
        
        log(f"[PROCESSAR] Classificando intenção para: {msg_lower[:50]}", "DEBUG")
        
        # Palavras-chave para classificação rápida (fallback)
        palavras_emitir_boleto = ["boleto", "fatura", "pagar", "2 via", "segunda via", "pix", "codigo", "código", 
                                  "barras", "linha digitavel", "codigo de barras", "codigo pix", "qr code", 
                                  "pagamento", "vencimento", "valor da conta", "meu boleto"]
        
        palavras_verificar_pendencias = ["pendência", "debito", "débito", "atraso", "estou devendo", "devo", 
                                         "verificar pendencia", "tenho pendencia", "conta vencida", 
                                         "estou negativo", "bloqueado", "regularizar"]
        
        palavras_suporte = ["internet", "conexão", "caiu", "lento", "modem", "roteador", "wi-fi", 
                           "sinal", "rede", "cabo", "fibra", "técnico", "suporte", "offline", 
                           "desconectou", "reiniciar", "nao funciona", "sem internet"]
        
        palavras_vendas = ["vendas", "contratar", "plano", "aumentar", "velocidade", "novo", 
                          "instalar", "upgrade", "promoção", "desconto", "mudar de plano", "quero contratar"]
        
        # Verificar palavras-chave primeiro
        if any(p in msg_lower for p in palavras_emitir_boleto):
            ctx["intencao_definida"] = "emitir_boleto"
            log("[PROCESSAR] Intenção classificada localmente como: emitir_boleto", "INFO")
        elif any(p in msg_lower for p in palavras_verificar_pendencias):
            ctx["intencao_definida"] = "verificar_pendencias"
            log("[PROCESSAR] Intenção classificada localmente como: verificar_pendencias", "INFO")
        elif any(p in msg_lower for p in palavras_suporte):
            ctx["intencao_definida"] = "suporte_tecnico"
            log("[PROCESSAR] Intenção classificada localmente como: suporte_tecnico", "INFO")
        elif any(p in msg_lower for p in palavras_vendas):
            ctx["intencao_definida"] = "vendas"
            log("[PROCESSAR] Intenção classificada localmente como: vendas", "INFO")
        else:
            # Chamar IA para classificação
            log("[PROCESSAR] Nenhuma palavra-chave encontrada. Chamando DeepSeek para classificação...", "DEBUG")
            
            try:
                DEEPSEEK_KEY = "sk-c8cf0f0276c64266baee49dd07b33ac7"
                DEEPSEEK_URL = "https://api.deepseek.com/v1/chat/completions"
                
                system_prompt = """Você é um CLASSIFICADOR de intenções para um atendente virtual de telecomunicações.

Analise a mensagem do cliente e retorne APENAS um JSON com a intenção.

Intenções possíveis:
- "emitir_boleto": cliente quer boleto, fatura, pix, código de barras, linha digitável, 2ª via, pagamento
- "verificar_pendencias": cliente quer saber se tem débito, pendência, atraso, conta vencida, bloqueio
- "suporte_tecnico": problemas com internet, modem, sinal, conexão lenta, offline
- "vendas": contratar plano, aumentar velocidade, upgrade, novo serviço
- "encerrar": terminar atendimento (tchau, obrigado, sair, finalizar)
- "outros": qualquer outra coisa

Responda APENAS com: {"intencao": "..."}

Mensagem: """
                
                payload = {
                    "model": "deepseek-chat",
                    "messages": [
                        {"role": "system", "content": system_prompt},
                        {"role": "user", "content": mensagem}
                    ],
                    "temperature": 0.1,
                    "max_tokens": 100
                }
                
                headers = {"Authorization": f"Bearer {DEEPSEEK_KEY}", "Content-Type": "application/json"}
                
                log(f"[PROCESSAR] Enviando requisição para DeepSeek...", "DEBUG")
                resp = requests.post(DEEPSEEK_URL, json=payload, headers=headers, timeout=10)
                
                log(f"[PROCESSAR] DeepSeek respondeu com status: {resp.status_code}", "DEBUG")
                
                if resp.status_code == 200:
                    data = resp.json()
                    conteudo = data["choices"][0]["message"]["content"]
                    log(f"[PROCESSAR] DeepSeek resposta: {conteudo}", "DEBUG")
                    
                    json_match = re.search(r'\{[^{}]*\}', conteudo)
                    if json_match:
                        intencao_data = json.loads(json_match.group())
                        intencao = intencao_data.get("intencao", "outros")
                        ctx["intencao_definida"] = intencao
                        log(f"[PROCESSAR] Intenção classificada pela IA: {intencao}", "INFO")
                    else:
                        ctx["intencao_definida"] = "outros"
                        log("[PROCESSAR] Falha ao extrair JSON da resposta da IA. Usando 'outros'", "WARNING")
                else:
                    log(f"[PROCESSAR] Erro na chamada DeepSeek: {resp.status_code} - {resp.text[:200]}", "ERROR")
                    ctx["intencao_definida"] = "outros"
                    
            except Exception as e:
                log(f"[PROCESSAR] Exceção na classificação da IA: {e}", "ERROR")
                ctx["intencao_definida"] = "outros"
    
    # ============================================
    # ETAPA 5: EXECUTAR FLUXO CONFORME INTENÇÃO
    # ============================================
    intencao = ctx.get("intencao_definida", "outros")
    log(f"[PROCESSAR] Executando fluxo para intenção: {intencao}", "DEBUG")
    
    if intencao == "emitir_boleto":
        return executar_fluxo_boleto(ctx, mensagem, atendimento_id)
    
    elif intencao == "verificar_pendencias":
        return executar_fluxo_pendencias(ctx, mensagem, atendimento_id)
    
    elif intencao == "suporte_tecnico":
        return executar_fluxo_suporte(ctx, mensagem, atendimento_id)
    
    elif intencao == "vendas":
        ctx["aguardando_confirmacao_transferencia"] = True
        ctx["transferencia_setor_id"] = 3
        ctx["transferencia_setor_nome"] = "Vendas"
        return {"resposta": "Deseja ser transferido para o setor de Vendas? (responda SIM ou NÃO)"}
    
    elif intencao == "encerrar":
        horario = "bom dia" if datetime.now().hour < 12 else "boa tarde" if datetime.now().hour < 18 else "boa noite"
        despedida = MENSAGEM_DESPEDIDA_PADRAO.replace("{horario}", horario) if 'MENSAGEM_DESPEDIDA_PADRAO' in dir() else f"Obrigado por entrar em contato! Tenha um {horario}! 😊"
        ctx["intencao_definida"] = None
        return {"resposta": despedida, "acao": "encerrar"}
    
    else:
        # Intenção não identificada - limpa e pergunta novamente
        log("[PROCESSAR] Intenção não identificada. Solicitando esclarecimento.", "DEBUG")
        ctx["intencao_definida"] = None
        return {
            "resposta": "Em que posso ajudá-lo hoje? Diga em poucas palavras o que deseja.\n\n"
                       "📄 Emitir boleto / Pix / Código de barras\n"
                       "🔍 Verificar pendências / Dívidas\n"
                       "🔧 Suporte Técnico / Internet\n"
                       "💰 Falar com Vendas\n"
                       "👋 Encerrar atendimento"
        }