@danieltmn/tamnora 0.25.0 → 0.25.1

package/CHANGELOG.md

@@ -5,6 +5,12 @@ Todos los cambios relevantes de este proyecto se documentan en este archivo.
 El formato sigue [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/)
 y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.25.1] - 2026-11-04
+
+### Cambios
+
+- feat: esfuerzo de razonamiento y subagentes en archivos
+
 ## [0.25.0] - 2026-11-01
 
 ### Cambios

package/harness/packages/cli/src/commands/repl.js

@@ -7,6 +7,7 @@ import {
   createTools,
   buildMcpRegistry,
   scopeDirective,
+  normalizeEffort,
 } from '../lib/core.js';
 import { parse, databasePath, num } from '../lib/util.js';
 import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider, mcpSettings, mcpIndexBlock } from '../lib/runtime.js';
@@ -21,6 +22,7 @@ const OPTIONS = {
   'no-tools': { type: 'boolean' },
   strict: { type: 'boolean' },
   'no-strict': { type: 'boolean' },
+  effort: { type: 'string' },
   yes: { type: 'boolean', short: 'y' },
 };
 
@@ -35,6 +37,7 @@ export async function replCommand(argv) {
   const maxRounds = num(values['max-steps'], config.maxRounds);
   const store = new Store(databasePath(cwd));
   let strict = values.strict ? true : values['no-strict'] ? false : store.getSetting('strictScope') === true;
+  let effort = normalizeEffort(values.effort ?? store.getSetting('activeEffort') ?? config.effort);
   const buildPrompt = () =>
     buildSystemPrompt(instructions, [systemExtra, mcpBlock, scopeDirective(strict)].filter(Boolean).join('\n\n'));
   const resolved = resolveCliProvider(store, config, { provider: values.provider, model: values.model });
@@ -97,7 +100,7 @@ export async function replCommand(argv) {
     mcpPinned,
   });
 
-  process.stdout.write(color.dim(`Tamnora REPL · ${providerId}/${model}\n`));
+  process.stdout.write(color.dim(`Tamnora REPL · ${providerId}/${model}${effort ? ` · esfuerzo ${effort}` : ''}\n`));
   process.stdout.write(color.dim(`workspace ${cwd}\n`));
   process.stdout.write(color.dim(`session ${sessionId} · /help para comandos · Ctrl+C para salir\n\n`));
   rl.prompt();
