Redacta: un modelo de lenguaje en tu teléfono

git clone https://github.com/rpversontec/practica-13-redacta.git

[versions]
litertlm = "0.18.0"

[libraries]
litertlm-android = { group = "com.google.ai.edge.litertlm", name = "litertlm-android", version.ref = "litertlm" }

    // LiteRT-LM: corre un modelo de lenguaje en el teléfono. Trae su motor nativo
    // (arm64 para teléfonos, x86_64 para el emulador); el modelo NO viene aquí.
    implementation(libs.litertlm.android)

package mx.tec.redacta.data

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.StateFlow
import mx.tec.redacta.domain.EstadoModelo
import mx.tec.redacta.domain.Pedido

/**
 * Un modelo de lenguaje que corre en el teléfono. El ViewModel solo conoce
 * esta interfaz: en la app es Gemma (GemmaLocal); en las pruebas, uno de
 * mentira que contesta al instante.
 */
interface ModeloLocal {
    val estado: StateFlow<EstadoModelo>

    /** Busca el archivo y lo sube a memoria. Tarda segundos: se llama desde una corrutina. */
    suspend fun cargar()

    /**
     * La respuesta, en pedazos, conforme se genera. Cada pedazo suele ser un token.
     * Cancelar la corrutina que la recolecta detiene la generación.
     */
    fun generar(pedido: Pedido): Flow<String>
}

package mx.tec.redacta.data

import android.content.Context
import com.google.ai.edge.litertlm.Backend
import com.google.ai.edge.litertlm.Engine
import com.google.ai.edge.litertlm.EngineConfig
import dagger.hilt.android.qualifiers.ApplicationContext
import java.io.File
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.emptyFlow
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import mx.tec.redacta.domain.EstadoModelo
import mx.tec.redacta.domain.Pedido

/**
 * Gemma 3 1B, con LiteRT-LM, en el CPU del teléfono.
 *
 * `@Singleton`: el modelo ocupa más de 1 GB de memoria y tarda segundos en
 * cargar. Se carga una vez y lo usa toda la app.
 */
@Singleton
class GemmaLocal @Inject constructor(
    @ApplicationContext private val contexto: Context
) : ModeloLocal {

    private val _estado = MutableStateFlow<EstadoModelo>(EstadoModelo.Cargando)
    override val estado: StateFlow<EstadoModelo> = _estado.asStateFlow()

    private var motor: Engine? = null
    private val candado = Mutex()

    override suspend fun cargar() = candado.withLock {
        if (motor != null) return@withLock
        // Donde lo deja `adb push`: la carpeta de la app en el almacenamiento compartido.
        val archivo = File(contexto.getExternalFilesDir(null), ARCHIVO)
        if (!archivo.exists()) {
            _estado.value = EstadoModelo.Falta(archivo.absolutePath)
            return@withLock
        }
        _estado.value = EstadoModelo.Cargando
        val nuevo = Engine(
            EngineConfig(
                modelPath = archivo.absolutePath,
                backend = Backend.CPU(),
                cacheDir = contexto.cacheDir.absolutePath
            )
        )
        runCatching { withContext(Dispatchers.Default) { nuevo.initialize() } }
            .onSuccess {
                motor = nuevo
                _estado.value = EstadoModelo.Listo
            }
            .onFailure { e ->
                // Si lo cancelaron, el motor sí llegó a cargar: se libera. Si falló, no hay nada que cerrar.
                if (nuevo.isInitialized()) nuevo.close()
                if (e is CancellationException) throw e
                _estado.value = EstadoModelo.Error(e.message ?: "No se pudo cargar el modelo")
            }
    }

    // B1
    override fun generar(pedido: Pedido): Flow<String> = emptyFlow()

    companion object {
        const val ARCHIVO = "gemma3-1b-it-int4.litertlm"

        /** Un tope de seguridad. Que conteste corto lo pide la instrucción, no este número. */
        const val MAX_TOKENS = 256
    }
}

