npm - @danieltmn/tamnora - Versions diffs - 0.8.0 → 0.9.1 - Mend

@danieltmn/tamnora 0.8.0 → 0.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

package/CHANGELOG.md +89 -0
package/harness/packages/cli/src/cli.js +1 -1
package/harness/packages/cli/src/commands/bridge.js +180 -119
package/harness/packages/cli/src/commands/server.js +26 -50
package/harness/packages/cli/src/lib/daemon.js +92 -40
package/harness/packages/cli/test/release.test.js +9 -0
package/harness/packages/core/src/agent/modes.js +1 -1
package/harness/packages/core/src/index.js +14 -1
package/harness/packages/core/src/open.js +43 -0
package/harness/packages/core/src/pid.js +35 -0
package/harness/packages/core/src/tools/executors.js +16 -0
package/harness/packages/core/src/tools/labels.js +2 -0
package/harness/packages/core/src/tools/permissions.js +1 -0
package/harness/packages/core/src/tools/schema.js +17 -0
package/harness/packages/core/src/tts/edge.js +232 -0
package/harness/packages/core/src/tunnel.js +180 -19
package/harness/packages/core/test/open.test.js +19 -0
package/harness/packages/core/test/tools.test.js +12 -0
package/harness/packages/core/test/tts.test.js +41 -0
package/harness/packages/server/public/app.js +4665 -3975
package/harness/packages/server/public/index.html +62 -5
package/harness/packages/server/public/reconcile.js +121 -0
package/harness/packages/server/public/relayClient.js +170 -0
package/harness/packages/server/public/runStream.js +207 -0
package/harness/packages/server/public/styles.css +142 -5
package/harness/packages/server/src/auth.js +29 -5
package/harness/packages/server/src/lib/agentRun.js +77 -0
package/harness/packages/server/src/lib/announcer.js +92 -0
package/harness/packages/server/src/lib/approvals.js +25 -3
package/harness/packages/server/src/lib/channels/telegram.js +85 -20
package/harness/packages/server/src/lib/ffmpeg.js +48 -0
package/harness/packages/server/src/lib/procs.js +3 -18
package/harness/packages/server/src/lib/runManager.js +24 -2
package/harness/packages/server/src/lib/sessionView.js +43 -0
package/harness/packages/server/src/lib/tasks.js +4 -9
package/harness/packages/server/src/lib/ttsSettings.js +42 -0
package/harness/packages/server/src/lib/workspace.js +37 -1
package/harness/packages/server/src/routes/chat.js +48 -47
package/harness/packages/server/src/routes/events.js +35 -0
package/harness/packages/server/src/routes/files.js +22 -26
package/harness/packages/server/src/routes/folders.js +9 -17
package/harness/packages/server/src/routes/git.js +6 -14
package/harness/packages/server/src/routes/procs.js +14 -16
package/harness/packages/server/src/routes/sessions.js +12 -19
package/harness/packages/server/src/routes/shell.js +5 -9
package/harness/packages/server/src/routes/state.js +32 -0
package/harness/packages/server/src/routes/tts.js +82 -0
package/harness/packages/server/src/server.js +21 -1
package/harness/packages/server/test/announcer.test.js +51 -0
package/harness/packages/server/test/reconcile.test.js +146 -0
package/harness/packages/server/test/relay.test.js +219 -0
package/harness/packages/server/test/runStream.test.js +245 -0
package/harness/packages/server/test/security.test.js +252 -0
package/harness/packages/server/test/server.test.js +511 -1
package/harness/packages/server/test/telegram-voz.test.js +156 -0
package/harness/packages/server/test/tts.test.js +133 -0
package/package.json +1 -1

package/harness/packages/server/public/index.html CHANGED Viewed

