chocolatito-code 1.2.0 → 1.3.0

package/dist/agent/huecos.d.ts

@@ -0,0 +1,58 @@
+/**
+ * NO GASTAR UN HUECO DE PETICION QUE YA SABEMOS QUE NO HAY
+ *
+ * DE DONDE SALE
+ *
+ * Sesion real. Una respuesta se corto a mitad, el bucle reintento, y en cuatro
+ * mensajes el usuario se quedo sin servicio:
+ *
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 197s.
+ *     ❯ q paso?
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 189s.
+ *
+ * Fijate en la segunda. El agente ya SABIA que no habia huecos y que faltaban
+ * 197 segundos; ocho segundos despues volvio a llamar al motor para que se lo
+ * repitiera. Esa llamada no podia salir bien por definicion, y ademas es la
+ * clase de peticion que puede refrescar la reserva del proxy y alargar la
+ * espera. El usuario tecleaba, esperaba, y se llevaba la misma pared.
+ *
+ * LO QUE HACE
+ *
+ * Se apunta hasta cuando no hay huecos y se responde desde aqui, sin red. Deja
+ * de gastarse una peticion por cada intento y el usuario ve la cuenta atras
+ * bajar de verdad en lugar de quedarse clavada.
+ *
+ * POR QUE NO SE FIA DEL RELOJ A CIEGAS
+ *
+ * Un reloj que se adelanta desbloquea antes de tiempo -inofensivo, la siguiente
+ * peticion dira la verdad-. Pero uno que se atrasa dejaria `ocupadoHasta` en un
+ * futuro lejano y el agente se negaria a llamar al motor durante horas sin que
+ * nada lo despierte. Por eso la espera nunca puede pasar de la ventana que se
+ * anoto: en el peor caso se espera de mas una vez, no para siempre.
+ */
+/** Cuando el proxy no dice cuanto falta. Un minuto es su reserva mas corta. */
+export declare const SEGUNDOS_POR_DEFECTO = 60;
+/** Techo de la espera. Ninguna reserva del proxy dura mas de unos minutos. */
+export declare const SEGUNDOS_MAXIMOS = 300;
+/**
+ * Apunta que los huecos estan llenos.
+ *
+ * `retryAfterS` es lo que dice el proxy en `error.retry_after_s`. Si no viene,
+ * o viene con un valor absurdo, se usa un minuto: adivinar de mas encierra al
+ * usuario y adivinar de menos le devuelve a la misma pared.
+ */
+export declare function anotarHuecosOcupados(retryAfterS?: unknown): void;
+/** Segundos que faltan para volver a tener hueco. 0 si ya lo hay. */
+export declare function segundosDeEspera(): number;
+/**
+ * Olvida la espera. Se llama en cuanto el motor concede una peticion: si
+ * contesta, es que habia hueco, y seguir bloqueando seria mentir.
+ */
+export declare function liberarHuecos(): void;
+/**
+ * Lo que se le dice al usuario en vez de llamar al motor.
+ *
+ * Dice de donde sale la cuenta -no es una invencion del cliente- y que no tiene
+ * que hacer nada: es lo unico que se arregla solo con esperar.
+ */
+export declare function mensajeDeEspera(segundos: number): string;

package/dist/agent/huecos.js