package mx.tec.redacta.di

import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import mx.tec.redacta.data.GemmaLocal
import mx.tec.redacta.data.ModeloLocal

/** Quien pida un ModeloLocal recibe a Gemma. Las pruebas no usan Hilt: arman el suyo. */
@Module
@InstallIn(SingletonComponent::class)
abstract class ModeloModule {
    @Binds
    abstract fun modelo(gemma: GemmaLocal): ModeloLocal
}

package mx.tec.redacta.ui.state

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import mx.tec.redacta.data.ModeloLocal
import mx.tec.redacta.domain.Tarea

@HiltViewModel
class RedactaViewModel @Inject constructor(
    private val modelo: ModeloLocal
) : ViewModel() {

    private val _ui = MutableStateFlow(RedactaUiState())
    val ui: StateFlow<RedactaUiState> = _ui.asStateFlow()

    init {
        viewModelScope.launch {
            modelo.estado.collect { estado -> _ui.update { it.copy(modelo = estado) } }
        }
        buscarModelo()
    }

    /** Busca el archivo y lo carga. Es también el botón «Ya lo copié: buscar otra vez». */
    fun buscarModelo() {
        viewModelScope.launch { modelo.cargar() }
    }

    fun alCambiarTexto(texto: String) = _ui.update { it.copy(texto = texto) }

    fun elegirTarea(tarea: Tarea) = _ui.update { it.copy(tarea = tarea) }

    /** «Usar este texto»: la respuesta pasa a ser tu texto, para pedirle otra cosa. */
    fun usarRespuesta(texto: String) = _ui.update { it.copy(texto = texto, respuesta = null) }

    fun redactar() {
        // B2
    }

    fun detener() {
        // B2
    }
}

adb push gemma3-1b-it-int4.litertlm /sdcard/Android/data/mx.tec.redacta/files/

package mx.tec.redacta.data

import android.content.Context
import com.google.ai.edge.litertlm.Backend
import com.google.ai.edge.litertlm.Content
import com.google.ai.edge.litertlm.Contents
import com.google.ai.edge.litertlm.ConversationConfig
import com.google.ai.edge.litertlm.Engine
import com.google.ai.edge.litertlm.EngineConfig
import com.google.ai.edge.litertlm.Message
import dagger.hilt.android.qualifiers.ApplicationContext
import java.io.File
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
import mx.tec.redacta.domain.EstadoModelo
import mx.tec.redacta.domain.Pedido

/**
 * Gemma 3 1B, con LiteRT-LM, en el CPU del teléfono.
 *
 * `@Singleton`: el modelo ocupa más de 1 GB de memoria y tarda segundos en
 * cargar. Se carga una vez y lo usa toda la app.
 */
