@danieltmn/tamnora 0.11.2 → 0.12.0

package/harness/packages/core/src/providers/presets.js

@@ -2,16 +2,19 @@ import { openaiCompatibleProvider } from './openaiCompatible.js';
 
 // Most commercial providers expose an OpenAI-compatible chat completions API,
 // so they only differ by label and base URL. Adding one is a one-liner.
-function preset(id, label, baseUrl) {
-  return { ...openaiCompatibleProvider, id, label, defaultBaseUrl: baseUrl, requiresKey: true };
+function preset(id, label, baseUrl, extra = {}) {
+  return { ...openaiCompatibleProvider, id, label, defaultBaseUrl: baseUrl, requiresKey: true, ...extra };
 }
 
 export const OPENAI_COMPATIBLE_PRESETS = [
   preset('deepseek', 'DeepSeek', 'https://api.deepseek.com/v1'),
-  preset('openai', 'OpenAI', 'https://api.openai.com/v1'),
+  preset('openai', 'OpenAI', 'https://api.openai.com/v1', {
+    maxTokensField: 'max_completion_tokens',
+    caching: 'openai',
+  }),
   // Anthropic y Gemini exponen una capa compatible con OpenAI (chat/completions
   // + tools) que usa el mismo Bearer; sirven con este adaptador sin cambios.
-  preset('anthropic', 'Anthropic (Claude)', 'https://api.anthropic.com/v1'),
+  preset('anthropic', 'Anthropic (Claude)', 'https://api.anthropic.com/v1', { caching: 'anthropic' }),
   preset('gemini', 'Google Gemini', 'https://generativelanguage.googleapis.com/v1beta/openai'),
   preset('groq', 'Groq', 'https://api.groq.com/openai/v1'),
   preset('mistral', 'Mistral AI', 'https://api.mistral.ai/v1'),

package/harness/packages/core/src/providers/stream.js

@@ -9,6 +9,47 @@
  * string or as an object (`message`, `data.message`, serialized `data`).
  * (openbridge-style tolerance: errors come in many shapes per provider.)
  */
+function abortError() {
+  return new DOMException('Aborted', 'AbortError');
+}
+
+/**
+ * `reader.read()` abortable. Aunque `fetch` deberia cancelar el body al abortar,
+ * no todos los runtimes lo hacen de forma inmediata; esto garantiza que el
+ * stream se corte apenas el usuario detiene el run.
+ */
+function readChunk(reader, signal) {
+  if (!signal) return reader.read();
+  if (signal.aborted) {
+    reader.cancel().catch(() => {});
+    return Promise.reject(abortError());
+  }
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      reader.cancel().catch(() => {});
+      reject(abortError());
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    reader.read().then(
+      (result) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener('abort', onAbort);
+        resolve(result);
+      },
+      (error) => {
+        if (settled) return;
+        settled = true;
+        signal.removeEventListener('abort', onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+
 export function providerErrorMessage(payload) {
   const err = typeof payload === 'string' ? payload : (payload?.error ?? payload);
   if (typeof err === 'string' && err) return err;
@@ -39,7 +80,7 @@ export function providerErrorMessage(payload) {
  * Parse an OpenAI-compatible SSE stream.
  * @returns {Promise<{content:string, reasoning:string, toolCalls:object[], usage:object|null}>}
  */
-export async function readOpenAISSE(response, { onEvent } = {}) {
+export async function readOpenAISSE(response, { onEvent, signal } = {}) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder('utf-8');
   let partial = '';
@@ -50,7 +91,7 @@ export async function readOpenAISSE(response, { onEvent } = {}) {
   let usage = null;
 
   while (true) {
-    const { done, value } = await reader.read();
+    const { done, value } = await readChunk(reader, signal);
     if (done) break;
     partial += decoder.decode(value, { stream: true });
     const lines = partial.split('\n');
@@ -108,7 +149,7 @@ export async function readOpenAISSE(response, { onEvent } = {}) {
  * Parse Ollama's native NDJSON stream (`/api/chat`).
  * @returns {Promise<{content:string, reasoning:string, toolCalls:object[], usage:object|null}>}
  */
-export async function readNDJSON(response, { onEvent } = {}) {
+export async function readNDJSON(response, { onEvent, signal } = {}) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder('utf-8');
   let partial = '';
@@ -155,7 +196,7 @@ export async function readNDJSON(response, { onEvent } = {}) {
   };
 
   while (true) {
-    const { done, value } = await reader.read();
+    const { done, value } = await readChunk(reader, signal);
     if (done) break;
     partial += decoder.decode(value, { stream: true });
     const lines = partial.split('\n');

package/harness/packages/core/src/skills/index.js

@@ -77,6 +77,27 @@ export async function writeSkillFiles(dir, files = []) {
   }
 }
 
+const INDEX_WHEN_CHARS = 220;
+
+/**
+ * Índice compacto (name + when/description, sin body) para *progressive
+ * disclosure*: el modelo ve qué skills hay y carga el body on-demand con la
+ * herramienta `skill`. Mucho más barato en tokens que inyectar todos los bodies.
+ */
+export function buildSkillsIndex(skills = []) {
+  if (!skills.length) return '';
+  const lines = [
+    'Tenés skills disponibles (instrucciones especializadas). Cuando una aplique a la tarea, cargá su contenido con la herramienta `skill({ name })`:',
+  ];
+  for (const skill of skills) {
+    const title = skill.name || skill.id;
+    const when = String(skill.when || skill.description || '').replace(/\s+/g, ' ').trim();
+    const hint = when.length > INDEX_WHEN_CHARS ? `${when.slice(0, INDEX_WHEN_CHARS)}…` : when;
+    lines.push(`- ${skill.id}: ${title}${hint ? ` — ${hint}` : ''}`);
+  }
+  return lines.join('\n');
+}
+
 /** Text block appended to the system prompt with the enabled skills. */
 export function buildSkillsPrompt(skills = []) {
   if (!skills.length) return '';

package/harness/packages/core/src/tools/executors.js

@@ -301,12 +301,16 @@ export async function grepTool(root, { pattern, include, path: p } = {}) {
   return results.length ? results.join('\n') : 'Sin coincidencias';
 }
 
-export function bashTool(root, { command, timeout } = {}) {
+export function bashTool(root, { command, timeout } = {}, { signal } = {}) {
   return new Promise((resolve) => {
     if (!command || typeof command !== 'string') {
       resolve('Error: falta "command".');
       return;
     }
+    if (signal?.aborted) {
+      resolve('Comando cancelado por el usuario.');
+      return;
+    }
     const seconds = Math.min(Math.max(Number(timeout) || 30, 1), 300);
     let child;
     try {
@@ -318,31 +322,35 @@ export function bashTool(root, { command, timeout } = {}) {
 
     let output = '';
     let settled = false;
+    let timer = null;
     const append = (chunk) => {
       if (output.length < MAX_BASH_OUTPUT) output += chunk.toString();
     };
 
-    const timer = setTimeout(() => {
+    const finish = (text) => {
       if (settled) return;
       settled = true;
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+      resolve(text);
+    };
+    const onAbort = () => {
       child.kill('SIGKILL');
-      resolve(`${output}\n[timeout tras ${seconds}s]\n[exit -1]`);
+      finish(`${output}\n[comando cancelado por el usuario]\n[exit -1]`);
+    };
+    signal?.addEventListener('abort', onAbort, { once: true });
+
+    timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      finish(`${output}\n[timeout tras ${seconds}s]\n[exit -1]`);
     }, seconds * 1000);
 
     child.stdout?.on('data', append);
     child.stderr?.on('data', append);
-    child.on('error', (err) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve(`Error ejecutando el comando: ${err.message}`);
-    });
+    child.on('error', (err) => finish(`Error ejecutando el comando: ${err.message}`));
     child.on('close', (code) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
       const truncated = output.length >= MAX_BASH_OUTPUT ? '\n[output truncado]' : '';
-      resolve(`${output}${truncated}\n[exit ${code}]`);
+      finish(`${output}${truncated}\n[exit ${code}]`);
     });
   });
 }

package/harness/packages/core/src/tools/index.js

@@ -18,8 +18,8 @@ export function createTools({ mcp, ...registryOptions } = {}) {
   const registry = createToolRegistry(registryOptions);
   const definitions = [...registry.definitions, ...(mcp?.definitions ?? [])];
 
-  async function execute(name, args) {
-    if (registry.handles(name)) return registry.execute(name, args);
+  async function execute(name, args, context) {
+    if (registry.handles(name)) return registry.execute(name, args, context);
     if (mcp?.handles?.(name)) return mcp.call(name, args);
     return `Error: herramienta desconocida "${name}".`;
   }

package/harness/packages/core/src/tools/registry.js

@@ -11,8 +11,9 @@ import { evaluatePermission } from './permissions.js';
  * @param {object} [opts.permissions] - policy per tool ('allow'|'ask'|'deny' or pattern map)
  * @param {(name:string, args:object)=>Promise<boolean>} [opts.onAsk] - interactive approval
  * @param {boolean} [opts.yes] - auto-approve 'ask' (non-interactive)
+ * @param {AbortSignal} [opts.signal] - cancela las tools de larga duracion (bash, git)
  */
-export function createToolRegistry({ root, enabled, permissions = {}, onAsk, yes = false } = {}) {
+export function createToolRegistry({ root, enabled, permissions = {}, onAsk, yes = false, signal } = {}) {
   const names = new Set(enabled?.length ? enabled : TOOL_NAMES);
   const definitions = TOOL_DEFINITIONS.filter((d) => names.has(d.function.name));
 
@@ -31,7 +32,7 @@ export function createToolRegistry({ root, enabled, permissions = {}, onAsk, yes
       return `Permiso denegado para "${name}"${detail ? ` (${detail})` : ''}.`;
     }
 
-    return EXECUTORS[name](root, args);
+    return EXECUTORS[name](root, args, { signal });
   }
 
   return {

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

@@ -357,3 +357,41 @@ test('tool_result propaga el meta del executor sin ensuciar el contenido', async
   assert.equal(result.result, 'captura');
   assert.deepEqual(result.meta, { screenshot: { name: 'a.png' } });
 });
+
+test('runAgent propaga maxOutputTokens al proveedor', async () => {
+  const seen = [];
+  const provider = {
+    async streamChat(_config, params) {
+      seen.push(params.maxOutputTokens);
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    maxOutputTokens: 1234,
+  });
+  assert.deepEqual(seen, [1234]);
+});
+
+test('runAgent emite el ciclo de vida (run.start/end, tool.before/after)', async () => {
+  const life = [];
+  const provider = {
+    async streamChat(_config, { messages }) {
+      if (messages.some((m) => m.role === 'tool')) return { content: 'listo', reasoning: '', toolCalls: [] };
+      return { content: '', reasoning: '', toolCalls: [{ id: 'c1', function: { name: 'step', arguments: '{}' } }] };
+    },
+  };
+  await runAgent({
+    provider,
+    config: {},
+    model: 'm',
+    messages: [{ role: 'user', content: 'x' }],
+    tools: [{ type: 'function', function: { name: 'step', parameters: {} } }],
+    execute: async () => 'ok',
+    onLifecycle: (event) => life.push(event.type),
+  });
+  assert.deepEqual(life, ['run.start', 'tool.before', 'tool.after', 'run.end']);
+});

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

@@ -0,0 +1,33 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { liveHistory, planCompaction } from '../src/agent/compact.js';
+
+test('liveHistory saca al asesor y recorta hasta el cursor', () => {
+  const history = [
+    { id: 'a', role: 'user', content: '1' },
+    { id: 'b', role: 'assistant', name: 'advisor', content: 'charla' },
+    { id: 'c', role: 'assistant', content: '2' },
+    { id: 'd', role: 'user', content: '3' },
+  ];
+  assert.deepEqual(liveHistory(history).map((m) => m.id), ['a', 'c', 'd']);
+  assert.deepEqual(liveHistory(history, 'a').map((m) => m.id), ['c', 'd']);
+  // Cursor inexistente: no perdemos contexto, devolvemos todo (sin asesor).
+  assert.deepEqual(liveHistory(history, 'zzz').map((m) => m.id), ['a', 'c', 'd']);
+});
+
+test('planCompaction decide por umbral, tamano y contexto', () => {
+  const mk = (n, size = 4000) => Array.from({ length: n }, (_, i) => ({ id: `m${i}`, role: 'user', content: 'x'.repeat(size) }));
+  // Sin contexto conocido no compacta.
+  assert.equal(planCompaction(mk(20), { contextTokens: 0 }), null);
+  // Debajo del umbral no compacta.
+  assert.equal(planCompaction(mk(3), { contextTokens: 100000, threshold: 0.75, keepLast: 2 }), null);
+  // Muy pocos mensajes: no compacta aunque el contexto sea chico.
+  assert.equal(planCompaction(mk(4), { contextTokens: 100, threshold: 0.75, keepLast: 4 }), null);
+
+  const live = mk(12);
+  const plan = planCompaction(live, { contextTokens: 1000, threshold: 0.75, keepLast: 8 });
+  assert.ok(plan);
+  assert.equal(plan.toSummarize.length, 4);
+  assert.equal(plan.keep.length, 8);
+  assert.equal(plan.cursor, 'm3');
+});

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

@@ -42,3 +42,17 @@ test('trimContext drops oldest groups but keeps the system and the tail', () =>
   assert.ok(result.messages.length <= messages.length);
   assert.ok(result.messages.length > 4);
 });
+
+test('trimContext protege los system iniciales (objetivo y resumen)', () => {
+  const messages = [
+    { role: 'system', content: 'base' },
+    { role: 'system', content: 'Objetivo: X' },
+    { role: 'system', content: 'Resumen de la conversación anterior:\nviejo' },
+    { role: 'user', content: 'u '.repeat(3000) },
+    { role: 'assistant', content: 'a '.repeat(3000) },
+  ];
+  const result = trimContext(messages, { maxTokens: 200, keepLast: 1 });
+  assert.equal(result.messages[0].content, 'base');
+  assert.equal(result.messages[1].content, 'Objetivo: X');
+  assert.match(result.messages[2].content, /Resumen de la conversación anterior/);
+});

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

@@ -4,6 +4,8 @@ import { Store } from '../src/storage/sqlite.js';
 import { composeProviderSettings } from '../src/config/providers.js';
 import { toOllamaMessages } from '../src/providers/ollama.js';
 import { providerFetch, normalizeModel } from '../src/providers/utils.js';
+import { openaiCompatibleProvider } from '../src/providers/openaiCompatible.js';
+import { applyPromptCache } from '../src/providers/cache.js';
 import { isRetryableError } from '../src/providers/resilience.js';
 
 test('normalizeModel reads the context window across provider shapes', () => {
@@ -105,3 +107,67 @@ test('providerFetch turns network failures into a readable, retryable error', as
     globalThis.fetch = original;
   }
 });
+
+test('openaiCompatible manda max_tokens y respeta maxTokensField', async () => {
+  const bodies = [];
+  const original = globalThis.fetch;
+  const sse = 'data: {"choices":[{"delta":{"content":"hi"}}]}\n\ndata: [DONE]\n\n';
+  globalThis.fetch = async (_url, init) => {
+    bodies.push(JSON.parse(init.body));
+    return new Response(sse, { status: 200, headers: { 'content-type': 'text/event-stream' } });
+  };
+  const cfg = { baseUrl: 'https://x/v1', apiKey: 'k' };
+  const user = [{ role: 'user', content: 'u' }];
+  try {
+    await openaiCompatibleProvider.streamChat(cfg, { model: 'm', messages: user, maxOutputTokens: 100 });
+    const openai = { ...openaiCompatibleProvider, maxTokensField: 'max_completion_tokens' };
+    await openai.streamChat(cfg, { model: 'm', messages: user, maxOutputTokens: 200 });
+    await openaiCompatibleProvider.streamChat(cfg, { model: 'm', messages: user });
+  } finally {
+    globalThis.fetch = original;
+  }
+  assert.equal(bodies[0].max_tokens, 100);
+  assert.equal(bodies[0].max_completion_tokens, undefined);
+  assert.equal(bodies[1].max_completion_tokens, 200);
+  assert.equal(bodies[2].max_tokens, undefined);
+});
+
+test('applyPromptCache: anthropic marca el system, openai agrega la clave', () => {
+  const anthropic = { messages: [{ role: 'system', content: 'sys' }, { role: 'user', content: 'u' }] };
+  applyPromptCache(anthropic, { mode: 'anthropic' });
+  assert.deepEqual(anthropic.messages[0].content, [
+    { type: 'text', text: 'sys', cache_control: { type: 'ephemeral' } },
+  ]);
+  assert.equal(anthropic.messages[1].content, 'u');
+
+  const openai = { messages: [{ role: 'system', content: 'sys' }], tools: [] };
+  applyPromptCache(openai, { mode: 'openai' });
+  assert.equal(typeof openai.prompt_cache_key, 'string');
+  assert.equal(openai.prompt_cache_key.length, 32);
+
+  const none = { messages: [{ role: 'system', content: 'sys' }] };
+  applyPromptCache(none, { mode: 'none' });
+  assert.equal(none.messages[0].content, 'sys');
+  assert.equal(none.prompt_cache_key, undefined);
+});
+
+test('openaiCompatible aplica prompt caching solo si está activado', async () => {
+  const bodies = [];
+  const original = globalThis.fetch;
+  const sse = 'data: {"choices":[{"delta":{"content":"hi"}}]}\n\ndata: [DONE]\n\n';
+  globalThis.fetch = async (_url, init) => {
+    bodies.push(JSON.parse(init.body));
+    return new Response(sse, { status: 200, headers: { 'content-type': 'text/event-stream' } });
+  };
+  const cfg = { baseUrl: 'https://x/v1', apiKey: 'k' };
+  const user = [{ role: 'user', content: 'u' }];
+  const openai = { ...openaiCompatibleProvider, caching: 'openai' };
+  try {
+    await openai.streamChat(cfg, { model: 'm', messages: user, promptCaching: true });
+    await openai.streamChat(cfg, { model: 'm', messages: user, promptCaching: false });
+  } finally {
+    globalThis.fetch = original;
+  }
+  assert.equal(typeof bodies[0].prompt_cache_key, 'string');
+  assert.equal(bodies[1].prompt_cache_key, undefined);
+});

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

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { parseSkillMarkdown, loadSkills, mergeSkills, buildSkillsPrompt } from '../src/skills/index.js';
+import { parseSkillMarkdown, loadSkills, mergeSkills, buildSkillsPrompt, buildSkillsIndex } from '../src/skills/index.js';
 import { parseSkillRef } from '../src/skills/remote.js';
 
 test('parseSkillMarkdown reads frontmatter and body', () => {
@@ -67,3 +67,12 @@ test('buildSkillsPrompt lists enabled skills and is empty without skills', () =>
   assert.match(text, /Demo/);
   assert.match(text, /Hacé X\./);
 });
+
+test('buildSkillsIndex lists id + when without the body (progressive disclosure)', () => {
+  assert.equal(buildSkillsIndex([]), '');
+  const text = buildSkillsIndex([{ id: 'demo', name: 'Demo', when: 'usar en PRs', body: 'SECRETO_BODY' }]);
+  assert.match(text, /demo/);
+  assert.match(text, /usar en PRs/);
+  assert.match(text, /skill\(\{ name \}\)/);
+  assert.doesNotMatch(text, /SECRETO_BODY/);
+});

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

@@ -89,3 +89,23 @@ test('usage is null when the provider does not report it', async () => {
   const res = await readOpenAISSE(new Response(sse));
   assert.equal(res.usage, null);
 });
+
+test('readOpenAISSE corta el stream cuando la señal aborta', async () => {
+  const encoder = new TextEncoder();
+  // Un body que emite un frame y nunca cierra: el unico corte posible es abort.
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode('data: {"choices":[{"delta":{"content":"hola"}}]}\n\n'));
+    },
+  });
+  const ac = new AbortController();
+  const promise = readOpenAISSE(new Response(stream), { signal: ac.signal });
+  setTimeout(() => ac.abort(), 10);
+  await assert.rejects(promise, (error) => error.name === 'AbortError');
+});
+
+test('readOpenAISSE con la señal ya abortada no lee nada', async () => {
+  const ac = new AbortController();
+  ac.abort();
+  await assert.rejects(readOpenAISSE(new Response('data: [DONE]\n'), { signal: ac.signal }), (error) => error.name === 'AbortError');
+});

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

@@ -158,6 +158,24 @@ test('bash runs inside the workspace root', async () => {
   assert.match(out, /\[exit 0\]/);
 });
 
+test('bash se cancela cuando aborta la señal del run', async () => {
+  const root = await makeWorkspace();
+  const ac = new AbortController();
+  const reg = createToolRegistry({ root, permissions: { bash: 'allow' }, signal: ac.signal });
+  const promise = reg.execute('bash', { command: 'node -e "setTimeout(() => {}, 5000)"', timeout: 30 });
+  setTimeout(() => ac.abort(), 150);
+  const out = await promise;
+  assert.match(out, /cancelado/);
+});
+
+test('bash con la señal ya abortada no arranca el proceso', async () => {
+  const root = await makeWorkspace();
+  const ac = new AbortController();
+  ac.abort();
+  const reg = createToolRegistry({ root, permissions: { bash: 'allow' }, signal: ac.signal });
+  assert.match(await reg.execute('bash', { command: 'echo hola' }), /cancelado/);
+});
+
 test('la tool speak valida el texto y la recorta', async () => {
   const root = await makeWorkspace();
   const reg = createToolRegistry({ root });