@@ -0,0 +1,81 @@
+/**
+ * NO GASTAR UN HUECO DE PETICION QUE YA SABEMOS QUE NO HAY
+ *
+ * DE DONDE SALE
+ *
+ * Sesion real. Una respuesta se corto a mitad, el bucle reintento, y en cuatro
+ * mensajes el usuario se quedo sin servicio:
+ *
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 197s.
+ *     ❯ q paso?
+ *     ⏸  Tienes 4 peticiones en curso. Reintenta en 189s.
+ *
+ * Fijate en la segunda. El agente ya SABIA que no habia huecos y que faltaban
+ * 197 segundos; ocho segundos despues volvio a llamar al motor para que se lo
+ * repitiera. Esa llamada no podia salir bien por definicion, y ademas es la
+ * clase de peticion que puede refrescar la reserva del proxy y alargar la
+ * espera. El usuario tecleaba, esperaba, y se llevaba la misma pared.
+ *
+ * LO QUE HACE
+ *
+ * Se apunta hasta cuando no hay huecos y se responde desde aqui, sin red. Deja
+ * de gastarse una peticion por cada intento y el usuario ve la cuenta atras
+ * bajar de verdad en lugar de quedarse clavada.
+ *
+ * POR QUE NO SE FIA DEL RELOJ A CIEGAS
+ *
+ * Un reloj que se adelanta desbloquea antes de tiempo -inofensivo, la siguiente
+ * peticion dira la verdad-. Pero uno que se atrasa dejaria `ocupadoHasta` en un
+ * futuro lejano y el agente se negaria a llamar al motor durante horas sin que
+ * nada lo despierte. Por eso la espera nunca puede pasar de la ventana que se
+ * anoto: en el peor caso se espera de mas una vez, no para siempre.
+ */
+/** Cuando el proxy no dice cuanto falta. Un minuto es su reserva mas corta. */
+export const SEGUNDOS_POR_DEFECTO = 60;
+/** Techo de la espera. Ninguna reserva del proxy dura mas de unos minutos. */
+export const SEGUNDOS_MAXIMOS = 300;
+let ocupadoHasta = 0;
+let ventanaMs = 0;
+/**
+ * Apunta que los huecos estan llenos.
+ *
+ * `retryAfterS` es lo que dice el proxy en `error.retry_after_s`. Si no viene,
+ * o viene con un valor absurdo, se usa un minuto: adivinar de mas encierra al
+ * usuario y adivinar de menos le devuelve a la misma pared.
+ */
+export function anotarHuecosOcupados(retryAfterS) {
+    const dicho = Number(retryAfterS);
+    const segundos = Number.isFinite(dicho) && dicho > 0 ? Math.min(dicho, SEGUNDOS_MAXIMOS) : SEGUNDOS_POR_DEFECTO;
+    ventanaMs = segundos * 1000;
+    ocupadoHasta = Date.now() + ventanaMs;
+}
+/** Segundos que faltan para volver a tener hueco. 0 si ya lo hay. */
+export function segundosDeEspera() {
+    if (ocupadoHasta === 0)
+        return 0;
+    const faltan = Math.min(ocupadoHasta - Date.now(), ventanaMs);
+    if (faltan <= 0) {
+        liberarHuecos();
+        return 0;
+    }
+    return Math.ceil(faltan / 1000);
+}
+/**
+ * Olvida la espera. Se llama en cuanto el motor concede una peticion: si
+ * contesta, es que habia hueco, y seguir bloqueando seria mentir.
+ */
+export function liberarHuecos() {
+    ocupadoHasta = 0;
+    ventanaMs = 0;
+}
+/**
+ * Lo que se le dice al usuario en vez de llamar al motor.
+ *
+ * Dice de donde sale la cuenta -no es una invencion del cliente- y que no tiene
+ * que hacer nada: es lo unico que se arregla solo con esperar.
+ */
+export function mensajeDeEspera(segundos) {
+    return (`Los huecos de peticion de tu licencia siguen ocupados. Faltan ${segundos}s. ` +
+        "No llamo al motor porque la respuesta seria la misma y cada intento puede alargar la espera. " +
+        "No hace falta que hagas nada: el hueco se libera solo.");
+}

package/dist/agent/loop.js

@@ -5,9 +5,10 @@ import { executeToolCall } from "../tools/runner.js";
 import { TokenTracker } from "./tracker.js";
 import { renderToolStart, renderToolSuccess, renderToolError, renderDiff, renderFooter, renderError, } from "../ui/renderer.js";
 import { CONTEXT_WINDOW, MAX_OUTPUT_TOKENS, COMPACT_THRESHOLD_TOKENS, } from "../config/constants.js";
-import { withRetry, isContextOverflow } from "./retry.js";
+import { withRetry, isContextOverflow, esDemasiadasEnCurso } from "./retry.js";
 import { canRunInParallel } from "../tools/safety.js";
 import { createEngineClient, explicarErrorDelMotor, motivoDeParadaDelError, } from "../config/engine.js";
+import { anotarHuecosOcupados, liberarHuecos, mensajeDeEspera, segundosDeEspera } from "./huecos.js";
 import { MarkdownStream } from "../ui/markdownStream.js";
 import { checkQuota, recordUsage, mensajeDeCorte, quotaBadge } from "../config/quota.js";
 import { ReasoningStream } from "../ui/reasoningStream.js";
