chocolatito-code 1.0.0 → 1.1.0

package/dist/agent/retry.d.ts

@@ -5,6 +5,19 @@
  * conexion cortada) abortaba el turno entero con "Error en el motor" y el
  * usuario perdia el trabajo en curso. Un fallo transitorio no deberia costar
  * una tarea.
+ *
+ * Dos reglas que se anadieron despues, y que cambian el resultado mas que el
+ * propio backoff:
+ *
+ *  1. **Si el servidor dice cuanto esperar, se le hace caso.** Ante un 429 con
+ *     `retry-after: 60`, esperar 0,8 s y volver a chocar gasta los cuatro
+ *     intentos en seis segundos y acaba en el mismo error, pero ahora sin
+ *     intentos. El tope de espera solo tiene sentido cuando nadie ha dicho
+ *     nada; cuando lo dice el servidor, el tope sobra.
+ *
+ *  2. **Un desbordamiento de contexto no se reintenta nunca.** Si la peticion
+ *     no cabe, mandarla otra vez identica no puede funcionar: hay que compactar
+ *     o abortar. Reintentarla son tres esperas tiradas y tres facturas.
  */
 export interface RetryOptions {
     attempts?: number;
@@ -12,6 +25,28 @@ export interface RetryOptions {
     maxDelayMs?: number;
     onRetry?: (attempt: number, delayMs: number, reason: string) => void;
 }
+/**
+ * Espera que ha pedido el servidor, en milisegundos, o null si no ha pedido
+ * ninguna. Se mira primero `retry-after-ms` porque es exacta; `retry-after`
+ * puede venir en segundos o como fecha HTTP.
+ */
+export declare function esperaPedidaPorElServidor(err: any): number | null;
+/**
+ * El contexto no cabe. Puede llegar como 400 (que ya no se reintentaba, por
+ * suerte mas que por diseno) o disfrazado de 5xx segun el proveedor, que es el
+ * caso que hacia perder los cuatro intentos.
+ */
+export declare function isContextOverflow(err: any): boolean;
+/**
+ * El 429 de "tienes N peticiones en curso" NO es un limite de ritmo del motor.
+ *
+ * Es que los huecos de esta licencia estan ocupados, y si estan atascados por
+ * una peticion que se perdio, no se desatascan en seis segundos: se desatascan
+ * cuando caduca la reserva. Reintentarlo cuatro veces con espera exponencial
+ * gasta los intentos, tarda seis segundos y acaba en "Error en el motor tras
+ * varios reintentos", que no dice nada de lo que de verdad pasa.
+ */
+export declare function esDemasiadasEnCurso(err: any): boolean;
 /** Errores que merece la pena reintentar: transitorios, no de programacion. */
 export declare function isRetryable(err: any): boolean;
 export declare function withRetry<T>(fn: () => Promise<T>, opts?: RetryOptions): Promise<T>;

package/dist/agent/retry.js

@@ -5,9 +5,118 @@
  * conexion cortada) abortaba el turno entero con "Error en el motor" y el
  * usuario perdia el trabajo en curso. Un fallo transitorio no deberia costar
  * una tarea.
