elffuss-code / js /engine /registro.js
KikoCis's picture
Sync with code.elffuss.com (fc5b0ba): LFM3 on our own engine, installable app, VS Code extensions, new look; README refreshed
4bd8362 verified
Raw History Blame Contribute Delete
13.9 kB
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 UtopiaIA
// Elffuss Runtime · el REGISTRO de modelos: qué hay, dónde vive y cómo se lee.
// ─────────────────────────────────────────────────────────────────────────────
// Vive aparte del proveedor por una razón concreta: la app necesita SONDEAR si
// un modelo está disponible antes de ofrecerlo en el selector, y hacerlo
// importando el proveedor entero costaría traerse el motor completo a todo el
// que abra la página sin usarlo nunca.
//
// Tener las URLs en dos sitios ya salió mal una vez: cuando el 27B pasó de ser
// un fichero suelto a dos fragmentos en dos hosts, el sondeo de la app se quedó
// apuntando a la URL VIEJA, y nada lo habría dicho hasta que esa URL dejara de
// responder. Una sola fuente.
//
// Licencia: código propio, Apache-2.0 (ver SPDX arriba y LICENSE). Sin dependencias externas.
// Registro de modelos. `bytes` no es decorativo: se compara con el
// content-length real y avisa si el fichero de origen ha cambiado, porque un
// cambio de cuantización aguas arriba altera la salida sin previo aviso.
export const MODELS = {
// LFM3-1.7B (LiquidAI) en Q8_0: el modelo POR DEFECTO del motor.
//
// Híbrido de otra familia: 13 capas de convolución corta (sin estado más allá
// de su ventana de 6 tokens), 6 de atención global y 5 de atención por
// ventana de 256. Solo las 11 de atención pagan contexto.
//
// RAZONA. Sin razonar se queda claramente por detrás en tareas de agente;
// razonando se pone a la altura de modelos bastante más grandes, y el
// razonamiento le cuesta poco porque genera rápido.
//
// `muestreo` es el de su ficha para agentes y herramientas (0,1 / k50 / rep 1,1).
// `lote`: sin bucle recurrente dentro del despacho, un lote de prefill largo
// no compromete el escritorio (el forward se sigue troceando por capa y con
// respiros). Medido en la misma sesión: de 32 a 256, ×1,57; con el GEMM de
// ML Drift y un prompt de 2.048 tokens, 512 y 1.024 empatan por encima de 256.
//
// Licencia LFM Open License v1.0, NO Apache: se sirve con su LICENSE al lado
// (`licencia`), que es la condición para redistribuir los pesos.
'lfm3-1.7b': {
label: 'LFM3 1.7B · Q8_0',
url: 'https://m1.elffuss.com/lfm3-1.7b.q8',
bytes: 1846238496,
ctx: 32768,
razona: true,
presupuesto: 4000,
muestreo: { temperature: 0.1, topP: 1, topK: 50, minP: 0, presence: 0, repeatPenalty: 1.1 },
lote: 512,
licencia: 'https://m1.elffuss.com/lfm3-1.7b.LICENSE.txt',
},
// El mismo LFM3 en el QAD-Q4_0 de LiquidAI (entrenado para esa cuantización),
// para el MÓVIL. El Q8_0 no cabe ahí: la pestaña de un teléfono muere antes
// de sostenerlo, y este pesa poco más de la mitad. Con los interruptores
// rápidos genera más deprisa que el Q8_0 y pasa los mismos oráculos de
// llama.cpp. Contexto 8k y no 32k: la KV crece con el contexto y, a 32k,
// pesos y KV juntos se pasan del presupuesto del teléfono; a 8k es la cuarta parte.
//
// Se lee de Hugging Face fijado a una revisión (no `main`), sin redistribuirlo.
'lfm3-1.7b-q4': {
label: 'LFM3 1.7B · Q4_0',
url: 'https://huggingface.co/LiquidAI/LFM3-1.7B-GGUF/resolve/bad5729bba61d076fff20d2548e62526665af215/LFM3-1.7B-QAD-Q4_0.gguf',
bytes: 1049615680,
ctx: 8192,
razona: true,
presupuesto: 4000,
muestreo: { temperature: 0.1, topP: 1, topK: 50, minP: 0, presence: 0, repeatPenalty: 1.1 },
lote: 512,
licencia: 'https://huggingface.co/LiquidAI/LFM3-1.7B-GGUF/blob/bad5729bba61d076fff20d2548e62526665af215/LICENSE',
},
// MiniCPM5-2B en Q8_0.
//
// Entra sin tocar el motor porque su GGUF declara `general.architecture =
// llama`, que ya se lee. Es un transformer PURO: las 42 capas son de atención
// y las 42 pagan contexto, así que no tiene la ventaja del híbrido —en los
// Qwen la mayoría de los bloques son SSM con estado de tamaño fijo— y su
// caché KV por ficha es casi la del 27B teniendo diez veces menos parámetros.
//
// El fichero declara un contexto de 131.072 y aquí se pide 65.536. Lo que
// manda no es el modelo, es lo que cuesta su KV: a 131k en f16 no cabe en el
// presupuesto de una pestaña, y a 65k sí. Con la KV a 8 bits —no implementada
// todavía, hoy solo hay f16 y f32— el contexto declarado sería alcanzable.
//
// Q8_0 y no algo más pequeño a propósito: es uno de los dos únicos tipos que
// entran por el GEMM teselado del prefill. Un Q4_K cae al camino por filas y
// paga una relectura de los pesos POR CADA ficha del lote.
'minicpm5-2b': {
label: 'MiniCPM5 2B · Q8_0',
url: 'https://m1.elffuss.com/minicpm5-2b.q8',
bytes: 2679710688,
ctx: 65536,
// RAZONA, con presupuesto amplio. En tareas de agente, con el razonamiento
// cerrado se paraba al segundo paso sin tocar ningún fichero, y razonando sí
// avanzaba; darle más presupuesto que este no lo mejoraba. provider.js abre
// el bloque y cuenta el razonamiento dentro de este tope.
razona: true,
presupuesto: 4000,
},
'qwen35-0.8b': {
label: 'Qwen3.5 0.8B · Q8_0',
url: 'https://huggingface.co/ggml-org/Qwen3.5-0.8B-GGUF/resolve/main/Qwen3.5-0.8B-Q8_0.gguf',
bytes: 833592096,
// 64k, medido en los dos modelos: la reserva funciona y el prefill NO cambia
// (el contexto cuesta memoria, no tiempo — solo se paga por los tokens que
// de verdad se procesan). Con la caché en f16 son la mitad de bytes que la
// cuenta de antes: el modelo grande pide la mitad de memoria para la misma
// ventana.
//
// Si no cupiera, `provider.js` baja por mitades hasta 2048 en vez de dejar
// al usuario sin modelo: un contexto de 16k sigue siendo ocho veces el de
// antes y no se parece en nada a no tener modelo.
ctx: 65536,
},
// El 27B, en dos fragmentos. Es una opción avanzada por lo que CUESTA, no por
// lo que falle: la descarga es grande y el prefill de un prompt largo, lento;
// el retraso cae entero antes del primer token. llama.cpp no lee su formato,
// así que se comprueba internamente por piezas —el formato contra su
// definición publicada, la rotación contra la matriz explícita, que se aplique
// a todos los tensores que la declaran— y de extremo a extremo: que conteste
// con sentido.
//
// El `bytes` es el del fichero verificado: si el de origen cambia de
// cuantización, la salida cambia sin avisar y esto lo caza.
'qwen38-27b': {
// El id es el de antes por compatibilidad (las apps lo escriben a mano); el
// modelo es el ternario de Prism ML. Frente a las alternativas del mismo
// tamaño, su matmul gana porque NO hay codebook: el peso sale de un
// desplazamiento y una máscara, no de una tabla de rejilla con gather
// disperso por carril.
//
// Se elige el formato PQ2_0 y no el PTQ1_0 aunque ocupe más: 128 pesos a
// 2 bits son 32 bytes JUSTOS y, con subgrupos de 32 carriles, toca un byte
// por carril, sin divergencia. El de base 3 reparte en tres etapas de tamaños
// distintos y va 1,53x más lento. Y se puede trasladar la medida de calidad
// entre los dos porque guardan los MISMOS pesos bit a bit (comprobado en 4
// tensores, 20.480 valores).
//
// ⚠️ Requiere la rotación de Hadamard sobre las activaciones: el fichero la
// declara en sus metadatos y `hadamard.js` la aplica. Un motor que no la
// tenga NO falla — carga y devuelve ruido.
label: 'Bonsai 27B · ternario',
// Servido desde el host del BROKER, no desde la web. Ahí el broker lo lee
// en su MISMO origen (sin CORS de por medio) y lo guarda en el almacén de
// ese origen, pensado para que las webs de Elffuss no se lo bajen cada una.
// Y el host deja leerlo por CORS a las webs de Elffuss, así que desde ellas
// el camino directo —sin broker— también funciona.
//
// Servido desde la propia web era IMPOSIBLE compartirlo: el broker vive en
// otro origen y sin CORS su fetch fallaba con «Failed to fetch», sin más
// explicación.
// REPARTIDO entre dos hosts, y la razón es medible: la cuota del navegador
// es POR ORIGEN. En uno solo el modelo entero no cabía fiable; en dos, cada
// mitad va sobrada. Y como los dos son subdominios del mismo sitio, lo
// guardado puede servir a las demás webs de Elffuss sin volver a bajarlo.
//
// `bytes` por fragmento NO es decorativo: si uno cambia de tamaño, las
// fronteras se desplazan y todo lo que venga detrás se lee corrido — basura
// sin un solo error.
url: [
{ url: 'https://m1.elffuss.com/bonsai-27b.p0', bytes: 3602907136 },
{ url: 'https://m2.elffuss.com/bonsai-27b.p1', bytes: 3603261792 },
],
// El tamaño exacto del fichero servido (los dos fragmentos juntos): si
// cambia, el motor avisa en cada carga de que el origen ha cambiado.
bytes: 7206168928,
// 512 era INVIABLE y no por poco: el prompt de sistema de Elffuss son 626
// tokens él solo (medido con este mismo tokenizador), así que la caché KV
// reventaba —«la caché se llena»— antes de que el usuario escribiera nada.
// El modelo no fallaba: no llegaba a ver la pregunta.
//
// Subirlo NO cuesta tiempo, cuesta memoria: `ctx` solo dimensiona la caché
// KV (cuatro veces más a 2048 que a 512). El prefill lo paga el número de
// tokens que se procesan de verdad, que es el mismo. Bajarlo para «ir más
// rápido» fue confundir las dos cosas.
ctx: 65536, // ver la nota del modelo pequeño: medido, y con red si no cabe
// SE CACHEA: el almacén del anfitrión lo guarda entre visitas, y la segunda
// carga no vuelve a pedirlo por red.
cache: true,
// El muestreo de la ficha de Prism para responder SIN razonar (que es como
// lo usa el motor): 0,7 / 0,8 / top-k 20 / min-p 0 / presence 1,5, y sin la
// penalización de repetición: es lo que recomienda quien lo cuantizó. Y
// respuestas de hasta 2000 fichas: escribe ficheros enteros, y 512 los
// cortaba.
muestreo: { temperature: 0.7, topP: 0.8, topK: 20, minP: 0, presence: 1.5, repeatPenalty: 1 },
tope: 2000,
// El prompt compacto ESTUVO aquí y se ha quitado. La razón de ponerlo era
// de velocidad: el completo tarda más en procesarse y el usuario espera
// mirando una caja quieta. Pero un prompt recortado deja al modelo sin
// saber hacer tareas, y un asistente que carga, responde y no sirve para
// nada es peor que uno lento — probado en uso real, no en un banco.
//
// El coste de volver al prompt completo es un primer prefill más largo.
// Eso se ataca donde toca: reutilizando el prefijo entre turnos (ya hecho,
// ver provider.js) y guardando la foto del estado entre SESIONES, que es lo
// que hace que se pague una vez y no cada vez que se abre la web.
},
};
// ¿Se puede usar este modelo AHORA? Se pregunta a los ficheros de verdad, con
// una petición de un solo byte por fragmento: comprueba de paso que el host
// responda, que admita rangos y que el CORS deje leerlo, que es exactamente lo
// que hará la carga después. Ofrecer una opción que falla al elegirla es peor
// que no ofrecerla.
// Todos los ORIGENES donde puede haber pesos guardados.
//
// Cada fragmento lo guarda el broker de SU PROPIO host (ver `model-broker.js`),
// asi que un modelo repartido entre dos servidores ocupa DOS origenes. El panel
// de almacenamiento preguntaba solo al broker por defecto y por eso enseñaba
// una fraccion: con el 27B guardado en m1 y m2, el contador miraba a un tercer
// origen que no tiene nada. Una cifra de ocupacion que no suma donde estan los
// bytes es peor que no tenerla, porque parece exacta.
export function origenesAlmacen() {
// Solo los origenes NUESTROS: un modelo servido desde un tercero (Hugging
// Face, por ejemplo) no tiene nuestra pagina de broker, asi que preguntarle
// no devolveria nada y ademas costaria la espera entera del timeout, con el
// panel colgado por un origen que nunca iba a responder.
const NUESTRO = /(^|\.)elffuss\.com$|(^|\.)utopiaia\.com$|^localhost$/;
const o = new Set();
for (const m of Object.values(MODELS)) {
const urls = Array.isArray(m.url) ? m.url.map(f => f.url) : (m.url ? [m.url] : []);
for (const u of urls) {
try {
const { hostname, origin } = new URL(u);
if (NUESTRO.test(hostname)) o.add(origin + '/');
} catch { /* url relativa o rara */ }
}
}
return [...o];
}
export async function disponible(id) {
const m = MODELS[id];
if (!m) return false;
const urls = Array.isArray(m.url) ? m.url.map(f => f.url) : [m.url];
try {
const rs = await Promise.all(urls.map(u =>
fetch(u, { headers: { Range: 'bytes=0-0' }, cache: 'no-store' })));
return rs.every(r => r.ok);
} catch { return false; }
}
// ¿Se guarda este modelo en el navegador? Normalmente lo dice el registro, pero
// se puede FORZAR desde fuera con `localStorage['elffuss.engine.cache']`
// ('1' enciende, '0' apaga).
//
// No es un ajuste para usuarios, es un instrumento: el cacheo del 27B solo se
// comprueba de verdad en una web servida, y sin este interruptor la única forma
// de probarlo sería encendérselo a todo el mundo. Si sale mal, quien lo paga es
// quien esté cargando el modelo en ese momento: la descarga entera perdida y
// vuelta a empezar por el otro camino.
export function cachea(m) {
try {
const o = localStorage.getItem('elffuss.engine.cache');
if (o === '1') return true;
if (o === '0') return false;
} catch { /* sin localStorage (worker, sandbox) */ }
return m.cache !== false;
}