@danieltmn/tamnora 0.5.1 → 0.6.1

package/harness/packages/server/test/server.test.js

@@ -6,6 +6,7 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { createTamnoraServer } from '../src/index.js';
 import { setHome, ensureApp, readApp, writeApp, makeUser } from '../../core/src/index.js';
+import { completionFooter } from '../src/lib/channels/telegram.js';
 
 const fakeProvider = {
   id: 'fake',
@@ -141,6 +142,172 @@ test('streams a chat turn over SSE and persists the messages', async () => {
   }
 });
 
+test('persists the run log and replays it on the stream endpoint', async () => {
+  const { instance, base } = await startServer();
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'hola', model: 'm' }),
+      })
+    ).text();
+    const list = await (await fetch(`${base}/api/sessions`)).json();
+    const id = list.sessions[0].id;
+
+    const stream = await (await fetch(`${base}/api/sessions/${id}/stream?from=0`)).text();
+    assert.match(stream, /event: start/);
+    assert.match(stream, /event: text/);
+    assert.match(stream, /event: done/);
+    assert.match(stream, /event: idle/);
+    assert.match(stream, /^id: \d+$/m);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('keeps a run alive after the client disconnects and can stop it', async () => {
+  let release;
+  const gate = new Promise((resolve) => (release = resolve));
+  const slowProvider = {
+    id: 'slow',
+    async streamChat(_config, { onEvent, signal }) {
+      onEvent?.({ type: 'text', delta: '…', full: '…' });
+      await new Promise((resolve, reject) => {
+        if (signal?.aborted) return reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+        signal?.addEventListener('abort', () =>
+          reject(Object.assign(new Error('aborted'), { name: 'AbortError' }))
+        );
+        gate.then(resolve);
+      });
+      return { content: 'fin', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider: slowProvider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ model: 'm' }),
+      })
+    ).json();
+    const id = created.session.id;
+
+    const controller = new AbortController();
+    const chat = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'hola', model: 'm', sessionId: id }),
+      signal: controller.signal,
+    }).catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 80));
+    controller.abort();
+    await chat;
+
+    const during = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    assert.equal(during.running, true);
+
+    const stopped = await (
+      await fetch(`${base}/api/sessions/${id}/stop`, { method: 'POST', headers: json })
+    ).json();
+    assert.equal(stopped.stopped, true);
+
+    release();
+    await new Promise((resolve) => setTimeout(resolve, 80));
+    const after = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    assert.equal(after.running, false);
+  } finally {
+    release();
+    await instance.close();
+  }
+});
+
+test('done reports max_rounds and the tool count when the model never answers', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-loop-'));
+  await writeFile(path.join(cwd, 'a.txt'), 'hola');
+  let seq = 0;
+  const provider = {
+    id: 'loop',
+    async streamChat() {
+      seq += 1;
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          { id: `call_${seq}`, function: { name: 'read', arguments: JSON.stringify({ path: 'a.txt' }) } },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    const sse = await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'leé', model: 'm', maxRounds: 2 }),
+      })
+    ).text();
+    assert.match(sse, /event: done/);
+    assert.match(sse, /"stopReason":"max_rounds"/);
+    const match = sse.match(/"toolCalls":(\d+)/);
+    assert.ok(match && Number(match[1]) >= 2, 'el done debe reportar las tools usadas');
+    assert.match(sse, /"durationMs":\d+/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('completionFooter resume el cierre del turno', () => {
+  assert.equal(completionFooter('end_turn', 1, 0, 0), '✓ terminado · 1 ronda');
+  assert.equal(completionFooter('end_turn', 3, 5, 1200), '✓ terminado · 3 rondas · 5 herramientas · 1.2s');
+  assert.match(completionFooter('max_rounds', 2, 2, 300), /^⚠ máximo de rondas · 2 rondas · 2 herramientas · 300ms$/);
+});
+
+test('configures Telegram from the console (masked token)', async () => {
+  const { instance, base } = await startServer({ telegram: false });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    let data = await (await fetch(`${base}/api/channels`)).json();
+    assert.equal(data.telegram.tokenSet, false);
+    assert.equal(data.telegram.transcribeModel, 'whisper-1');
+
+    let res = await fetch(`${base}/api/channels/telegram`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ allowedChatIds: '123, 456', transcribeModel: '' }),
+    });
+    data = await res.json();
+    assert.deepEqual(data.telegram.allowedChatIds, ['123', '456']);
+    assert.equal(data.telegram.transcribeModel, 'whisper-1');
+
+    res = await fetch(`${base}/api/channels/telegram`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ token: '123456:ABCDEFghij' }),
+    });
+    data = await res.json();
+    assert.equal(data.telegram.tokenSet, true);
+    assert.match(data.telegram.tokenHint, /ghij$/);
+    assert.doesNotMatch(JSON.stringify(data), /ABCDEF/);
+
+    // Mandar la mascara no pisa el token real.
+    res = await fetch(`${base}/api/channels/telegram`, {
+      method: 'PUT',
+      headers: json,
+      body: JSON.stringify({ token: data.telegram.tokenHint, allowedChatIds: ['1'] }),
+    });
+    data = await res.json();
+    assert.equal(data.telegram.tokenSet, true);
+    assert.match(data.telegram.tokenHint, /ghij$/);
+  } finally {
+    await instance.close();
+  }
+});
+
 test('manages MCP servers from the console', async () => {
   const { instance, base } = await startServer();
   const json = { 'Content-Type': 'application/json' };
@@ -898,13 +1065,58 @@ test('plan mode exposes only read-only tools and adds guidance', async () => {
         body: JSON.stringify({ input: 'planificá', model: 'm', mode: 'plan' }),
       })
     ).text();
-    assert.deepEqual(captured.tools, ['fetch_url', 'git_diff', 'git_log', 'git_status', 'glob', 'grep', 'list', 'read']);
+    assert.deepEqual(captured.tools, ['fetch_url', 'git_diff', 'git_log', 'git_status', 'glob', 'grep', 'list', 'read', 'task']);
     assert.match(captured.system, /modo PLAN/);
   } finally {
     await instance.close();
   }
 });
 