@Singleton
class GemmaLocal @Inject constructor(
    @ApplicationContext private val contexto: Context
) : ModeloLocal {

    private val _estado = MutableStateFlow<EstadoModelo>(EstadoModelo.Cargando)
    override val estado: StateFlow<EstadoModelo> = _estado.asStateFlow()

    private var motor: Engine? = null
    private val candado = Mutex()

    override suspend fun cargar() = candado.withLock {
        if (motor != null) return@withLock
        // Donde lo deja `adb push`: la carpeta de la app en el almacenamiento compartido.
        val archivo = File(contexto.getExternalFilesDir(null), ARCHIVO)
        if (!archivo.exists()) {
            _estado.value = EstadoModelo.Falta(archivo.absolutePath)
            return@withLock
        }
        _estado.value = EstadoModelo.Cargando
        val nuevo = Engine(
            EngineConfig(
                modelPath = archivo.absolutePath,
                backend = Backend.CPU(),
                cacheDir = contexto.cacheDir.absolutePath
            )
        )
        runCatching { withContext(Dispatchers.Default) { nuevo.initialize() } }
            .onSuccess {
                motor = nuevo
                _estado.value = EstadoModelo.Listo
            }
            .onFailure { e ->
                // Si lo cancelaron, el motor sí llegó a cargar: se libera. Si falló, no hay nada que cerrar.
                if (nuevo.isInitialized()) nuevo.close()
                if (e is CancellationException) throw e
                _estado.value = EstadoModelo.Error(e.message ?: "No se pudo cargar el modelo")
            }
    }

    override fun generar(pedido: Pedido): Flow<String> = flow {
        val motor = checkNotNull(motor) { "El modelo todavía no está cargado" }
        val config = ConversationConfig(
            systemInstruction = pedido.instruccion?.let { Contents.of(it) },
            maxOutputToken = MAX_TOKENS
        )
        // Una conversación por pedido: sin historia, cada texto se trata solo.
        motor.createConversation(config).use { conversacion ->
            try {
                conversacion.sendMessageAsync(pedido.mensaje).collect { emit(it.texto()) }
            } catch (e: CancellationException) {
                conversacion.cancelProcess()   // que el CPU deje de generar lo que ya nadie va a leer
                throw e
            }
        }
    }.flowOn(Dispatchers.Default)

    private fun Message.texto(): String =
        contents.contents.filterIsInstance<Content.Text>().joinToString("") { it.text }

    companion object {
        const val ARCHIVO = "gemma3-1b-it-int4.litertlm"

        /** Un tope de seguridad. Que conteste corto lo pide la instrucción, no este número. */
        const val MAX_TOKENS = 256
    }
}

package mx.tec.redacta.domain

/**
 * Tokens por segundo, contados desde que llegó el PRIMERO.
 *
 * Lo de antes —leer tu texto y la instrucción— es otra fase, y en un
 * teléfono es mucho más rápida. Con un solo token todavía no hay intervalo
 * que medir: null.
 */
fun tokensPorSegundo(tokens: Int, milisDesdeElPrimero: Long): Double? =
    if (tokens < 2 || milisDesdeElPrimero <= 0) null
    else (tokens - 1) * 1000.0 / milisDesdeElPrimero

package mx.tec.redacta.ui.state

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.Job
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import mx.tec.redacta.data.ModeloLocal
import mx.tec.redacta.domain.Tarea
import mx.tec.redacta.domain.limpiar
import mx.tec.redacta.domain.tokensPorSegundo

@HiltViewModel
class RedactaViewModel @Inject constructor(
    private val modelo: ModeloLocal
) : ViewModel() {

    private val _ui = MutableStateFlow(RedactaUiState())
    val ui: StateFlow<RedactaUiState> = _ui.asStateFlow()

    private var redaccion: Job? = null

    init {
        viewModelScope.launch {
            modelo.estado.collect { estado -> _ui.update { it.copy(modelo = estado) } }
        }
        buscarModelo()
    }

    /** Busca el archivo y lo carga. Es también el botón «Ya lo copié: buscar otra vez». */
    fun buscarModelo() {
        viewModelScope.launch { modelo.cargar() }
    }

    fun alCambiarTexto(texto: String) = _ui.update { it.copy(texto = texto) }

    fun elegirTarea(tarea: Tarea) = _ui.update { it.copy(tarea = tarea) }

    /** «Usar este texto»: la respuesta pasa a ser tu texto, para pedirle otra cosa. */
    fun usarRespuesta(texto: String) = _ui.update { it.copy(texto = texto, respuesta = null) }

    fun redactar() {
        val actual = _ui.value
        if (!actual.puedeRedactar) return
        _ui.update { it.copy(respuesta = Respuesta(actual.tarea)) }
        redaccion = viewModelScope.launch {
            var tokens = 0
            var primero = 0L
            try {
                modelo.generar(actual.tarea.pedidoPara(actual.texto)).collect { pedazo ->
                    val ahora = System.nanoTime() / 1_000_000
                    if (tokens == 0) primero = ahora
                    tokens++
                    alResponder { r ->
                        r.copy(texto = r.texto + pedazo, tokens = tokens, tokensPorSegundo = tokensPorSegundo(tokens, ahora - primero))
                    }
                }
            } catch (e: CancellationException) {
                throw e
            } catch (e: Exception) {
                alResponder { it.copy(error = e.message ?: "El modelo no pudo contestar") }
            } finally {
                // Terminó, falló o lo detuviste: en los tres casos deja de generar.
                alResponder { r -> r.copy(texto = limpiar(r.texto), generando = false) }
            }
        }
    }

    /** Cancela la corrutina; GemmaLocal se entera y le dice al motor que pare. */
    fun detener() {
        redaccion?.cancel()
    }

    private fun alResponder(cambio: (Respuesta) -> Respuesta) =
        _ui.update { estado -> estado.copy(respuesta = estado.respuesta?.let(cambio)) }
}

