@bto-labs/agy-bridge 0.5.0 → 0.6.0

package/README.md

@@ -89,10 +89,18 @@ On first use the bridge runs `agy models` (cached for the process lifetime) and
 agy never surfaces quota exhaustion in print mode — it silently retries the 429 until its print-timeout, then exits 0 with empty output, which used to look like an indefinite hang. The bridge now watches each run's log file (via `--log-file`) and on `RESOURCE_EXHAUSTED (code 429)`:
 
 1. kills the agy process group immediately (no waiting out the timeout),
-2. parses the reset time ("Resets in 4h24m") into an in-process cooldown registry,
+2. parses the reset time ("Resets in 4h24m") into a cooldown record,
 3. retries the same prompt on the next model in the tool's chain,
 4. skips cooled-down models on all subsequent calls until their quota resets.
 
+Cooldowns are shared **across every concurrent agy-bridge process** on a host, not just
+within one — the bridge runs as a separate process per MCP client/session, and several can
+share the same underlying account's quota. Each model's cooldown deadline is recorded as the
+mtime of a small marker file under `~/.cache/agy-bridge/cooldowns/`, so one process's quota
+hit immediately protects every other concurrent process from retrying the same
+already-exhausted model. A cooldown is never shortened by a later, shorter-duration write
+(e.g. a per-minute rate limit racing a per-day quota on the same model) — only extended.
+
 Failovers are annotated in the response footer (`failover: <model>: quota exhausted (resets in 4h24m)`). Only when every candidate is exhausted does the call fail — in seconds, with reset times listed — instead of hanging.
 
 ### Timeouts and cancellation

package/dist/index.js