@@ -120,7 +123,7 @@ export async function replCommand(argv) {
       } else if (cmd === 'help') {
         process.stdout.write(
           `${color.dim(
-            '/model <id>  /provider <id>  /system <texto>  /strict  /clear  /session  /exit'
+            '/model <id>  /provider <id>  /system <texto>  /strict  /esfuerzo <nivel>  /clear  /session  /exit'
           )}\n`
         );
       } else if (cmd === 'model') {
@@ -137,6 +140,18 @@ export async function replCommand(argv) {
         else strict = !strict;
         store.setSetting('strictScope', strict);
         process.stdout.write(color.dim(`solo lo pedido: ${strict ? 'activado' : 'desactivado'}\n`));
+      } else if (cmd === 'effort' || cmd === 'esfuerzo') {
+        if (arg) {
+          const level = normalizeEffort(arg);
+          if (!level && !/^(auto|default)$/i.test(arg)) {
+            process.stdout.write(color.red('nivel inválido: off | low | medium | high | max | auto\n'));
+            rl.prompt();
+            return;
+          }
+          effort = level;
+          store.setSetting('activeEffort', level || null);
+        }
+        process.stdout.write(color.dim(`esfuerzo: ${effort || 'auto'}\n`));
       } else if (cmd === 'clear') {
         history = [];
         process.stdout.write(color.dim('historial limpiado\n'));
@@ -167,6 +182,7 @@ export async function replCommand(argv) {
         maxDurationMs: config.maxDurationMs,
         maxOutputTokens: config.maxOutputTokens,
         promptCaching: config.promptCaching === true,
+        reasoningEffort: effort,
         tools: toolDefs,
         execute,
         onEvent: printer.onEvent,

package/harness/packages/cli/src/commands/run.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { loadConfig, loadInstructions, Store, createTools, buildMcpRegistry, scopeDirective } from '../lib/core.js';
+import { loadConfig, loadInstructions, Store, createTools, buildMcpRegistry, scopeDirective, normalizeEffort } from '../lib/core.js';
 import { parse, databasePath, num } from '../lib/util.js';
 import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider, mcpSettings, mcpIndexBlock } from '../lib/runtime.js';
 import { color } from '../ui/color.js';
@@ -17,6 +17,7 @@ const OPTIONS = {
   'no-tools': { type: 'boolean' },
   strict: { type: 'boolean' },
   'no-strict': { type: 'boolean' },
+  effort: { type: 'string' },
   yes: { type: 'boolean', short: 'y' },
   help: { type: 'boolean', short: 'h' },
 };
@@ -101,6 +102,7 @@ export async function runCommand(argv) {
   process.once('SIGINT', onSigint);
 
   const strict = values.strict ? true : values['no-strict'] ? false : store.getSetting('strictScope') === true;
+  const effort = normalizeEffort(values.effort ?? store.getSetting('activeEffort') ?? config.effort);
 
   try {
     const { result, newMessages } = await runTurn({
@@ -120,6 +122,7 @@ export async function runCommand(argv) {
       maxDurationMs: config.maxDurationMs,
       maxOutputTokens: config.maxOutputTokens,
       promptCaching: config.promptCaching === true,
+      reasoningEffort: effort,
       signal: controller.signal,
       tools: toolDefs,
       execute,
@@ -176,6 +179,7 @@ Opciones:
   --tools <lista>    Tools habilitadas (coma), ej. read,list,grep
   --no-tools         Deshabilitar todas las tools
   --strict           Hacer solo lo pedido (estricto)   --no-strict
+  --effort <nivel>   Esfuerzo de razonamiento: off | low | medium | high | max
   -y, --yes          Aprobar automáticamente los permisos "ask"
   --json             Salida JSON (sin streaming)`);
 }

package/harness/packages/cli/src/commands/tui.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { loadConfig, loadInstructions, Store, buildMcpRegistry, resolveMode, scopeDirective } from '../lib/core.js';
+import { loadConfig, loadInstructions, Store, buildMcpRegistry, resolveMode, scopeDirective, normalizeEffort } from '../lib/core.js';
 import { parse, databasePath, num } from '../lib/util.js';
 import { buildSystemPrompt, resolveCliProvider, mcpSettings, mcpIndexBlock } from '../lib/runtime.js';
 import { runTui } from '../tui/app.js';
@@ -16,6 +16,7 @@ const OPTIONS = {
   'no-tools': { type: 'boolean' },
   strict: { type: 'boolean' },
   'no-strict': { type: 'boolean' },
+  effort: { type: 'string' },
   yes: { type: 'boolean', short: 'y' },
   help: { type: 'boolean', short: 'h' },
 };
@@ -68,6 +69,7 @@ export async function tuiCommand(argv) {
 
   const mode = resolveMode(values.mode || store.getSetting('activeMode') || 'agent');
   let strict = values.strict ? true : values['no-strict'] ? false : store.getSetting('strictScope') === true;
+  const effort = normalizeEffort(values.effort ?? store.getSetting('activeEffort') ?? config.effort);
   const enabledFor = (m) =>
     m.tools ? (baseEnabled ? baseEnabled.filter((tool) => m.tools.includes(tool)) : m.tools) : baseEnabled;
   const promptFor = (m) =>
@@ -102,6 +104,7 @@ export async function tuiCommand(argv) {
     maxDurationMs: config.maxDurationMs,
     maxOutputTokens: config.maxOutputTokens,
     promptCaching: config.promptCaching === true,
+    reasoningEffort: effort,
     toolOptions: {
       root: cwd,
       enabled: enabledFor(mode),
@@ -133,5 +136,6 @@ Opciones:
   --max-steps <n>   Techo de rondas de herramientas (0 = sin límite, default)
   --tools <lista>   Tools habilitadas (coma)   --no-tools
   --strict          Hacer solo lo pedido (estricto)   --no-strict
+  --effort <nivel>  Esfuerzo de razonamiento: off | low | medium | high | max
   -y, --yes         Auto-aprobar tools con permiso "ask"`);
 }

package/harness/packages/cli/src/lib/runtime.js

@@ -78,6 +78,7 @@ export async function runTurn({
   maxDurationMs,
   maxOutputTokens,
   promptCaching,
+  reasoningEffort,
   stallWarnMs,
   signal,
   execute,
@@ -106,6 +107,7 @@ export async function runTurn({
     maxDurationMs,
     maxOutputTokens,
     promptCaching,
+    reasoningEffort,
     stallWarnMs,
     signal,
     onEvent,

package/harness/packages/cli/src/tui/app.js

@@ -2,7 +2,7 @@
 // Alt-screen + raw input + incremental rendering; reuses the harness engine.
 
 import { readFileSync } from 'node:fs';
-import { createTools, diffRows, resolveInRoot } from '../lib/core.js';
+import { createTools, diffRows, resolveInRoot, normalizeEffort } from '../lib/core.js';
 import { runTurn } from '../lib/runtime.js';
 import { parseKeys } from './keys.js';
 import { render } from './layout.js';
@@ -25,6 +25,7 @@ export function runTui({
   maxDurationMs,
   maxOutputTokens,
   promptCaching,
+  reasoningEffort,
   toolOptions,
   store,
   sessionId,
@@ -37,8 +38,9 @@ export function runTui({
   let activeMode = readMode(mode);
   let modePrompt = activeMode.systemPrompt ?? systemPrompt;
   let modeEnabled = activeMode.enabled;
+  let effort = reasoningEffort || '';
   const state = {
-    header: { provider: providerId, model, cwd: toolOptions.root },
+    header: { provider: providerId, model, cwd: toolOptions.root, effort },
     messages: [],
     input: '',
     inputCursor: 0,
@@ -176,6 +178,23 @@ export function runTui({
       toggleStrict(/^(on|si|sí)$/i.test(strictArg[1]));
       return;
     }
+    const effortArg = text.match(/^\/(?:esfuerzo|effort)(?:\s+(\S+))?$/i);
+    if (effortArg) {
+      if (effortArg[1]) {
+        const next = normalizeEffort(effortArg[1]);
+        if (!next && !/^(auto|default)$/i.test(effortArg[1])) {
+          addMessage('assistant', 'Nivel inválido: off | low | medium | high | max | auto.');
+          draw();
+          return;
+        }
+        effort = next;
+        state.header.effort = effort;
+        store.setSetting('activeEffort', effort || null);
+      }
+      addMessage('assistant', `Esfuerzo: ${effort || 'auto'}.`);
+      draw();
+      return;
+    }
     if (text === '/limpiar' || text === '/clear') {
       state.input = '';
       state.messages = [];
@@ -209,6 +228,7 @@ export function runTui({
         maxDurationMs,
         maxOutputTokens,
         promptCaching,
+        reasoningEffort: effort,
         signal: controller.signal,
         tools: toolset.definitions,
         execute: toolset.execute,

package/harness/packages/cli/src/tui/layout.js

@@ -126,7 +126,7 @@ function buildBody(state, width) {
 
 function headerText(state, width) {
   const left = `  ❯ tamnora`;
-  const middle = `  ${state.header.provider}/${state.header.model}`;
+  const middle = `  ${state.header.provider}/${state.header.model}${state.header.effort ? ` · ${state.header.effort}` : ''}`;
   const tokens = state.tokens?.prompt ? `  ctx ${formatK(state.tokens.prompt)}` : '';
   const right = state.streaming ? `generando…${tokens} ` : `${state.header.cwd ?? ''}${tokens} `;
   const pad = Math.max(0, width - chars(left).length - chars(middle).length - chars(right).length);

package/harness/packages/core/src/agent/runAgent.js

@@ -60,6 +60,7 @@ export async function runAgent({
   maxDurationMs = 0,
   maxOutputTokens = 0,
   promptCaching = false,
+  reasoningEffort = '',
   repeatLimit = 3,
   wrapUp = true,
   stallWarnMs = 90000,
@@ -148,6 +149,7 @@ export async function runAgent({
             signal,
             maxOutputTokens,
             promptCaching,
+            reasoningEffort,
             onEvent: (event) => {
               if (event && (event.type === 'reasoning' || event.type === 'tool_calls')) emitted = true;
               if (event?.type === 'text' && event.delta) emitted = true;
@@ -274,7 +276,7 @@ export async function runAgent({
 
   let wrappedUp = false;
   if (wrapUp && (stopReason === 'max_rounds' || stopReason === 'no_progress' || stopReason === 'budget')) {
-    const wrap = await runFinalAnswer({ provider, config, model, working, signal, onEvent, maxRetries: retries, retryDelayMs, maxOutputTokens, promptCaching });
+    const wrap = await runFinalAnswer({ provider, config, model, working, signal, onEvent, maxRetries: retries, retryDelayMs, maxOutputTokens, promptCaching, reasoningEffort });
     if (wrap.usage) accumulateUsage(wrap.usage);
     if (wrap.content) {
       working.push({ role: 'assistant', content: wrap.content, tokens_in: wrap.usage?.prompt_tokens, tokens_out: wrap.usage?.completion_tokens });
@@ -297,7 +299,7 @@ export async function runAgent({
 }
 
 /** Ronda final con tools deshabilitadas para forzar un cierre con texto. */
-async function runFinalAnswer({ provider, config, model, working, signal, onEvent, maxRetries, retryDelayMs, maxOutputTokens, promptCaching }) {
+async function runFinalAnswer({ provider, config, model, working, signal, onEvent, maxRetries, retryDelayMs, maxOutputTokens, promptCaching, reasoningEffort }) {
   try {
     const result = await withRetry(
       () =>
@@ -308,6 +310,7 @@ async function runFinalAnswer({ provider, config, model, working, signal, onEven
           signal,
           maxOutputTokens,
           promptCaching,
+          reasoningEffort,
           onEvent,
         }),
       { retries: maxRetries, baseDelayMs: retryDelayMs, signal }

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

@@ -0,0 +1,141 @@
+// Subagentes: definiciones en markdown con frontmatter (`<casa>/agents/<id>/AGENT.md`
+// o `<cwd>/.tamnora/agents/<id>.md`). El agente principal los ve como un índice
+// en el system prompt y delega en ellos con `task({ agent })`.
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export const AGENT_FILE = 'AGENT.md';
+
+function parseList(value) {
+  if (value === undefined || value === null) return null;
+  const cleaned = String(value).trim().replace(/^\[|\]$/g, '');
+  return cleaned
+    .split(',')
+    .map((item) => item.trim().replace(/^["']|["']$/g, ''))
+    .filter(Boolean);
+}
+
+/** Parse an AGENT.md: frontmatter `--- key: value ---` plus the body prompt. */
+export function parseAgentMarkdown(text, fallbackId = '') {
+  const source = String(text ?? '');
+  const agent = {
+    id: fallbackId,
+    name: fallbackId,
+    description: '',
+    model: '',
+    provider: '',
+    mode: '',
+    effort: '',
+    maxRounds: 0,
+    tools: null,
+    skills: null,
+    body: source.trim(),
+  };
+  const match = source.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?([\s\S]*)$/);
+  if (!match) return agent;
+
+  agent.body = match[2].trim();
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z][\w-]*)\s*:\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1].toLowerCase();
+    const value = kv[2].trim().replace(/^["']|["']$/g, '');
+    if (key === 'name') agent.name = value || fallbackId;
+    else if (key === 'description') agent.description = value;
+    else if (key === 'model') agent.model = value;
+    else if (key === 'provider') agent.provider = value;
+    else if (key === 'mode') agent.mode = value;
+    else if (key === 'effort' || key === 'reasoning' || key === 'reasoning_effort') agent.effort = value;
+    else if (key === 'maxrounds' || key === 'max_rounds') agent.maxRounds = Number(value) || 0;
+    else if (key === 'tools') agent.tools = parseList(value);
+    else if (key === 'skills') agent.skills = parseList(value);
+  }
+  return agent;
+}
+
+/** List agents under a root (missing root -> []). Directory form wins. */
+export function loadAgents(root) {
+  const agents = [];
+  let entries = [];
+  try {
+    entries = readdirSync(root, { withFileTypes: true });
+  } catch {
+    return agents;
+  }
+  for (const entry of entries) {
+    const full = path.join(root, entry.name);
+    const file = entry.isDirectory() ? path.join(full, AGENT_FILE) : entry.name.toLowerCase().endsWith('.md') ? full : null;
+    if (!file) continue;
+    try {
+      if (!statSync(file).isFile()) continue;
+      const id = entry.isDirectory() ? entry.name : entry.name.replace(/\.md$/i, '');
+      const parsed = parseAgentMarkdown(readFileSync(file, 'utf8'), id);
+      agents.push({ ...parsed, id, path: file });
+    } catch {
+      // ignore unreadable agents
+    }
+  }
+  return agents.sort((a, b) => a.id.localeCompare(b.id, 'es'));
+}
+
+/** Merge several roots; later roots win on id collisions (workspace over casa). */
+export function mergeAgents(rootLists = []) {
+  const byId = new Map();
+  for (const list of rootLists) for (const agent of list) byId.set(agent.id, agent);
+  return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id, 'es'));
+}
+
+/**
+ * Índice compacto para el system prompt: qué subagentes hay y cómo delegar.
+ * Sin agentes devuelve '' (no ensucia el contexto).
+ */
+export function buildAgentsIndex(agents = []) {
+  if (!agents.length) return '';
+  const lines = [
+    'Tenés subagentes disponibles. Para delegarles una subtarea, usá `task({ agent: "<id>", prompt: "..." })` con una instrucción autocontenida:',
+  ];
+  for (const agent of agents) {
+    const title = agent.name || agent.id;
+    const desc = String(agent.description || '').replace(/\s+/g, ' ').trim();
+    lines.push(`- ${agent.id}: ${title}${desc ? ` — ${desc}` : ''}`);
+  }
+  return lines.join('\n');
+}
+
+/** Ficha del subagente para su propio system prompt. */
+export function buildSubagentPrompt(agent, { basePrompt = '' } = {}) {
+  const parts = [];
+  if (basePrompt) parts.push(basePrompt);
+  parts.push(
+    [
+      `Sos el subagente "${agent.name || agent.id}" de Tamnora.`,
+      agent.description ? `Rol: ${agent.description}` : '',
+      'Ejecutá de forma autónoma la tarea encomendada con las herramientas disponibles y devolvé un resumen conciso y concreto de lo que encontraste o hiciste (archivos, hallazgos, decisiones). No pidas confirmaciones: si algo no es posible, explicalo en el resumen.',
+      agent.body ? `\nInstrucciones del subagente:\n${agent.body}` : '',
+    ]
+      .filter(Boolean)
+      .join('\n')
+  );
+  return parts.join('\n\n---\n\n');
+}
+
+/** Escribe el AGENT.md de un subagente (con guarda de traversal en el id). */
+export async function writeAgentFile(dir, agent) {
+  const id = String(agent.id ?? '').trim();
+  if (!id || !/^[a-z0-9][a-z0-9_-]{0,39}$/i.test(id)) throw new Error('Id de subagente inválido.');
+  const lines = ['---', `name: ${agent.name || id}`];
+  if (agent.description) lines.push(`description: ${agent.description}`);
+  if (agent.model) lines.push(`model: ${agent.model}`);
+  if (agent.provider) lines.push(`provider: ${agent.provider}`);
+  if (agent.mode) lines.push(`mode: ${agent.mode}`);
+  if (agent.effort) lines.push(`effort: ${agent.effort}`);
+  if (agent.maxRounds > 0) lines.push(`maxRounds: ${Math.round(agent.maxRounds)}`);
+  if (Array.isArray(agent.tools)) lines.push(`tools: ${agent.tools.join(', ')}`);
+  if (Array.isArray(agent.skills)) lines.push(`skills: ${agent.skills.join(', ')}`);
+  lines.push('---', '', String(agent.body ?? '').trim(), '');
+  await mkdir(dir, { recursive: true });
+  await writeFile(path.join(dir, AGENT_FILE), lines.join('\n'), 'utf8');
+  return path.join(dir, AGENT_FILE);
+}

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

@@ -12,6 +12,7 @@ export const DEFAULT_CONFIG = {
   maxDurationMs: 0,
   maxOutputTokens: 0,
   promptCaching: false,
+  effort: '',
   skills: { mode: 'lazy' },
   compact: { enabled: true, threshold: 0.75, keepLast: 8 },
   rules: ['.tamnora/rules/*.md'],

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

@@ -32,6 +32,7 @@ export {
   testProviderConnection,
   streamChat,
 } from './providers/index.js';
+export { EFFORT_LEVELS, EFFORT_LABELS, normalizeEffort, applyReasoningEffort } from './providers/reasoning.js';
 export {
   connectMcpServer,
   connectMcpHttpServer,
@@ -108,6 +109,15 @@ export {
   buildSkillsPrompt,
   buildSkillsIndex,
 } from './skills/index.js';
+export {
+  AGENT_FILE,
+  parseAgentMarkdown,
+  loadAgents,
+  mergeAgents,
+  buildAgentsIndex,
+  buildSubagentPrompt,
+  writeAgentFile,
+} from './agents/index.js';
 export { parseSkillRef, fetchSkillFromGithub, searchSkillsGithub } from './skills/remote.js';
 export { SKILLS_CATALOG, skillCatalogEntry } from './skills/catalog.js';
 export {

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

@@ -12,11 +12,12 @@ export const PROVIDERS = [
 ];
 
 /** Lightweight metadata for the settings UI. */
-export const PROVIDER_META = PROVIDERS.map(({ id, label, defaultBaseUrl, requiresKey }) => ({
+export const PROVIDER_META = PROVIDERS.map(({ id, label, defaultBaseUrl, requiresKey, reasoning }) => ({
   id,
   label,
   defaultBaseUrl,
   requiresKey,
+  reasoning: reasoning ?? 'none',
 }));
 
 /**
@@ -31,6 +32,7 @@ export function createCustomProvider(def) {
     defaultBaseUrl: def.baseUrl,
     requiresKey: true,
     custom: true,
+    reasoning: def.reasoning ?? 'none',
     manualModels: def.models ?? [],
   };
 }

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

@@ -1,4 +1,5 @@
 import { readNDJSON } from './stream.js';
+import { applyReasoningEffort } from './reasoning.js';
 import { joinUrl, providerError, providerFetch, sortModels } from './utils.js';
 
 const OLLAMA_BASE_URL = 'http://localhost:11434';
@@ -44,6 +45,7 @@ export const ollamaProvider = {
   label: 'Ollama (local)',
   defaultBaseUrl: OLLAMA_BASE_URL,
   requiresKey: false,
+  reasoning: 'think',
 
   async listModels({ baseUrl }) {
     const res = await providerFetch(joinUrl(baseUrl, '/api/tags'));
@@ -52,10 +54,11 @@ export const ollamaProvider = {
     return sortModels((data.models ?? []).map(toOllamaModel).filter((m) => m.id));
   },
 
-  async streamChat({ baseUrl }, { model, messages, tools, signal, onEvent, maxOutputTokens }) {
+  async streamChat({ baseUrl }, { model, messages, tools, signal, onEvent, maxOutputTokens, reasoningEffort }) {
     const body = { model, messages: toOllamaMessages(messages), stream: true };
     if (tools?.length) body.tools = tools;
     if (maxOutputTokens > 0) body.options = { ...(body.options ?? {}), num_predict: maxOutputTokens };
+    applyReasoningEffort(body, reasoningEffort, this);
 
     const res = await providerFetch(joinUrl(baseUrl, '/api/chat'), {
       method: 'POST',

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

@@ -1,5 +1,6 @@
 import { readOpenAISSE } from './stream.js';
 import { applyPromptCache } from './cache.js';
+import { applyReasoningEffort } from './reasoning.js';
 import { joinUrl, authHeaders, providerError, providerFetch, normalizeModel, sortModels } from './utils.js';
 
 /**
@@ -11,6 +12,9 @@ export const openaiCompatibleProvider = {
   label: 'OpenAI-compatible',
   defaultBaseUrl: 'https://api.openai.com/v1',
   requiresKey: true,
+  // El adaptador generico no sabe si el servidor entiende `reasoning_effort`;
+  // los presets que si lo soportan lo declaran (`reasoning: 'effort'`).
+  reasoning: 'none',
 
   async listModels({ baseUrl, apiKey, headers }) {
     const res = await providerFetch(joinUrl(baseUrl, '/models'), {
@@ -22,7 +26,7 @@ export const openaiCompatibleProvider = {
     return sortModels(list.map(normalizeModel).filter((m) => m.id));
   },
 
-  async streamChat({ baseUrl, apiKey, headers }, { model, messages, tools, signal, onEvent, maxOutputTokens, promptCaching }) {
+  async streamChat({ baseUrl, apiKey, headers }, { model, messages, tools, signal, onEvent, maxOutputTokens, promptCaching, reasoningEffort }) {
     const buildBody = () => {
       const body = { model, messages, stream: true };
       if (tools?.length) body.tools = tools;
@@ -32,6 +36,7 @@ export const openaiCompatibleProvider = {
         body[field] = maxOutputTokens;
       }
       if (promptCaching) applyPromptCache(body, { mode: this?.caching ?? 'none' });
+      applyReasoningEffort(body, reasoningEffort, this);
       return body;
     };
     const run = (body) =>

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

@@ -1,5 +1,6 @@
 import { requestStream } from './openaiCompatible.js';
 import { applyPromptCache } from './cache.js';
+import { applyReasoningEffort } from './reasoning.js';
 import { joinUrl, providerFetch, normalizeModel, sortModels } from './utils.js';
 
 const OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1';
@@ -26,6 +27,8 @@ export const openrouterProvider = {
   requiresKey: true,
   // OpenRouter pasa cache_control a Anthropic; en otros modelos queda sin efecto.
   caching: 'anthropic',
+  // OpenRouter acepta el enum completo (max/xhigh/high/medium/low/minimal/none).
+  reasoning: 'effort',
 
   async listModels({ apiKey, siteUrl, siteName }) {
     const res = await providerFetch(joinUrl(OPENROUTER_BASE_URL, '/models'), {
@@ -41,11 +44,12 @@ export const openrouterProvider = {
     ).sort((a, b) => Number(b.free) - Number(a.free));
   },
 
-  async streamChat(ctx, { model, messages, tools, signal, onEvent, maxOutputTokens, promptCaching }) {
+  async streamChat(ctx, { model, messages, tools, signal, onEvent, maxOutputTokens, promptCaching, reasoningEffort }) {
     const body = { model, messages, stream: true };
     if (tools?.length) body.tools = tools;
     if (maxOutputTokens > 0) body.max_tokens = maxOutputTokens;
     if (promptCaching) applyPromptCache(body, { mode: this?.caching ?? 'none' });
+    applyReasoningEffort(body, reasoningEffort, this);
 
     return requestStream({
       url: joinUrl(OPENROUTER_BASE_URL, '/chat/completions'),

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

@@ -7,18 +7,19 @@ function preset(id, label, baseUrl, extra = {}) {
 }
 
 export const OPENAI_COMPATIBLE_PRESETS = [
-  preset('deepseek', 'DeepSeek', 'https://api.deepseek.com/v1'),
+  preset('deepseek', 'DeepSeek', 'https://api.deepseek.com/v1', { reasoning: 'deepseek' }),
   preset('openai', 'OpenAI', 'https://api.openai.com/v1', {
     maxTokensField: 'max_completion_tokens',
     caching: 'openai',
+    reasoning: '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', { caching: 'anthropic' }),
-  preset('gemini', 'Google Gemini', 'https://generativelanguage.googleapis.com/v1beta/openai'),
+  preset('gemini', 'Google Gemini', 'https://generativelanguage.googleapis.com/v1beta/openai', { reasoning: 'effort' }),
   preset('groq', 'Groq', 'https://api.groq.com/openai/v1'),
   preset('mistral', 'Mistral AI', 'https://api.mistral.ai/v1'),
-  preset('xai', 'xAI (Grok)', 'https://api.x.ai/v1'),
+  preset('xai', 'xAI (Grok)', 'https://api.x.ai/v1', { reasoning: 'effort' }),
   preset('together', 'Together AI', 'https://api.together.xyz/v1'),
   preset('fireworks', 'Fireworks AI', 'https://api.fireworks.ai/inference/v1'),
   preset('cerebras', 'Cerebras', 'https://api.cerebras.ai/v1'),

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

@@ -0,0 +1,58 @@
+// Esfuerzo de razonamiento: un vocabulario comun que cada adaptador traduce al
+// parametro de su proveedor. `''` significa "sin override" (default del modelo).
+
+export const EFFORT_LEVELS = ['off', 'low', 'medium', 'high', 'max'];
+
+export const EFFORT_LABELS = {
+  off: 'Sin razonamiento',
+  low: 'Bajo',
+  medium: 'Medio',
+  high: 'Alto',
+  max: 'Máximo',
+};
+
+const ALIASES = {
+  none: 'off',
+  minimal: 'low',
+  medium: 'medium',
+  xhigh: 'max',
+  ultra: 'max',
+};
+
+/** Normaliza lo que manda el usuario/proveedor al vocabulario comun. */
+export function normalizeEffort(value) {
+  if (value === null || value === undefined) return '';
+  const raw = String(value).trim().toLowerCase();
+  if (!raw || raw === 'auto' || raw === 'default') return '';
+  const level = ALIASES[raw] ?? raw;
+  return EFFORT_LEVELS.includes(level) ? level : '';
+}
+
+/**
+ * Agrega al body del request el parametro de esfuerzo que entiende el
+ * proveedor. Los adaptadores que no lo soportan (`reasoning: 'none'`) no
+ * reciben nada, asi un modelo sin razonamiento no rompe con un 400.
+ */
+export function applyReasoningEffort(body, effort, provider = {}) {
+  const level = normalizeEffort(effort);
+  if (!level) return body;
+  const mode = provider?.reasoning ?? 'none';
+
+  if (mode === 'think') {
+    // Ollama: `think` acepta boolean o (en versiones nuevas) un nivel.
+    body.think = level === 'off' ? false : level;
+    return body;
+  }
+
+  if (mode === 'effort' || mode === 'openai' || mode === 'deepseek') {
+    // OpenAI solo llega hasta high; DeepSeek y OpenRouter aceptan max.
+    const effortValue = level === 'max' && mode === 'openai' ? 'high' : level === 'off' ? 'none' : level;
+    body.reasoning_effort = effortValue;
+    if (mode === 'deepseek') {
+      body.thinking = { type: level === 'off' ? 'disabled' : 'enabled' };
+    }
+    return body;
+  }
+
+  return body;
+}