vipcode 0.2.3 → 0.2.4

package/dist/images.js

@@ -36,10 +36,26 @@ function run(command, args) {
         });
     });
 }
-// Lee una imagen del portapapeles (macOS con osascript, Linux con wl-paste o xclip)
+// La imagen que ha dejado el portapapeles en un fichero temporal (y lo borra)
+function takePng(tmp) {
+    try {
+        const size = fs.statSync(tmp).size;
+        if (size === 0) {
+            return null;
+        }
+        return `data:image/png;base64,${fs.readFileSync(tmp).toString("base64")}`;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        fs.rmSync(tmp, { force: true });
+    }
+}
+// Lee una imagen del portapapeles (macOS con osascript, Windows con PowerShell, Linux con wl-paste o xclip)
 export async function readClipboardImage() {
+    const tmp = path.join(os.tmpdir(), `vipcode-clip-${process.pid}-${Date.now()}.png`);
     if (process.platform === "darwin") {
-        const tmp = path.join(os.tmpdir(), `vipcode-clip-${process.pid}-${Date.now()}.png`);
         const script = [
             `set f to open for access POSIX file "${tmp}" with write permission`,
             "try",
@@ -52,19 +68,18 @@ export async function readClipboardImage() {
             args.push("-e", line);
         }
         await run("osascript", args);
-        try {
-            const size = fs.statSync(tmp).size;
-            if (size === 0) {
-                return null;
-            }
-            return `data:image/png;base64,${fs.readFileSync(tmp).toString("base64")}`;
-        }
-        catch {
-            return null;
-        }
-        finally {
-            fs.rmSync(tmp, { force: true });
-        }
+        return takePng(tmp);
+    }
+    if (process.platform === "win32") {
+        // El PowerShell que trae Windows, con el portapapeles de .NET (que necesita -STA)
+        const script = [
+            "Add-Type -AssemblyName System.Windows.Forms",
+            "Add-Type -AssemblyName System.Drawing",
+            "$image = [System.Windows.Forms.Clipboard]::GetImage()",
+            `if ($image) { $image.Save('${tmp.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png) }`,
+        ].join("\n");
+        await run("powershell.exe", ["-NoProfile", "-NonInteractive", "-STA", "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64")]);
+        return takePng(tmp);
     }
     if (process.platform === "linux") {
         for (const [command, args] of [

package/dist/index.js

@@ -3,10 +3,12 @@ import fs from "node:fs";
 import path from "node:path";
 import readline from "node:readline/promises";
 import pc from "picocolors";
+import { agentName } from "./agents.js";
 import { App, BUILTIN_COMMANDS } from "./app.js";
 import { removeAuth } from "./auth.js";
 import { configNotices, loadConfig } from "./config.js";
 import { isImagePath, toDataUrl } from "./images.js";
+import { limitsReport } from "./limits.js";
 import { REPO_URL, VERSION } from "./meta.js";
 import { NoSlotError } from "./router.js";
 import { appendHistory, exportMarkdown, listSessions, loadSession, saveExport } from "./session.js";
@@ -25,6 +27,7 @@ Uso:
   vipcode auth list                proveedores, claves configuradas y dónde conseguirlas
   vipcode auth logout <proveedor>  borra una clave guardada
   vipcode models [refresh]         modelos disponibles (refresh busca modelos gratis nuevos)
+  vipcode limites                  cuánto te queda hoy de cada plan gratis
   vipcode skills                   skills instaladas (instrucciones que el agente carga cuando las necesita)
   vipcode skills add <origen>      instala skills de una carpeta o de un repositorio git (p. ej. anthropics/skills)
   vipcode skills new <nombre>      crea una skill vacía para rellenar
@@ -39,7 +42,7 @@ Opciones:
   -s, --session <id>    abrir una sesión concreta
   -m, --model <p/m>     modelo preferido, por ejemplo groq/openai/gpt-oss-120b
   --agent <nombre>      agente con el que empezar (build, plan o uno tuyo)
-  --plan                empezar en modo plan (solo lectura)
+  --plan                empezar con el agente planear (solo lectura)
   --yolo                aprobar todo sin preguntar
   --project             con vipcode skills: en la carpeta .vipcode/skills del proyecto en vez de la tuya
   --force               con vipcode skills add: sustituir las que ya existan
@@ -73,7 +76,7 @@ function parseArgs(argv) {
         project: false,
         force: false,
     };
-    const commands = ["run", "auth", "models", "skills", "sessions", "export", "update", "trust", "untrust", "help"];
+    const commands = ["run", "auth", "models", "limites", "limits", "skills", "sessions", "export", "update", "trust", "untrust", "help"];
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
         if (arg === "-c" || arg === "--continue") {
@@ -92,7 +95,7 @@ function parseArgs(argv) {
             i++;
         }
         else if (arg === "--plan") {
-            options.agent = "plan";
+            options.agent = "planear";
         }
         else if (arg === "--yolo") {
             options.yolo = true;
@@ -557,7 +560,7 @@ async function main() {
         }
     }
     const app = new App(root, { session, agentName: options.agent || undefined, trusted });
-    if (options.agent && !app.agents.some((agent) => agent.name === options.agent)) {
+    if (options.agent && !app.agents.some((agent) => agent.name === agentName(options.agent))) {
         ui.error(`No existe el agente «${options.agent}».`);
         process.exitCode = 1;
         return;
@@ -591,6 +594,10 @@ async function main() {
         console.log(app.modelsTable());
         return;
     }
+    if (options.command === "limites" || options.command === "limits") {
+        console.log(limitsReport(app.router));
+        return;
+    }
     if (!interactive && app.router.slots.length === 0) {
         noModelsHelp();
         process.exitCode = 1;

package/dist/limits.js

@@ -0,0 +1,160 @@
+import pc from "picocolors";
+// Cuánto te queda de cada plan gratis: lo que dice el proveedor en sus cabeceras y, si no lo dice, sus límites
+// conocidos menos lo que ha pedido vipcode
+const HOUR_MS = 60 * 60 * 1000;
+const PERIOD = { day: "hoy", hour: "esta hora", minute: "por minuto" };
+function number(n) {
+    return n.toLocaleString("es-ES");
+}
+function short(n) {
+    if (n >= 1e6) {
+        return `${(n / 1e6).toLocaleString("es-ES", { maximumFractionDigits: 1 })} M`;
+    }
+    if (n >= 1e4) {
+        return `${Math.round(n / 1e3).toLocaleString("es-ES")} k`;
+    }
+    if (n >= 1e3) {
+        return `${(n / 1e3).toLocaleString("es-ES", { maximumFractionDigits: 1 })} k`;
+    }
+    return String(n);
+}
+function clock(time, now) {
+    const hour = new Date(time).toLocaleTimeString("es-ES", { hour: "2-digit", minute: "2-digit" });
+    const day = new Date(time).toDateString();
+    if (day === new Date(now).toDateString()) {
+        return `las ${hour}`;
+    }
+    if (day === new Date(now + 24 * HOUR_MS).toDateString()) {
+        return `mañana a las ${hour}`;
+    }
+    return `el ${new Date(time).toLocaleDateString("es-ES", { weekday: "long" })} a las ${hour}`;
+}
+// Lo que dijo el proveedor, si todavía vale (pasada la hora de recuperarse ya no)
+function fromHeaders(window, now, unit = "") {
+    if (!window || (window.resetAt !== null && window.resetAt <= now)) {
+        return null;
+    }
+    const amount = unit ? short : number;
+    const of = window.limit !== null ? ` de ${amount(window.limit)}` : "";
+    const period = window.period ? ` ${PERIOD[window.period]}` : "";
+    return { text: `quedan ${amount(window.remaining)}${of}${unit}${period}`, remaining: window.remaining, limit: window.limit, period: window.period };
+}
+// Lo último que ha dicho el proveedor de este modelo (o de cualquiera de los suyos si el límite es de toda la cuenta)
+function snapshotFor(router, slot) {
+    if (slot.provider.limitScope !== "provider") {
+        return router.limits[slot.key];
+    }
+    let latest;
+    for (const other of router.slots) {
+        const snapshot = other.provider.name === slot.provider.name ? router.limits[other.key] : undefined;
+        if (snapshot && (!latest || snapshot.at > latest.at)) {
+            latest = snapshot;
+        }
+    }
+    return latest;
+}
+// Peticiones que te quedan en este modelo (o en su proveedor), o null si no se sabe
+export function quotaFor(router, slot, now = Date.now()) {
+    const header = fromHeaders(snapshotFor(router, slot)?.requests, now);
+    // El límite por minuto se recupera enseguida: si hay uno diario u horario conocido, es más útil
+    if (header && header.period !== "minute") {
+        return header;
+    }
+    const limits = slot.provider.freeLimits;
+    if (!limits || (limits.keyless && !slot.anonymous)) {
+        return header;
+    }
+    const usage = router.today().providers[slot.provider.name];
+    if (limits.perDay) {
+        const used = slot.provider.limitScope === "provider" ? usage?.requests || 0 : usage?.models[slot.model.id] || 0;
+        // Si ya llevas más de las que dice el plan, es que tu límite es mayor (por ejemplo OpenRouter con créditos)
+        if (used <= limits.perDay) {
+            return { text: `≈ quedan ${number(limits.perDay - used)} de ${number(limits.perDay)} hoy`, remaining: limits.perDay - used, limit: limits.perDay };
+        }
+    }
+    if (limits.perHour) {
+        const used = (router.recent[slot.provider.name] || []).filter((time) => now - time < HOUR_MS).length;
+        if (used <= limits.perHour) {
+            return { text: `≈ quedan ${number(limits.perHour - used)} de ${number(limits.perHour)} esta hora`, remaining: limits.perHour - used, limit: limits.perHour };
+        }
+    }
+    return header;
+}
+function pausedUntil(router, slot, now) {
+    const until = router.cooldowns[slot.key] || 0;
+    return until > now ? until : null;
+}
+function plural(n, one, many) {
+    return `${number(n)} ${n === 1 ? one : many}`;
+}
+// Informe de /limites: uso de hoy por proveedor y modelo, lo que queda y las pausas
+export function limitsReport(router, now = Date.now()) {
+    const day = router.today();
+    const totals = Object.values(day.providers).reduce((sum, entry) => ({ requests: sum.requests + entry.requests, tokens: sum.tokens + entry.tokens }), { requests: 0, tokens: 0 });
+    const today = new Date(now);
+    const midnight = Date.UTC(today.getUTCFullYear(), today.getUTCMonth(), today.getUTCDate() + 1);
+    const lines = [
+        `Hoy llevas ${plural(totals.requests, "petición", "peticiones")}${totals.tokens > 0 ? ` y ${short(totals.tokens)} tokens` : ""} ${pc.dim(`(el día cuenta en hora UTC: vuelve a empezar ${clock(midnight, now)})`)}`,
+        "",
+    ];
+    const providers = [];
+    for (const slot of router.slots) {
+        if (!providers.includes(slot.provider)) {
+            providers.push(slot.provider);
+        }
+    }
+    const unused = [];
+    for (const provider of providers) {
+        const label = provider.label || provider.name;
+        const slots = router.slots.filter((slot) => slot.provider === provider);
+        const usage = day.providers[provider.name];
+        const shown = slots.filter((slot) => (usage?.models[slot.model.id] || 0) > 0 || pausedUntil(router, slot, now) || router.limits[slot.key]);
+        if (!usage && shown.length === 0) {
+            unused.push(label);
+            continue;
+        }
+        const whole = provider.limitScope === "provider";
+        const head = [`${pc.bold(label)}: ${plural(usage?.requests || 0, "petición", "peticiones")}`];
+        if (usage?.tokens) {
+            head.push(`${short(usage.tokens)} tokens`);
+        }
+        if (whole) {
+            const quota = quotaFor(router, slots[0], now);
+            if (quota) {
+                head.push(quota.remaining <= 0 ? pc.red(quota.text) : quota.text);
+            }
+            const until = slots.map((slot) => pausedUntil(router, slot, now)).find((value) => value !== null);
+            if (until) {
+                head.push(pc.yellow(`en pausa hasta ${clock(until, now)}`));
+            }
+        }
+        lines.push(head.join(" · "));
+        const width = Math.min(40, Math.max(...shown.map((slot) => slot.model.id.length)));
+        for (const slot of shown) {
+            const parts = [`  ${slot.model.id.padEnd(width)}  ${plural(usage?.models[slot.model.id] || 0, "petición", "peticiones")}`];
+            if (!whole) {
+                const quota = quotaFor(router, slot, now);
+                if (quota) {
+                    parts.push(quota.remaining <= 0 ? pc.red(quota.text) : quota.text);
+                }
+                const until = pausedUntil(router, slot, now);
+                if (until) {
+                    parts.push(pc.yellow(`en pausa hasta ${clock(until, now)}`));
+                }
+            }
+            const tokens = fromHeaders(router.limits[slot.key]?.tokens, now, " tokens");
+            if (tokens) {
+                parts.push(pc.dim(tokens.text));
+            }
+            lines.push(parts.join(" · "));
+        }
+        if (provider.freeInfo) {
+            lines.push(pc.dim(`  ${provider.freeInfo}`));
+        }
+    }
+    if (unused.length > 0) {
+        lines.push("", `Sin usar hoy: ${unused.join(", ")}`);
+    }
+    lines.push("", pc.dim("«quedan» es lo que dice el proveedor; «≈ quedan», la cuenta de vipcode con los límites de su plan gratis, contando solo lo que ha pedido vipcode en este ordenador."));
+    return lines.join("\n");
+}

package/dist/login.js

@@ -2,11 +2,13 @@ import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import http from "node:http";
 import { debugLog } from "./debug.js";
-// Abre una dirección en el navegador. VIPCODE_BROWSER permite usar otro comando ("firefox", "echo"…)
+import { splitArgs } from "./shell.js";
+// Abre una dirección en el navegador. VIPCODE_BROWSER permite usar otro comando ("firefox", "echo"…);
+// con comillas si la ruta lleva espacios: "C:\Program Files\Mozilla Firefox\firefox.exe"
 export function openBrowser(url) {
     let command;
     let args;
-    const custom = (process.env.VIPCODE_BROWSER || "").split(/\s+/).filter(Boolean);
+    const custom = splitArgs(process.env.VIPCODE_BROWSER || "");
     if (custom.length > 0) {
         [command, ...args] = custom;
         args.push(url);

package/dist/lsp.js

@@ -1,9 +1,9 @@
-import { spawn } from "node:child_process";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { debugLog } from "./debug.js";
+import { killTree, spawnProgram } from "./shell.js";
 const LANGUAGE_IDS = {
     ".ts": "typescript", ".tsx": "typescriptreact", ".mts": "typescript", ".cts": "typescript",
     ".js": "javascript", ".jsx": "javascriptreact", ".mjs": "javascript", ".cjs": "javascript",
@@ -107,10 +107,12 @@ class LspClient {
     constructor(spec, command, root) {
         this.spec = spec;
         this.root = root;
-        this.child = spawn(command[0], command.slice(1), {
+        // En Windows muchos servidores son .cmd (instalados con npm)
+        this.child = spawnProgram(command[0], command.slice(1), {
             cwd: root,
             env: { ...process.env, ...(spec.env || {}) },
             stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
         });
         this.child.on("error", (err) => {
             debugLog("lsp error", spec.id, err);
@@ -293,9 +295,10 @@ class LspClient {
         return this.published.get(key)?.items || [];
     }
     async shutdown() {
-        if (this.dead) {
+        if (this.dead || this.child.exitCode !== null) {
             return;
         }
+        const exited = new Promise((resolve) => this.child.once("exit", () => resolve()));
         try {
             await this.request("shutdown", null, 1500);
             this.notify("exit", null);
@@ -303,11 +306,14 @@ class LspClient {
         catch {
             // si no contesta, lo matamos
         }
-        setTimeout(() => {
+        const timer = setTimeout(() => {
             if (!this.dead) {
-                this.child.kill("SIGTERM");
+                killTree(this.child);
             }
-        }, 300).unref();
+        }, 300);
+        // Hasta que no termina no acabamos: en Windows la carpeta del proyecto sigue ocupada mientras viva
+        await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, 2000).unref())]);
+        clearTimeout(timer);
     }
 }
 function toDiagnostic(item) {
@@ -434,7 +440,8 @@ export class LspManager {
         if (relevant.length === 0) {
             return "";
         }
-        const name = path.relative(this.root, file);
+        // Con / también en Windows, como el resto de rutas que ve el modelo
+        const name = path.relative(this.root, file).split(path.sep).join("/");
         const lines = relevant.slice(0, 20).map((item) => {
             const code = item.code ? ` ${item.source || ""}${item.code}` : "";
             return `${name}:${item.line}:${item.column} ${SEVERITY[item.severity] || "error"}${code}: ${item.message}`;

package/dist/paths.js

@@ -44,6 +44,14 @@ export const INSTALL_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.u
 // Lo que el agente no puede tocar: los datos de vipcode (claves, configuración, carpetas de confianza) ni leerlos,
 // y su propio código no modificarlo. Quien desarrolle vipcode con vipcode puede permitir lo segundo con
 // VIPCODE_ALLOW_SELF_EDIT=1.
+// macOS y Windows no distinguen mayúsculas en las rutas: ~/.VIPCODE es la misma carpeta que ~/.vipcode
+const FOLD_CASE = process.platform === "darwin" || process.platform === "win32";
+// true si file es dir o está dentro de dir
+export function isInside(file, dir) {
+    const a = FOLD_CASE ? file.toLowerCase() : file;
+    const b = FOLD_CASE ? dir.toLowerCase() : dir;
+    return a === b || a.startsWith(b.endsWith(path.sep) ? b : b + path.sep);
+}
 export function protectedDirs() {
     const dirs = [{ dir: HOME_DIR, read: true }];
     if (process.env.VIPCODE_ALLOW_SELF_EDIT !== "1") {

package/dist/permissions.js

@@ -119,13 +119,23 @@ export class SessionGrants {
 // Un comando que nombra la carpeta de datos de vipcode o su instalación (para leer tus claves, cambiar la
 // configuración o tocar su propio código) se pregunta siempre: no vale ninguna regla allow ni «sí a todo»
 export function touchesVipcode(command) {
+    // Sin distinguir mayúsculas (macOS y Windows no las distinguen) ni / de \ (en Windows valen las dos)
+    const normalize = (text) => text.replace(/\\/g, "/").toLowerCase();
     const home = os.homedir();
-    const names = [HOME_DIR, INSTALL_DIR, "lib/node_modules/vipcode"];
-    if (HOME_DIR.startsWith(home + path.sep)) {
+    const names = [HOME_DIR, INSTALL_DIR, "node_modules/vipcode"];
+    if (normalize(HOME_DIR).startsWith(normalize(home + path.sep))) {
         const inHome = HOME_DIR.slice(home.length + 1);
-        names.push(`~/${inHome}`, `$HOME/${inHome}`, `\${HOME}/${inHome}`);
+        for (const prefix of ["~", "$HOME", "${HOME}", "%USERPROFILE%", "$env:USERPROFILE", "${env:USERPROFILE}"]) {
+            names.push(`${prefix}/${inHome}`);
+        }
     }
-    return names.some((name) => command.includes(name));
+    const text = normalize(command);
+    return names.some((name) => {
+        const clean = normalize(name);
+        // C:\Users\… también se escribe /c/Users/… en el bash de Git para Windows
+        const msys = /^[a-z]:\//.test(clean) ? `/${clean[0]}${clean.slice(2)}` : null;
+        return text.includes(clean) || (msys !== null && text.includes(msys));
+    });
 }
 export function createAsker(getConfig, grants, prompt) {
     return async (request) => {

package/dist/prompt.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import fg from "fast-glob";
 import { GLOBAL_INSTRUCTIONS_PATH } from "./paths.js";
+import { commandShell } from "./shell.js";
 function readLimited(file, max = 15000) {
     try {
         return fs.readFileSync(file, "utf8").slice(0, max);
@@ -40,7 +41,7 @@ function projectInstructions(root, extra) {
                 continue;
             }
             seen.add(file);
-            parts.push(`# Instrucciones (${path.relative(root, file)})\n${readLimited(file, 8000)}`);
+            parts.push(`# Instrucciones (${path.relative(root, file).split(path.sep).join("/")})\n${readLimited(file, 8000)}`);
         }
     }
     if (parts.length === 0) {
@@ -49,6 +50,20 @@ function projectInstructions(root, extra) {
     return `\n\n${parts.join("\n\n")}`;
 }
 // Lo que hay en la raíz del proyecto, para que el modelo se oriente sin gastar una llamada
+// Para que el modelo escriba los comandos en el idioma de la shell que hay de verdad
+function shellLine() {
+    const shell = commandShell();
+    if (shell.name === "PowerShell") {
+        return "PowerShell (write PowerShell commands, not bash)";
+    }
+    if (shell.name === "cmd") {
+        return "cmd.exe (write Windows cmd commands, not bash)";
+    }
+    if (shell.name === "Git Bash") {
+        return "Git Bash on Windows (bash syntax; Windows tools like npm, node and git work as usual)";
+    }
+    return shell.name;
+}
 function topLevel(root) {
     try {
         const entries = fs
@@ -118,6 +133,7 @@ Environment:
 - Working directory: ${root}
 - Git repository: ${isGit}
 - Platform: ${process.platform}
+- Shell for the bash tool: ${shellLine()}
 - Date: ${new Date().toISOString().slice(0, 10)}
 - Top-level entries: ${topLevel(root)}${projectInstructions(root, options.instructions)}`;
 }

package/dist/router.js

@@ -222,6 +222,76 @@ function prepareMessages(slot, messages) {
         return { ...message, tool_calls: toolCalls };
     });
 }
+function utcDay(time = Date.now()) {
+    return new Date(time).toISOString().slice(0, 10);
+}
+const HOUR_MS = 60 * 60 * 1000;
+// Cuándo se recupera un límite: segundos que faltan ("33011.38"), duración ("2m59.56s") o fecha en segundos o milisegundos
+function parseReset(value, now) {
+    if (!value) {
+        return null;
+    }
+    const text = value.trim();
+    if (/^\d+(\.\d+)?$/.test(text)) {
+        const n = Number(text);
+        if (n > 1e12) {
+            return n;
+        }
+        if (n > 1e9) {
+            return n * 1000;
+        }
+        return now + n * 1000;
+    }
+    const ms = parseDuration(text);
+    if (ms > 0) {
+        return now + ms;
+    }
+    const date = Date.parse(text);
+    return Number.isNaN(date) ? null : date;
+}
+// Las cabeceras x-ratelimit-* de una respuesta (o de un error): peticiones y tokens que quedan
+export function readLimitHeaders(headers, provider, now = Date.now()) {
+    if (!headers || typeof headers !== "object") {
+        return null;
+    }
+    const get = (name) => {
+        const h = headers;
+        if (typeof h.get === "function") {
+            return h.get(name);
+        }
+        const value = h[name] ?? h[name.toLowerCase()];
+        return typeof value === "string" ? value : null;
+    };
+    const read = (sets) => {
+        for (const [base, period] of sets) {
+            const remaining = get(`x-ratelimit-remaining${base}`);
+            if (remaining === null || remaining.trim() === "" || Number.isNaN(Number(remaining))) {
+                continue;
+            }
+            const limit = get(`x-ratelimit-limit${base}`);
+            return {
+                limit: limit !== null && !Number.isNaN(Number(limit)) ? Number(limit) : null,
+                remaining: Number(remaining),
+                resetAt: parseReset(get(`x-ratelimit-reset${base}`), now),
+                period,
+            };
+        }
+        return undefined;
+    };
+    const requests = read([
+        ["-requests-day", "day"],
+        ["-requests", provider.rateHeaders?.requests ?? null],
+        ["", null],
+    ]);
+    const tokens = read([
+        ["-tokens-minute", "minute"],
+        ["-tokens", provider.rateHeaders?.tokens ?? null],
+    ]);
+    if (!requests && !tokens) {
+        return null;
+    }
+    return { at: now, requests, tokens };
+}
 export class Router {
     config;
     ranking;
@@ -230,6 +300,10 @@ export class Router {
     cooldowns = {};
     unsupported = {};
     noStreamUsage = {};
+    // Para /limites (se guardan en state.json con las pausas)
+    usage = { day: utcDay(), providers: {} };
+    limits = {};
+    recent = {};
     // Slots descartados durante esta ejecución (clave mala…)
     skipped = new Set();
     // Si no es null, se usa ese slot primero
@@ -330,6 +404,11 @@ export class Router {
             this.cooldowns = data.cooldowns || {};
             this.unsupported = data.unsupported || {};
             this.noStreamUsage = data.noStreamUsage || {};
+            if (data.usage?.day === utcDay() && data.usage.providers) {
+                this.usage = data.usage;
+            }
+            this.limits = data.limits || {};
+            this.recent = data.recent || {};
         }
         catch {
             this.cooldowns = {};
@@ -347,8 +426,27 @@ export class Router {
                 }
             }
         }
+        // Lo que dijeron los proveedores hace más de dos días ya no sirve
+        for (const [key, snapshot] of Object.entries(this.limits)) {
+            if (now - snapshot.at > 2 * DAY_MS) {
+                delete this.limits[key];
+            }
+        }
+        for (const [name, times] of Object.entries(this.recent)) {
+            this.recent[name] = times.filter((time) => now - time < HOUR_MS);
+            if (this.recent[name].length === 0) {
+                delete this.recent[name];
+            }
+        }
         try {
-            const state = { cooldowns: this.cooldowns, unsupported: this.unsupported, noStreamUsage: this.noStreamUsage };
+            const state = {
+                cooldowns: this.cooldowns,
+                unsupported: this.unsupported,
+                noStreamUsage: this.noStreamUsage,
+                usage: this.usage,
+                limits: this.limits,
+                recent: this.recent,
+            };
             fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
         }
         catch {
@@ -361,6 +459,36 @@ export class Router {
         }
         this.saveState();
     }
+    // Uso de hoy (si ha cambiado el día, empieza de cero)
+    today() {
+        if (this.usage.day !== utcDay()) {
+            this.usage = { day: utcDay(), providers: {} };
+        }
+        return this.usage;
+    }
+    countRequest(slot) {
+        const day = this.today();
+        const entry = (day.providers[slot.provider.name] ??= { requests: 0, tokens: 0, models: {} });
+        entry.requests++;
+        entry.models[slot.model.id] = (entry.models[slot.model.id] || 0) + 1;
+        const now = Date.now();
+        const times = (this.recent[slot.provider.name] || []).filter((time) => now - time < HOUR_MS);
+        times.push(now);
+        // Basta con saber cuántas van en la última hora; más de 1.000 no hace falta guardarlas
+        this.recent[slot.provider.name] = times.slice(-1000);
+    }
+    countTokens(slot, usage) {
+        const entry = this.today().providers[slot.provider.name];
+        if (entry && usage) {
+            entry.tokens += usage.prompt + usage.completion;
+        }
+    }
+    noteLimits(slot, headers) {
+        const snapshot = readLimitHeaders(headers, slot.provider);
+        if (snapshot) {
+            this.limits[slot.key] = snapshot;
+        }
+    }
     slotFor(key) {
         return this.slots.find((slot) => slot.key === key);
     }
@@ -512,6 +640,7 @@ export class Router {
             const slot = list[0];
             let streamedText = false;
             handlers.onAttempt?.(slot.key);
+            this.countRequest(slot);
             try {
                 const result = await this.streamOnce(slot, { ...request, messages }, signal, {
                     onText: (text) => {
@@ -524,10 +653,14 @@ export class Router {
                     handlers.onNotice?.(`usando ${slot.key}`);
                 }
                 this.lastSlot = slot;
+                this.countTokens(slot, result.usage);
+                this.saveState();
                 return { ...result, slot };
             }
             catch (err) {
+                this.noteLimits(slot, err?.headers);
                 if (isAbort(err, signal)) {
+                    this.saveState();
                     throw err;
                 }
                 const info = classify(err);
@@ -583,6 +716,7 @@ export class Router {
                     excluded.add(slot.key);
                     action = "pruebo otro";
                 }
+                this.saveState();
                 let prefix = "";
                 if (streamedText) {
                     prefix = "\n";
@@ -625,7 +759,10 @@ export class Router {
         const byIndex = new Map();
         const byId = new Map();
         try {
-            const stream = (await slot.client.chat.completions.create(params, { signal: combined }));
+            // withResponse para leer las cabeceras: algunos proveedores dicen ahí cuántas peticiones te quedan
+            const { data, response } = await slot.client.chat.completions.create(params, { signal: combined }).withResponse();
+            this.noteLimits(slot, response.headers);
+            const stream = data;
             for await (const chunk of stream) {
                 bump();
                 // Algunos proveedores mandan el error dentro del stream