package mx.tec.redacta.domain

/**
 * Lo que Redacta sabe hacer con tu texto, y cómo se le pide al modelo.
 *
 * Cuatro reglas que salieron de probar Gemma 3 1B, no de la teoría:
 *  1. El texto va ENMARCADO dentro del pedido («Texto: «…»»). Suelto, el
 *     modelo lo toma como un mensaje para él, y lo contesta.
 *  2. El pedido dice qué NO hacer: inventar, agregar introducción.
 *  3. Si el formato importa, un ejemplo resuelto vale más que explicarlo.
 *  4. Temperatura baja para no cambiar el sentido; alta para no repetirse.
 */
enum class Tarea(
    val etiqueta: String,
    val pedido: String,
    val rotulo: String = "Texto",
    val ejemplo: Ejemplo? = null,
    val temperatura: Double = 0.2
) {
    Amable(
        "Más amable",
        "Reescribe este texto con un tono amable y respetuoso. Conserva todos los datos y no inventes nada. " +
            "Escribe solo el texto nuevo.",
        ejemplo = Ejemplo(
            "Entreguen el proyecto el viernes. No voy a aceptar nada tarde, ni me escriban para pedir prórroga.",
            "Les recuerdo que el proyecto se entrega el viernes. Por favor, planéenlo con tiempo: esta vez " +
                "no podré aceptar entregas tarde ni dar prórrogas. ¡Gracias!"
        )
    ),
    Breve(
        "Más corto",
        "Resume este texto en una sola oración. Usa solo lo que dice el texto. Escribe solo el resumen."
    ),
    Responder(
        "3 respuestas",
        "Recibí este mensaje. Escribe tres respuestas cortas que yo podría enviar. " +
            "Numéralas 1., 2. y 3., una por renglón, sin nada más.",
        rotulo = "Mensaje",
        temperatura = 0.8
    );

    /** El texto del usuario, enmarcado en el pedido de esta tarea. */
    fun enmarcar(texto: String): String = "$pedido\n\n$rotulo: «${texto.trim()}»"

    fun pedidoPara(texto: String): Pedido = Pedido(
        mensaje = enmarcar(texto),
        ejemplo = ejemplo?.let { Ejemplo(enmarcar(it.pregunta), it.respuesta) },
        temperatura = temperatura
    )
}

        val config = ConversationConfig(
            systemInstruction = pedido.instruccion?.let { Contents.of(it) },
            // El ejemplo entra como si fuera una pregunta que el modelo ya contestó.
            initialMessages = pedido.ejemplo?.let { listOf(Message.user(it.pregunta), Message.model(it.respuesta)) }.orEmpty(),
            samplerConfig = pedido.temperatura?.let { SamplerConfig(topK = 40, topP = 0.95, temperature = it) },
            maxOutputToken = MAX_TOKENS
        )

import com.google.ai.edge.litertlm.SamplerConfig

package mx.tec.redacta.domain

