Spaces:
Running
Running
Download js/conversations.js from UtopiaIA/elffuss-code: direct link, hf CLI and curl.
- Browser
- Download file 23.6 kB
-
https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/conversations.js
- Command line
-
hf download hf://spaces/UtopiaIA/elffuss-code/js/conversations.js
-
curl -L -o conversations.js https://huggingface.co/spaces/UtopiaIA/elffuss-code/resolve/main/js/conversations.js
23.6 kB
| // Conversaciones: varias a la vez, como pestañas — cada una con su propio | |
| // historial (su propio Agent) y su propia cola de mensajes pendientes. | |
| // Cerrar una pestaña NO borra la conversación (solo la Historial sí). Todo | |
| // persiste en IndexedDB, sobrevive a recargar. | |
| // | |
| // Procesado: cada conversación acepta y encola mensajes de forma totalmente | |
| // independiente (mandar en la pestaña B mientras la A está pensando no | |
| // bloquea nada). La generación en sí (la llamada real al modelo) se | |
| // serializa con un cerrojo global — solo hay UN modelo cargado en el | |
| // navegador y una sesión de inferencia no admite dos generate() a la vez sin | |
| // corromperse — así que las conversaciones se turnan para «hablar» con el | |
| // modelo, pero cada una sigue funcionando y aceptando mensajes de forma | |
| // independiente mientras espera su turno. | |
| import { Agent } from './agent.js'; | |
| import { runGoal, TASK_PREFIX } from './goal.js'; | |
| import * as db from './db.js'; | |
| import * as telemetry from './telemetry.js'; | |
| const NS = 'elffusscode'; | |
| const TABS_KEY = NS + '.openTabs'; | |
| const ACTIVE_KEY = NS + '.activeConv'; | |
| const HIST_CAP = 80; // mensajes por conversación que se persisten | |
| let providerRef = null; | |
| const convs = new Map(); // id -> { id, title, agent, queue, pumping, createdAt, updatedAt } | |
| let openTabIds = []; | |
| let activeId = null; | |
| let onChange = () => {}; | |
| const genId = () => 'c' + Date.now().toString(36) + Math.random().toString(36).slice(2, 7); | |
| const cleanTitle = s => String(s).replace(/\s+/g, ' ').trim(); | |
| const GOAL_PREFIX = TASK_PREFIX + 'Objetivo: '; | |
| export function titleFor(conv) { | |
| if (conv.title) return conv.title; | |
| const firstUser = conv.agent.history.find(m => | |
| m.role === 'user' && !m.content.startsWith('[resultado') && | |
| (!m.content.startsWith(TASK_PREFIX) || m.content.startsWith(GOAL_PREFIX))); | |
| if (!firstUser) return 'Nueva conversación'; | |
| // el objetivo lleva un prefijo interno ([tarea-objetivo] Objetivo: …) que | |
| // no debe filtrarse al título de la pestaña — se muestra el texto limpio. | |
| const raw = firstUser.content.startsWith(GOAL_PREFIX) ? firstUser.content.slice(GOAL_PREFIX.length) : firstUser.content; | |
| const t = cleanTitle(raw); | |
| return t.length > 40 ? t.slice(0, 40) + '…' : t || 'Nueva conversación'; | |
| } | |
| export function setProvider(mod) { | |
| providerRef = mod; | |
| for (const c of convs.values()) c.agent.setProvider(mod); | |
| } | |
| export function getProvider() { return providerRef; } | |
| export function isBusy() { | |
| for (const c of convs.values()) if (c.pumping || c.queue.length) return true; | |
| return false; | |
| } | |
| export function getActive() { return activeId ? convs.get(activeId) : null; } | |
| // Parar la conversación activa mientras trabaja: aborta el turno en curso (su | |
| // señal llega al agente, al proveedor y a las herramientas), vacía la cola y lo | |
| // GUARDA YA. Antes la cola vaciada solo vivía en memoria hasta que el turno | |
| // terminaba: si recargabas justo después de parar, el mensaje parado seguía en | |
| // IndexedDB y se volvía a ejecutar al abrir. | |
| // | |
| // `parando` cubre el rato entre el clic y el final real del turno (un modelo | |
| // lento tarda en soltar la generación): la UI lo enseña como «Parando…» en vez | |
| // de dejar un ■ que parece no hacer caso. Sin turno en marcha no hay nada que | |
| // soltar, y se dice ya que está parado. | |
| export function stopActive() { | |
| const c = getActive(); | |
| if (!c || (!c.pumping && !c.queue.length)) return false; | |
| c.stopped = true; | |
| c.parando = c.pumping; | |
| try { c.aborter?.abort(); } catch { /* */ } | |
| try { c.agent.stop(); } catch { /* */ } | |
| c.queue.length = 0; | |
| persistConv(c).catch(e => console.warn('[elffuss] no se pudo guardar la cola vaciada', e)); | |
| onChange('stopping', c.id, c.parando); | |
| return true; | |
| } | |
| export function getOpenTabs() { return openTabIds.map(id => convs.get(id)).filter(Boolean); } | |
| // Todas las conversaciones viven en UNA clave ('conversations'), y guardar una | |
| // es leer la lista entera, cambiar su registro y escribirla entera. Dos de esas | |
| // a la vez se pisan: la que escribe la última lo hace con lo que leyó ANTES de | |
| // la otra y borra lo que la otra guardó. Pasaba al parar un mensaje que | |
| // esperaba turno: se saltaba y guardaba justo cuando la conversación que tenía | |
| // el cerrojo guardaba su respuesta, y esa respuesta desaparecía de IndexedDB con | |
| // su mensaje aún en cola, así que al recargar se volvía a ejecutar (en un IDE | |
| // con agente, otra vez las ediciones y los comandos). Por eso cada escritura de | |
| // la lista espera a la anterior, y cada una lee el estado del momento en que le | |
| // toca, no el del momento en que se pidió. | |
| let escrituras = Promise.resolve(); | |
| function enOrden(fn) { | |
| const hecho = escrituras.then(fn, fn); | |
| escrituras = hecho.catch(() => {}); | |
| return hecho; | |
| } | |
| function persistConv(conv) { return enOrden(() => persistConvYa(conv)); } | |
| async function persistConvYa(conv) { | |
| // Borrada desde la Historial (también mientras su guardado esperaba): no se | |
| // vuelve a escribir, o resucitaría. | |
| if (conv.borrada || convs.get(conv.id) !== conv) return; | |
| // NO tragarse el error de lectura: un fallo transitorio devolvía [] y el | |
| // db.set de abajo reescribía el store entero con UNA sola conversación, | |
| // borrando el resto. Distinguir «no existe aún» (undefined → []) de «no se | |
| // pudo leer» (excepción → no escribir nada este turno). | |
| let stored; | |
| try { stored = await db.get('kv', 'conversations'); } | |
| catch (e) { console.warn('[elffuss] no se pudo leer conversations; no sobrescribo', e); return; } | |
| const all = stored == null ? [] : stored; | |
| if (!Array.isArray(all)) { console.warn('[elffuss] conversations corrupto; no sobrescribo'); return; } | |
| const i = all.findIndex(c => c.id === conv.id); | |
| const rec = { | |
| id: conv.id, title: titleFor(conv), history: conv.agent.history.slice(-HIST_CAP), | |
| queue: conv.queue, plan: planParaGuardar(conv), createdAt: conv.createdAt, updatedAt: conv.updatedAt, | |
| }; | |
| if (i >= 0) all[i] = rec; else all.push(rec); | |
| await db.set('kv', 'conversations', all).catch(() => {}); | |
| } | |
| // El plan de un objetivo PARADO que aún se está soltando se guarda ya como | |
| // parado: stopActive() guarda en el acto (para que recargar no repita nada), y | |
| // en ese momento el plan en memoria todavía dice «ejecutando», con su tarea en | |
| // curso. Recargando antes de que el objetivo terminase de soltarse, la tarjeta | |
| // decía «ejecutando…» para siempre sin que nada se ejecutara. Es lo mismo que | |
| // runGoal deja al terminar: la tarea en curso parada y las pendientes saltadas. | |
| function planParaGuardar(conv) { | |
| const plan = conv.plan || null; | |
| if (!plan || !conv.stopped || (plan.status !== 'planning' && plan.status !== 'running')) return plan; | |
| return { | |
| ...plan, status: 'stopped', | |
| tasks: (plan.tasks || []).map(t => ({ | |
| ...t, status: t.status === 'in-progress' ? 'stopped' : t.status === 'pending' ? 'skipped' : t.status, | |
| })), | |
| }; | |
| } | |
| function persistMeta() { | |
| try { localStorage.setItem(TABS_KEY, JSON.stringify(openTabIds)); } catch { /* lleno */ } | |
| try { localStorage.setItem(ACTIVE_KEY, activeId || ''); } catch { /* lleno */ } | |
| } | |
| function makeConv(id, saved) { | |
| const conv = { | |
| id, title: saved?.title || null, agent: new Agent(providerRef), | |
| queue: saved?.queue ? [...saved.queue] : [], pumping: false, plan: saved?.plan || null, | |
| createdAt: saved?.createdAt || Date.now(), updatedAt: saved?.updatedAt || Date.now(), | |
| }; | |
| if (saved?.history) conv.agent.history = saved.history; | |
| convs.set(id, conv); | |
| return conv; | |
| } | |
| export function create() { | |
| const conv = makeConv(genId()); | |
| openTabIds.push(conv.id); | |
| activeId = conv.id; | |
| persistMeta(); | |
| onChange('switch', conv.id); | |
| return conv; | |
| } | |
| // reabre una conversación guardada (de la Historial) como pestaña, o activa | |
| // la pestaña si ya estaba abierta | |
| export async function open(id) { | |
| if (!convs.has(id)) { | |
| const saved = (await db.get('kv', 'conversations').catch(() => null) || []).find(c => c.id === id); | |
| if (!saved) return null; | |
| makeConv(id, saved); | |
| } | |
| if (!openTabIds.includes(id)) openTabIds.push(id); | |
| activeId = id; | |
| persistMeta(); | |
| onChange('switch', id); | |
| return convs.get(id); | |
| } | |
| export function switchTo(id) { | |
| if (!convs.has(id) || activeId === id) return; | |
| activeId = id; | |
| persistMeta(); | |
| onChange('switch', id); | |
| } | |
| // añade un mensaje fuera del ciclo normal de envío (p.ej. el informe | |
| // autónomo del cerebro CEO) al historial REAL de una conversación — si no, | |
| // solo viviría en el DOM y desaparecería al cambiar de pestaña o recargar. | |
| // `extra` se guarda junto al mensaje (p. ej. la propuesta que acompaña al | |
| // informe del cerebro, para volver a pintar su botón al recargar). | |
| export async function appendMessage(id, role, content, extra = {}) { | |
| const c = convs.get(id); | |
| if (!c) return; | |
| c.agent.history.push({ ...extra, role, content, ts: Date.now() }); | |
| c.updatedAt = Date.now(); | |
| await persistConv(c); | |
| } | |
| // Ponerle nombre a una conversación (menú de su pestaña). Vacío vuelve al | |
| // título automático (el primer mensaje). | |
| export async function rename(id, title) { | |
| const c = convs.get(id); | |
| if (!c) return; | |
| c.title = cleanTitle(title || '').slice(0, 80) || null; | |
| await persistConv(c); | |
| onChange('tabs', activeId); | |
| } | |
| // quita la pestaña de la vista — la conversación sigue viva en la Historial | |
| // | |
| // Si la pestaña cerrada era la ACTIVA, se avisa con 'switch' y no con 'tabs': | |
| // con 'tabs' la barra se repintaba pero el chat seguía enseñando la | |
| // conversación cerrada, y lo siguiente que escribías iba a parar a otra que no | |
| // estaba en pantalla. | |
| export function closeTab(id) { | |
| const eraActiva = activeId === id; | |
| openTabIds = openTabIds.filter(x => x !== id); | |
| if (eraActiva) activeId = openTabIds[openTabIds.length - 1] || null; | |
| persistMeta(); | |
| if (!openTabIds.length) create(); | |
| else onChange(eraActiva ? 'switch' : 'tabs', activeId); | |
| } | |
| // borra la conversación de verdad (desde la Historial) | |
| // | |
| // Si estaba trabajando se para antes de borrarla: su turno, al terminar, | |
| // llamaba a persistConv y la volvía a escribir en IndexedDB, así que una | |
| // conversación borrada resucitaba en la Historial. | |
| export async function remove(id) { | |
| const c = convs.get(id); | |
| if (c) { | |
| c.borrada = true; | |
| c.queue.length = 0; | |
| try { c.aborter?.abort(); } catch { /* */ } | |
| try { c.agent.stop(); } catch { /* */ } | |
| } | |
| convs.delete(id); | |
| const eraActiva = activeId === id; | |
| openTabIds = openTabIds.filter(x => x !== id); | |
| if (eraActiva) activeId = openTabIds[openTabIds.length - 1] || null; | |
| // En la misma fila que los guardados: si no, un guardado en curso de esta | |
| // conversación la volvía a meter después de borrarla. | |
| await enOrden(async () => { | |
| const all = (await db.get('kv', 'conversations').catch(() => null) || []).filter(c => c.id !== id); | |
| await db.set('kv', 'conversations', all).catch(() => {}); | |
| }); | |
| persistMeta(); | |
| if (!openTabIds.length) create(); | |
| else onChange(eraActiva ? 'switch' : 'tabs', activeId); | |
| } | |
| export async function listAll() { | |
| const all = await db.get('kv', 'conversations').catch(() => null) || []; | |
| return all.slice().sort((a, b) => b.updatedAt - a.updatedAt); | |
| } | |
| // ---- envío / procesado ---- | |
| // items de la cola: {kind:'chat'|'goal'|'hard', text} — 'chat' es un turno normal | |
| // (agent.handle), 'goal' dispara el planificador/ejecutor de goal.js, 'hard' | |
| // el Hard Work (ver setHardWorkRunner). Las | |
| // colas persistidas ANTES de que existiera el modo Objetivo guardaban texto | |
| // suelto (strings) — normalizeItem() los sigue aceptando como 'chat'. | |
| let inferenceLock = Promise.resolve(); | |
| const normalizeItem = it => (typeof it === 'string' ? { kind: 'chat', text: it } : it); | |
| // Reanudar lo que quedó a medias, UNA VEZ HAY CEREBRO. Lo llama main.js después | |
| // de cargar el modelo. | |
| // | |
| // La guarda del contador no es paranoia: si un turno se llevó la pestaña por | |
| // delante —pasa con el modelo grande y poca memoria— reanudarlo al abrir la | |
| // vuelve a tumbar, y el usuario entra en un bucle del que no puede salir ni | |
| // abriendo la web. Se cuenta el intento ANTES de ejecutar y se persiste; si el | |
| // turno acaba, el item sale de la cola y el contador se va con él. Si la | |
| // pestaña muere, el contador sobrevive y al tercer intento ya no se reanuda | |
| // solo: se avisa y decide el usuario. | |
| const MAX_INTENTOS = 2; | |
| export function resumePending(onAviso = () => {}) { | |
| for (const conv of convs.values()) { | |
| if (!conv.queue.length) continue; | |
| const it = normalizeItem(conv.queue[0]); | |
| if ((it.intentos || 0) >= MAX_INTENTOS) { | |
| onAviso(conv.id, it); | |
| continue; | |
| } | |
| pump(conv); | |
| } | |
| } | |
| // Descarta el turno atascado y sigue con el resto de la cola. Para el botón del | |
| // aviso: sin esto, una conversación con un turno que cuelga queda bloqueada | |
| // para siempre y no hay forma de usarla. | |
| export async function descartarPendiente(id) { | |
| const conv = convs.get(id); | |
| if (!conv || !conv.queue.length) return; | |
| conv.queue.shift(); | |
| await persistConv(conv); | |
| if (conv.queue.length) pump(conv); | |
| } | |
| // Cada mensaje de la cola lleva su id: la UI marca «en cola» (⏳) la burbuja de | |
| // ESE mensaje y se la quita cuando empieza su turno ('turn' trae el item). Los | |
| // tres envíos devuelven el id. | |
| const genQid = () => 'q' + Date.now().toString(36) + Math.random().toString(36).slice(2, 7); | |
| function encola(id, kind, text) { | |
| const conv = convs.get(id); | |
| if (!conv) return null; | |
| const item = { kind, text, id: genQid() }; | |
| conv.queue.push(item); | |
| persistConv(conv); | |
| pump(conv); | |
| return item.id; | |
| } | |
| export function send(id, text) { return encola(id, 'chat', text); } | |
| // 🎯 Modo Objetivo: en vez de un turno de chat normal, el mensaje se trata | |
| // como un objetivo — se planifica en tareas y se ejecutan una a una (ver | |
| // goal.js, mismo patrón planificador/ejecutor de clonagent). | |
| export function startGoal(id, text) { return encola(id, 'goal', text); } | |
| // ⛏ Hard Work: lee el proyecto entero por partes. Va por la MISMA cola que el | |
| // resto: así el ■ lo para, la conversación se ve ocupada (el cerebro CEO | |
| // espera) y la pregunta y la respuesta se guardan como cualquier turno. Antes | |
| // corría por fuera: no se podía parar y desaparecía al cambiar de pestaña. | |
| // Quien sabe leer el proyecto (main.js) registra cómo se ejecuta. | |
| let hardWorkRunner = null; | |
| export function setHardWorkRunner(fn) { hardWorkRunner = fn; } | |
| export function startHardWork(id, text) { return encola(id, 'hard', text); } | |
| // true cuando le toca el turno; false si la parada llega antes. | |
| function turnoOParada(turno, signal) { | |
| if (signal.aborted) return Promise.resolve(false); | |
| return new Promise(resolve => { | |
| const alParar = () => resolve(false); | |
| signal.addEventListener('abort', alParar, { once: true }); | |
| turno.then(() => { signal.removeEventListener('abort', alParar); resolve(true); }); | |
| }); | |
| } | |
| // Cada turno lleva su propia parada (conv.aborter), creada ANTES de esperar el | |
| // cerrojo: parar mientras espera turno lo cancela sin llegar a llamar al | |
| // modelo. Antes la parada solo alcanzaba al turno que ya estaba generando, así | |
| // que un mensaje parado en la cola se ejecutaba igual en cuanto le tocaba. | |
| // | |
| // Y el turno solo se quita de la cola si sigue siendo el primero. Parar vacía | |
| // la cola, y lo que el usuario mande justo después entra en ella mientras el | |
| // turno parado termina de soltarse: el `shift()` a ciegas de antes se llevaba | |
| // ESE mensaje nuevo, y además el `break` por conv.stopped dejaba la cola | |
| // parada con él dentro. Mandar algo después de parar no obtenía respuesta. | |
| async function pump(conv) { | |
| if (conv.pumping) return; | |
| conv.pumping = true; | |
| onChange('pumping', conv.id, true); | |
| while (conv.queue.length) { | |
| const item = normalizeItem(conv.queue[0]); | |
| conv.queue[0] = item; // misma referencia para saber luego si sigue ahí | |
| // Lo que está en la cola llegó DESPUÉS de cualquier parada (parar la vacía), | |
| // así que la marca de la parada anterior no le aplica. Tampoco «Parando…»: | |
| // una parada que cayó entre dos turnos no tenía turno que soltar. | |
| conv.stopped = false; | |
| if (conv.parando) { conv.parando = false; onChange('stopping', conv.id, false); } | |
| // La parada del turno existe ANTES de la primera espera (guardar el intento | |
| // y luego el cerrojo): un ■ que cae en cualquiera de las dos lo cancela. | |
| const aborter = (conv.aborter = new AbortController()); | |
| const signal = aborter.signal; | |
| // El intento se cuenta y se GUARDA antes de ejecutar: si el turno se lleva | |
| // la pestaña, esto es lo único que queda para saber que ya se intentó. | |
| // Guardarlo después no serviría de nada — no habría «después». | |
| item.intentos = (item.intentos || 0) + 1; | |
| await persistConv(conv); | |
| const myTurn = inferenceLock; | |
| let release; | |
| inferenceLock = new Promise(r => { release = r; }); | |
| // Espera su turno de inferencia (un solo modelo cargado, no admite 2 | |
| // generate() a la vez)… o la parada, lo que llegue antes. Parar un mensaje | |
| // que solo espera turno no tiene nada que soltar: antes el botón se quedaba | |
| // en «Parando…» todo lo que durase el turno de OTRA conversación. Su hueco | |
| // en el cerrojo se suelta igualmente en orden, cuando lo suelte el de | |
| // delante, para que nadie se cuele por detrás mientras aquel sigue. | |
| const tengoTurno = await turnoOParada(myTurn, signal); | |
| if (!tengoTurno) myTurn.then(release); | |
| try { | |
| // Parado (o quitado de la cola) mientras esperaba: ni se llama al modelo, | |
| // y se dice en el chat como cualquier otro turno parado. | |
| if (signal.aborted && !tengoTurno) { | |
| try { onChange('event', conv.id, { type: 'aborted', text: '(Parado.)' }); } catch (e) { console.error('[elffuss] fallo pintando un evento de chat', e); } | |
| } | |
| if (tengoTurno && !signal.aborted && conv.queue[0] === item) { | |
| // Empieza DE VERDAD este mensaje: la UI deja de pintarlo «en cola». | |
| conv.turno = item; | |
| try { onChange('turn', conv.id, item); } catch (e) { console.error('[elffuss] fallo pintando el inicio de un turno', e); } | |
| // un fallo aquí (del modelo, de una tool, o del propio repintado en | |
| // main.js) NUNCA debe dejar la conversación "pumping" para siempre — | |
| // eso bloquearía sus futuros mensajes Y al cerebro CEO (isBusy()). | |
| // Tasa de resolución y tiempo por tarea. Se mide aquí, que es donde una | |
| // tarea empieza y acaba de verdad: el motor solo ve turnos y no sabe qué | |
| // es una tarea. «Resuelta» = ni excepción ni evento de error, porque el | |
| // fallo típico no es una excepción sino una respuesta que llega al | |
| // usuario como error — contar solo excepciones daría un 100 % perpetuo. | |
| // Una tarea PARADA no cuenta ni como resuelta ni como fallida: la cortó | |
| // quien la pidió. Contarla como resuelta inflaría la tasa (parar no | |
| // emite 'error'), y como fallida la hundiría por pulsar ■. Y va con el | |
| // cerebro que la empezó: el velocímetro solo apunta las del motor. | |
| const tTarea = (typeof performance !== 'undefined' ? performance.now() : Date.now()); | |
| const cerebro = providerRef; | |
| let huboError = false, parada = false; | |
| const onEvent = ev => { | |
| if (ev && ev.type === 'error') huboError = true; | |
| if (ev && ev.type === 'aborted') parada = true; | |
| try { onChange('event', conv.id, ev); } catch (e) { console.error('[elffuss] fallo pintando un evento de chat', e); } | |
| }; | |
| try { | |
| if (item.kind === 'goal') await runGoal(conv, item.text, onEvent, { signal }); | |
| else if (item.kind === 'hard' && hardWorkRunner) await hardWorkRunner(conv, item.text, onEvent, { signal }); | |
| else await conv.agent.handle(item.text, onEvent, { signal }); | |
| } finally { | |
| if (!parada && !signal.aborted) { | |
| try { | |
| const vm = await import('./velocimetro.js'); | |
| const fin = (typeof performance !== 'undefined' ? performance.now() : Date.now()); | |
| vm.tarea({ ok: !huboError, ms: fin - tTarea, cerebro }); | |
| } catch { /* sin velocímetro la app funciona igual */ } | |
| } | |
| } | |
| } | |
| } catch (e) { | |
| console.error('[elffuss] fallo procesando el turno', e); | |
| telemetry.reportError('pump: ' + (e?.message || e), { stack: e?.stack || '' }); | |
| try { onChange('event', conv.id, { type: 'error', text: 'Error interno: ' + (e?.message || e) }); } catch { /* ya está registrado arriba */ } | |
| } finally { if (tengoTurno) release(); } | |
| if (conv.turno === item) conv.turno = null; | |
| if (conv.aborter === aborter) conv.aborter = null; | |
| if (conv.queue[0] === item) conv.queue.shift(); | |
| conv.updatedAt = Date.now(); | |
| // «Parando…» se quita aquí solo si hay otro turno detrás. Si la cola queda | |
| // vacía se quita DESPUÉS del bucle, junto con `pumping`: quitarlo aquí, con | |
| // la conversación aún «trabajando» mientras se guarda, devolvía el botón a | |
| // un ■ «Parar» habilitado durante ese rato antes de pasar a «Enviar». | |
| if (conv.parando && conv.queue.length) { conv.parando = false; onChange('stopping', conv.id, false); } | |
| await persistConv(conv); | |
| } | |
| const sueltaParada = conv.parando; // una parada que llegó entre turnos ya no tiene nada que esperar | |
| conv.parando = false; | |
| conv.pumping = false; | |
| if (sueltaParada) onChange('stopping', conv.id, false); | |
| onChange('pumping', conv.id, false); | |
| } | |
| export async function init({ onEvent }) { | |
| onChange = onEvent; | |
| // migración única: el esquema viejo era UNA sola conversación (kv/history + kv/queue) | |
| const already = await db.get('kv', 'conversations').catch(() => null); | |
| if (!already) { | |
| const oldHistory = await db.get('kv', 'history').catch(() => null); | |
| if (oldHistory?.length) { | |
| const oldQueue = await db.get('kv', 'queue').catch(() => null); | |
| await db.set('kv', 'conversations', [{ | |
| id: genId(), title: null, history: oldHistory, queue: oldQueue || [], | |
| createdAt: Date.now(), updatedAt: Date.now(), | |
| }]).catch(() => {}); | |
| } | |
| } | |
| let tabIds = [], active = null; | |
| try { tabIds = JSON.parse(localStorage.getItem(TABS_KEY) || '[]'); } catch { /* corrupto */ } | |
| try { active = localStorage.getItem(ACTIVE_KEY) || null; } catch { /* */ } | |
| const all = await db.get('kv', 'conversations').catch(() => null) || []; | |
| for (const id of tabIds) { | |
| const saved = all.find(c => c.id === id); | |
| if (saved) { makeConv(id, saved); openTabIds.push(id); } | |
| } | |
| if (active && convs.has(active)) activeId = active; | |
| else if (openTabIds.length) activeId = openTabIds[0]; | |
| if (!openTabIds.length) { | |
| // nada abierto (primera vez, o se perdió el estado de pestañas): retoma | |
| // la conversación más reciente si hay alguna, si no, una nueva vacía | |
| const mostRecent = all.slice().sort((a, b) => b.updatedAt - a.updatedAt)[0]; | |
| if (mostRecent) { makeConv(mostRecent.id, mostRecent); openTabIds.push(mostRecent.id); activeId = mostRecent.id; } | |
| else create(); | |
| } | |
| // NO se reanuda aquí. Esta línea hacía `pump(conv)` directamente, y `init()` | |
| // corre ANTES de que el modelo esté cargado: el proveedor en ese momento es | |
| // `rules`, así que al refrescar a mitad de turno el mensaje en cola se | |
| // reprocesaba con el cerebro BÁSICO y se gastaba — peor que no reanudar, | |
| // porque además parecía que había contestado. Ahora lo dispara quien sabe | |
| // que hay cerebro: main.js, tras cargar el modelo, llamando a | |
| // `resumePending()`. | |
| persistMeta(); | |
| } | |