@danieltmn/tamnora 0.25.0 → 0.26.0

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

@@ -0,0 +1,113 @@
+// 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';
+import { parseFrontmatter, parseListValue } from '../frontmatter.js';
+
+export const AGENT_FILE = 'AGENT.md';
+
+/** Parse an AGENT.md: frontmatter `--- key: value ---` plus the body prompt. */
+export function parseAgentMarkdown(text, fallbackId = '') {
+  const { fields, body } = parseFrontmatter(text);
+  return {
+    id: fallbackId,
+    name: fields.name || fallbackId,
+    description: fields.description || '',
+    model: fields.model || '',
+    provider: fields.provider || '',
+    mode: fields.mode || '',
+    effort: fields.effort || fields.reasoning || fields.reasoning_effort || '',
+    maxRounds: Number(fields.maxrounds || fields.max_rounds) || 0,
+    tools: fields.tools === undefined ? null : parseListValue(fields.tools),
+    skills: fields.skills === undefined ? null : parseListValue(fields.skills),
+    body,
+  };
+}
+
+/** 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/app.js

@@ -29,10 +29,6 @@ export function readApp() {
   }
   const app = { ...DEFAULT_APP, ...(data && typeof data === 'object' ? data : {}) };
   app.tunnel = { ...DEFAULT_APP.tunnel, ...(app.tunnel || {}) };
-  // `tunnelmole` fue el default viejo y `relay` fue un proveedor retirado: lo
-  // persistido en instalaciones previas se migra a tailscale.
-  const legacy = ['tunnelmole', 'tmole', 'relay'];
-  if (legacy.includes(app.tunnel.provider)) app.tunnel.provider = 'tailscale';
   return app;
 }
 

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, copyFileSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
@@ -82,22 +82,3 @@ export function ensureHome() {
 export function homeExists() {
   return existsSync(appConfigPath());
 }
-
-/**
- * Migra una base local legacy (`<cwd>/.tamnora/tamnora.db`) a la casa global,
- * una sola vez. Devuelve la ruta del archivo global.
- */
-export function migrateLegacyDb(cwd = process.cwd()) {
-  const target = databaseFile();
-  if (existsSync(target)) return target;
-  const legacy = path.join(cwd, DIR_NAME, 'tamnora.db');
-  if (existsSync(legacy)) {
-    try {
-      ensureHome();
-      copyFileSync(legacy, target);
-    } catch {
-      /* si falla, se arranca con una base nueva */
-    }
-  }
-  return target;
-}

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

@@ -1,7 +1,7 @@
 import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-import { migrateLegacyDb } from './home.js';