+ *
+ * Dos reglas que se anadieron despues, y que cambian el resultado mas que el
+ * propio backoff:
+ *
+ *  1. **Si el servidor dice cuanto esperar, se le hace caso.** Ante un 429 con
+ *     `retry-after: 60`, esperar 0,8 s y volver a chocar gasta los cuatro
+ *     intentos en seis segundos y acaba en el mismo error, pero ahora sin
+ *     intentos. El tope de espera solo tiene sentido cuando nadie ha dicho
+ *     nada; cuando lo dice el servidor, el tope sobra.
+ *
+ *  2. **Un desbordamiento de contexto no se reintenta nunca.** Si la peticion
+ *     no cabe, mandarla otra vez identica no puede funcionar: hay que compactar
+ *     o abortar. Reintentarla son tres esperas tiradas y tres facturas.
+ */
+/** Lee una cabecera venga como objeto plano o como Headers de fetch. */
+function leerCabecera(err, nombre) {
+    const headers = err?.headers ?? err?.response?.headers;
+    if (!headers)
+        return null;
+    if (typeof headers.get === "function") {
+        const v = headers.get(nombre);
+        return v == null ? null : String(v);
+    }
+    // Los objetos planos pueden traer la clave con cualquier caja.
+    for (const clave of Object.keys(headers)) {
+        if (clave.toLowerCase() === nombre) {
+            const v = headers[clave];
+            return v == null ? null : String(v);
+        }
+    }
+    return null;
+}
+/**
+ * Espera que ha pedido el servidor, en milisegundos, o null si no ha pedido
+ * ninguna. Se mira primero `retry-after-ms` porque es exacta; `retry-after`
+ * puede venir en segundos o como fecha HTTP.
+ */
+export function esperaPedidaPorElServidor(err) {
+    const ms = leerCabecera(err, "retry-after-ms");
+    if (ms !== null) {
+        const n = Number(ms);
+        if (Number.isFinite(n) && n >= 0)
+            return n;
+    }
+    const after = leerCabecera(err, "retry-after");
+    if (after === null)
+        return null;
+    const segundos = Number(after);
+    if (Number.isFinite(segundos) && segundos >= 0)
+        return segundos * 1000;
+    const fecha = Date.parse(after);
+    if (!Number.isNaN(fecha)) {
+        // Una fecha ya pasada significa "ya puedes": cero, no un numero negativo.
+        return Math.max(0, fecha - Date.now());
+    }
+    return null;
+}
+/**
+ * El contexto no cabe. Puede llegar como 400 (que ya no se reintentaba, por
+ * suerte mas que por diseno) o disfrazado de 5xx segun el proveedor, que es el
+ * caso que hacia perder los cuatro intentos.
+ */
+export function isContextOverflow(err) {
+    const texto = [
+        err?.message,
+        err?.error?.message,
+        err?.response?.data?.error?.message,
+        err?.code,
+        err?.error?.code,
+    ]
+        .filter(Boolean)
+        .join(" ")
+        .toLowerCase();
+    if (!texto)
+        return false;
+    return (texto.includes("context_length_exceeded") ||
+        texto.includes("context length") ||
+        texto.includes("maximum context") ||
+        texto.includes("context window") ||
+        texto.includes("too many tokens") ||
+        texto.includes("reduce the length of the messages") ||
+        (texto.includes("token") && texto.includes("exceed")));
+}
+/**
+ * El 429 de "tienes N peticiones en curso" NO es un limite de ritmo del motor.
+ *
+ * Es que los huecos de esta licencia estan ocupados, y si estan atascados por
+ * una peticion que se perdio, no se desatascan en seis segundos: se desatascan
+ * cuando caduca la reserva. Reintentarlo cuatro veces con espera exponencial
+ * gasta los intentos, tarda seis segundos y acaba en "Error en el motor tras
+ * varios reintentos", que no dice nada de lo que de verdad pasa.
  */
+export function esDemasiadasEnCurso(err) {
+    if ((err?.status ?? err?.response?.status) !== 429)
+        return false;
+    const codigo = String(err?.error?.code ?? err?.error?.type ?? "");
+    if (codigo === "demasiadas_en_curso")
+        return true;
+    // Compatibilidad con proxys anteriores al codigo: se mira el texto.
+    return /peticiones en curso/i.test(String(err?.error?.message ?? err?.message ?? ""));
+}
 /** Errores que merece la pena reintentar: transitorios, no de programacion. */
 export function isRetryable(err) {
+    // Va primero: un desbordamiento de contexto devuelto como 503 seguiria
+    // pareciendo transitorio, y no lo es. Repetir la misma peticion que no cabe
+    // no puede empezar a caber.
+    if (isContextOverflow(err))
+        return false;
+    // Tampoco esto: no se arregla esperando un poco mas, y hay algo util que
+    // decirle al usuario en vez de agotar los intentos en silencio.
+    if (esDemasiadasEnCurso(err))
+        return false;
     const status = err?.status ?? err?.response?.status;
     if (typeof status === "number") {
         // 429 limite de ritmo; 5xx problemas del servidor. Un 400/401/403 es culpa
@@ -23,7 +132,12 @@ export function isRetryable(err) {
         msg.includes("socket hang up") ||
         msg.includes("network") ||
         msg.includes("fetch failed") ||
-        msg.includes("terminated"));
+        msg.includes("terminated") ||
+        // Frases que los proveedores devuelven sin codigo de estado util.
+        msg.includes("rate limit") ||
+        msg.includes("overloaded") ||
+        msg.includes("try again later") ||
+        msg.includes("temporarily"));
 }
 function describe(err) {
     const status = err?.status ?? err?.response?.status;
@@ -47,9 +161,14 @@ export async function withRetry(fn, opts = {}) {
             const isLast = i === attempts - 1;
             if (isLast || !isRetryable(err))
                 throw err;
-            // Espera exponencial con jitter, para no sincronizar reintentos.
-            const delay = Math.min(max, base * Math.pow(2, i)) * (0.7 + Math.random() * 0.6);
-            opts.onRetry?.(i + 1, Math.round(delay), describe(err));
+            const pedida = esperaPedidaPorElServidor(err);
+            const delay = pedida !== null
+                ? // El tope NO se aplica: si el servidor pide 60 s, esperar 15 y
+                    // volver a chocar es gastar un intento a cambio de nada.
+                    pedida
+                : Math.min(max, base * Math.pow(2, i)) * (0.7 + Math.random() * 0.6);
+            const motivo = pedida !== null ? `${describe(err)} (pide esperar)` : describe(err);
+            opts.onRetry?.(i + 1, Math.round(delay), motivo);
             await new Promise((r) => setTimeout(r, delay));
         }
     }

