@danieltmn/tamnora 0.8.0 → 0.9.0

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

@@ -66,9 +66,18 @@ test('serves health, providers and the console', async () => {
       'id="slash-menu"',
       'id="statusbar"',
       'id="sb-activity"',
+      // Nueva sesion tambien en el topbar: en movil el sidebar es un drawer y
+      // crear una sesion eran varios toques.
+      'id="new-session-top"',
     ]) {
       assert.ok(html.includes(hook), `falta ${hook}`);
     }
+    // El boton del topbar tiene que estar en el header, no escondido en el
+    // drawer (que es donde vive `#new-session`).
+    const header = html.slice(0, html.indexOf('<main'));
+    assert.ok(header.includes('id="new-session-top"'), 'nueva sesion deberia estar en el topbar');
+    assert.equal((html.match(/id="new-session-top"/g) ?? []).length, 1);
+    assert.equal((html.match(/id="new-session"/g) ?? []).length, 1);
     // Los controles de agente se declaran una sola vez (se mueven entre slots).
     assert.equal((html.match(/id="mode"/g) ?? []).length, 1);
 
@@ -253,6 +262,507 @@ test('keeps a run alive after the client disconnects and can stop it', async ()
   }
 });
 
+/** Lee un SSE hasta que `until(data)` se cumpla, y devuelve lo acumulado. */
+async function readSse(url, options, until, timeoutMs = 5000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const frames = [];
+  try {
+    const res = await fetch(url, { ...options, signal: controller.signal });
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    for (;;) {
+      const { value, done } = await reader.read();
+      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 = '';
+        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();
+        }
+        if (!event) continue;
+        const parsed = data ? JSON.parse(data) : {};
+        frames.push({ event, data: parsed });
+        if (until(parsed, event)) return frames;
+      }
+    }
+  } catch (error) {
+    if (error?.name !== 'AbortError') throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+  return frames;
+}
+
+test('the global channel announces run_start and run_end to another client', async () => {
+  const { instance, base } = await startServer();
+  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;
+
+    // Cliente B: abre el canal global antes de que arranque nada.
+    const events = readSse(`${base}/api/events`, {}, (data, event) => event === 'run_end');
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // Cliente A: pide una tarea.
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'hola', model: 'm', sessionId: id }),
+      })
+    ).text();
+
+    const frames = await events;
+    const names = frames.map((frame) => frame.event);
+    assert.deepEqual(names[0], 'snapshot');
+    assert.ok(names.includes('run_start'), 'esperaba run_start');
+    assert.ok(names.includes('run_end'), 'esperaba run_end');
+
+    const start = frames.find((frame) => frame.event === 'run_start');
+    const end = frames.find((frame) => frame.event === 'run_end');
+    assert.equal(start.data.sessionId, id);
+    assert.equal(end.data.sessionId, id);
+    assert.ok(typeof end.data.durationMs === 'number');
+
+    // El canal global no debe filtrar el detalle del turno: eso va por el
+    // stream de la sesion, o seria duplicarlo.
+    for (const detail of ['start', 'user', 'text', 'tool_call', 'done']) {
+      assert.ok(!names.includes(detail), `el canal global no debe emitir ${detail}`);
+    }
+  } finally {
+    await instance.close();
+  }
+});
+
+test('connecting to the global channel mid-run returns it in the snapshot', async () => {
+  let release;
+  const gate = new Promise((resolve) => (release = resolve));
+  const slowProvider = {
+    id: 'slow',
+    async streamChat() {
+      await gate;
+      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 chat = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'hola', model: 'm', sessionId: id }),
+    }).catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 120));
+
+    // Cliente nuevo: el snapshot tiene que informarle que hay un run vivo, y
+    // por eso el cliente se engancha sin que nadie le avise.
+    const frames = await readSse(`${base}/api/events`, {}, (data, event) => event === 'snapshot');
+    assert.equal(frames[0].event, 'snapshot');
+    assert.ok(frames[0].data.active.includes(id), 'el snapshot deberia listar la sesion activa');
+
+    release();
+    await chat;
+  } finally {
+    release();
+    await instance.close();
+  }
+});
+
+test('the session list reports which sessions are running', async () => {
+  let release;
+  const gate = new Promise((resolve) => (release = resolve));
+  const slowProvider = {
+    id: 'slow',
+    async streamChat() {
+      await gate;
+      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 idle = await (await fetch(`${base}/api/sessions`)).json();
+    assert.equal(idle.sessions.find((session) => session.id === id).running, false);
+
+    const chat = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'hola', model: 'm', sessionId: id }),
+    }).catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 120));
+
+    const busy = await (await fetch(`${base}/api/sessions`)).json();
+    assert.equal(busy.sessions.find((session) => session.id === id).running, true);
+
+    release();
+    await chat;
+  } finally {
+    release();
+    await instance.close();
+  }
+});
+
+test('resuming a run from a cursor replays only what was missed', async () => {
+  const { instance, base } = await startServer();
+  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;
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'hola', model: 'm', sessionId: id }),
+      })
+    ).text();
+
+    const full = await (await fetch(`${base}/api/sessions/${id}/stream?from=0`)).text();
+    const ids = [...full.matchAll(/^id: (\d+)$/gm)].map((match) => Number(match[1]));
+    assert.ok(ids.length > 2, 'esperaba varios eventos con id');
+    const last = ids[ids.length - 1];
+
+    // Cliente que se cortó justo antes del ultimo evento: al volver no debe
+    // recibir lo que ya tenia.
+    const tail = await (await fetch(`${base}/api/sessions/${id}/stream?from=${last - 1}`)).text();
+    const tailIds = [...tail.matchAll(/^id: (\d+)$/gm)].map((match) => Number(match[1]));
+    assert.deepEqual(tailIds, [last]);
+
+    // Y el log del run no secontamination con el canal global.
+    assert.ok(!/event: run_start/.test(full));
+    assert.ok(!/event: run_end/.test(full));
+  } finally {
+    await instance.close();
+  }
+});
+
+test('a pending permission is visible to any client, not only the one streaming', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-ask-'));
+  let calls = 0;
+  const provider = {
+    id: 'tooly',
+    async streamChat() {
+      calls += 1;
+      if (calls === 1) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [{ id: 'call_1', function: { name: 'write', arguments: JSON.stringify({ path: 'nota.txt', content: 'hi' }) } }],
+        };
+      }
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, 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;
+
+    // Cliente B: canal global abierto, sin ningun stream de la sesion.
+    const seen = [];
+    const watching = readSse(`${base}/api/events`, {}, (data, event) => event === 'permission');
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // Cliente A: pide la tarea y se queda esperando el permiso.
+    const chat = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'crea nota.txt', model: 'm', sessionId: id }),
+    }).catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    const frames = await watching;
+    const permission = frames.find((frame) => frame.event === 'permission');
+    assert.ok(permission, 'el canal global deberia avisar del permiso');
+    assert.equal(permission.data.sessionId, id);
+    assert.equal(permission.data.name, 'write');
+    seen.push(permission.data.askId);
+
+    // Y tambien se puede consultar, que es lo que cubre una recarga de pagina.
+    const list = await (await fetch(`${base}/api/permissions`)).json();
+    assert.equal(list.pending.length, 1);
+    assert.equal(list.pending[0].askId, permission.data.askId);
+    assert.equal(list.pending[0].sessionId, id);
+    assert.deepEqual(list.pending[0].args, { path: 'nota.txt', content: 'hi' });
+
+    const scoped = await (await fetch(`${base}/api/permissions?sessionId=${id}`)).json();
+    assert.equal(scoped.pending.length, 1);
+    const other = await (await fetch(`${base}/api/permissions?sessionId=otra`)).json();
+    assert.equal(other.pending.length, 0);
+
+    const detail = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    assert.equal(detail.permissions.length, 1, 'el detalle debe traer los pendientes para reengancharse');
+    const listSessions = await (await fetch(`${base}/api/sessions`)).json();
+    assert.equal(listSessions.sessions.find((s) => s.id === id).awaiting, 1);
+
+    const decision = await (
+      await fetch(`${base}/api/permissions/${permission.data.askId}`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ allow: true }),
+      })
+    ).json();
+    assert.equal(decision.ok, true);
+
+    const after = await (await fetch(`${base}/api/permissions`)).json();
+    assert.equal(after.pending.length, 0);
+    await chat;
+  } finally {
+    await instance.close();
+  }
+});
+
+/**
+ * Espera a que la sesion se quede sin run.
+ *
+ * Hace falta antes de `instance.close()`: un run que sigue vivo emite `aborted`
+ * en otro tick y escribe sobre la base ya cerrada.
+ */
+async function waitIdle(base, id, attempts = 60) {
+  for (let i = 0; i < attempts; i += 1) {
+    const detail = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    if (!detail.running) return true;
+    await fetch(`${base}/api/sessions/${id}/stop`, { method: 'POST' }).catch(() => {});
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return false;
+}
+
+test('/api/state carries liveness and pending permissions in one request', async () => {
+  let release;
+  const gate = new Promise((resolve) => (release = resolve));
+  let calls = 0;
+  const provider = {
+    id: 'tooly',
+    async streamChat() {
+      calls += 1;
+      if (calls === 1) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [{ id: 'call_1', function: { name: 'write', arguments: JSON.stringify({ path: 'nota.txt', content: 'hi' }) } }],
+        };
+      }
+      await gate;
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider, 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 idle = await (await fetch(`${base}/api/state`)).json();
+    assert.equal(idle.sessions.find((s) => s.id === id).running, false);
+    assert.equal(idle.sessions.find((s) => s.id === id).awaiting, 0);
+    assert.deepEqual(idle.permissions, []);
+    assert.equal(typeof idle.now, 'number');
+    // El snapshot no lleva mensajes: es lo que se puede pedir seguido.
+    assert.equal(idle.sessions[0].messages, undefined);
+
+    const chat = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'crea nota.txt', model: 'm', sessionId: id }),
+    }).catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // Un permiso creado despues aparece en el siguiente read: esto es lo que
+    // hace que la consola se recupere sin ningun SSE.
+    const busy = await (await fetch(`${base}/api/state`)).json();
+    const session = busy.sessions.find((s) => s.id === id);
+    assert.equal(session.running, true);
+    assert.equal(session.awaiting, 1);
+    assert.equal(busy.permissions.length, 1);
+    assert.equal(busy.permissions[0].name, 'write');
+    assert.deepEqual(busy.permissions[0].args, { path: 'nota.txt', content: 'hi' });
+    assert.equal(busy.permissions[0].sessionId, id);
+
+    const askId = busy.permissions[0].askId;
+    await fetch(`${base}/api/permissions/${askId}`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ allow: true }),
+    });
+
+    const after = await (await fetch(`${base}/api/state`)).json();
+    assert.deepEqual(after.permissions, []);
+    assert.equal(after.sessions.find((s) => s.id === id).awaiting, 0);
+
+    release();
+    await chat;
+    await waitIdle(base, id);
+  } finally {
+    release();
+    await instance.close();
+  }
+});
+
+test('a client with no streams at all can find and resolve a permission', async () => {
+  // El escenario que reporto el celular: sin stream de sesion y sin canal global.
+  let release;
+  const gate = new Promise((resolve) => (release = resolve));
+  let calls = 0;
+  const provider = {
+    id: 'tooly',
+    async streamChat() {
+      calls += 1;
+      if (calls === 1) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [{ id: 'call_1', function: { name: 'bash', arguments: JSON.stringify({ command: 'ls' }) } }],
+        };
+      }
+      await gate;
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider, 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 chat = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'lista los archivos', model: 'm', sessionId: id }),
+    }).catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // Solo requests cortos: es lo que sobrevive en un enlace movil.
+    const state = await (await fetch(`${base}/api/state`)).json();
+    assert.equal(state.permissions.length, 1);
+    assert.equal(state.permissions[0].name, 'bash');
+
+    const decision = await (
+      await fetch(`${base}/api/permissions/${state.permissions[0].askId}`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ allow: true, scope: 'once' }),
+      })
+    ).json();
+    assert.equal(decision.ok, true);
+    assert.deepEqual((await (await fetch(`${base}/api/state`)).json()).permissions, []);
+
+    release();
+    await chat;
+    await waitIdle(base, id);
+  } finally {
+    release();
+    await instance.close();
+  }
+});
+
+test('approving clears the permission instead of bringing it back', async () => {
+  // El sintoma era "le doy que si y me vuelve a pedir lo mismo". Dos causas
+  // distintas y esta las separa: el server vacia el estado al resolver, y una
+  // peticion nueva del agente es un `askId` nuevo (no el mismo permiso
+  // revivido).
+  let round = 0;
+  const provider = {
+    id: 'loopish',
+    async streamChat() {
+      round += 1;
+      if (round <= 3) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [{ id: `c${round}`, function: { name: 'bash', arguments: JSON.stringify({ command: `echo paso-${round}` }) } }],
+        };
+      }
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider, 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 chat = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'hacé tres pasos', model: 'm', sessionId: id }),
+    }).catch(() => null);
+
+    const approved = [];
+    for (let i = 0; i < 40 && approved.length < 3; i += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      const state = await (await fetch(`${base}/api/state`)).json();
+      for (const ask of state.permissions) {
+        const decision = await fetch(`${base}/api/permissions/${ask.askId}`, {
+          method: 'POST',
+          headers: json,
+          body: JSON.stringify({ allow: true }),
+        });
+        assert.equal(decision.status, 200);
+        approved.push(ask.askId);
+        // Inmediatamente despues de resolver, no queda pendiente: si volviera,
+        // el cliente lo re-pintaria en bucle.
+        const after = await (await fetch(`${base}/api/state`)).json();
+        assert.equal(after.permissions.length, 0, 'el permiso resuelto no debe reaparecer');
+      }
+    }
+    // Tres peticiones del agente -> tres askId distintos, ninguno revivido.
+    assert.equal(approved.length, 3);
+    assert.equal(new Set(approved).size, 3);
+
+    await waitIdle(base, id);
+    await chat;
+  } finally {
+    await instance.close();
+  }
+});
+
+test('resolving a permission that no longer exists reports 404', async () => {
+  const { instance, base } = await startServer();
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    // Un askId inventado: la tarjeta era vieja. Con esto el cliente puede
+    // decir "ya no aplica" en vez de dejar el permiso esperando.
+    const res = await fetch(`${base}/api/permissions/inexistente`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ allow: true }),
+    });
+    assert.equal(res.status, 404);
+  } finally {
+    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');
@@ -1248,7 +1758,7 @@ 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', 'task']);
+    assert.deepEqual(captured.tools, ['fetch_url', 'git_diff', 'git_log', 'git_status', 'glob', 'grep', 'list', 'read', 'speak', 'task']);
     assert.match(captured.system, /modo PLAN/);
   } finally {
     await instance.close();

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

@@ -0,0 +1,156 @@
+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 });
+
+const FAKE_FRAME = new TextEncoder().encode('Path:audio\r\nFFF364MP3').buffer;
+
+/** WebSocket falso: entrega un frame de audio y cierra con turn.end. */
+class FakeWebSocket {
+  constructor() {
+    this.listeners = new Map();
+    this.binaryType = 'arraybuffer';
+    setTimeout(() => {
+      this.fire('open', {});
+      this.fire('message', FAKE_FRAME);
+      this.fire('message', 'X-RequestId:1\r\nPath:turn.end\r\n');
+    }, 0);
+  }
+  addEventListener(type, fn) {
+    if (!this.listeners.has(type)) this.listeners.set(type, new Set());
+    this.listeners.get(type).add(fn);
+  }
+  removeEventListener() {}
+  send() {}
+  close() {
+    this.fire('close', {});
+  }
+  fire(type, arg) {
+    for (const fn of this.listeners.get(type) ?? []) fn({ data: arg, message: 'fake' });
+  }
+}
+
+/** Mock de fetch que registra los envios multipart (sendVoice/sendAudio). */
+function installVozFetchMock() {
+  const sent = [];
+  const multipart = [];
+  const updates = [];
+  const original = global.fetch;
+  global.fetch = async (url, opts = {}) => {
+    const method = String(url).split('/').pop();
+    if (opts.body instanceof FormData) {
+      multipart.push({ method, chatId: String(opts.body.get('chat_id') ?? '') });
+      return reply({ ok: true, result: true });
+    }
+    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, multipart, restore: () => { global.fetch = original; } };
+}
+
+function makeCtx(cwd, app = {}) {
+  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('con la voz activada, el turno de Telegram termina con una nota de voz', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgvoz-'));
+  const ctx = makeCtx(cwd, { tts: { enabled: true, voice: 'es-AR-ElenaNeural', rate: '+0%', announce: { end: true } } });
+  const mock = installVozFetchMock();
+  const original = global.WebSocket;
+  global.WebSocket = FakeWebSocket;
+  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.multipart.length > 0);
+    const nota = mock.multipart[0];
+    assert.equal(nota.chatId, '7');
+    assert.match(nota.method, /^send(Voice|Audio)$/);
+  } finally {
+    global.WebSocket = original;
+    channel.stop();
+    mock.restore();
+  }
+});
+
+test('con la voz apagada, el turno de Telegram termina sin audios', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgvoz-'));
+  const ctx = makeCtx(cwd, {});
+  const mock = installVozFetchMock();
+  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 ?? '')));
+    assert.equal(mock.multipart.length, 0);
+  } finally {
+    channel.stop();
+    mock.restore();
+  }
+});
+
+test('la tool speak manda una nota de voz aunque la narración esté apagada', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgspeak-'));
+  const ctx = makeCtx(cwd, {});
+  const mock = installVozFetchMock();
+  const original = global.WebSocket;
+  global.WebSocket = FakeWebSocket;
+  const channel = startTelegramChannel(ctx, { token: 'x', allowedChatIds: ['7'], log: () => {} });
+  try {
+    ctx.store.setSetting('telegram:session:sess-1', '7');
+    channel.notify('sess-1', { type: 'tool_call', data: { name: 'speak', args: { texto: 'Hola, esto es una prueba' } } });
+    await waitFor(() => mock.multipart.length > 0);
+    assert.equal(mock.multipart[0].chatId, '7');
+    assert.match(mock.multipart[0].method, /^send(Voice|Audio)$/);
+  } finally {
+    global.WebSocket = original;
+    channel.stop();
+    mock.restore();
+  }
+});