@@ -4,6 +4,7 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>Tamnora Console</title>
+    <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='7' fill='%23231a17'/%3E%3Ctext x='16' y='23' font-family='Georgia,serif' font-size='18' font-weight='700' fill='%23e8dfd6' text-anchor='middle'%3ET%3C/text%3E%3C/svg%3E" />
     <script>
       (function () {
         var theme = null;
@@ -29,11 +30,11 @@
       rel="stylesheet"
       href="https://fonts.googleapis.com/css2?family=DM+Mono:wght@400;500&family=Libre+Baskerville:wght@400;700&family=Manrope:wght@400;500;600;700&display=swap"
     />
-    <link rel="stylesheet" href="/styles.css" />
+    <link rel="stylesheet" href="styles.css" />
   </head>
   <body>
     <header class="topbar">
-      <div class="brand"><span class="logo"><span class="logo-t">T</span><span class="logo-h">H</span></span> <span class="ver">v0.8.0</span></div>
+      <div class="brand"><span class="logo"><span class="logo-t">T</span><span class="logo-h">H</span></span> <span class="ver">v0.9.1</span></div>
       <nav class="tabs">
         <button class="tab active" data-tab="chat">chat</button>
         <button class="tab" data-tab="providers">proveedores</button>
@@ -57,6 +58,12 @@
         </div>
       </nav>
       <div class="settings">
+        <button id="new-session-top" type="button" class="btn topbar-new" title="nueva sesión" aria-label="nueva sesión">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" aria-hidden="true">
+            <path d="M12 5v14M5 12h14" />
+          </svg>
+          <span class="topbar-new-label">nueva sesión</span>
+        </button>
         <button id="search-toggle" type="button" class="btn icon" title="buscar (Ctrl/Cmd+K)" aria-label="buscar">
           <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
             <circle cx="11" cy="11" r="8" />
@@ -130,8 +137,9 @@
             </div>
           </div>
           <form id="chat-form" class="composer">
-            <div id="slash-menu" class="slash-menu" hidden></div>
-            <div id="attach-preview" class="attach-preview" hidden></div>
+<div id="slash-menu" class="slash-menu" hidden></div>
+        <div id="toasts" class="toasts" aria-live="polite"></div>
+        <div id="attach-preview" class="attach-preview" hidden></div>
             <div id="chat-queue" class="chat-queue" hidden></div>
             <div class="composer-row">
               <span class="prompt-mark">❯</span>
@@ -156,6 +164,8 @@
             <span id="sb-model">—</span>
             <span class="dot">·</span>
             <span id="sb-activity" class="sb-activity" hidden></span>
+            <span id="sb-sync" class="sb-channel retrying" hidden title="sin sincronía con el server"></span>
+            <span id="sb-channel" class="sb-channel" hidden title="canal de eventos entre dispositivos"></span>
             <span id="sb-rounds">listo</span>
             <span class="spacer"></span>
             <span id="sb-context" class="ctx muted" title="uso del contexto del modelo">
@@ -395,6 +405,7 @@
             <button type="button" class="ajustes-tab" data-panel="mcp" role="tab">MCP</button>
             <button type="button" class="ajustes-tab" data-panel="skills" role="tab">Skills</button>
             <button type="button" class="ajustes-tab" data-panel="telegram" role="tab">Telegram</button>
+            <button type="button" class="ajustes-tab" data-panel="voz" role="tab">Voz</button>
             <button type="button" class="ajustes-tab" data-panel="limites" role="tab">Límites</button>
           </nav>
@@ -517,6 +528,52 @@
           </div>
         </div>
+        <div class="panel ajustes-panel" data-panel="voz">
+          <div class="row between">
+            <h2>Voz</h2>
+            <span id="voz-status" class="summary">cargando…</span>
+          </div>
+          <p class="muted verify-line">
+            El agente cuenta lo que hace con frases cortas (voces neuronales de Edge, sin API
+            key): arranque, herramientas y cierre. No lee la respuesta entera. En Telegram llega
+            como nota de voz al terminar.
+          </p>
+          <label class="check" title="hablar mientras trabaja">
+            <input id="voz-enabled" type="checkbox" /> Hablar mientras trabaja
+          </label>
+          <label class="field"><span>voz</span>
+            <select id="voz-voice" title="voz del catálogo de Edge"></select>
+          </label>
+          <label class="field"><span>velocidad</span>
+            <select id="voz-rate" title="velocidad del habla">
+              <option value="-20%">más lenta</option>
+              <option value="+0%">normal</option>
+              <option value="+20%">más rápida</option>
+            </select>
+          </label>
+          <div class="voz-announce">
+            <span class="muted">qué cuenta:</span>
+            <label class="check" title="avisar al arrancar el turno">
+              <input id="voz-ann-start" type="checkbox" /> el arranque
+            </label>
+            <label class="check" title="avisar las herramientas (como mucho una cada 20 s)">
+              <input id="voz-ann-tools" type="checkbox" /> las herramientas
+            </label>
+            <label class="check" title="avisar al terminar">
+              <input id="voz-ann-end" type="checkbox" /> el cierre
+            </label>
+          </div>
+          <p id="voz-ffmpeg" class="muted" hidden>
+            Sin <code>ffmpeg</code> en el PATH, en Telegram llega como audio MP3 en vez de nota
+            de voz.
+          </p>
+          <div class="row">
+            <button id="voz-save" class="btn primary" type="button">guardar</button>
+            <button id="voz-test" class="btn" type="button">probar voz</button>
+            <span id="voz-msg" class="summary"></span>
+          </div>
+        </div>
         <div class="panel ajustes-panel" data-panel="limites">
           <div class="row between">
             <h2>Límites del agente</h2>
@@ -698,6 +755,6 @@
       </div>
     </dialog>
-    <script type="module" src="/app.js"></script>
+      <script type="module" src="app.js"></script>
   </body>
 </html>

package/harness/packages/server/public/reconcile.js ADDED Viewed

@@ -0,0 +1,121 @@
+/**
+ * Reconciliacion entre el estado remoto (`GET /api/state`) y el local.
+ *
+ * Es puro a proposito: sin DOM, sin fetch, sin timers. Los tres intentos
+ * anteriores de arreglar "la consola no ve lo que pasa en otro dispositivo"
+ * fallaron porque esa logica vivia enterrada en un `app.js` de miles de lineas
+ * sin un solo test, asi que cada fix era una hipotesis. Este modulo se testea
+ * con `node:test` y cubre los casos que nos quemaron.
+ *
+ * Principio: los streams SSE son un **atajo de latencia**, nunca la verdad. La
+ * verdad se lee con un request corto, que es lo unico que sobrevive a un tunel
+ * con 4G (y a iOS matando los timers al mandar la pestana a background).
+ */
+/** Estado local minimo: que sesiones tiene abiertas la consola y como. */
+export function localState({ panes, asks }) {
+  return {
+    panes: [...panes].map(([id, pane]) => ({
+      id,
+      working: Boolean(pane.working),
+      attached: Boolean(pane.attached),
+    })),
+    asks: [...asks],
+  };
+}
+/**
+ * Compara el estado remoto con el local y dice que hay que hacer.
+ *
+ * @param {{panes: Array, asks: Array<string>}} local
+ * @param {{sessions: Array, permissions: Array}} remote
+ */
+export function diffState(local, remote) {
+  const sessions = remote?.sessions ?? [];
+  const permissions = remote?.permissions ?? [];
+  const panes = new Map((local?.panes ?? []).map((pane) => [pane.id, pane]));
+  const knownAsks = new Set(local?.asks ?? []);
+  const serverAsks = new Set(permissions.map((ask) => ask.askId));
+  const toAttach = [];
+  const toDetach = [];
+  const gone = [];
+  for (const session of sessions) {
+    const busy = session.running || session.awaiting > 0;
+    const pane = panes.get(session.id);
+    if (!pane) continue;
+    const attached = pane.working && pane.attached;
+    // Un permiso pendiente obliga a estar enganchado aunque `running` sea false:
+    // el permiso no se reconstruye desde los mensajes, vive en /api/state.
+    if (busy && !attached) toAttach.push(session.id);
+    else if (!busy && attached) toDetach.push(session.id);
+  }
+  for (const id of panes.keys()) {
+    if (!sessions.some((session) => session.id === id)) gone.push(id);
+  }
+  const newAsks = permissions.filter((ask) => !knownAsks.has(ask.askId));
+  const resolvedAsks = [...knownAsks].filter((askId) => !serverAsks.has(askId));
+  return {
+    toAttach,
+    toDetach,
+    gone,
+    newAsks,
+    resolvedAsks,
+    // Los permisos siguen esperando: el banner no se baja.
+    pending: permissions,
+    // Para repintar insignias sin volver a pegarle al server.
+    sessions,
+    remoteActive: sessions.filter((session) => session.running || session.awaiting > 0).map((session) => session.id),
+  };
+}
+/**
+ * Cada cuanto preguntar. Un permiso pendiente es algo que te esta esperando:
+ * ahí la latencia se nota y se paga. Idle, se aburre al server.
+ */
+export function pollDelayMs(state) {
+  const permissions = state?.permissions?.length ?? 0;
+  const running = (state?.sessions ?? []).some((session) => session.running);
+  if (permissions > 0) return 5000;
+  if (running) return 10000;
+  return 25000;
+}
+export function humanSize(text) {
+  const bytes = new TextEncoder().encode(String(text ?? '')).length;
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} kB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/**
+ * Resumen legible de los argumentos de una tool, para un permiso.
+ *
+ * Volcar el JSON crudo era inutil: al pedir permiso para `write` se veia medio
+ * archivo entero con los `\n` escapados, que es justo lo contrario de una
+ * pantalla hecha para decidir. Para `bash` lo que interesa es el comando; para
+ * las tools de archivo, la ruta y cuanto se esta escribiendo.
+ */
+export function summarizeArgs(name, args, max = 240) {
+  const cut = (value) => {
+    const text = String(value ?? '');
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+  };
+  const a = args ?? {};
+  if (name === 'bash' && a.command) return cut(a.command);
+  if ((name === 'write' || name === 'edit' || name === 'read') && a.path) {
+    return a.content ? `${a.path} · ${humanSize(a.content)}` : String(a.path);
+  }
+  if ((name === 'fetch_url' || name === 'preview_url') && a.url) return cut(a.url);
+  if (name === 'task' && (a.description || a.prompt)) return cut(a.description || a.prompt);
+  const keys = Object.keys(a);
+  if (keys.length === 1 && typeof a[keys[0]] === 'string') return cut(a[keys[0]]);
+  if (!keys.length) return '';
+  // Cualquier otra tool: el JSON, pero en una linea para que no aparezca un
+  // muro con los saltos de linea escapados.
+  return cut(JSON.stringify(a).replace(/\\n/g, ' '));
+}

package/harness/packages/server/public/relayClient.js ADDED Viewed

@@ -0,0 +1,170 @@
+// Transporte relay para la consola estatica (harness.tamnora.com/console/).
+//
+// La misma consola corre en el harness local y en el tamnora del sitio: aqui
+// cada llamada a `api()` y cada stream se manda por el mailbox del relay y el
+// daemon local (`tamnora bridge --tunnel relay`) la ejecuta contra su propio
+// server. El token (?t=...) es la credencial compartida con el mailbox.
+//
+// Requiere runStream.js (streamSse/delay) que ya carga la consola.
+import { streamSse, delay } from './runStream.js';
+export function installRelayTransport({ base, token }) {
+  const cleanToken = String(token ?? '').trim();
+  if (!cleanToken) {
+    console.warn('[relay] sin token: la consola vera solo la pantalla de login');
+  }
+  const b64decode = (value) =>
+    new TextDecoder().decode(Uint8Array.from(atob(String(value ?? '')), (c) => c.charCodeAt(0)));
+  const relayUrl = (action) => `${base}?a=${action}&t=${encodeURIComponent(cleanToken)}`;
+  async function post(action, payload, signal) {
+    const res = await fetch(relayUrl(action), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+      signal,
+    });
+    if (!res.ok) {
+      const error = new Error(`relay HTTP ${res.status}`);
+      error.status = res.status;
+      throw error;
+    }
+    return res.json();
+  }
+  function applyCookies(headers) {
+    for (const cookie of headers?.['set-cookie'] ?? []) {
+      const kv = String(cookie).split(';')[0];
+      if (kv && kv.includes('=')) document.cookie = `${kv}; Path=/`;
+    }
+  }
+  /** Request sincrono: PHP espera inline la respuesta completa del mailbox. */
+  async function request(path, { method = 'GET', body, headers = {} } = {}) {
+    const envelope = {
+      method,
+      path,
+      headers,
+      body: body === undefined ? null : JSON.stringify(body),
+      stream: false,
+    };
+    const data = await post('send', envelope);
+    if (data.error) {
+      const error = new Error(data.error);
+      error.status = Number(data.status) || 0;
+      throw error;
+    }
+    applyCookies(data.headers);
+    const text = b64decode(data.body);
+    let parsed = null;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = { raw: text };
+    }
+    if (Number(data.status) >= 400) {
+      const error = new Error(parsed?.error ?? `HTTP ${data.status}`);
+      error.status = Number(data.status);
+      throw error;
+    }
+    return parsed;
+  }
+  const parseOrRaw = (text) => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { raw: text };
+    }
+  };
+  /**
+   * Stream via mailbox: abre el rid y consume `a=stream` (SSE con cursor).
+   * Si el PHP corta (max_execution_time) reconecta y repite desde el cursor:
+   * el replay es del mailbox, NO re-ejecuta el request original.
+   */
+  async function stream(path, { method = 'POST', body, headers = {}, signal, silenceMs } = {}, onEvent) {
+    const envelope = {
+      method,
+      path,
+      headers,
+      body: body === undefined ? null : JSON.stringify(body),
+      stream: true,
+    };
+    const opened = await post('send', envelope, signal);
+    if (opened.error) {
+      const error = new Error(opened.error);
+      error.status = Number(opened.status) || 0;
+      throw error;
+    }
+    const rid = opened.rid;
+    let cursor = 0;
+    let attempt = 0;
+    for (;;) {
+      if (signal?.aborted) {
+        const error = new Error('Aborted', 'AbortError');
+        error.name = 'AbortError';
+        throw error;
+      }
+      try {
+        let finished = false;
+        await streamSse(
+          `${base}?a=stream&t=${encodeURIComponent(cleanToken)}&rid=${encodeURIComponent(rid)}&from=${cursor}`,
+          { signal, silenceMs },
+          (event, data, id) => {
+            if (id != null) cursor = Number(id) || cursor;
+            if (event === 'chunk') {
+              const payload = data?.payload ?? {};
+              if (!payload.done) {
+                onEvent(payload.ev || 'message', payload.data != null ? parseOrRaw(payload.data) : {}, payload.id ?? null);
+              }
+              return;
+            }
+            // meta: headers del run o cierre del daemon.
+            if (data?.payload?.done) finished = true;
+            else if (data?.payload?.error) {
+              const error = new Error(data.payload.error);
+              error.fatalRelay = true;
+              throw error;
+            }
+          }
+        );
+        return { finished };
+      } catch (error) {
+        if (error?.name === 'AbortError' || error?.fatalRelay) throw error;
+        attempt += 1;
+        await delay(Math.min(8000, 1000 * 2 ** (attempt - 1)), signal);
+      }
+    }
+  }
+  window.relayTransport = { token: cleanToken, base, request, stream, enabled: Boolean(cleanToken) };
+  return window.relayTransport;
+}
+/** Pantalla minima si no hay token: pide uno y recarga. */
+export function showRelayTokenGate() {
+  document.body.innerHTML = '';
+  document.body.style.visibility = 'visible';
+  const form = document.createElement('form');
+  form.style.cssText = 'max-width:420px;margin:15vh auto;font-family:ui-sans-serif,system-ui;padding:0 16px';
+  form.innerHTML = `
+    <h1 style="font-size:20px">Tamnora Console</h1>
+    <p style="color:#777;font-size:14px">Pegá el token del bridge (o escaneá el QR del <code>tamnora bridge --tunnel relay</code>).</p>
+    <input name="t" placeholder="token" style="width:100%;padding:10px;font-size:14px" autocomplete="off" />
+    <button style="margin-top:10px;padding:10px 16px">entrar</button>`;
+  form.addEventListener('submit', (event) => {
+    event.preventDefault();
+    const value = form.elements.t.value.trim();
+    if (!value) return;
+    localStorage.setItem('tamnora-relay-token', value);
+    const params = new URLSearchParams(location.search);
+    params.delete('t');
+    location.href = location.pathname + (params.toString() ? `?${params}` : '');
+    location.reload();
+  });
+  document.body.append(form);
+}

