@danieltmn/tamnora 0.9.1 → 0.9.2

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

@@ -0,0 +1,241 @@
+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 { createPresence } from '../src/lib/presence.js';
+import { startTelegramChannel } from '../src/lib/channels/telegram.js';
+
+const reply = (data) => ({ ok: true, json: async () => data });
+
+class FakeWebSocket {
+  constructor() {
+    this.listeners = new Map();
+    this.binaryType = 'arraybuffer';
+    setTimeout(() => {
+      this.fire('open', {});
+      this.fire('message', new TextEncoder().encode('Path:audio\r\nFFF364MP3').buffer);
+      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' });
+  }
+}
+
+function installFetchMock() {
+  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, multipart, updates, restore: () => { global.fetch = original; } };
+}
+
+function makeCtx(cwd, { app = {}, presence } = {}) {
+  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,
+    presence,
+    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');
+}
+
+function seedConversation(ctx, cwd, chatId = '7') {
+  const sessionId = ctx.store.createSession({ title: 'test', provider: 'fake', model: 'm', cwd });
+  ctx.store.setSetting(`telegram:chat:${chatId}`, sessionId);
+  ctx.store.addMessages(sessionId, [
+    { role: 'user', content: 'hola' },
+    { role: 'assistant', content: 'listo' },
+  ]);
+  return sessionId;
+}
+
+test('/resumen devuelve un resumen en texto', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgfeat-'));
+  const ctx = makeCtx(cwd);
+  seedConversation(ctx, 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: '/resumen' } });
+    await waitFor(() => mock.sent.some((m) => /📝 Resumen/.test(m.text ?? '')));
+    const resumen = mock.sent.find((m) => /📝 Resumen/.test(m.text ?? ''));
+    assert.match(resumen.text, /listo/);
+  } finally {
+    channel.stop();
+    mock.restore();
+    ctx.store.close();
+  }
+});
+
+test('/audioresumen devuelve el resumen como nota de voz', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgfeat-'));
+  const ctx = makeCtx(cwd);
+  seedConversation(ctx, cwd);
+  const mock = installFetchMock();
+  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: '/audioresumen' } });
+    await waitFor(() => mock.multipart.length > 0);
+    assert.ok(mock.sent.some((m) => /📝 Resumen/.test(m.text ?? '')));
+    assert.equal(mock.multipart[0].chatId, '7');
+  } finally {
+    global.WebSocket = original;
+    channel.stop();
+    mock.restore();
+    ctx.store.close();
+  }
+});
+
+test('/proyecto elige una carpeta y crea la sesión ahí', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgfeat-'));
+  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: `/proyecto ${cwd}` } });
+    await waitFor(() => mock.sent.some((m) => /Proyecto «/.test(m.text ?? '')));
+    const sessionId = ctx.store.getSetting('telegram:chat:7');
+    assert.ok(sessionId);
+    assert.equal(ctx.store.getSession(sessionId).cwd, cwd);
+  } finally {
+    channel.stop();
+    mock.restore();
+    ctx.store.close();
+  }
+});
+
+test('notify avisa de un proyecto abierto, con el nombre del proyecto', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgfeat-'));
+  const presence = createPresence();
+  const ctx = makeCtx(cwd, { presence });
+  const sessionId = ctx.store.createSession({ title: 'consola', provider: 'fake', model: 'm', cwd });
+  presence.touch([sessionId]);
+  const mock = installFetchMock();
+  const channel = startTelegramChannel(ctx, {
+    token: 'x',
+    allowedChatIds: ['7'],
+    notify: { enabled: true },
+    log: () => {},
+  });
+  try {
+    channel.notify(sessionId, { type: 'done', data: { content: 'hecho', rounds: 1, toolCalls: 0, durationMs: 5 } });
+    await waitFor(() => mock.sent.some((m) => /Sesión terminada/.test(m.text ?? '')));
+    const msg = mock.sent.find((m) => /Sesión terminada/.test(m.text ?? ''));
+    assert.match(msg.text, new RegExp(`\\[${path.basename(cwd)}\\]`));
+    assert.match(msg.text, /hecho/);
+  } finally {
+    channel.stop();
+    mock.restore();
+    ctx.store.close();
+  }
+});
+
+test('notify no avisa si el proyecto no está abierto en la consola', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgfeat-'));
+  const ctx = makeCtx(cwd, { presence: createPresence() });
+  const sessionId = ctx.store.createSession({ title: 'consola', provider: 'fake', model: 'm', cwd });
+  const mock = installFetchMock();
+  const channel = startTelegramChannel(ctx, {
+    token: 'x',
+    allowedChatIds: ['7'],
+    notify: { enabled: true },
+    log: () => {},
+  });
+  try {
+    channel.notify(sessionId, { type: 'done', data: { content: 'hecho' } });
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    assert.equal(mock.sent.length, 0);
+  } finally {
+    channel.stop();
+    mock.restore();
+    ctx.store.close();
+  }
+});
+
+test('notify de permiso incluye el proyecto y los botones', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgfeat-'));
+  const presence = createPresence();
+  const ctx = makeCtx(cwd, { presence });
+  const sessionId = ctx.store.createSession({ title: 'consola', provider: 'fake', model: 'm', cwd });
+  presence.touch([sessionId]);
+  const mock = installFetchMock();
+  const channel = startTelegramChannel(ctx, {
+    token: 'x',
+    allowedChatIds: ['7'],
+    notify: { enabled: true },
+    log: () => {},
+  });
+  try {
+    channel.notify(sessionId, { type: 'permission', data: { askId: 'ask-1', name: 'bash' } });
+    await waitFor(() => mock.sent.some((m) => /Permiso para bash/.test(m.text ?? '')));
+    const msg = mock.sent.find((m) => /Permiso para bash/.test(m.text ?? ''));
+    assert.match(msg.text, new RegExp(`\\[${path.basename(cwd)}\\]`));
+    const datas = msg.reply_markup.inline_keyboard.flat().map((b) => b.callback_data);
+    assert.ok(datas.includes('perm:ask-1:allow'));
+  } finally {
+    channel.stop();
+    mock.restore();
+    ctx.store.close();
+  }
+});

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