/**
 * Las respuestas de la tarea «3 respuestas», cada una por separado.
 *
 * El modelo no siempre respeta el formato al pie de la letra: a veces escribe
 * «1)», a veces pone negritas, a veces agrega un renglón antes, y si le pides
 * «1., 2. y 3.» puede copiar hasta la coma: «1., Sí». Aquí se toman solo los
 * renglones numerados, y se limpian.
 */
fun separarOpciones(texto: String): List<String> =
    texto.lines()
        .mapNotNull { renglon -> NUMERADO.matchEntire(renglon.replace("**", "").trim())?.groupValues?.get(1) }
        .map { it.trim().trim('"', '«', '»', '“', '”').trim() }
        .filter { it.isNotEmpty() }

private val NUMERADO = Regex("""^\d+\s*[.)]\s*[,;:\-]?\s*(.+)$""")

            } finally {
                // Terminó, falló o lo detuviste: en los tres casos deja de generar.
                alResponder { r ->
                    val opciones = if (r.tarea == Tarea.Responder) separarOpciones(r.texto) else emptyList()
                    r.copy(texto = limpiar(r.texto), generando = false, opciones = opciones)
                }
            }

import mx.tec.redacta.domain.separarOpciones

[versions]
junit = "4.13.2"
coroutinesTest = "1.11.0"

[libraries]
junit = { group = "junit", name = "junit", version.ref = "junit" }
kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "coroutinesTest" }

    // Pruebas locales (src/test): corren en la JVM de tu computadora, sin emulador ni modelo.
    testImplementation(libs.junit)
    testImplementation(libs.kotlinx.coroutines.test)

package mx.tec.redacta

import kotlinx.coroutines.awaitCancellation
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.flow
import mx.tec.redacta.data.ModeloLocal
import mx.tec.redacta.domain.EstadoModelo
import mx.tec.redacta.domain.Pedido

/**
 * Un modelo de mentira: contesta al instante lo que le digas, y anota lo que
 * le pidieron. Implementa la misma interfaz que Gemma, así que el ViewModel
 * no nota la diferencia.
 */
class ModeloFalso(
    /** Lo que `cargar()` deja como estado: Listo, o Falta para probar sin archivo. */
    private val alCargar: EstadoModelo = EstadoModelo.Listo
) : ModeloLocal {

    private val _estado = MutableStateFlow<EstadoModelo>(EstadoModelo.Cargando)
    override val estado: StateFlow<EstadoModelo> = _estado

    /** Los pedazos de la próxima respuesta. */
    var pedazos: List<String> = listOf("Hola", ", ", "mundo")

    /** true: después del último pedazo se queda generando, hasta que lo cancelen. */
    var seQuedaGenerando = false

    /** Si no es null, falla con este error después de los pedazos. */
    var falla: Exception? = null

    val pedidos = mutableListOf<Pedido>()

    override suspend fun cargar() {
        _estado.value = alCargar
    }

    override fun generar(pedido: Pedido): Flow<String> = flow {
        pedidos += pedido
        pedazos.forEach { emit(it) }
        falla?.let { throw it }
        if (seQuedaGenerando) awaitCancellation()
    }
}

package mx.tec.redacta.ui.state

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.test.UnconfinedTestDispatcher
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.setMain
import mx.tec.redacta.ModeloFalso
import mx.tec.redacta.domain.EstadoModelo
import mx.tec.redacta.domain.Tarea
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test

/**
 * El ViewModel, con un modelo de mentira. Sin emulador, sin Gemma y sin Hilt:
 * el ViewModel se construye aquí, y por eso se le puede dar el modelo que sea.
 */
@OptIn(ExperimentalCoroutinesApi::class)
class RedactaViewModelTest {

    // viewModelScope corre en Dispatchers.Main. En la JVM no hay hilo principal de
    // Android: se cambia por uno que ejecuta todo en cuanto se pide (Práctica 11).
    @Before
    fun cambiarMain() {
        Dispatchers.setMain(UnconfinedTestDispatcher())
    }