package/harness/packages/server/public/runStream.js ADDED Viewed

@@ -0,0 +1,207 @@
+// Streaming SSE resumible para la consola.
+//
+// El tunel (o un proxy) puede cortar la conexion sin que el `fetch` se entere:
+// `reader.read()` queda esperando para siempre y el turno se queda "pensando..."
+// sin fin. Estos helpers agregan un watchdog de silencio, recuerdan el cursor
+// (`id:`) de cada frame para reanudar donde se quedo, y reintentan con backoff.
+// El server manda un comentario `: ping` cada 15 s (lib/http.js). Tres pings
+// perdidos ya no son transitorios: algo se murio.
+export const SILENCE_MS = 45000;
+const DEFAULT_BACKOFF = [1000, 2000, 4000, 8000, 10000];
+function abortError() {
+  return new DOMException('Aborted', 'AbortError');
+}
+/** Espera `ms` abortable: si el caller cancela, no hay que esperar al timer. */
+export function delay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(abortError());
+    const timer = setTimeout(() => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(abortError());
+    }
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
+}
+/**
+ * Combina varias senales en una. No usamos `AbortSignal.any` porque en Android
+ * Chrome viejo no existe y la consola se abre mucho desde el celular.
+ */
+export function linkSignals(signals) {
+  const list = signals.filter(Boolean);
+  if (!list.length) return { signal: undefined, abort: () => {} };
+  if (list.length === 1) return { signal: list[0], abort: () => list[0].abort() };
+  const controller = new AbortController();
+  const onAbort = (event) => controller.abort(event.target.reason);
+  for (const signal of list) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener('abort', onAbort, { once: true });
+  }
+  return { signal: controller.signal, abort: () => controller.abort() };
+}
+async function httpError(res) {
+  let message = res.statusText;
+  try {
+    message = (await res.json())?.error ?? message;
+  } catch {
+    // nos quedamos con statusText
+  }
+  const error = new Error(message || `HTTP ${res.status}`);
+  error.status = res.status;
+  return error;
+}
+/** El stream quedo mudo: cortamos por nuestra cuenta, no el servidor. */
+function silentError(from) {
+  const error = new Error('La conexion quedo muda (se corto el stream).');
+  error.name = 'SilentStream';
+  error.resumable = true;
+  error.from = from;
+  return error;
+}
+/**
+ * Lee un stream SSE y entrega `(event, data, id)` por frame.
+ *
+ * Corta si pasan `silenceMs` sin bytes. Al hacerlo tira un error `SilentStream`
+ * con `from` = ultimo cursor recibido, para que el llamador pueda reanudar
+ * desde ahi en vez de desde cero.
+ */
+export async function streamSse(
+  url,
+  { method = 'GET', body, csrf, signal, silenceMs = SILENCE_MS, fetchImpl = fetch } = {},
+  onEvent
+) {
+  const headers = {};
+  if (body) headers['Content-Type'] = 'application/json';
+  if (method !== 'GET' && csrf) headers['x-csrf'] = csrf;
+  const watchdog = new AbortController();
+  let lastId = null;
+  let timer = null;
+  let silent = false;
+  const linked = linkSignals([signal, watchdog.signal]);
+  const arm = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      silent = true;
+      watchdog.abort();
+    }, silenceMs);
+  };
+  try {
+    const res = await fetchImpl(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+      signal: linked.signal,
+    });
+    if (!res.ok) throw await httpError(res);
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    arm();
+    for (;;) {
+      const { value, done } = await reader.read();
+      // Cualquier byte cuenta como vida: el heartbeat es un comentario SSE y
+      // nunca llega a `onEvent`.
+      arm();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let index;
+      while ((index = buffer.indexOf('\n\n')) !== -1) {
+        const frame = buffer.slice(0, index);
+        buffer = buffer.slice(index + 2);
+        let event = null;
+        let data = '';
+        let id = null;
+        for (const line of frame.split('\n')) {
+          if (line.startsWith('event:')) event = line.slice(6).trim();
+          else if (line.startsWith('data:')) data += line.slice(5).trim();
+          else if (line.startsWith('id:')) id = line.slice(3).trim();
+        }
+        if (id !== null) lastId = id;
+        // Frame de comentario (`: ping`): el watchdog ya lo conto como vida,
+        // pero no hay nada que entregar.
+        if (!event && !data) continue;
+        let parsed = {};
+        if (data) {
+          try {
+            parsed = JSON.parse(data);
+          } catch {
+            parsed = { raw: data };
+          }
+        }
+        try {
+          onEvent(event || 'message', parsed, id);
+        } catch (error) {
+          // Un error del handler NO es una caida del transporte: si lo dejamos
+          // pasar, `followRun` reintenta en bucle y el sintoma es un
+          // "reconectando..." eterno que no dice nada. Se propaga con su tipo
+          // para que el llamador pueda distinguirlo y no reintentar.
+          error.eventHandler = true;
+          throw error;
+        }
+      }
+    }
+    if (silent) throw silentError(lastId);
+  } catch (error) {
+    // Si el watchdog fue el que corto, el AbortError obscurece la causa.
+    if (silent && error?.name === 'AbortError') throw silentError(lastId);
+    throw error;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+export function backoffDelay(index, backoff = DEFAULT_BACKOFF) {
+  const step = backoff[Math.min(Math.max(index, 0), backoff.length - 1)];
+  return Number(step) || 1000;
+}
+/**
+ * Reintenta `open()` con backoff hasta que el run termine o se agoten los
+ * intentos.
+ *
+ * `open(cursor)` hace una conexion y devuelve `{ finished, cursor }` cuando el
+ * turno acaba, o tira error si el transporte se cayo. Los `AbortError` nunca se
+ * reintentan: son el usuario cancelando o el boton `parar`. Tampoco los errores
+ * marcados con `eventHandler`: esos son un bug de la consola, y reintentarlos
+ * solo tapa el sintoma y quema el backoff.
+ *
+ * `from` es el cursor inicial: se pasa el ultimo `id:` conocido cuando ya
+ * estabamos escuchando este turno y lo que se perdio esta despues.
+ */
+export async function followRun({ open, onRetry = null, backoff = DEFAULT_BACKOFF, attempts = Infinity, signal, from = 0, sleep = delay }) {
+  let cursor = Number(from) || 0;
+  let attempt = 0;
+  for (;;) {
+    if (signal?.aborted) throw abortError();
+    try {
+      const result = await open(cursor, signal);
+      if (result?.cursor !== undefined) cursor = result.cursor;
+      return { finished: true, cursor, attempts: attempt };
+    } catch (error) {
+      if (error?.name === 'AbortError' || error?.eventHandler) throw error;
+      // El error sabe hasta donde llegamos: preferimos su cursor.
+      if (error?.from != null) cursor = Number(error.from) || cursor;
+      attempt += 1;
+      if (attempt > attempts) throw error;
+      const wait = backoffDelay(attempt - 1, backoff);
+      onRetry?.({ attempt, delay: wait, error, cursor });
+      await sleep(wait, signal);
+    }
+  }
+}