@@ -120,11 +120,14 @@ ${available.join("\n")}`
 import { execFile, spawn } from "child_process";
 import { promisify } from "util";
 import { readFile, rm } from "fs/promises";
-import { homedir, tmpdir } from "os";
+import { homedir as homedir2, tmpdir } from "os";
 import { randomUUID } from "crypto";
-import path from "path";
+import path2 from "path";
 
 // src/quota.ts
+import { mkdir, open, stat, utimes } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
 var DEFAULT_COOLDOWN_SEC = 15 * 60;
 var QUOTA_RE = /RESOURCE_EXHAUSTED \(code 429\)/;
 var RESET_RE = /Resets in ((?:\d+h)?(?:\d+m)?(?:\d+s)?)\b/;
@@ -164,29 +167,67 @@ var QuotaError = class extends Error {
   resetSeconds;
   resetText;
 };
+var DEFAULT_COOLDOWN_DIR = path.join(homedir(), ".cache", "agy-bridge", "cooldowns");
+function slugifyModel(model) {
+  return model.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "model";
+}
+async function ensureDir(dir) {
+  try {
+    await mkdir(dir, { recursive: true });
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+}
+function defaultCooldownDeps(dir = DEFAULT_COOLDOWN_DIR) {
+  const filePath = (model) => path.join(dir, `${slugifyModel(model)}.cooldown`);
+  return {
+    async readDeadline(model) {
+      try {
+        return (await stat(filePath(model))).mtimeMs;
+      } catch {
+        return void 0;
+      }
+    },
+    async writeDeadline(model, untilMs) {
+      try {
+        await ensureDir(dir);
+        const file = filePath(model);
+        const handle = await open(file, "a");
+        await handle.close();
+        const when = new Date(untilMs);
+        await utimes(file, when, when);
+      } catch {
+      }
+    }
+  };
+}
 var CooldownRegistry = class {
-  constructor(now = Date.now) {
+  constructor(now = Date.now, deps = defaultCooldownDeps()) {
     this.now = now;
+    this.deps = deps;
   }
   now;
-  until = /* @__PURE__ */ new Map();
-  set(model, resetSeconds) {
-    this.until.set(model, this.now() + (resetSeconds ?? DEFAULT_COOLDOWN_SEC) * 1e3);
+  deps;
+  async set(model, resetSeconds) {
+    const until = this.now() + (resetSeconds ?? DEFAULT_COOLDOWN_SEC) * 1e3;
+    const existing = await this.deps.readDeadline(model);
+    if (existing !== void 0 && existing >= until) return;
+    await this.deps.writeDeadline(model, until);
   }
-  cooling(model) {
-    const t = this.until.get(model);
+  async cooling(model) {
+    const t = await this.deps.readDeadline(model);
     return t !== void 0 && t > this.now();
   }
-  describe(model) {
-    const t = this.until.get(model);
+  async describe(model) {
+    const t = await this.deps.readDeadline(model);
     return formatDuration(t === void 0 ? 0 : (t - this.now()) / 1e3);
   }
 };
 
 // src/runner.ts
 var execFileAsync = promisify(execFile);
-var SESSIONS_FILE = path.join(
-  homedir(),
+var SESSIONS_FILE = path2.join(
+  homedir2(),
   ".gemini",
   "antigravity-cli",
   "cache",
@@ -258,7 +299,7 @@ var defaultDeps = {
   },
   removeLog: (logPath) => rm(logPath, { force: true }),
   readSessionsFile: () => readFile(SESSIONS_FILE, "utf8"),
-  makeLogPath: () => path.join(tmpdir(), `agy-bridge-${process.pid}-${randomUUID()}.log`)
+  makeLogPath: () => path2.join(tmpdir(), `agy-bridge-${process.pid}-${randomUUID()}.log`)
 };
 function buildArgs(req, cfg, logPath) {
   const timeoutSec = req.timeoutSec ?? cfg.timeoutSec;
@@ -383,7 +424,7 @@ async function runAgy(req, cfg, deps = defaultDeps) {
   let sessionId;
   try {
     const map = JSON.parse(await deps.readSessionsFile());
-    sessionId = map[path.resolve(req.cwd)];
+    sessionId = map[path2.resolve(req.cwd)];
   } catch {
     sessionId = void 0;
   }
@@ -391,11 +432,11 @@ async function runAgy(req, cfg, deps = defaultDeps) {
 }
 
 // src/tools.ts
-import path2 from "path";
+import path3 from "path";
 import { z } from "zod";
 var OUTPUT_RULES = "Answer directly with no preamble or closing remarks. Be thorough but concise. Cite file:line for every code-level finding.";
 function resolveFiles(files, cwd) {
-  return files.map((f) => path2.isAbsolute(f) ? f : path2.resolve(cwd, f));
+  return files.map((f) => path3.isAbsolute(f) ? f : path3.resolve(cwd, f));
 }
 var commonShape = {
   cwd: z.string().optional().describe(
@@ -534,8 +575,8 @@ function createToolHandler(tool, cfg, registry, deps = defaultDeps, cooldowns =
       let result;
       let used;
       for (const model of resolution.models) {
-        if (model && cooldowns.cooling(model)) {
-          attempts.push(`${model}: quota cooldown, ${cooldowns.describe(model)} left`);
+        if (model && await cooldowns.cooling(model)) {
+          attempts.push(`${model}: quota cooldown, ${await cooldowns.describe(model)} left`);
           continue;
         }
         try {
@@ -548,7 +589,7 @@ function createToolHandler(tool, cfg, registry, deps = defaultDeps, cooldowns =
           break;
         } catch (err) {
           if (err instanceof QuotaError && model) {
-            cooldowns.set(model, err.resetSeconds);
+            await cooldowns.set(model, err.resetSeconds);
             attempts.push(
               `${model}: quota exhausted${err.resetText ? ` (resets in ${err.resetText})` : ""}`
             );
@@ -599,7 +640,7 @@ function createServer() {
     return stdout;
   });
   const cooldowns = new CooldownRegistry();
-  const server = new McpServer({ name: "agy-bridge", version: "0.5.0" });
+  const server = new McpServer({ name: "agy-bridge", version: "0.6.0" });
   for (const tool of TOOLS) {
     server.registerTool(
       tool.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bto-labs/agy-bridge",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "MCP bridge that lets Claude Code delegate heavy tasks to the Antigravity CLI (agy) — purpose-built tools, model routing with fallback, and multi-turn session continuity.",
   "mcpName": "io.github.bto-labs.agy-bridge",
   "type": "module",