    @After
    fun restaurarMain() {
        Dispatchers.resetMain()
    }

    private val modelo = ModeloFalso()

    private fun listoConTexto(texto: String = "mañana no hay clase") =
        RedactaViewModel(modelo).apply { alCambiarTexto(texto) }

    @Test
    fun al_crearse_busca_el_modelo() {
        val viewModel = RedactaViewModel(modelo)

        assertEquals(EstadoModelo.Listo, viewModel.ui.value.modelo)
    }

    @Test
    fun sin_modelo_no_se_puede_redactar() {
        val sinArchivo = ModeloFalso(alCargar = EstadoModelo.Falta("/ruta"))
        val viewModel = RedactaViewModel(sinArchivo)
        viewModel.alCambiarTexto("hola")

        viewModel.redactar()

        assertFalse(viewModel.ui.value.puedeRedactar)
        assertEquals(null, viewModel.ui.value.respuesta)
        assertTrue(sinArchivo.pedidos.isEmpty())
    }

    @Test
    fun la_respuesta_se_arma_con_los_pedazos_en_orden() {
        val viewModel = listoConTexto()

        viewModel.redactar()

        val respuesta = viewModel.ui.value.respuesta!!
        assertEquals("Hola, mundo", respuesta.texto)
        assertEquals(3, respuesta.tokens)
        assertFalse(respuesta.generando)
    }

    @Test
    fun al_terminar_se_quitan_los_espacios_de_mas() {
        modelo.pedazos = listOf("Les aviso.", "  Mañana", "  no hay clase.  ")
        val viewModel = listoConTexto()

        viewModel.redactar()

        assertEquals("Les aviso. Mañana no hay clase.", viewModel.ui.value.respuesta?.texto)
    }

    @Test
    fun al_modelo_le_llega_el_texto_enmarcado() {
        val viewModel = listoConTexto("  mañana no hay clase  ")
        viewModel.elegirTarea(Tarea.Breve)

        viewModel.redactar()

        assertEquals(Tarea.Breve.enmarcar("mañana no hay clase"), modelo.pedidos.single().mensaje)
    }

    @Test
    fun detener_corta_la_respuesta_y_deja_lo_que_llego() {
        modelo.seQuedaGenerando = true
        val viewModel = listoConTexto()
        viewModel.redactar()
        assertTrue(viewModel.ui.value.generando)

        viewModel.detener()

        assertFalse(viewModel.ui.value.generando)
        assertEquals("Hola, mundo", viewModel.ui.value.respuesta?.texto)
    }

    @Test
    fun mientras_genera_no_se_puede_pedir_otra() {
        modelo.seQuedaGenerando = true
        val viewModel = listoConTexto()

        viewModel.redactar()
        viewModel.redactar()

        assertEquals(1, modelo.pedidos.size)
    }

    @Test
    fun tres_respuestas_se_separan_al_terminar() {
        modelo.pedazos = listOf("1. ¡Claro!\n", "2. Hoy no puedo.\n", "3. Te los paso mañana.")
        val viewModel = listoConTexto()
        viewModel.elegirTarea(Tarea.Responder)

        viewModel.redactar()

        assertEquals(
            listOf("¡Claro!", "Hoy no puedo.", "Te los paso mañana."),
            viewModel.ui.value.respuesta?.opciones
        )
    }

    @Test
    fun si_el_modelo_falla_se_muestra_el_error() {
        modelo.falla = IllegalStateException("Sin memoria")
        val viewModel = listoConTexto()

        viewModel.redactar()

        val respuesta = viewModel.ui.value.respuesta!!
        assertEquals("Sin memoria", respuesta.error)
        assertFalse(respuesta.generando)
    }

    @Test
    fun usar_la_respuesta_la_vuelve_tu_texto() {
        val viewModel = listoConTexto()
        viewModel.redactar()

        viewModel.usarRespuesta("Hola, mundo")

        assertEquals("Hola, mundo", viewModel.ui.value.texto)
        assertEquals(null, viewModel.ui.value.respuesta)
    }
}