@@ -100,9 +100,17 @@ async function waitFor(fn, timeout = 3000) {
   throw new Error('timeout esperando la condición');
 }
 
+/** Deja un proyecto ya elegido (sin pasar por el selector). */
+function preselect(ctx, cwd, chatId = '7') {
+  const sessionId = ctx.store.createSession({ title: 'test', provider: 'fake', model: 'm', cwd });
+  ctx.store.setSetting(`telegram:chat:${chatId}`, sessionId);
+  return sessionId;
+}
+
 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 } } });
+  preselect(ctx, cwd);
   const mock = installVozFetchMock();
   const original = global.WebSocket;
   global.WebSocket = FakeWebSocket;
@@ -123,6 +131,7 @@ test('con la voz activada, el turno de Telegram termina con una nota de voz', as
 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, {});
+  preselect(ctx, cwd);
   const mock = installVozFetchMock();
   const channel = startTelegramChannel(ctx, { token: 'x', allowedChatIds: ['7'], log: () => {} });
   try {

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

@@ -67,9 +67,17 @@ async function waitFor(fn, timeout = 3000) {
   throw new Error('timeout esperando la condición');
 }
 
+/** Deja un proyecto ya elegido (sin pasar por el selector). */
+function preselect(ctx, cwd, chatId = '7') {
+  const sessionId = ctx.store.createSession({ title: 'test', provider: 'fake', model: 'm', cwd });
+  ctx.store.setSetting(`telegram:chat:${chatId}`, sessionId);
+  return sessionId;
+}
+
 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);
+  preselect(ctx, cwd);
   const mock = installFetchMock();
   const channel = startTelegramChannel(ctx, { token: 'x', allowedChatIds: ['7'], log: () => {} });
   try {
@@ -80,8 +88,9 @@ test('el canal de Telegram cierra el turno y muestra el panel', async () => {
     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);
+    await waitFor(() => mock.sent.some((m) => m.text?.startsWith('⚙ Panel')));
+    const menu = mock.sent.find((m) => m.text?.startsWith('⚙ Panel'));
+    assert.match(menu.text, /proyecto:/);
     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'));
@@ -92,3 +101,29 @@ test('el canal de Telegram cierra el turno y muestra el panel', async () => {
     ctx.store.close();
   }
 });
+
+test('sin proyecto elegido, el bot pregunta en qué proyecto trabajar', 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) => /En qué proyecto/.test(m.text ?? '')));
+    const picker = mock.sent.find((m) => /En qué proyecto/.test(m.text ?? ''));
+    const datas = picker.reply_markup.inline_keyboard.flat().map((b) => b.callback_data);
+    assert.ok(datas.includes('proj:root'));
+
+    // Al elegir el proyecto corre el mensaje que había quedado pendiente.
+    mock.updates.push({
+      update_id: 2,
+      callback_query: { id: 'cb1', message: { chat: { id: 7 }, message_id: 1 }, data: 'proj:root' },
+    });
+    await waitFor(() => mock.sent.some((m) => /✓ terminado/.test(m.text ?? '')));
+    assert.ok(ctx.store.getSetting('telegram:chat:7'));
+  } finally {
+    channel.stop();
+    mock.restore();
+    ctx.store.close();
+  }
+});

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

