@danieltmn/tamnora 0.21.2 → 0.23.0

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

@@ -0,0 +1,816 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, writeFile, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { startServer, readSse, waitIdle, readEvents } from './helpers.js';
+
+test('streams a chat turn over SSE and persists the messages', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const res = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'hola', model: 'm' }),
+    });
+    assert.equal(res.status, 200);
+    assert.match(res.headers.get('content-type'), /text\/event-stream/);
+    const text = await res.text();
+    assert.match(text, /event: start/);
+    assert.match(text, /event: text/);
+    assert.match(text, /event: done/);
+
+    const list = await (await fetch(`${base}/api/sessions`)).json();
+    assert.equal(list.sessions.length, 1);
+    const detail = await (await fetch(`${base}/api/sessions/${list.sessions[0].id}`)).json();
+    const assistant = detail.messages.find((m) => m.role === 'assistant');
+    assert.equal(assistant.content, 'hola');
+  } finally {
+    await instance.close();
+  }
+});
+
+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('interrupt cancels the running turn and starts the new message right away', async () => {
+  const calls = { n: 0 };
+  let abortedFirst = false;
+  const provider = {
+    id: 'interrupt',
+    async streamChat(_config, { onEvent, signal }) {
+      calls.n += 1;
+      if (calls.n === 1) {
+        onEvent?.({ type: 'text', delta: 'trabajando', full: 'trabajando' });
+        await new Promise((resolve, reject) => {
+          const timer = setTimeout(resolve, 5000);
+          const onAbort = () => {
+            clearTimeout(timer);
+            abortedFirst = true;
+            reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+          };
+          if (signal?.aborted) return onAbort();
+          signal?.addEventListener('abort', onAbort, { once: true });
+        });
+      }
+      onEvent?.({ type: 'text', delta: 'listo', full: 'listo' });
+      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 first = fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ input: 'uno', model: 'm', sessionId: id }),
+    })
+      .then((res) => res.text())
+      .catch(() => null);
+    await new Promise((resolve) => setTimeout(resolve, 80));
+
+    const second = await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'dos', model: 'm', sessionId: id, interrupt: true }),
+      })
+    ).text();
+
+    assert.match(second, /event: text/);
+    assert.match(second, /listo/);
+    assert.equal(abortedFirst, true);
+    await first;
+
+    await new Promise((resolve) => setTimeout(resolve, 60));
+    const after = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    assert.equal(after.running, false);
+  } finally {
+    await instance.close();
+  }
+});
+
+/** Lee un SSE hasta que `until(data)` se cumpla, y devuelve lo acumulado. */
+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.
+ */
+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, ese permiso no queda pendiente: si
+        // volviera, el cliente lo re-pintaria en bucle. (Puede haber otro askId
+        // nuevo del siguiente paso, pero el resuelto no puede reaparecer.)
+        const after = await (await fetch(`${base}/api/state`)).json();
+        assert.ok(
+          !after.permissions.some((p) => p.askId === ask.askId),
+          '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');
+  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('auto-compact resume el historial cuando el contexto se pasa', async () => {
+  let captured = '';
+  const provider = {
+    id: 'capture',
+    async streamChat(_config, { messages }) {
+      captured = (messages ?? [])
+        .map((m) => (typeof m.content === 'string' ? m.content : ''))
+        .join('\n');
+      return { content: 'RESUMEN OK', reasoning: '', toolCalls: [] };
+    },
+  };
+  const json = { 'Content-Type': 'application/json' };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ title: 't', model: 'm' }),
+      })
+    ).json();
+    const id = created.session.id;
+    const big = 'x'.repeat(4000);
+    instance.store.addMessages(
+      id,
+      Array.from({ length: 12 }, (_, i) => ({ role: i % 2 ? 'assistant' : 'user', content: `m${i} ${big}` }))
+    );
+
+    await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ sessionId: id, model: 'm', input: 'hola', contextTokens: 1000 }),
+    }).then((r) => r.text());
+
+    const meta = instance.store.getSession(id).meta;
+    assert.ok(meta.summaryCursor, 'debe guardar el cursor de compactación');
+    assert.match(captured, /Resumen de la conversación anterior/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('rejects chat without input or model', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const noInput = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model: 'm' }),
+    });
+    assert.equal(noInput.status, 400);
+
+    const noModel = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'hola' }),
+    });
+    assert.equal(noModel.status, 400);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('forwards attached images as multimodal content', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-img-'));
+  let captured = null;
+  const provider = {
+    id: 'vision',
+    async streamChat(_config, opts) {
+      captured = opts.messages.find((m) => m.role === 'user');
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    const image = 'data:image/png;base64,iVBORw0KGgo=';
+    const res = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'mirá', model: 'm', images: [image] }),
+    });
+    await res.text();
+    assert.ok(Array.isArray(captured.content));
+    assert.deepEqual(captured.content[0], { type: 'text', text: 'mirá' });
+    assert.equal(captured.content[1].type, 'image_url');
+    assert.equal(captured.content[1].image_url.url, image);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('scope=session approves later asks without prompting again', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-scope-'));
+  let round = 0;
+  const provider = {
+    id: 'twice',
+    async streamChat() {
+      round += 1;
+      if (round <= 2) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [
+            {
+              id: `call_${round}`,
+              function: { name: 'write', arguments: JSON.stringify({ path: `f${round}.txt`, content: 'x' }) },
+            },
+          ],
+        };
+      }
+      return { content: 'fin', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    const res = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'creá dos archivos', model: 'm' }),
+    });
+    let decisions = 0;
+    const text = await readEvents(res, async (buffer) => {
+      if (decisions === 0 && buffer.includes('event: permission')) {
+        decisions += 1;
+        const askId = buffer.match(/"askId":"([0-9a-f-]+)"/)[1];
+        await fetch(`${base}/api/permissions/${askId}`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ allow: true, scope: 'session' }),
+        });
+      }
+    });
+    assert.equal(decisions, 1, 'solo pidió permiso una vez');
+    assert.equal((text.match(/event: permission\n/g) ?? []).length, 1);
+    assert.equal(await readFile(path.join(cwd, 'f1.txt'), 'utf8'), 'x');
+    assert.equal(await readFile(path.join(cwd, 'f2.txt'), 'utf8'), 'x');
+  } finally {
+    await instance.close();
+  }
+});
+