+import { databaseFile } from './home.js';
 
 export const DEFAULT_CONFIG = {
   provider: 'openrouter',
@@ -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'],
@@ -25,21 +26,18 @@ export const DEFAULT_CONFIG = {
   mcpPinned: [],
   server: { host: '127.0.0.1', port: 4517 },
   processes: { enabled: true, allow: [] },
-  preview: { provider: 'tailscale', tailscalePort: 8443, fallback: true },
+  preview: { provider: 'tailscale', tailscalePort: 8443 },
   telegram: { token: '', allowedChatIds: [] },
   agents: { maxRounds: 6 },
 };
 
-/** Directory (relative to the project) where harness state lived historically. */
-export const STATE_DIR = '.tamnora';
-
 /**
  * Absolute path to the SQLite database. Es **global** (casa de Tamnora) para
  * que proveedores y claves no se dupliquen entre proyectos. `TAMNORA_DB` lo
- * sobrescribe; si no existe la base global se migra la legacy del `cwd`.
+ * sobrescribe.
  */
-export function databasePath(cwd = process.cwd()) {
-  return process.env.TAMNORA_DB || migrateLegacyDb(cwd);
+export function databasePath() {
+  return process.env.TAMNORA_DB || databaseFile();
 }
 
 /**

package/harness/packages/core/src/extensions/load.js

@@ -0,0 +1,22 @@
+// Carga de modulos de extension locales (hooks/plugins): solo los patrones
+// explicitos, deduplicados; un modulo roto se ignora.
+
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { globFiles } from '../tools/glob.js';
+
+export async function loadExtensionModules(cwd, patterns, normalize) {
+  const list = [...new Set(patterns ?? [])];
+  if (!list.length) return [];
+  const items = [];
+  for (const rel of await globFiles(cwd, list)) {
+    try {
+      const mod = await import(pathToFileURL(path.join(cwd, rel)).href);
+      const item = normalize(mod, rel);
+      if (item) items.push({ ...item, path: rel });
+    } catch {
+      /* modulo roto: se ignora */
+    }
+  }
+  return items;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Frontmatter simple compartido por skills, subagentes y reglas: un bloque
+ * `--- clave: valor ---` (una clave por linea) y el resto del documento.
+ */
+
+const FRONTMATTER = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?([\s\S]*)$/;
+
+export function parseFrontmatter(text) {
+  const source = String(text ?? '');
+  const fields = {};
+  let body = source.trim();
+  const match = source.match(FRONTMATTER);
+  if (!match) return { fields, body };
+  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;
+    fields[kv[1].toLowerCase()] = kv[2].trim().replace(/^["']|["']$/g, '');
+  }
+  return { fields, body };
+}
+
+/** Lista por comas: `tools: read, grep` o `paths: [a, b]`. */
+export function parseListValue(value) {
+  const raw = String(value ?? '').trim();
+  if (!raw) return [];
+  const inner = raw.startsWith('[') && raw.endsWith(']') ? raw.slice(1, -1) : raw;
+  return inner
+    .split(',')
+    .map((item) => item.trim().replace(/^["']|["']$/g, ''))
+    .filter(Boolean);
+}

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

@@ -5,9 +5,7 @@
 // `{ name?, events: { '<tipo>': fn } }` o una funcion (se llama para todos los
 // eventos).
 
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { globFiles } from '../tools/glob.js';
+import { loadExtensionModules } from '../extensions/load.js';
 
 export const DEFAULT_HOOK_PATTERNS = ['.tamnora/hooks/*.mjs'];
 
@@ -30,17 +28,5 @@ export function normalizeHookModule(mod, id = '') {
  * Un modulo roto se ignora.
  */
 export async function loadHooks(cwd, patterns = []) {
-  const list = [...new Set(patterns ?? [])];
-  if (!list.length) return [];
-  const hooks = [];
-  for (const rel of await globFiles(cwd, list)) {
-    try {
-      const mod = await import(pathToFileURL(path.join(cwd, rel)).href);
-      const hook = normalizeHookModule(mod, rel);
-      if (hook) hooks.push({ ...hook, path: rel });
-    } catch {
-      /* modulo roto: se ignora */
-    }
-  }
-  return hooks;
+  return loadExtensionModules(cwd, patterns, normalizeHookModule);
 }

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,
@@ -49,7 +50,6 @@ export {
   resolveModel,
   resolveProvider,
   databasePath,
-  STATE_DIR,
   DEFAULT_CONFIG,
 } from './config/index.js';
 export {
@@ -68,7 +68,6 @@ export {
   bridgeStatePath,
   ensureHome,
   homeExists,
-  migrateLegacyDb,
 } from './config/home.js';
 export { DEFAULT_APP, readApp, writeApp, ensureApp, randomToken } from './config/app.js';
 export { exportConfig, importConfig, CONFIG_KIND, CONFIG_VERSION, MASKED } from './config/portable.js';
@@ -93,13 +92,6 @@ export {
   planMcpTools,
 } from './tools/index.js';
 export { Store, openDatabase } from './storage/sqlite.js';
-export { runTask } from './eval/runTask.js';
-export { loadDataset } from './eval/dataset.js';
-export { runDataset, extractToolCalls } from './eval/runner.js';
-export { summarize } from './eval/report.js';
-export { runScorers, validateSchema, extractJson, SCORERS } from './eval/scorers.js';
-export { createJudge } from './eval/judge.js';
-export { createTaskWorkspace, normalizeExpect } from './eval/task.js';
 export {
   parseSkillMarkdown,
   loadSkills,
@@ -108,6 +100,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 {
@@ -148,17 +149,13 @@ export {
 } from './mcp/registry.js';
 export { MCP_CATALOG, mcpCatalogEntry } from './mcp/catalog.js';
 export {
-  parseTunnelmoleUrls,
   parseTailscaleStatus,
   probeTailscale,
   stopTailscaleServe,
   startTailscaleServe,
   startTailscalePreview,
-  startTunnelmole,
   startTunnel,
   tailscalePreviewUrl,
-  tunnelState,
-  tunnelActive,
 } from './tunnel.js';
 export {
   TRUSTED_CLIENT_TOKEN,
@@ -174,7 +171,8 @@ export {
 export { reconocerGoogle, wavToPcm } from './stt/google.js';
 export { pidAlive, killPidTree } from './pid.js';
 export { openBrowser, openerFor } from './open.js';
-export { detectProcs, loadProjectProcs, packageManager, DEFAULT_PROCESS_ALLOW, staticServerChip, PROCS_FILE } from './procs/detect.js';
+export { loadProjectProcs, DEFAULT_PROCESS_ALLOW, PROCS_FILE } from './procs/project.js';
+export { staticServerChip } from './procs/static.js';
 export { killPort, portInfo, pidsOnPort } from './procs/kill.js';
 export {
   ROOT_PACKAGE_NAME,

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

@@ -4,9 +4,7 @@
 // presencia de archivos en el cwd no ejecuta nada. Cada tool:
 // `{ name, description, parameters?, required?, handler(args, ctx) }`.
 
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { globFiles } from '../tools/glob.js';
+import { loadExtensionModules } from '../extensions/load.js';
 
 export const DEFAULT_PLUGIN_PATTERNS = ['.tamnora/plugins/*.mjs'];
 
@@ -22,17 +20,5 @@ export function normalizePlugin(mod, id = '') {
 
 /** Carga los plugins de los `patterns` explicitos (relativos a `cwd`). */
 export async function loadPlugins(cwd, patterns = []) {
-  const list = [...new Set(patterns ?? [])];
-  if (!list.length) return [];
-  const plugins = [];
-  for (const rel of await globFiles(cwd, list)) {
-    try {
-      const mod = await import(pathToFileURL(path.join(cwd, rel)).href);
-      const plugin = normalizePlugin(mod, rel);
-      if (plugin) plugins.push({ ...plugin, path: rel });
-    } catch {
-      /* plugin roto: se ignora */
-    }
-  }
-  return plugins;
+  return loadExtensionModules(cwd, patterns, normalizePlugin);
 }

package/harness/packages/core/src/procs/project.js

@@ -0,0 +1,68 @@
+// Procesos de desarrollo declarados por el proyecto en `.tamnora/procs.json`.
+// No se autodetecta nada: el usuario declara como arrancar cada servidor.
+
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+
+export const DEFAULT_PROCESS_ALLOW = [
+  'npm',
+  'node',
+  'npx',
+  'pnpm',
+  'yarn',
+  'bun',
+  'bunx',
+  'php',
+  'python',
+  'python3',
+  'composer',
+];
+
+/** Archivo por proyecto (relativo a su raiz) que define sus procesos de dev. */
+export const PROCS_FILE = '.tamnora/procs.json';
+
+/** True si `target` es `root` o vive dentro de el (sin salirse por `..`). */
+function isInside(root, target) {
+  const rel = path.relative(root, target);
+  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+
+/**
+ * Procesos definidos a mano por el proyecto en `<root>/.tamnora/procs.json`.
+ * Formato: `{ "processes": [{ label?, dir?, command, args?, port? }] }` o un array
+ * directo. `dir` es relativo a la raiz y debe quedar dentro de ella. Cada chip
+ * sigue pasando por la whitelist (`processes.allow`) al arrancar.
+ */
+export function loadProjectProcs(root) {
+  const file = path.join(root, PROCS_FILE);
+  if (!existsSync(file)) return [];
+  const raw = readJson(file);
+  const list = Array.isArray(raw) ? raw : Array.isArray(raw?.processes) ? raw.processes : [];
+  const chips = [];
+  for (const entry of list) {
+    if (!entry || typeof entry !== 'object') continue;
+    const command = String(entry.command ?? '').trim();
+    if (!command) continue;
+    const rel = String(entry.dir ?? '').trim().replace(/^[/\\]+/, '');
+    const cwd = path.resolve(root, rel || '.');
+    if (!isInside(root, cwd) || !existsSync(cwd)) continue;
+    const port = entry.port ? Number(entry.port) : undefined;
+    chips.push({
+      label: String(entry.label ?? command).trim() || command,
+      command,
+      args: Array.isArray(entry.args) ? entry.args.map(String) : [],
+      cwd,
+      port: Number.isInteger(port) && port > 0 ? port : undefined,
+      source: 'project',
+    });
+  }
+  return chips;
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}

package/harness/packages/core/src/procs/static.js

@@ -0,0 +1,17 @@
+// Chip para servir un directorio como sitio estatico con el servidor sin
+// dependencias. Lo usa la vista previa de un HTML en el explorador.
+
+import { fileURLToPath } from 'node:url';
+
+const STATIC_SERVER = fileURLToPath(new URL('../../../../scripts/static-server.mjs', import.meta.url));
+const STATIC_PORT = 8080;
+
+export function staticServerChip(dir, { port = STATIC_PORT, label } = {}) {
+  return {
+    label: label ?? `sitio estático (${port})`,
+    command: process.execPath,
+    args: [STATIC_SERVER, dir, String(port)],
+    cwd: dir,
+    port,
+  };
+}

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'),