@@ -76,8 +77,8 @@ function parsearArgumentos(bruto) {
 /** Lo que se le dice al modelo cuando sus argumentos llegaron a medias. */
 function mensajeDeArgumentosRotos(herramienta) {
     return (`No se ejecuto "${herramienta}": los argumentos llegaron incompletos, seguramente porque la ` +
-        `respuesta se corto por longitud. No se ha hecho nada.
-
+        `respuesta se corto por longitud. No se ha hecho nada.
+
 ` +
         `Si era un archivo largo, hazlo por partes: una primera llamada a write_file con el principio ` +
         `y las siguientes con modo="anadir" para ir pegando el resto. Cada trozo, por debajo de unas ` +
@@ -455,6 +456,15 @@ export class AgentLoop {
                 tokensSalida: turnCompletionTokens,
             };
         };
+        // Los huecos de peticion, ANTES de gastar uno. El proxy ya nos dijo cuanto
+        // falta; volver a preguntarselo no puede salir bien por definicion, y esa
+        // llamada es justo la que puede refrescar la reserva y alargar la espera.
+        const espera = segundosDeEspera();
+        if (espera > 0) {
+            const aviso = mensajeDeEspera(espera);
+            salida.linea(chalk.yellow(`\n⏸  ${aviso}\n`));
+            return parada("ocupado", aviso);
+        }
         // Cuota ANTES de gastar. Si no queda margen, se dice y no se llama al motor:
         // avisar despues de haber gastado no sirve de nada.
         const cuota = checkQuota();
@@ -553,10 +563,15 @@ export class AgentLoop {
                 // Un 402 (cuota agotada) o un 401 (licencia caida) no son "fallos del
                 // motor" y ademas no se reintentan nunca: decirlo como tal confunde y
                 // hace que el usuario piense que el producto esta roto.
+                // Si el 429 es de huecos ocupados, se apunta hasta cuando: asi el
+                // siguiente mensaje del usuario se responde desde aqui en vez de gastar
+                // otra peticion para que le repitan la misma pared.
+                if (esDemasiadasEnCurso(err))
+                    anotarHuecosOcupados(err?.error?.retry_after_s);
                 const claro = explicarErrorDelMotor(err);
                 if (claro) {
-                    salida.linea(chalk.yellow(`
-⏸  ${claro}
+                    salida.linea(chalk.yellow(`
+⏸  ${claro}
 `));
                     return parada(motivoDeParadaDelError(err), claro);
                 }
@@ -564,19 +579,34 @@ export class AgentLoop {
                 renderError(fallo);
                 return parada("error-motor", fallo);
             }
+            // El motor contesto: habia hueco. Seguir bloqueando por una espera vieja
+            // seria mentirle al usuario y negarle el servicio que si tiene.
+            liberarHuecos();
             let content = "";
             let reasoning = "";
             let motivoDeCorte = null;
+            /**
+             * Si llego la MARCA de final del stream.
+             *
+             * Un stream sano termina diciendo por que termina: un `finish_reason` y,
+             * con `include_usage`, un ultimo trozo con el gasto. Cuando el cuerpo se
+             * corta a mitad no llega ninguno de los dos y el iterador se acaba sin
+             * error, exactamente igual que si hubiera terminado bien. Hacen falta las
+             * dos ausencias: fiarse de una sola convertiria en "cortada" cualquier
+             * respuesta de un motor que no mande esa marca.
+             */
+            let llegoElFinal = false;
             const rawToolCalls = [];
-            let isFirstChunk = true;
             const reasoningStream = new ReasoningStream();
-            const markdown = new MarkdownStream();
+            // Por `salida`, no por stdout: mientras se escribe la respuesta el spinner
+            // sigue puesto abajo, y escribir directo lo pisaria.
+            const markdown = new MarkdownStream((s) => salida.crudo(s));
             try {
                 for await (const chunk of stream) {
-                    if (isFirstChunk) {
-                        spinner.stop();
-                        isFirstChunk = false;
-                    }
+                    // El spinner ya NO se para al llegar el primer trozo. Vive en el pie
+                    // fijo, asi que la respuesta sale por encima sin taparlo y el contador
+                    // de segundos sigue a la vista mientras el modelo habla, que es
+                    // exactamente cuando uno quiere saber cuanto lleva.
                     const delta = chunk.choices?.[0]?.delta;
                     // Handle real-time reasoning stream
                     if (delta?.reasoning_content) {
@@ -590,6 +620,12 @@ export class AgentLoop {
                         content += delta.content;
                         markdown.push(delta.content);
                     }
+                    // El contador del spinner, en vivo. El `usage` de verdad solo llega
+                    // en el ultimo trozo: sin esta estimacion el numero se queda a cero
+                    // durante toda la respuesta y aparece de golpe justo al acabar, que
+                    // es cuando ya no le sirve a nadie.
+                    spinner.tokenCount =
+                        turnCompletionTokens + Math.round((content.length + reasoning.length) / 4);
                     // Accumulate fragmented tool calls by index tc.index
                     if (delta?.tool_calls) {
                         for (const tc of delta.tool_calls) {
@@ -612,10 +648,13 @@ export class AgentLoop {
                     // El motivo por el que el modelo dejo de hablar. Sin esto, quedarse
                     // sin presupuesto de salida es indistinguible de terminar el turno.
                     const corte = chunk.choices?.[0]?.finish_reason;
-                    if (corte)
+                    if (corte) {
                         motivoDeCorte = corte;
+                        llegoElFinal = true;
+                    }
                     // Track streaming usage metrics
                     if (chunk.usage) {
+                        llegoElFinal = true;
                         this.tracker.addUsage(chunk.usage);
                         turnPromptTokens += chunk.usage.prompt_tokens || 0;
                         if (chunk.usage.prompt_tokens)
@@ -639,10 +678,12 @@ export class AgentLoop {
                     salida.linea(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
                     return parada("interrumpido");
                 }
+                if (esDemasiadasEnCurso(streamErr))
+                    anotarHuecosOcupados(streamErr?.error?.retry_after_s);
                 const claroStream = explicarErrorDelMotor(streamErr);
                 if (claroStream) {
-                    salida.linea(chalk.yellow(`
-⏸  ${claroStream}
+                    salida.linea(chalk.yellow(`
+⏸  ${claroStream}
 `));
                     return parada(motivoDeParadaDelError(streamErr), claroStream);
                 }
@@ -662,6 +703,49 @@ export class AgentLoop {
             }
             // Filter valid accumulated tool calls
             const toolCalls = rawToolCalls.filter((tc) => tc && tc.function && tc.function.name);
+            // LA RESPUESTA SE CORTO A MITAD Y EL STREAM ACABO COMO SI NADA
+            //
+            // Sesion real. El usuario pregunta por su consumo y ve esto:
+            //
+            //     ¿De cuál consumo me hab
+            //     ⚡ 12.4s · 0 tokens salida · 100% contexto libre
+            //
+            // Media palabra y el pie del turno, sin un solo aviso. El cuerpo de la
+            // respuesta se cerro por el camino -no el modelo: la conexion-, asi que no
+            // llego ni el finish_reason ni el trozo del gasto, y el iterador termino
+            // sin lanzar nada. El bucle no distingue "el modelo termino" de "no vino
+            // mas", asi que dio el turno por bueno.
+            //
+            // Y lo peor no se veia: esa media frase se guardaba en el historial como
+            // respuesta completa del asistente. El turno siguiente salia con un
+            // historial que acaba a mitad de palabra, el modelo contestaba vacio, y el
+            // reintento de las respuestas vacias gastaba otro hueco de peticion.
+            // Cuatro mensajes despues: "Tienes 4 peticiones en curso. Reintenta en
+            // 197s", y el usuario sin servicio durante tres minutos.
+            //
+            // NO SE REINTENTA, A PROPOSITO. Cada intento ocupa uno de los cuatro
+            // huecos de la licencia durante minutos, y los cortes vienen en rachas:
+            // reintentar es justo como se pasa de perder un hueco a perder los cuatro.
+            // Mas vale que el usuario reescriba una linea.
+            if (!llegoElFinal && (content.trim().length > 0 || toolCalls.length > 0)) {
+                watcher.stop();
+                // Lo que llego se guarda, pero MARCADO. Sin la marca, en el turno
+                // siguiente el modelo lee su propia frase a medias como algo que decidio
+                // dejar asi, y responde a un texto que nadie escribio.
+                if (content.trim()) {
+                    this.messages.push({
+                        role: "assistant",
+                        content: `${content}\n\n[Aqui se corto: la conexion con el motor se cerro a mitad de la respuesta.]`,
+                    });
+                }
+                // Las llamadas a herramienta de un stream cortado NO se ejecutan: sus
+                // argumentos estan tan a medias como el texto.
+                const aviso = "La respuesta se corto a mitad: la conexion con el motor se cerro sin avisar. " +
+                    "Lo que llego se queda arriba. No lo reintento solo porque cada intento ocupa uno de " +
+                    "los cuatro huecos de tu licencia durante varios minutos; vuelve a pedirmelo y sigo.";
+                salida.linea(chalk.yellow(`\n  ⚠ ${aviso}\n`));
+                return parada("error-motor", aviso);
+            }
             // El modelo se quedo sin presupuesto de salida y no llego a pedir nada.
             //
             // Esto se veia EXACTAMENTE igual que un turno terminado: sin llamadas a
@@ -910,7 +994,7 @@ export class AgentLoop {
                     toolResults.push({
                         role: "tool",
                         tool_call_id: tc.id,
-                        content: post.additionalContext ? `${texto}\n\n
+                        content: post.additionalContext ? `${texto}\n\n
 [Hook PostToolUse]: ${post.additionalContext}` : texto,
                     });
                 }

package/dist/agent/salidaDelAgente.js

@@ -1,35 +1,21 @@
+import { escribirEncimaDelPie } from "../ui/pieFijo.js";
 /**
- * Por donde habla el bucle del agente.
+ * Pasa por `pieFijo` y no por `console.log` a secas.
  *
- * POR QUE
+ * Mientras el spinner esta puesto hay un bloque pintado abajo del todo. Escribir
+ * directo lo pisaria: la respuesta saldria encima de la linea del spinner y el
+ * repintado siguiente ya no sabria donde empieza su bloque. Pasando por aqui, el
+ * pie se aparta, la linea entra en el historial como cualquier otra, y el pie
+ * vuelve a pintarse debajo.
  *
- * El bucle escribia con `console.log` en diecisiete sitios. Mientras el unico
- * sitio donde se ve al agente sea una terminal eso no molesta, pero ata el
- * motor a su pantalla: para poner el agente en un panel de VSCode, en una web o
- * en una app, hay que arrancarle esos diecisiete `console.log` uno a uno, y
- * cada uno es una ocasion de romper algo.
- *
- * Con esto en medio, el bucle deja de saber donde acaba lo que dice. La
- * terminal pasa a ser UNA implementacion, no LA implementacion.
- *
- * POR QUE RECIBE EL TEXTO YA COLOREADO
- *
- * Es a proposito, y es lo que hace que este cambio no pueda romper nada: lo que
- * el bucle manda es exactamente la misma cadena que antes le pasaba a
- * `console.log`, colores incluidos. La salida por terminal queda byte a byte
- * igual que ayer, y las 538 pruebas siguen valiendo como red.
- *
- * Un panel que quiera pintarlo a su manera quita los codigos de color con
- * `sinColores()` y se queda con el texto. Cuando haga falta distinguir un aviso
- * de una nota, se anaden metodos con significado; hoy no hace falta y adivinarlo
- * seria inventar trabajo.
+ * Sin pie puesto -que es casi todo el rato- esto es un `write` normal.
  */
 const A_LA_TERMINAL = {
     linea: (texto) => {
-        console.log(texto);
+        escribirEncimaDelPie(`${texto}\n`);
     },
     crudo: (texto) => {
-        process.stdout.write(texto);
+        escribirEncimaDelPie(texto);
     },
 };
 let actual = A_LA_TERMINAL;

package/dist/agent/toolGate.js

@@ -3,7 +3,7 @@ import chalk from "chalk";
 import { PermissionManager, commandSignature } from "../config/permissions.js";
 import { HookManager } from "../hooks/manager.js";
 import { askToolPermission } from "../ui/permissionPrompt.js";
-import { releaseKeyboard } from "../ui/interrupt.js";
+import { releaseKeyboard, retomarTeclado } from "../ui/interrupt.js";
 let activa = null;
 /** Lo llama el AgentLoop al construirse. */
 export function registerToolGate(permissions, hooks) {
@@ -75,6 +75,11 @@ export async function autorizarHerramienta(toolName, args, cwd = process.cwd(),
         releaseKeyboard();
         console.log(chalk.gray(`\n${origen} pide permiso para usar "${toolName}":`));
         const res = await askToolPermission(toolName, finales, cwd);
+        // Se devuelve el teclado a quien lo tenia. Sin esto, el resto del turno se
+        // queda sin vigilante: Esc deja de cancelar, lo que el usuario escriba no se
+        // encola, y el terminal vuelve al modo cocido -donde lo tecleado no aparece
+        // hasta pulsar Enter, que es como se veia el "se queda trabado".
+        retomarTeclado();
         if (!res.approved) {
             return {
                 permitida: false,

package/dist/config/engine.d.ts

@@ -38,7 +38,27 @@ export declare function engineCredential(fallbackApiKey: string): string;
  * cualquiera apuntando al mismo endpoint.
  */
 export declare function engineHeaders(route: EngineRoute): Record<string, string>;
-/** Cliente del motor ya configurado. Es el unico sitio donde se construye. */
+/**
+ * Cliente del motor ya configurado. Es el unico sitio donde se construye.
+ *
+ * POR QUE `maxRetries: 0`
+ *
+ * El SDK reintenta por su cuenta dos veces mas (su valor por defecto), y encima
+ * de eso el agente pasa cada llamada por `withRetry`. Dos capas apiladas, y solo
+ * una de las dos sabe algo del proxy.
+ *
+ * Medido contra un servidor de mentira: una sola llamada que recibe un 429 de
+ * "tienes 4 peticiones en curso" sale por la red TRES veces antes de que el
+ * error llegue siquiera a nuestro codigo. Y nuestro codigo lo tiene bien
+ * clasificado -`isRetryable` devuelve false para ese 429 justamente porque cada
+ * intento ocupa un hueco-, pero para entonces ya se han gastado los otros dos.
+ *
+ * Asi es como un solo corte de conexion se comia los cuatro huecos de la
+ * licencia y dejaba al usuario tres minutos sin servicio. La politica de
+ * reintentos vive en `withRetry` y en un solo sitio: ahi se sabe que un
+ * desbordamiento de contexto no puede empezar a caber, y que insistir con los
+ * huecos ocupados es la forma mas rapida de quedarse sin ninguno.
+ */
 export declare function createEngineClient(apiKey: string, route: EngineRoute): OpenAI;
 /**
  * De que tipo es el fallo, sin mirar el texto ya traducido.

package/dist/config/engine.js

@@ -55,12 +55,33 @@ export function engineHeaders(route) {
         cabeceras["X-Chocolatito-Instance"] = license.instanceId;
     return cabeceras;
 }
-/** Cliente del motor ya configurado. Es el unico sitio donde se construye. */
+/**
+ * Cliente del motor ya configurado. Es el unico sitio donde se construye.
+ *
+ * POR QUE `maxRetries: 0`
+ *
+ * El SDK reintenta por su cuenta dos veces mas (su valor por defecto), y encima
+ * de eso el agente pasa cada llamada por `withRetry`. Dos capas apiladas, y solo
+ * una de las dos sabe algo del proxy.
+ *
+ * Medido contra un servidor de mentira: una sola llamada que recibe un 429 de
+ * "tienes 4 peticiones en curso" sale por la red TRES veces antes de que el
+ * error llegue siquiera a nuestro codigo. Y nuestro codigo lo tiene bien
+ * clasificado -`isRetryable` devuelve false para ese 429 justamente porque cada
+ * intento ocupa un hueco-, pero para entonces ya se han gastado los otros dos.
+ *
+ * Asi es como un solo corte de conexion se comia los cuatro huecos de la
+ * licencia y dejaba al usuario tres minutos sin servicio. La politica de
+ * reintentos vive en `withRetry` y en un solo sitio: ahi se sabe que un
+ * desbordamiento de contexto no puede empezar a caber, y que insistir con los
+ * huecos ocupados es la forma mas rapida de quedarse sin ninguno.
+ */
 export function createEngineClient(apiKey, route) {
     return new OpenAI({
         apiKey: engineCredential(apiKey),
         baseURL: getEngineBaseUrl(),
         defaultHeaders: engineHeaders(route),
+        maxRetries: 0,
     });
 }
 export function clasificarErrorDelMotor(err) {

package/dist/tools/browserExtension.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { fileURLToPath } from "node:url";
 import { WebSocketServer, WebSocket } from "ws";
 import { describeScreen } from "./visionBridge.js";
 /**
@@ -278,6 +279,55 @@ function emparejar(objetivo, origen, destino) {
         return candidatos[pos].ref;
     return null;
 }
+/**
+ * Avisar cuando la extension de Chrome se quedo atras.
+ *
+ * POR QUE HACE FALTA
+ *
+ * El CLI se actualiza solo, y la extension viaja DENTRO del paquete npm. Asi
+ * que al actualizarse, los archivos de la extension en el disco pasan a ser
+ * nuevos... pero Chrome sigue ejecutando los que cargo en su dia. No se entera
+ * hasta que alguien pulsa "recargar" en chrome://extensions.
+ *
+ * Eso deja al usuario con una version del CLI que espera cosas que su extension
+ * no sabe hacer, y los fallos que salen de ahi no se parecen en nada a su causa:
+ * una captura que llega en PNG cuando el CLI ya cuenta con JPEG, una accion que
+ * contesta distinto de lo que se espera. Sintomas raros, causa invisible.
+ *
+ * La extension ya decia su version en cada `status` y nadie la miraba. Ahora se
+ * compara con la que trae este CLI, y si no cuadran se dice una vez.
+ */
+let yaAvisadoDeVersion = false;
+/** La version de extension que trae ESTE CLI, leida del paquete instalado. */
+function versionEsperadaDeExtension() {
+    try {
+        const aqui = path.dirname(fileURLToPath(import.meta.url));
+        const manifiesto = path.resolve(aqui, "..", "..", "extension", "manifest.json");
+        return String(JSON.parse(fs.readFileSync(manifiesto, "utf-8")).version || "");
+    }
+    catch {
+        // Sin manifiesto no se puede comparar, y adivinar seria peor que callar.
+        return "";
+    }
+}
+/**
+ * Aviso si la extension va por detras. Cadena vacia si todo cuadra o no se sabe.
+ *
+ * Solo se avisa UNA vez por sesion: repetirlo en cada accion seria ruido que
+ * acaba ignorandose, que es como se pierden los avisos que importan.
+ */
+function avisoDeVersion(deLaExtension) {
+    if (yaAvisadoDeVersion)
+        return "";
+    const esperada = versionEsperadaDeExtension();
+    if (!esperada || !deLaExtension || esperada === deLaExtension)
+        return "";
+    yaAvisadoDeVersion = true;
+    return (`\n\nAVISO: tu extension de Chrome es la v${deLaExtension} y este Chocolatito trae la v${esperada}. ` +
+        `Chrome sigue ejecutando la que cargo en su dia aunque los archivos del disco ya sean nuevos. ` +
+        `Recargala en chrome://extensions (boton de recargar en la tarjeta de Chocolatito Code) o ` +
+        `veras fallos raros que no se parecen a su causa.`);
+}
 class CatalogoDeRefs {
     /** Lo que vio el modelo: los numeros en los que habla. */
     vista = [];
@@ -315,6 +365,10 @@ class CatalogoDeRefs {
         return this.filtroVista;
     }
     /** Nombre que tenia ese ref cuando el modelo lo vio. */
+    /** Huella de lo que vio el modelo, para poder comparar despues de actuar. */
+    huellaVista() {
+        return this.vista.map((e) => `${e.role}::${e.name}`);
+    }
     nombreDe(ref) {
         return this.vista.find((e) => e.ref === ref)?.name || "";
     }
@@ -353,6 +407,61 @@ async function refrescarCatalogo(filtro) {
     catalogo.verInterno(fresh.data.elements || []);
     return true;
 }
+/**
+ * Comprobar que el clic hizo ALGO, en vez de dar por hecho que si.
+ *
+ * EL FALLO, VISTO EN UNA SESION REAL
+ *
+ * En Google Flow, el agente pulso el boton de generar y la herramienta contesto:
+ *
+ *     Pulsado [19] "Iniciar generación". Pagina ahora: "Google Flow: sept 06..."
+ *
+ * El modelo leyo eso como "hecho" y se puso a esperar el resultado. Pero el clic
+ * no habia disparado nada: la pagina seguia igual. Espero, no vio nada, volvio a
+ * pulsar, volvio a esperar, gasto una captura de pantalla, y solo se desatasco
+ * cuando el usuario le dijo a mano "dale al boton de la flechita".
+ *
+ * El problema no fue del modelo: la herramienta le habia dicho que el clic se
+ * habia dado. Y "se envio el evento" no es lo mismo que "la pagina reacciono".
+ * Una web puede ignorar un clic sintetico por mil motivos -el manejador esta en
+ * otro elemento, hay un overlay delante, el framework escucha pointerdown y no
+ * click-, y ninguno de esos se ve desde fuera.
+ *
+ * QUE SE HACE AHORA
+ *
+ * Se mira la pagina antes y despues. Si no cambio absolutamente nada, se dice —
+ * que es informacion util y no un error: significa "el evento salio pero nadie
+ * lo recogio, prueba otra cosa". Es la diferencia entre que el agente se quede
+ * quince segundos esperando algo que no va a pasar, y que cambie de estrategia
+ * en el turno siguiente.
+ */
+async function reaccionAlClic(filtro, antes) {
+    let fresh;
+    try {
+        fresh = await extensionBridge.send("snapshot", { filter: filtro || "", max: 200 });
+    }
+    catch {
+        return "";
+    }
+    if (!fresh?.ok)
+        return "";
+    const els = fresh.data.elements || [];
+    catalogo.verInterno(els);
+    const ahora = els.map((e) => `${e.role}::${e.name}`);
+    const nuevos = ahora.filter((k) => !antes.includes(k));
+    const idos = antes.filter((k) => !ahora.includes(k));
+    if (nuevos.length === 0 && idos.length === 0) {
+        return (`\nOJO: el clic se envio, pero la pagina NO cambio en nada. Eso suele significar que ` +
+            `el elemento pulsado no es el que dispara la accion (el manejador esta en otro, hay algo ` +
+            `delante, o el framework escucha otro evento). No esperes un resultado: haz snapshot y ` +
+            `busca el control de verdad, o usa computer_use para un clic real del sistema.`);
+    }
+    const resumen = [
+        ...nuevos.slice(0, 6).map((k) => `  + ${k.replace("::", " ")}`),
+        ...idos.slice(0, 4).map((k) => `  - ${k.replace("::", " ")} (ya no esta)`),
+    ].join("\n");
+    return `\nLa pagina reacciono (${nuevos.length} nuevos, ${idos.length} fuera):\n${resumen}`;
+}
 /**
  * Ejecuta una accion sobre un ref del snapshot del modelo, traduciendolo al
  * numero que la extension tiene vivo ahora mismo. Si el ref ha caducado (el
@@ -421,7 +530,8 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                         `Si no la reconoces, revisala en chrome://extensions.`
                     : "";
                 return (`Extension conectada (v${res.data.version}), emparejada con ${origin}. ` +
-                    `Puedo trabajar en tus pestanas en segundo plano, sin robarte el foco.${aviso}`);
+                    `Puedo trabajar en tus pestanas en segundo plano, sin robarte el foco.${aviso}` +
+                    avisoDeVersion(String(res.data.version || "")));
             }
             case "tabs": {
                 const res = await extensionBridge.send("tabs");
@@ -500,6 +610,9 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
             case "click": {
                 if (params.ref === undefined)
                     return fail(action, 'indica el "ref" del snapshot.');
+                // Se apunta como estaba la pagina ANTES: sin eso no hay con que comparar
+                // despues, y "se envio el clic" seguiria pasando por "la pagina reacciono".
+                const antesDelClic = catalogo.huellaVista();
                 const res = await accionSobreRef("click", {}, params.ref, params.filter);
                 if (!res.ok)
                     return fail(action, res.error);
@@ -512,7 +625,9 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                 const aviso = mismoElemento(pedido, pulsado)
                     ? ""
                     : `\nAVISO: pediste "${pedido}" y se pulso "${pulsado}". Haz snapshot y comprueba en que estado quedo la pagina.`;
-                return (`Pulsado [${params.ref}] "${pulsado}". Pagina ahora: "${res.data.title}" (${res.data.url})${aviso}`);
+                // Y lo que de verdad importa: si la pagina hizo algo o no. Ver reaccionAlClic.
+                const reaccion = antesDelClic.length > 0 ? await reaccionAlClic(params.filter || "", antesDelClic) : "";
+                return (`Pulsado [${params.ref}] "${pulsado}". Pagina ahora: "${res.data.title}" (${res.data.url})${aviso}${reaccion}`);
             }
             case "type": {
                 if (params.ref === undefined)
@@ -651,7 +766,7 @@ export async function chromeExtension(params, cwd = process.cwd(), apiKey) {
                     ? path.isAbsolute(params.outputPath)
                         ? params.outputPath
                         : path.resolve(cwd, params.outputPath)
-                    : path.join(dir, "chrome_tab.png");
+                    : path.join(dir, "chrome_tab.jpg");
                 const outDir = path.dirname(out);
                 if (!fs.existsSync(outDir))
                     fs.mkdirSync(outDir, { recursive: true });

package/dist/tools/computerUse.d.ts

@@ -23,7 +23,7 @@
  *     "background": se actua sobre una ventana concreta sin traerla al frente y
  *     sin mover el raton del usuario.
  */
-export type ComputerAction = "screenshot" | "ui_snapshot" | "ui_click" | "ui_type" | "ui_focus" | "find_element" | "left_click" | "click" | "double_click" | "triple_click" | "right_click" | "middle_click" | "mouse_move" | "move" | "left_click_drag" | "scroll" | "type" | "key" | "hotkey" | "wait" | "sleep" | "cursor_position" | "list_windows" | "focus_window" | "get_active_window" | "open_app";
+export type ComputerAction = "screenshot" | "ui_snapshot" | "ui_click" | "ui_type" | "ui_focus" | "find_element" | "left_click" | "click" | "double_click" | "triple_click" | "right_click" | "middle_click" | "mouse_move" | "move" | "left_click_drag" | "scroll" | "type" | "key" | "hotkey" | "wait" | "wait_change" | "sleep" | "cursor_position" | "list_windows" | "focus_window" | "get_active_window" | "open_app";
 export interface ComputerUseParams {
     action: ComputerAction;
     /** Ventana objetivo por titulo o proceso (ej. "chrome", "Flow"). */