+test('the agent can delegate to a subagent with the task tool', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-task-'));
+  const provider = {
+    id: 'multi',
+    async streamChat(_config, { messages, onEvent }) {
+      const isSub = messages.some((m) => m.role === 'system' && /subagente/i.test(String(m.content)));
+      if (isSub) {
+        onEvent?.({ type: 'text', delta: 'resumen', full: 'resumen subagente' });
+        return { content: 'resumen subagente', reasoning: '', toolCalls: [] };
+      }
+      const done = messages.some((m) => m.role === 'tool' && m.name === 'task');
+      if (done) return { content: 'listo', reasoning: '', toolCalls: [] };
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          { id: 't1', function: { name: 'task', arguments: JSON.stringify({ description: 'explorar', prompt: 'leé el proyecto' }) } },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const stream = await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'delegá', model: 'm' }),
+      })
+    ).text();
+    assert.match(stream, /event: agent_start/);
+    assert.match(stream, /event: agent_end/);
+
+    const list = await (await fetch(`${base}/api/sessions`)).json();
+    const id = list.sessions[0].id;
+    const agents = await (await fetch(`${base}/api/sessions/${id}/agents`)).json();
+    assert.equal(agents.agents.length, 1);
+    assert.equal(agents.agents[0].status, 'done');
+    assert.match(agents.agents[0].summary, /resumen subagente/);
+  } finally {
+    await instance.close();
+  }
+});
+
 test('aggregates the token usage of a session', async () => {
   const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tokens-'));
   const provider = {

package/harness/packages/server/test/telegram.test.js

@@ -0,0 +1,94 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { Store } from '../../core/src/index.js';
+import { createApprovalBroker } from '../src/lib/approvals.js';
+import { startTelegramChannel } from '../src/lib/channels/telegram.js';
+
+const reply = (data) => ({ ok: true, json: async () => data });
+
+function installFetchMock() {
+  const sent = [];
+  const updates = [];
+  const original = global.fetch;
+  global.fetch = async (url, opts = {}) => {
+    const method = String(url).split('/').pop();
+    const body = opts.body ? JSON.parse(opts.body) : {};
+    if (method === 'getUpdates') {
+      const out = updates.splice(0, updates.length);
+      if (!out.length) await new Promise((resolve) => setTimeout(resolve, 20));
+      return reply({ ok: true, result: out });
+    }
+    if (method === 'sendMessage' || method === 'editMessageText') {
+      sent.push(body);
+      return reply({ ok: true, result: { message_id: sent.length } });
+    }
+    return reply({ ok: true, result: true });
+  };
+  return { sent, updates, restore: () => { global.fetch = original; } };
+}
+
+function makeCtx(cwd) {
+  const store = new Store(':memory:');
+  const provider = {
+    id: 'fake',
+    async streamChat(_config, { onEvent }) {
+      onEvent?.({ type: 'text', delta: 'listo', full: 'listo' });
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  return {
+    cwd,
+    config: { maxRounds: 2, permissions: {}, telegram: {} },
+    app: {},
+    store,
+    approvals: createApprovalBroker({ timeoutMs: 1000 }),
+    effectiveProviderId: () => 'fake',
+    effectiveModel: () => 'm',
+    effectiveMode: () => 'agent',
+    providerSettings: () => ({ baseUrl: 'http://127.0.0.1:1', apiKey: '' }),
+    apiKeyFor: () => '',
+    customProviderDefs: () => [],
+    resolveProvider: () => ({ provider, config: {} }),
+    getMcp: async () => null,
+    systemPromptFor: async () => 'sys',
+    agentTools: { definitions: [], handles: () => false, execute: async () => '' },
+  };
+}
+
+async function waitFor(fn, timeout = 3000) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (fn()) return;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  throw new Error('timeout esperando la condición');
+}
+
+test('el canal de Telegram cierra el turno y muestra el panel', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tg-'));
+  const ctx = makeCtx(cwd);
+  const mock = installFetchMock();
+  const channel = startTelegramChannel(ctx, { token: 'x', allowedChatIds: ['7'], log: () => {} });
+  try {
+    mock.updates.push({ update_id: 1, message: { chat: { id: 7 }, text: 'hola' } });
+    await waitFor(() => mock.sent.some((m) => /✓ terminado/.test(m.text ?? '')));
+    const completion = mock.sent.find((m) => /✓ terminado/.test(m.text ?? ''));
+    assert.match(completion.text, /listo/);
+    assert.match(completion.text, /1 ronda/);
+
+    mock.updates.push({ update_id: 2, message: { chat: { id: 7 }, text: '/menu' } });
+    await waitFor(() => mock.sent.some((m) => m.reply_markup?.inline_keyboard));
+    const menu = mock.sent.find((m) => m.reply_markup?.inline_keyboard);
+    const datas = menu.reply_markup.inline_keyboard.flat().map((b) => b.callback_data);
+    assert.ok(datas.includes('mode:plan'));
+    assert.ok(datas.includes('menu:models'));
+    assert.ok(datas.includes('menu:stop'));
+  } finally {
+    channel.stop();
+    mock.restore();
+    ctx.store.close();
+  }
+});

package/harness/tamnora.example.json

@@ -28,5 +28,6 @@
     "allow": ["npm", "node", "npx", "pnpm", "yarn", "bun", "php", "python", "composer"]
   },
   "preview": { "provider": "tunnelmole" },
-  "telegram": { "token": "", "allowedChatIds": [] }
+  "telegram": { "token": "", "allowedChatIds": [], "transcribeModel": "whisper-1" },
+  "agents": { "maxRounds": 6 }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",

package/harness/packages/server/src/lib/telegram.js

@@ -1,267 +0,0 @@
-import { runAgent, createTools, resolveMode } from './core.js';
-import { resolveExistingDir } from './workspace.js';
-
-const API = 'https://api.telegram.org';
-
-const HELP = [
-  'Tamnora Harness — bot',
-  '',
-  '/new — nueva sesión',
-  '/status — proveedor, modelo, modo y sesión',
-  '/model <id> — cambia el modelo',
-  '/provider <id> — cambia el proveedor',
-  '/mode plan|build — cambia el modo',
-  '/stop — cancela la respuesta en curso',
-  '/help — esta ayuda',
-  '',
-  'Cualquier otro texto se envía al agente.',
-].join('\n');
-
-async function tg(token, method, payload) {
-  const res = await fetch(`${API}/bot${token}/${method}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(payload ?? {}),
-  });
-  let data = null;
-  try {
-    data = await res.json();
-  } catch {
-    data = null;
-  }
-  if (!data?.ok) {
-    const error = new Error(data?.description || `HTTP ${res.status}`);
-    error.status = res.status;
-    throw error;
-  }
-  return data.result;
-}
-
-function splitMessage(text, max = 3900) {
-  const value = String(text ?? '').trim() || '(sin texto)';
-  const parts = [];
-  for (let i = 0; i < value.length; i += max) parts.push(value.slice(i, i + max));
-  return parts;
-}
-
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-/**
- * Bot de Telegram por long polling (no necesita URL publica). Los chats
- * autorizados conversan con el mismo engine del harness; cada chat mapea a una
- * sesion. Devuelve `{ stop }` o `null` si no hay token.
- */
-export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () => {} } = {}) {
-  if (!token) return null;
-  const allowed = new Set(allowedChatIds.map(String));
-  const controllers = new Map();
-  let running = true;
-  let offset = 0;
-
-  const authorized = (chatId) => allowed.size > 0 && allowed.has(String(chatId));
-  const sessionKey = (chatId) => `telegram:chat:${chatId}`;
-
-  async function send(chatId, text) {
-    let first = null;
-    for (const chunk of splitMessage(text)) {
-      const result = await tg(token, 'sendMessage', { chat_id: chatId, text: chunk, disable_web_page_preview: true });
-      if (!first) first = result;
-    }
-    return first;
-  }
-
-  async function edit(chatId, messageId, text) {
-    const parts = splitMessage(text);
-    await tg(token, 'editMessageText', { chat_id: chatId, message_id: messageId, text: parts[0], disable_web_page_preview: true }).catch(() => null);
-    for (let i = 1; i < parts.length; i++) {
-      await tg(token, 'sendMessage', { chat_id: chatId, text: parts[i], disable_web_page_preview: true }).catch(() => null);
-    }
-  }
-
-  function ensureSession(chatId) {
-    const key = sessionKey(chatId);
-    let sessionId = ctx.store.getSetting(key);
-    if (!sessionId || !ctx.store.getSession(sessionId)) {
-      sessionId = ctx.store.createSession({
-        title: `Telegram ${chatId}`,
-        provider: ctx.effectiveProviderId(),
-        model: ctx.effectiveModel(),
-        cwd: ctx.cwd,
-        meta: { telegramChatId: String(chatId) },
-      });
-      ctx.store.setSetting(key, sessionId);
-    }
-    return sessionId;
-  }
-
-  async function run(chatId, input) {
-    const sessionId = ensureSession(chatId);
-    const session = ctx.store.getSession(sessionId);
-    const providerId = session.provider || ctx.effectiveProviderId();
-    const model = session.model || ctx.effectiveModel();
-    if (!model) {
-      await send(chatId, 'Falta el modelo. Usá /model <id> o configurá uno en Ajustes.');
-      return;
-    }
-    const mode = resolveMode(ctx.effectiveMode());
-    const cwd = resolveExistingDir(session.cwd || ctx.cwd);
-    const history = ctx.store.getMessages(sessionId);
-
-    let mcp = null;
-    try {
-      mcp = await ctx.getMcp();
-    } catch {
-      mcp = null;
-    }
-
-    const local = createTools({
-      root: cwd,
-      enabled: mode.tools ?? undefined,
-      permissions: ctx.config.permissions,
-      yes: false,
-      mcp,
-    });
-    const exposeAdmin = !mode.tools;
-    const admin = ctx.agentTools;
-    const definitions = exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions;
-    const execute = (name, args, context) =>
-      exposeAdmin && admin.handles(name)
-        ? admin.execute(name, args, { approve: async () => false })
-        : local.execute(name, args, context);
-    const { provider, config } = ctx.resolveProvider({
-      ...ctx.providerSettings(providerId),
-      apiKey: ctx.apiKeyFor(providerId),
-    });
-    const basePrompt = await ctx.systemPromptFor(cwd);
-    const messages = [
-      { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
-      ...history,
-      { role: 'user', content: input },
-    ];
-
-    const controller = new AbortController();
-    controllers.set(String(chatId), controller);
-    const message = await send(chatId, '…');
-    let full = '';
-    let lastEdit = 0;
-
-    try {
-      const result = await runAgent({
-        provider,
-        config,
-        model,
-        messages,
-        tools: definitions,
-        execute,
-        signal: controller.signal,
-        maxRounds: ctx.config.maxRounds,
-        onEvent(event) {
-          if (event.type !== 'text') return;
-          full = event.full;
-          const now = Date.now();
-          if (now - lastEdit > 1200) {
-            lastEdit = now;
-            edit(chatId, message.message_id, full || '…');
-          }
-        },
-      });
-      await edit(chatId, message.message_id, result.content?.trim() || full || '(sin texto)');
-      const newMessages = result.messages.slice(1 + history.length);
-      ctx.store.addMessages(sessionId, newMessages);
-      ctx.store.touchSession(sessionId, { provider: providerId, model });
-    } catch (error) {
-      await edit(chatId, message.message_id, error?.name === 'AbortError' ? 'Cancelado.' : `Error: ${error?.message ?? error}`);
-    } finally {
-      controllers.delete(String(chatId));
-      mcp?.close?.();
-    }
-  }
-
-  async function handleCommand(chatId, text) {
-    const [raw, ...rest] = text.slice(1).split(/\s+/);
-    const cmd = raw.toLowerCase();
-    const arg = rest.join(' ').trim();
-    const sessionId = ctx.store.getSetting(sessionKey(chatId));
-    if (cmd === 'start' || cmd === 'help' || cmd === 'ayuda') return send(chatId, HELP);
-    if (cmd === 'new' || cmd === 'nueva') {
-      ctx.store.setSetting(sessionKey(chatId), null);
-      return send(chatId, 'Nueva sesión. Mandá tu mensaje.');
-    }
-    if (cmd === 'status') {
-      const session = sessionId ? ctx.store.getSession(sessionId) : null;
-      return send(
-        chatId,
-        `proveedor: ${session?.provider || ctx.effectiveProviderId()}\nmodelo: ${session?.model || ctx.effectiveModel() || '—'}\nmodo: ${ctx.effectiveMode()}\nsesión: ${session?.title || '—'}`
-      );
-    }
-    if (cmd === 'model') {
-      if (!arg) return send(chatId, `modelo actual: ${ctx.effectiveModel() || '—'}`);
-      ctx.store.setSetting('activeModel', arg);
-      if (sessionId) ctx.store.touchSession(sessionId, { model: arg });
-      return send(chatId, `modelo: ${arg}`);
-    }
-    if (cmd === 'provider') {
-      if (!arg) return send(chatId, `proveedor actual: ${ctx.effectiveProviderId()}`);
-      ctx.store.setSetting('activeProvider', arg);
-      if (sessionId) ctx.store.touchSession(sessionId, { provider: arg });
-      return send(chatId, `proveedor: ${arg}`);
-    }
-    if (cmd === 'mode' || cmd === 'modo') {
-      if (!arg) return send(chatId, `modo actual: ${ctx.effectiveMode()}`);
-      const id = arg.toLowerCase() === 'build' ? 'agent' : arg.toLowerCase();
-      ctx.store.setSetting('activeMode', resolveMode(id).id);
-      return send(chatId, `modo: ${resolveMode(id).label}`);
-    }
-    if (cmd === 'stop' || cmd === 'parar') {
-      controllers.get(String(chatId))?.abort();
-      return send(chatId, 'Cancelando…');
-    }
-    return send(chatId, `Comando desconocido: /${cmd}.\n\n${HELP}`);
-  }
-
-  async function handleMessage(message) {
-    const chatId = String(message.chat.id);
-    if (!authorized(chatId)) {
-      await send(chatId, `No autorizado. Tu chat id es ${chatId}; agregalo a telegram.allowedChatIds para habilitarlo.`);
-      return;
-    }
-    const text = String(message.text ?? '').trim();
-    if (!text) return;
-    if (text.startsWith('/')) return handleCommand(chatId, text);
-    return run(chatId, text);
-  }
-
-  async function loop() {
-    while (running) {
-      let updates = [];
-      try {
-        updates = await tg(token, 'getUpdates', { offset, timeout: 25, allowed_updates: ['message'] });
-      } catch (error) {
-        if (error.status === 401 || error.status === 404) {
-          log(`telegram: token inválido (${error.message}); se detiene el bot.`);
-          running = false;
-          return;
-        }
-        await sleep(3000);
-        continue;
-      }
-      for (const update of updates) {
-        offset = update.update_id + 1;
-        if (update.message?.text) {
-          handleMessage(update.message).catch((error) => log(`telegram: ${error?.message ?? error}`));
-        }
-      }
-    }
-  }
-
-  // Arranca en segundo plano; no bloquea el server.
-  loop().catch((error) => log(`telegram: ${error?.message ?? error}`));
-
-  return {
-    stop() {
-      running = false;
-      for (const controller of controllers.values()) controller.abort();
-      controllers.clear();
-    },
-  };
-}