@@ -0,0 +1,215 @@
+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 { createTamnoraServer } from '../src/index.js';
+import { setHome } from '../../core/src/index.js';
+import { resolveTranscribe } from '../src/routes/transcribe.js';
+
+/** Intercepta las llamadas de transcripción (proveedor y Google). */
+function installTranscribeMock({ text = 'hola mundo', status = 200, error = 'audio inválido', googleText = 'hola google' } = {}) {
+  const original = global.fetch;
+  const calls = [];
+  const googleCalls = [];
+  global.fetch = async (url, opts = {}) => {
+    const target = String(url);
+    if (target.includes('/speech-api/v2/recognize')) {
+      googleCalls.push({ url: target });
+      const body = `${JSON.stringify({ result: [] })}\n${JSON.stringify({
+        result: [{ alternative: [{ transcript: googleText }], final: true }],
+      })}\n`;
+      return { ok: status === 200, status, text: async () => body, json: async () => ({}) };
+    }
+    if (target.includes('/audio/transcriptions')) {
+      const file = opts.body?.get?.('file');
+      calls.push({
+        url: target,
+        model: opts.body?.get?.('model'),
+        filename: file?.name,
+        type: file?.type,
+        language: opts.body?.get?.('language'),
+      });
+      return {
+        ok: status === 200,
+        status,
+        json: async () => ({ text }),
+        text: async () => JSON.stringify({ error: { message: error } }),
+      };
+    }
+    return original(url, opts);
+  };
+  return { calls, googleCalls, restore: () => { global.fetch = original; } };
+}
+
+async function startServer() {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tr-'));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url };
+}
+
+const dataUrl = (bytes) => `data:audio/webm;base64,${Buffer.from(bytes).toString('base64')}`;
+
+test('resolveTranscribe prioriza own -> Telegram -> activo', () => {
+  assert.deepEqual(resolveTranscribe({}), { provider: undefined, model: undefined });
+  const fromTelegram = resolveTranscribe({ telegram: { transcribeProvider: 'groq', transcribeModel: 'whisper-large-v3-turbo' } });
+  assert.equal(fromTelegram.provider, 'groq');
+  assert.equal(fromTelegram.model, 'whisper-large-v3-turbo');
+  const own = resolveTranscribe(
+    { transcribe: { provider: 'openai', model: 'whisper-1' }, telegram: { transcribeProvider: 'groq' } },
+    { provider: 'mistral' }
+  );
+  assert.equal(own.provider, 'mistral');
+  assert.equal(own.model, 'whisper-1');
+});
+
+test('el dictado guarda su proveedor/modelo y lo usa', async () => {
+  const { instance, base } = await startServer();
+  const mock = installTranscribeMock({ text: 'dale' });
+  try {
+    const put = await fetch(`${base}/api/transcribe/settings`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ mode: 'browser', language: 'es-MX', provider: 'groq', model: 'whisper-large-v3-turbo' }),
+    });
+    assert.equal(put.status, 200);
+    const saved = await put.json();
+    assert.equal(saved.mode, 'browser');
+    assert.equal(saved.language, 'es-MX');
+
+    // El modo browser no afecta la transcripcion por server: usa el provider.
+    const res = await fetch(`${base}/api/transcribe`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ audio: dataUrl('x') }),
+    });
+    assert.equal(res.status, 200);
+    assert.match(mock.calls[0].url, /groq\.com/);
+    assert.equal(mock.calls[0].model, 'whisper-large-v3-turbo');
+  } finally {
+    mock.restore();
+    await instance.close();
+  }
+});
+
+test('POST /api/transcribe devuelve el texto del proveedor', async () => {
+  const { instance, base } = await startServer();
+  const mock = installTranscribeMock({ text: 'prendé las luces' });
+  try {
+    const res = await fetch(`${base}/api/transcribe`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ audio: dataUrl('fake-audio') }),
+    });
+    assert.equal(res.status, 200);
+    assert.equal((await res.json()).text, 'prendé las luces');
+    assert.equal(mock.calls.length, 1);
+    assert.equal(mock.calls[0].model, 'whisper-1');
+  } finally {
+    mock.restore();
+    await instance.close();
+  }
+});
+
+test('acepta data URLs con parámetros de tipo (codecs)', async () => {
+  const { instance, base } = await startServer();
+  const mock = installTranscribeMock({ text: 'ok' });
+  try {
+    const audio = `data:audio/webm;codecs=opus;base64,${Buffer.from('x').toString('base64')}`;
+    const res = await fetch(`${base}/api/transcribe`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ audio }),
+    });
+    assert.equal(res.status, 200);
+    assert.equal((await res.json()).text, 'ok');
+  } finally {
+    mock.restore();
+    await instance.close();
+  }
+});
+
+test('el WAV del dictado se manda con nombre y tipo correctos', async () => {
+  const { instance, base } = await startServer();
+  const mock = installTranscribeMock({ text: 'ok' });
+  try {
+    const audio = `data:audio/wav;base64,${Buffer.from('RIFF....').toString('base64')}`;
+    const res = await fetch(`${base}/api/transcribe`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ audio }),
+    });
+    assert.equal(res.status, 200);
+    assert.equal(mock.calls[0].filename, 'audio.wav');
+    assert.equal(mock.calls[0].type, 'audio/wav');
+    // El idioma configurado se manda como ISO-639-1 (es-AR -> es).
+    assert.equal(mock.calls[0].language, 'es');
+  } finally {
+    mock.restore();
+    await instance.close();
+  }
+});
+
+test('el motor google transcribe en el servidor sin API key', async () => {
+  const { instance, base } = await startServer();
+  const mock = installTranscribeMock({ googleText: 'prendé la luz' });
+  try {
+    await fetch(`${base}/api/transcribe/settings`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ mode: 'google', language: 'es-AR' }),
+    });
+    const res = await fetch(`${base}/api/transcribe`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ audio: `data:audio/wav;base64,${Buffer.from('RIFF....WAVEfmt ').toString('base64')}` }),
+    });
+    assert.equal(res.status, 200);
+    assert.equal((await res.json()).text, 'prendé la luz');
+    assert.match(mock.googleCalls[0].url, /speech-api\/v2\/recognize/);
+    assert.match(mock.googleCalls[0].url, /lang=es-AR/);
+    // No tocó al proveedor con API key.
+    assert.equal(mock.calls.length, 0);
+  } finally {
+    mock.restore();
+    await instance.close();
+  }
+});
+
+test('POST /api/transcribe rechaza un cuerpo sin audio', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const res = await fetch(`${base}/api/transcribe`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({}),
+    });
+    assert.equal(res.status, 400);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('POST /api/transcribe expone el fallo del proveedor como 502', async () => {
+  const { instance, base } = await startServer();
+  const mock = installTranscribeMock({ status: 400, error: 'invalid file format' });
+  try {
+    const res = await fetch(`${base}/api/transcribe`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ audio: dataUrl('x') }),
+    });
+    assert.equal(res.status, 502);
+    // El mensaje del proveedor viaja en la respuesta, no un genérico.
+    assert.match((await res.json()).error, /invalid file format/);
+  } finally {
+    mock.restore();
+    await instance.close();
+  }
+});

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