package mx.tec.redacta.domain

import org.junit.Assert.assertEquals
import org.junit.Test

/** Cada caso es un formato que el modelo de verdad ha escrito. */
class OpcionesTest {

    @Test
    fun tres_renglones_numerados() {
        assertEquals(
            listOf("¡Claro!", "Hoy no puedo.", "Mañana te digo."),
            separarOpciones("1. ¡Claro!\n2. Hoy no puedo.\n3. Mañana te digo.")
        )
    }

    @Test
    fun con_parentesis_y_negritas() {
        assertEquals(listOf("Sí", "No"), separarOpciones("**1)** Sí\n**2)** No"))
    }

    @Test
    fun ignora_la_introduccion() {
        assertEquals(listOf("Sí", "No"), separarOpciones("Aquí tienes tres opciones:\n1. Sí\n2. No"))
    }

    @Test
    fun quita_la_coma_que_copio_del_pedido() {
        // Se le pidió «Numéralas 1., 2. y 3.» y escribió «1., Sí, por favor.»
        assertEquals(listOf("Sí, por favor."), separarOpciones("1., Sí, por favor."))
    }

    @Test
    fun quita_las_comillas() {
        assertEquals(listOf("Te los paso hoy"), separarOpciones("1. «Te los paso hoy»"))
    }

    @Test
    fun sin_numeros_no_hay_opciones() {
        assertEquals(emptyList<String>(), separarOpciones("Claro, te los paso hoy en la noche."))
    }
}

package mx.tec.redacta.domain

import org.junit.Assert.assertEquals
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Test

class TareaTest {

    @Test
    fun el_texto_va_enmarcado_despues_del_pedido() {
        val mensaje = Tarea.Breve.enmarcar("  Mañana no hay clase.  ")

        assertTrue(mensaje.startsWith(Tarea.Breve.pedido))
        assertTrue(mensaje.endsWith("Texto: «Mañana no hay clase.»"))
    }

    @Test
    fun responder_enmarca_un_mensaje() {
        assertTrue(Tarea.Responder.enmarcar("¿Vienes?").endsWith("Mensaje: «¿Vienes?»"))
    }

    @Test
    fun el_ejemplo_se_enmarca_igual_que_el_texto() {
        val ejemplo = Tarea.Amable.pedidoPara("hola").ejemplo

        assertNotNull(ejemplo)
        assertTrue(ejemplo!!.pregunta.startsWith(Tarea.Amable.pedido))
    }

    @Test
    fun sin_instruccion_de_sistema() {
        // Todo va en el mensaje: Gemma no tiene un rol de sistema propio.
        Tarea.entries.forEach { assertNull(it.pedidoPara("hola").instruccion) }
    }

    @Test
    fun responder_se_arriesga_mas_que_las_demas() {
        assertEquals(0.2, Tarea.Amable.pedidoPara("x").temperatura!!, 0.0)
        assertTrue(Tarea.Responder.temperatura > Tarea.Breve.temperatura)
    }
}

package mx.tec.redacta.domain

import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Test

class VelocidadTest {

    @Test
    fun once_tokens_en_un_segundo_son_diez_por_segundo() {
        // Entre el primero y el último hay 10 intervalos, no 11.
        assertEquals(10.0, tokensPorSegundo(11, 1000)!!, 0.001)
    }

    @Test
    fun con_un_solo_token_no_hay_velocidad() {
        assertNull(tokensPorSegundo(1, 500))
    }

    @Test
    fun sin_tiempo_no_hay_velocidad() {
        assertNull(tokensPorSegundo(5, 0))
    }
}

        runCatching { nuevo.initialize() }

I Choreographer: Skipped 152 frames!  The application may be doing too much work on its main thread.

git commit -m "checkpoint c3: pedirle bien" -m "Co-Authored-By: Claude <noreply@anthropic.com>"