// Frágil: sujeito a quebras por pequenas variações no retorno
var textoResumo = resposta.Text;
var secoes = textoResumo.Split("Acompanhamento:");

public sealed class ValidadorResumoConsulta
{
    public void Validar(RascunhoResumoConsulta resumo)
    {
        if (string.IsNullOrWhiteSpace(resumo.Resumo))
        {
            throw new ExcecaoSaidaAiInvalidaException(
                "O resumo gerado estava vazio.");
        }

        if (!resumo.RequerRevisaoMedica)
        {
            throw new ExcecaoSaidaAiInvalidaException(
                "Os resumos de consulta devem exigir obrigatoriamente revisão médica.");
        }

        if (resumo.Resumo.Length > 5_000)
        {
            throw new ExcecaoSaidaAiInvalidaException(
                "O resumo gerado excedeu o tamanho máximo permitido.");
        }
    }
}

Resposta da IA ──► Rascunho ──► Validação da Aplicação ──► 
                              Revisão Humana ──► Registro Aprovado

public enum StatusResumo
{
    RascunhoGerado = 1,
    AguardandoRevisao = 2,
    Aprovado = 3,
    Rejeitado = 4
}

public void AprovarResumo(Guid medicoId, string resumoAprovado)
{
    if (MedicoId != medicoId)
    {
        throw new ExcecaoDominioException(
            "Apenas o médico responsável pode aprovar o resumo.");
    }

    if (Status != StatusConsulta.Concluida)
    {
        throw new ExcecaoDominioException(
            "Apenas consultas concluídas podem ter um resumo aprovado.");
    }

    ResumoAprovado = resumoAprovado;
    ResumoAprovadoEmUtc = DateTime.UtcNow;
}

public static class PromptResumoConsulta
{
    public const string Versao = "2026-07-01";

    public const string Sistema =
        """
        Você prepara rascunhos de resumos de consultas para revisão médica.
        Não diagnostique.
        Não prescreva medicamentos.
        Não invente informações.
        Utilize apenas as informações presentes na fonte.
        Identifique incertezas claramente.
        """;
}

public sealed record MetadadosGeracaoAi(
    string VersaoPrompt,
    string? ModeloId,
    DateTime GeradoEmUtc,
    string CorrelacaoId);

public sealed class FerramentasPoliticaConsulta
{
    private readonly ILeitorPoliticaConsulta _leitorPolitica;

    public FerramentasPoliticaConsulta(ILeitorPoliticaConsulta leitorPolitica)
    {
        _leitorPolitica = leitorPolitica;
    }

    public Task<RespostaPoliticaConsulta> ObterPoliticaAsync(
        string tipoConsulta,
        CancellationToken tokenCancelamento)
    {
        return _leitorPolitica.ObterAsync(tipoConsulta, tokenCancelamento);
    }
}

var ferramentaObterPolitica = AIFunctionFactory.Create(
    ferramentasPolitica.ObterPoliticaAsync,
    name: "obter_politica_consulta",
    description: "Retorna a política vigente para um tipo de consulta.");

var opcoes = new ChatOptions
{
    Tools = [ferramentaObterPolitica]
};

// Perigoso: o modelo pode tentar gerar SQL malicioso ou amplo
public Task<List<Consulta>> BuscarBancoDadosAsync(string sql)
{
    return contextoBanco.Database.SqlQueryRaw<Consulta>(sql).ToListAsync();
}

// Seguro: capacidade pontual e tipada
public Task<IReadOnlyList<ResultadoMedicoDisponivel>> BuscarMedicosDisponiveisAsync(
    string especializacao,
    DateOnly data,
    CancellationToken tokenCancelamento)
{
    return _leitorDisponibilidadeMedicos.BuscarAsync(
        especializacao,
        data,
        tokenCancelamento);
}

public sealed class FerramentaAgendamentoConsulta
{
    private readonly IUsuarioAtual _usuarioAtual;
    private readonly IDespachanteComandos _despachante;

    public FerramentaAgendamentoConsulta(
        IUsuarioAtual usuarioAtual,
        IDespachanteComandos despachante)
    {
        _usuarioAtual = usuarioAtual;
        _despachante = despachante;
    }

    public Task<Guid> PrepararAgendamentoAsync(
        Guid medicoId,
        DateTime agendadoParaUtc,
        CancellationToken tokenCancelamento)
    {
        // A identidade vem do contexto de autenticação confiável:
        var comando = new PrepararAgendamentoConsultaComando(
            _usuarioAtual.UsuarioId,
            medicoId,
            agendadoParaUtc);

        return _despachante.Enviar(comando, tokenCancelamento);
    }
}

IA Propõe a Ação ──► Validação ──► Usuário Revisa ──► 
                               Usuário Confirma ──► Comando Executa

public async Task<RascunhoResumoConsulta> GerarAsync(
    TranscricaoConsulta transcricao,
    CancellationToken tokenCancelamento)
{
    using var fonteTimeout =
        CancellationTokenSource.CreateLinkedTokenSource(tokenCancelamento);

    fonteTimeout.CancelAfter(TimeSpan.FromSeconds(20));

    try
    {
        return await GerarInternamenteAsync(
            transcricao,
            fonteTimeout.Token);
    }
    catch (OperationCanceledException)
        when (!tokenCancelamento.IsCancellationRequested)
    {
        throw new ExcecaoTimeoutServicoAiException(
            "O serviço de resumo por IA não respondeu a tempo.");
    }
}

Cliente Requisita Resumo
    │
    ▼
API Cria o Trabalho de IA
    │
    ▼
HTTP 202 Accepted
    │
    ▼
Worker em Segundo Plano
    │
    ▼
Modelo de IA (Ollama)
    │
    ▼
Rascunho Armazenado
    │
    ▼
Usuário Consulta o Resultado