package/dist/agent/subagent.js

@@ -1,14 +1,17 @@
 import { TOOLS, getAllTools } from "../tools/definitions.js";
 import { executeToolCall } from "../tools/runner.js";
 import { truncateOutput } from "../tools/truncator.js";
-import { isReadOnly } from "../tools/safety.js";
+import { isReadOnly, canRunInParallel } from "../tools/safety.js";
 import { MAX_OUTPUT_TOKENS } from "../config/constants.js";
 import { withRetry } from "./retry.js";
 import { createEngineClient } from "../config/engine.js";
+import { autorizarHerramienta, notificarPostHerramienta } from "./toolGate.js";
+import { apuntarUso } from "./usageMeter.js";
+import { leerLimites } from "../config/limits.js";
 /**
  * Subagentes.
  *
- * Tres arreglos sobre la version anterior:
+ * Arreglos sobre la version anterior:
  *
  *  1. 'explore' y 'plan' recibian TODAS las herramientas, incluidas delete_file,
  *     write_file y run_command. Un agente que se presenta como "de solo lectura"
@@ -21,14 +24,32 @@ import { createEngineClient } from "../config/engine.js";
  *     resumen de lo averiguado antes de rendirse.
  *
  *  3. Sin reintentos: un 429 mataba al subagente y con el la tarea del padre.
+ *
+ *  4. Ejecutaba las herramientas a pelo, sin permisos, sin hooks y sin el
+ *     bloqueo del modo plan. La contencion de 'explore' y 'plan' era solo la
+ *     lista de herramientas del punto 1, y el tipo 'general' no tenia ninguna:
+ *     por esa puerta se borraban archivos sin preguntar y se ejecutaban comandos
+ *     en modo plan, que el producto anuncia como de solo lectura. Ahora cada
+ *     llamada pasa por la misma puerta que las del bucle padre (toolGate.ts), y
+ *     la contencion deja de depender de que nadie meta una herramienta de
+ *     escritura en la lista de lectura.
+ *
+ *  5. Lanzaba el lote entero con Promise.all "porque un explorador solo lee".
+ *     Cierto para 'explore' y 'plan', falso para 'general': con write_file y
+ *     run_command en la mano, dos escrituras sobre el mismo archivo salian a la
+ *     vez y en orden indeterminado. Se aplica la misma regla que el padre.
  */
 const READ_ONLY_TYPES = ["explore", "plan"];
 function toolsFor(type) {
     // Un subagente general hereda tambien las herramientas MCP; uno de solo
     // lectura no, porque no se puede saber si una herramienta MCP escribe.
-    if (!READ_ONLY_TYPES.includes(type))
-        return getAllTools();
-    return TOOLS.filter((t) => isReadOnly(t.function.name));
+    const base = READ_ONLY_TYPES.includes(type)
+        ? TOOLS.filter((t) => isReadOnly(t.function.name))
+        : getAllTools();
+    // Ninguno recibe spawn_agent. Un subagente que puede lanzar subagentes abre un
+    // arbol sin fondo: el usuario ve una sola linea "spawn_agent" y detras corren
+    // los que sea, gastando cuota que nadie ha contado.
+    return base.filter((t) => t.function?.name !== "spawn_agent");
 }
 export async function runSubagent(type, prompt, apiKey, baseURL, modelName, cwd = process.cwd()) {
     const client = createEngineClient(apiKey, "subagent");
@@ -49,7 +70,24 @@ export async function runSubagent(type, prompt, apiKey, baseURL, modelName, cwd
         { role: "user", content: prompt },
     ];
     const tools = toolsFor(type);
-    const maxIterations = 14;
+    const maxIterations = leerLimites(cwd).iteracionesDeSubagente;
+    const etiqueta = `El subagente ${type}`;
+    /** Una llamada, con los mismos controles que aplica el bucle padre. */
+    async function ejecutarLlamada(tc) {
+        let args = {};
+        try {
+            args = JSON.parse(tc.function.arguments);
+        }
+        catch { }
+        const decision = await autorizarHerramienta(tc.function.name, args, cwd, etiqueta);
+        if (!decision.permitida) {
+            return { id: tc.id, content: decision.motivo || "Accion no autorizada." };
+        }
+        const { result } = await executeToolCall(tc.function.name, decision.args, cwd, apiKey, modelName);
+        const aviso = await notificarPostHerramienta(tc.function.name, decision.args, result, cwd);
+        const texto = aviso ? `${result}\n\n[Hook PostToolUse]: ${aviso}` : result;
+        return { id: tc.id, content: truncateOutput(texto, 20_000) };
+    }
     for (let iterations = 0; iterations < maxIterations; iterations++) {
         // Al acercarse al limite se avisa, para que cierre en vez de que le corten.
         if (iterations === maxIterations - 2) {
@@ -72,21 +110,29 @@ export async function runSubagent(type, prompt, apiKey, baseURL, modelName, cwd
         catch (err) {
             return `Error en subagente (${type}): ${err?.message || String(err)}`;
         }
+        // Un subagente puede encadenar 14 iteraciones con el contexto entero de la
+        // subtarea, y todo ese gasto se apuntaba como 0,00 $: la cuota local solo
+        // miraba el stream del bucle padre. Se cuenta donde se gasta.
+        apuntarUso(res.usage, modelName, "subagent");
         const message = res.choices[0]?.message;
         if (!message)
             break;
         if (message.tool_calls && message.tool_calls.length > 0) {
             messages.push(message);
-            // Las llamadas de un subagente explorador son todas de lectura: van a la vez.
-            const results = await Promise.all(message.tool_calls.map(async (tc) => {
-                let args = {};
-                try {
-                    args = JSON.parse(tc.function.arguments);
+            // Un lote va a la vez solo si TODAS las llamadas son de lectura. Aqui se
+            // daba por hecho que un subagente solo lee, y para 'general' es falso: dos
+            // write_file simultaneos sobre el mismo archivo dejan el resultado al azar,
+            // que es justo lo que safety.ts existe para evitar.
+            const nombres = message.tool_calls.map((tc) => tc.function.name);
+            const results = [];
+            if (canRunInParallel(nombres)) {
+                results.push(...(await Promise.all(message.tool_calls.map(ejecutarLlamada))));
+            }
+            else {
+                for (const tc of message.tool_calls) {
+                    results.push(await ejecutarLlamada(tc));
                 }
-                catch { }
-                const { result } = await executeToolCall(tc.function.name, args, cwd, apiKey, modelName);
-                return { id: tc.id, content: truncateOutput(result, 20_000) };
-            }));
+            }
             for (const r of results) {
                 messages.push({ role: "tool", tool_call_id: r.id, content: r.content });
             }
@@ -107,6 +153,7 @@ export async function runSubagent(type, prompt, apiKey, baseURL, modelName, cwd
             temperature: 0.1,
             max_tokens: MAX_OUTPUT_TOKENS,
         }));
+        apuntarUso(final.usage, modelName, "subagent");
         const text = final.choices[0]?.message?.content;
         if (text)
             return `[Subagente ${type}: limite de iteraciones alcanzado]\n\n${text}`;