Spaces:
Running
Running
Download js/engine/registro.js from UtopiaIA/elffuss-code: direct link, hf CLI and curl.
- Browser
- Download file 13.9 kB
-
https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/engine/registro.js
- Command line
-
hf download hf://spaces/UtopiaIA/elffuss-code/js/engine/registro.js
-
curl -L -o registro.js https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/engine/registro.js
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; | |
| } | |