@@ -117,6 +117,30 @@ test('la sintesis exige texto y entrega MP3', async () => {
   }
 });
 
+test('el catálogo de voces filtra por idioma (default español)', async () => {
+  const { instance, base } = await startServer();
+  const original = global.fetch;
+  const voces = [
+    { ShortName: 'es-AR-ElenaNeural', Locale: 'es-AR', Gender: 'Female' },
+    { ShortName: 'es-MX-JorgeNeural', Locale: 'es-MX', Gender: 'Male' },
+    { ShortName: 'en-US-AriaNeural', Locale: 'en-US', Gender: 'Female' },
+    { ShortName: 'fr-FR-DeniseNeural', Locale: 'fr-FR', Gender: 'Female' },
+  ];
+  global.fetch = async (url, opts = {}) => {
+    if (String(url).includes('voices/list')) return { ok: true, status: 200, json: async () => voces };
+    return original(url, opts);
+  };
+  try {
+    const todas = await (await fetch(`${base}/api/tts/voices`)).json();
+    assert.deepEqual(todas.voices.map((v) => v.ShortName), ['es-AR-ElenaNeural', 'es-MX-JorgeNeural']);
+    const francesas = await (await fetch(`${base}/api/tts/voices?filter=fr-`)).json();
+    assert.deepEqual(francesas.voices.map((v) => v.ShortName), ['fr-FR-DeniseNeural']);
+  } finally {
+    global.fetch = original;
+    await instance.close();
+  }
+});
+
 test('un fallo del servicio de voz se ve como 502, no como crash', async () => {
   const { instance, base } = await startServer();
   const original = global.WebSocket;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "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",