chocolatito-code 1.6.11 → 1.6.12

package/dist/agent/huecos.d.ts

@@ -56,3 +56,27 @@ export declare function liberarHuecos(): void;
  * que hacer nada: es lo unico que se arregla solo con esperar.
  */
 export declare function mensajeDeEspera(segundos: number): string;
+/**
+ * Espera a que se libere el hueco, en vez de devolverle la pared al usuario.
+ *
+ * DE DONDE SALE
+ *
+ * La misma sesion, un paso mas alla. Ya no se gastaba una peticion por intento
+ * -eso lo arreglo lo de arriba-, pero el usuario seguia atrapado:
+ *
+ *     > sigue
+ *     ⏸  Faltan 144s.
+ *     > sigoe
+ *     ⏸  Faltan 133s.
+ *
+ * Tecleando contra una pared que el programa sabia medir. Si sabemos que faltan
+ * 133 segundos, esperarlos es trabajo del programa, no del que paga. Se avisa,
+ * se cuenta hacia atras y se sigue solo; con Esc se deja.
+ *
+ * Vuelve `true` si ya hay hueco y `false` si el usuario corto.
+ */
+export declare function esperarAlHueco(opciones: {
+    signal?: AbortSignal;
+    alPasarUnSegundo?: (quedan: number) => void;
+    dormir?: (ms: number) => Promise<void>;
+}): Promise<boolean>;

package/dist/agent/huecos.js

@@ -79,3 +79,37 @@ export function mensajeDeEspera(segundos) {
         "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.");
 }
+/**
+ * Espera a que se libere el hueco, en vez de devolverle la pared al usuario.
+ *
+ * DE DONDE SALE
+ *
+ * La misma sesion, un paso mas alla. Ya no se gastaba una peticion por intento
+ * -eso lo arreglo lo de arriba-, pero el usuario seguia atrapado:
+ *
+ *     > sigue
+ *     ⏸  Faltan 144s.
+ *     > sigoe
+ *     ⏸  Faltan 133s.
+ *
+ * Tecleando contra una pared que el programa sabia medir. Si sabemos que faltan
+ * 133 segundos, esperarlos es trabajo del programa, no del que paga. Se avisa,
+ * se cuenta hacia atras y se sigue solo; con Esc se deja.
+ *
+ * Vuelve `true` si ya hay hueco y `false` si el usuario corto.
+ */
+export async function esperarAlHueco(opciones) {
+    const { signal, alPasarUnSegundo } = opciones;
+    const dormir = opciones.dormir || ((ms) => new Promise((r) => setTimeout(r, ms)));
+    // Se relee en cada vuelta en vez de contar desde un numero fijo: si algo
+    // libera los huecos antes -otra respuesta del motor-, se sale en el acto.
+    let quedan = segundosDeEspera();
+    while (quedan > 0) {
+        if (signal?.aborted)
+            return false;
+        alPasarUnSegundo?.(quedan);
+        await dormir(1000);
+        quedan = segundosDeEspera();
+    }
+    return !signal?.aborted;
+}

package/dist/agent/loop.js

