@danieltmn/tamnora 0.22.0 → 0.23.1

package/harness/packages/core/test/agent.test.js

@@ -376,6 +376,24 @@ test('runAgent propaga maxOutputTokens al proveedor', async () => {
   assert.deepEqual(seen, [1234]);
 });
 
+test('runAgent propaga promptCaching al proveedor', async () => {
+  const seen = [];
+  const provider = {
+    async streamChat(_config, params) {
+      seen.push(params.promptCaching);
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    promptCaching: true,
+  });
+  assert.deepEqual(seen, [true]);
+});
+
 test('runAgent emite el ciclo de vida (run.start/end, tool.before/after)', async () => {
   const life = [];
   const provider = {

package/harness/packages/core/test/servicios-vivos.test.js

@@ -0,0 +1,71 @@
+// Canary de los servicios no oficiales (TTS de Edge y STT de Google). Son los
+// unicos que dependen de un servicio externo sin contrato: si cambian el
+// protocolo o la clave, el unico sintoma real es un 403. Los tests con mocks
+// no lo ven, asi que estos prueban el camino real, pero solo con TAMNORA_LIVE=1
+// (piden red y a servicios que pueden estar caidos o barrerte).
+//
+//   TAMNORA_LIVE=1 node --test harness/packages/core/test/servicios-vivos.test.js
+//
+// El servicio de Edge solo devuelve MP3 (los formatos riff-/raw- cierran la
+// conexion antes de mandar audio), asi que el round trip se hace con ffmpeg en
+// el medio para convertir el MP3 a WAV.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { generarSecMsGec, listarVoces, reconocerGoogle, sintetizar, VOZ_POR_DEFECTO } from '../src/index.js';
+
+const LIVE = process.env.TAMNORA_LIVE === '1';
+const liveOpts = LIVE ? {} : { skip: 'red real: correr con TAMNORA_LIVE=1' };
+
+/** MP3 -> WAV 16 kHz mono con ffmpeg. `null` si no hay ffmpeg. */
+async function mp3AWav(mp3) {
+  return new Promise((resolve) => {
+    const hijo = spawn(
+      'ffmpeg',
+      ['-hide_banner', '-loglevel', 'error', '-i', 'pipe:0', '-f', 'wav', '-ar', '16000', '-ac', '1', 'pipe:1'],
+      { stdio: ['pipe', 'pipe', 'ignore'], windowsHide: true },
+    );
+    const salida = [];
+    hijo.stdout.on('data', (b) => salida.push(b));
+    hijo.on('error', () => resolve(null));
+    hijo.on('close', (code) => resolve(code === 0 && salida.length ? Buffer.concat(salida) : null));
+    hijo.stdin.on('error', () => {});
+    hijo.stdin.end(mp3);
+  });
+}
+
+test('sintetizar entrega un MP3 real (canary)', liveOpts, async () => {
+  const mp3 = await sintetizar('hola', { voice: VOZ_POR_DEFECTO });
+  assert.ok(Buffer.isBuffer(mp3), 'deberia devolver un Buffer');
+  assert.ok(mp3.length > 1000, `MP3 demasiado chico: ${mp3.length} bytes`);
+  assert.equal(mp3[0], 0xff, 'sin frame de MP3: el servicio cambio de formato');
+});
+
+test('el catalogo de voces responde con la voz por defecto (canary)', liveOpts, async () => {
+  await esperar(3000);
+  const voces = await listarVoces('es-');
+  assert.ok(Array.isArray(voces) && voces.length > 0, 'el catalogo vino vacio');
+  const nombres = voces.map((v) => v.ShortName ?? v.name ?? v);
+  assert.ok(nombres.includes(VOZ_POR_DEFECTO), `falta ${VOZ_POR_DEFECTO} en ${JSON.stringify(nombres.slice(0, 3))}`);
+});
+
+/** Espera ms antes de abrir otro socket: el servicio de Edge se queja (fallo de
+ * handshake) si se le abren varias conexiones seguidas. */
+const esperar = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+test('ida y vuelta: el audio del TTS se entiende en el STT (canary)', liveOpts, async () => {
+  await esperar(3000);
+  const mp3 = await sintetizar('hola mundo de prueba', { voice: VOZ_POR_DEFECTO });
+  const wav = await mp3AWav(mp3);
+  if (!wav) {
+    // Sin ffmpeg no hay WAV con el que hacer el viaje: se probo arriba el camino
+    // del TTS, que es el que mas se rompe.
+    return;
+  }
+  const texto = await reconocerGoogle(wav, { lang: 'es-AR' });
+  assert.ok(/hola/.test(texto), `se entiende otra cosa: "${texto}"`);
+});
+
+test('el anti-abuso de Edge sigue generando tokens de 64 hex', () => {
+  assert.match(generarSecMsGec(), /^[0-9A-F]{64}$/);
+});

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

@@ -39,3 +39,84 @@ test('sintetizar recorta el texto al tope del servicio', () => {
   const largo = 'x'.repeat(MAX_TEXTO + 100);
   assert.throws(() => sintetizar(largo, { signal: controller.signal }), /cancel/);
 });
+
+/** WebSocket falso: `guion` dice que hace cada intento ('error' o 'audio'). */
+function mockWebSocket(guion) {
+  const original = globalThis.WebSocket;
+  let intentos = 0;
+  globalThis.WebSocket = class {
+    constructor() {
+      this.listeners = new Map();
+      this.binaryType = 'arraybuffer';
+      const paso = guion[Math.min(intentos, guion.length - 1)];
+      intentos += 1;
+      setTimeout(() => {
+        // 'fallo' nunca llega a abrirse (fallo de transporte); 'error' abre la
+        // conexion y recien ahi falla (el servicio rechaza algo).
+        if (paso !== 'fallo') this.fire('open', {});
+        if (paso === 'error' || paso === 'fallo') {
+          this.fire('error', {});
+          return;
+        }
+        this.fire('message', new TextEncoder().encode('Path:audio\r\nFRAME').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' });
+    }
+  };
+  return {
+    get intentos() {
+      return intentos;
+    },
+    restaurar: () => {
+      globalThis.WebSocket = original;
+    },
+  };
+}
+
+test('sintetizar reintenta un fallo de conexion y devuelve el audio', async () => {
+  const mock = mockWebSocket(['fallo', 'audio']);
+  try {
+    const mp3 = await sintetizar('hola', { pausaReintentoMs: 5 });
+    assert.equal(mp3.toString(), 'FRAME');
+    assert.equal(mock.intentos, 2);
+  } finally {
+    mock.restaurar();
+  }
+});
+
+test('sintetizar no reintenta cuando el fallo es del propio servicio', async () => {
+  // Con la conexion abierta el servicio ya decidio: volver a conectar sirve
+  // para un corte de red, no para un rechazo.
+  const mock = mockWebSocket(['error']);
+  try {
+    await assert.rejects(() => sintetizar('hola', { reintentos: 5, pausaReintentoMs: 5 }), /WebSocket/);
+    assert.equal(mock.intentos, 1);
+  } finally {
+    mock.restaurar();
+  }
+});
+
+test('sintetizar no reintenta si el usuario cancela', async () => {
+  const mock = mockWebSocket(['fallo']);
+  const controller = new AbortController();
+  try {
+    const enCurso = sintetizar('hola', { reintentos: 5, pausaReintentoMs: 5, signal: controller.signal });
+    controller.abort();
+    await assert.rejects(() => enCurso, /cancel/);
+    assert.ok(mock.intentos <= 1, `intentos: ${mock.intentos}`);
+  } finally {
+    mock.restaurar();
+  }
+});

package/harness/packages/server/bin/tamnora-server.mjs

@@ -1,5 +1,13 @@
 #!/usr/bin/env node
-import { serveCommand } from '../src/cli.js';
+// node:sqlite sigue siendo "experimental" en Node 22, que avisa aunque ande. El
+// aviso no le aporta nada al usuario, asi que se filtra aca. Se quita el
+// impresor default de Node para que lo que si se imprime (lo que no sea
+// ExperimentalWarning) salga una sola vez, no dos.
+process.removeAllListeners('warning');
+process.on('warning', (warning) => {
+  if (warning.name !== 'ExperimentalWarning') console.warn(warning.stack ?? warning);
+});
+const { serveCommand } = await import('../src/cli.js');
 
 serveCommand(process.argv.slice(2))
   .then((code) => {

package/harness/packages/server/public/app.js

@@ -122,7 +122,9 @@ import {
   closeSkillForm,
   importMcp,
   importSkill,
+  limitsCachingEl,
   limitsDurationEl,
+  limitsOutputEl,
   limitsRoundsEl,
   limitsTokensEl,
   mcpForm,
@@ -201,9 +203,6 @@ import {
   trTestBtn,
 } from './voice.js';
 
-document.querySelectorAll('.tab[data-tab]').forEach((t) =>
-  t.addEventListener('click', () => activateTab(t.dataset.tab))
-);
 moreTab.addEventListener('click', (event) => {
   event.stopPropagation();
   const open = moreMenu.hidden;
@@ -538,6 +537,8 @@ $('#limits-save')?.addEventListener('click', async () => {
     maxRounds: Math.max(0, Number(limitsRoundsEl?.value) || 0),
     maxTokens: Math.max(0, Number(limitsTokensEl?.value) || 0),
     maxDurationMs: Math.max(0, Math.round((Number(limitsDurationEl?.value) || 0) * 1000)),
+    maxOutputTokens: Math.max(0, Number(limitsOutputEl?.value) || 0),
+    promptCaching: Boolean(limitsCachingEl?.checked),
   };
   try {
     await api('/api/settings', { method: 'PUT', body });