@@ -8,7 +8,7 @@ import { CONTEXT_WINDOW, MAX_OUTPUT_TOKENS, COMPACT_THRESHOLD_TOKENS, } from "..
 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 { anotarHuecosOcupados, esperarAlHueco, 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";
@@ -461,9 +461,43 @@ export class AgentLoop {
         // llamada es justo la que puede refrescar la reserva y alargar la espera.
         const espera = segundosDeEspera();
         if (espera > 0) {
+            // ESPERAR ES TRABAJO DEL PROGRAMA, NO DEL QUE PAGA
+            //
+            // Antes esto devolvia el aviso y cortaba el turno. El usuario escribia
+            // "sigue", se llevaba "faltan 144s", escribia otra vez y se llevaba
+            // "faltan 133s": tecleando contra una pared que el programa sabia medir.
+            // Si sabemos cuanto falta, se espera y se sigue solo. Con Esc se deja.
             const aviso = mensajeDeEspera(espera);
-            salida.linea(chalk.yellow(`\n⏸  ${aviso}\n`));
-            return parada("ocupado", aviso);
+            // SOLO SE ESPERA SI HAY ALGUIEN DELANTE.
+            //
+            // Esperar tres minutos es una pausa cuando se ve la cuenta atras y se
+            // puede cortar con Esc. Sin terminal -CI, `chocolatito "haz X"`, una
+            // tuberia- es un cuelgue mudo de tres minutos que nadie puede parar, y
+            // ademas ahi no hay nadie a quien ahorrarle el teclear. Se dice y se
+            // corta, como antes.
+            if (!process.stdin.isTTY) {
+                salida.linea(chalk.yellow(`\n⏸  ${aviso}\n`));
+                return parada("ocupado", aviso);
+            }
+            salida.linea(chalk.yellow(`\n⏸  ${aviso}`));
+            salida.linea(chalk.gray("   Espero y sigo solo cuando se libere. Esc para dejarlo.\n"));
+            const vigilante = new InterruptWatcher();
+            const senal = vigilante.start();
+            const spinnerEspera = new DynamicSpinner();
+            spinnerEspera.start();
+            const hayHueco = await esperarAlHueco({
+                signal: senal,
+                alPasarUnSegundo: (quedan) => {
+                    spinnerEspera.setPrefijo(`Esperando hueco de la licencia (quedan ${quedan}s)`);
+                },
+            });
+            spinnerEspera.stop();
+            vigilante.stop();
+            if (!hayHueco) {
+                salida.linea(chalk.yellow("\n⏸  Interrumpido. Dime como seguir."));
+                return parada("interrumpido");
+            }
+            salida.linea(chalk.green("  ✔ Hueco libre. Sigo.\n"));
         }
         // 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.
@@ -742,6 +776,18 @@ export class AgentLoop {
             // porque la conexion estaba bien.
             if (!llegoElFinal) {
                 watcher.stop();
+                // SE CIERRA LA PETICION MUERTA, Y ESTO NO ES LIMPIEZA: ES EL HUECO.
+                //
+                // El cuerpo se corto, pero por lo que respecta al proxy la peticion
+                // sigue en curso y sigue ocupando uno de los cuatro huecos de la
+                // licencia hasta que ALGO la cierre. Por eso el mensaje del proxy dice
+                // "si acabas de interrumpir una, el hueco se libera solo en 206s": son
+                // tres minutos y medio de servicio perdido por una conexion que ya
+                // estaba muerta de este lado. Abortando aqui se suelta en el momento.
+                try {
+                    stream?.controller?.abort();
+                }
+                catch { }
                 // 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.

package/dist/ui/spinner.d.ts

@@ -7,6 +7,12 @@ export declare class DynamicSpinner {
     private prefix;
     tokenCount: number;
     constructor(prefix?: string);
+    /**
+     * Cambia el texto mientras gira. Hace falta para las esperas con cuenta
+     * atras: el prefijo se fijaba al arrancar y el numero de segundos que faltan
+     * cambia cada vuelta.
+     */
+    setPrefijo(prefijo: string): void;
     start(initialPrefix?: string): void;
     private tick;
     /**

package/dist/ui/spinner.js

@@ -42,6 +42,14 @@ export class DynamicSpinner {
     constructor(prefix = "") {
         this.prefix = prefix;
     }
+    /**
+     * Cambia el texto mientras gira. Hace falta para las esperas con cuenta
+     * atras: el prefijo se fijaba al arrancar y el numero de segundos que faltan
+     * cambia cada vuelta.
+     */
+    setPrefijo(prefijo) {
+        this.prefix = prefijo;
+    }
     start(initialPrefix) {
         if (this.isRunning)
             return;

package/extension/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "minimum_chrome_version": "102",
   "name": "Chocolatito Code",
-  "version": "1.6.11",
+  "version": "1.6.12",
   "description": "Deja que Chocolatito Code trabaje dentro de tu Chrome, en segundo plano y con tus sesiones ya iniciadas.",
   "permissions": [
     "tabs",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chocolatito-code",
-  "version": "1.6.11",
+  "version": "1.6.12",
   "description": "Agente autónomo de programación para la terminal, con control real del ordenador y del navegador. Desarrollado por Chocolatito.",
   "type": "module",
   "bin": {