opencode-antigravity-img 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.0] - 2026-02-14
+
+### Added
+- Round-robin account selection for multi-account setups (least-recently-used first)
+- Auto-retry with next account on any failure (rate-limit, auth, project ID errors)
+- Rate-limit tracking with 5-minute cooldown per account
+- Per-account quota breakdown in `image_quota` for multi-account configurations
+- Graceful error summary listing each account and its failure reason
+- `/antigravity-quota-img` command for opencode
+- Unit tests for account selection logic (15 test cases)
+
+### Changed
+- Account state (`lastUsed`, `rateLimitedUntil`) persisted to `antigravity-accounts.json`
+- Single-account users see no behavior change
+- Fix command directory from `commands/` to `command/` (matching opencode convention)
+- Command files now include YAML frontmatter with description
+
 ## [0.2.1] - 2026-01-28
 
 ### Fixed

package/README.md

@@ -33,6 +33,22 @@ opencode
 
 This creates `antigravity-accounts.json` in your opencode config directory.
 
+### Multi-Account Setup
+
+You can add multiple Google accounts for higher throughput and automatic failover:
+
+```bash
+opencode auth login  # repeat for each Google account
+```
+
+With multiple accounts the plugin will:
+- **Round-robin** between accounts, picking the least-recently-used one
+- **Auto-retry** with the next account if one fails (rate-limit, auth error, etc.)
+- **Track cooldowns** so rate-limited accounts are skipped for 5 minutes
+- **Show per-account quota** via the `image_quota` tool
+
+Single-account users see no behavior change.
+
 ## Tools
 
 ### generate_image
@@ -61,10 +77,15 @@ Check the remaining quota for the Gemini 3 Pro Image model.
 
 **Arguments:** None
 
-**Output:**
+**Output (single account):**
 - Visual progress bar showing remaining quota percentage
 - Time until quota resets
 
+**Output (multi-account):**
+- Per-account progress bars with quota percentage
+- Rate-limit status per account
+- Time until reset for each account
+
 ## Image Details
 
 - **Model**: Gemini 3 Pro Image
@@ -88,7 +109,9 @@ These parameters may work with Imagen models but have no effect with Gemini 3 Pr
 
 ## Quota
 
-Image generation uses a separate quota from text models. The quota resets every 5 hours. Use the `image_quota` tool to check your remaining quota.
+Image generation uses a separate quota from text models. The quota resets every 5 hours. Use the `image_quota` tool (or the `/antigravity-quota-img` command) to check your remaining quota.
+
+With multiple accounts, each account has its own independent quota. The plugin automatically rotates to the account with the most available quota.
 
 ## Troubleshooting
 
@@ -101,9 +124,10 @@ Make sure you've:
 
 ### "Rate limited" or generation fails
 
-- Wait a few seconds and try again
-- Check your quota with `image_quota`
-- The plugin automatically tries multiple endpoints
+- With multiple accounts, the plugin automatically retries with the next available account
+- Check your quota with `image_quota` to see per-account status
+- If all accounts are exhausted, wait a few minutes for cooldowns to expire
+- The plugin also tries multiple API endpoints per account
 
 ### Slow generation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-antigravity-img",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "OpenCode plugin for Gemini image generation via Antigravity/CloudCode API",
   "main": "src/index.ts",
   "type": "module",

package/src/accounts.test.ts

@@ -0,0 +1,165 @@
+import { describe, expect, test } from "bun:test";
+import { selectAccount, markUsed, markRateLimited, RATE_LIMIT_COOLDOWN_MS } from "./accounts";
+import type { AccountsConfig } from "./types";
+
+// Helper to build a config with N accounts
+function makeConfig(count: number, overrides?: Partial<Record<string, any>>[]): AccountsConfig {
+  const accounts = Array.from({ length: count }, (_, i) => ({
+    email: `user${i + 1}@test.com`,
+    refreshToken: `token_${i + 1}`,
+    ...((overrides && overrides[i]) || {}),
+  }));
+  return { accounts };
+}
+
+// -- selectAccount ---------------------------------------------------------
+
+describe("selectAccount", () => {
+  test("returns null for empty accounts", () => {
+    const config: AccountsConfig = { accounts: [] };
+    expect(selectAccount(config)).toBeNull();
+  });
+
+  test("returns the only account when single", () => {
+    const config = makeConfig(1);
+    const result = selectAccount(config);
+    expect(result?.email).toBe("user1@test.com");
+  });
+
+  test("returns the least-recently-used account", () => {
+    const config = makeConfig(3, [
+      { lastUsed: 300 },
+      { lastUsed: 100 }, // oldest
+      { lastUsed: 200 },
+    ]);
+    const result = selectAccount(config);
+    expect(result?.email).toBe("user2@test.com");
+  });
+
+  test("never-used accounts (no lastUsed) get top priority", () => {
+    const config = makeConfig(3, [
+      { lastUsed: 100 },
+      {}, // never used
+      { lastUsed: 200 },
+    ]);
+    const result = selectAccount(config);
+    expect(result?.email).toBe("user2@test.com");
+  });
+
+  test("skips rate-limited accounts", () => {
+    const now = 1000;
+    const config = makeConfig(3, [
+      { rateLimitedUntil: now + 60000 }, // rate-limited
+      { lastUsed: 500 },
+      { lastUsed: 200 }, // oldest non-limited
+    ]);
+    const result = selectAccount(config, [], now);
+    expect(result?.email).toBe("user3@test.com");
+  });
+
+  test("rate-limited accounts with expired cooldown are available", () => {
+    const now = 1000;
+    const config = makeConfig(2, [
+      { rateLimitedUntil: now - 1 }, // expired, available again
+      { lastUsed: 500 },
+    ]);
+    const result = selectAccount(config, [], now);
+    expect(result?.email).toBe("user1@test.com");
+  });
+
+  test("skips excluded emails", () => {
+    const config = makeConfig(3);
+    const result = selectAccount(config, ["user1@test.com", "user2@test.com"]);
+    expect(result?.email).toBe("user3@test.com");
+  });
+
+  test("returns null when all accounts are excluded", () => {
+    const config = makeConfig(2);
+    const result = selectAccount(config, ["user1@test.com", "user2@test.com"]);
+    expect(result).toBeNull();
+  });
+
+  test("returns null when all accounts are rate-limited", () => {
+    const now = 1000;
+    const config = makeConfig(2, [
+      { rateLimitedUntil: now + 60000 },
+      { rateLimitedUntil: now + 60000 },
+    ]);
+    const result = selectAccount(config, [], now);
+    expect(result).toBeNull();
+  });
+
+  test("round-robin: sequential calls rotate through accounts", () => {
+    const config = makeConfig(3);
+
+    // First call: all unused, picks first in array (all have lastUsed 0)
+    const first = selectAccount(config);
+    expect(first?.email).toBe("user1@test.com");
+
+    // Simulate marking it used
+    markUsed(config, "user1@test.com", 100);
+
+    // Second call: user1 has lastUsed=100, user2 and user3 are still 0
+    const second = selectAccount(config);
+    expect(second?.email).toBe("user2@test.com");
+
+    markUsed(config, "user2@test.com", 200);
+
+    // Third call: user3 is still unused
+    const third = selectAccount(config);
+    expect(third?.email).toBe("user3@test.com");
+
+    markUsed(config, "user3@test.com", 300);
+
+    // Fourth call: back to user1 (oldest lastUsed)
+    const fourth = selectAccount(config);
+    expect(fourth?.email).toBe("user1@test.com");
+  });
+
+  test("rate-limit + exclude combo: finds next available", () => {
+    const now = 1000;
+    const config = makeConfig(4, [
+      { lastUsed: 10 },                  // excluded
+      { rateLimitedUntil: now + 60000 },  // rate-limited
+      { lastUsed: 30 },                  // available, older
+      { lastUsed: 20 },                  // available, oldest -> picked
+    ]);
+    const result = selectAccount(config, ["user1@test.com"], now);
+    expect(result?.email).toBe("user4@test.com");
+  });
+});
+
+// -- markUsed --------------------------------------------------------------
+
+describe("markUsed", () => {
+  test("sets lastUsed on the matching account", () => {
+    const config = makeConfig(2);
+    markUsed(config, "user2@test.com", 12345);
+    expect(config.accounts[1].lastUsed).toBe(12345);
+    expect(config.accounts[0].lastUsed).toBeUndefined();
+  });
+
+  test("does nothing for unknown email", () => {
+    const config = makeConfig(1);
+    markUsed(config, "unknown@test.com", 999);
+    expect(config.accounts[0].lastUsed).toBeUndefined();
+  });
+});
+
+// -- markRateLimited -------------------------------------------------------
+
+describe("markRateLimited", () => {
+  test("sets rateLimitedUntil with cooldown offset", () => {
+    const config = makeConfig(2);
+    const now = 50000;
+    markRateLimited(config, "user1@test.com", now);
+    expect(config.accounts[0].rateLimitedUntil).toBe(now + RATE_LIMIT_COOLDOWN_MS);
+    expect(config.accounts[1].rateLimitedUntil).toBeUndefined();
+  });
+
+  test("does nothing for unknown email", () => {
+    const config = makeConfig(1);
+    markRateLimited(config, "unknown@test.com", 999);
+    expect(config.accounts[0].rateLimitedUntil).toBeUndefined();
+  });
+});

package/src/accounts.ts

@@ -0,0 +1,51 @@
+import type { AccountsConfig, Account } from "./types";
+
+export const MAX_RETRIES = 3;
+export const RATE_LIMIT_COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Select the least-recently-used account that is not rate-limited or excluded.
+ * Returns null if no account is available.
+ */
+export function selectAccount(
+  config: AccountsConfig,
+  excludeEmails: string[] = [],
+  now: number = Date.now()
+): Account | null {
+  const available = config.accounts.filter((a) => {
+    if (excludeEmails.includes(a.email)) return false;
+    if (a.rateLimitedUntil && a.rateLimitedUntil > now) return false;
+    return true;
+  });
+
+  if (available.length === 0) return null;
+
+  // Least recently used first (never-used accounts get top priority)
+  available.sort((a, b) => (a.lastUsed || 0) - (b.lastUsed || 0));
+
+  return available[0];
+}
+
+/**
+ * Mark an account as recently used (mutates in place).
+ */
+export function markUsed(config: AccountsConfig, email: string, now: number = Date.now()): void {
+  const account = config.accounts.find((a) => a.email === email);
+  if (account) {
+    account.lastUsed = now;
+  }
+}
+
+/**
+ * Mark an account as rate-limited with a cooldown (mutates in place).
+ */
+export function markRateLimited(
+  config: AccountsConfig,
+  email: string,
+  now: number = Date.now()
+): void {
+  const account = config.accounts.find((a) => a.email === email);
+  if (account) {
+    account.rateLimitedUntil = now + RATE_LIMIT_COOLDOWN_MS;
+  }
+}

package/src/api.ts

@@ -213,6 +213,8 @@ export async function generateImage(
     };
 
     // Try each endpoint
+    let allRateLimited = true;
+
     for (const baseUrl of CLOUDCODE_FALLBACK_URLS) {
       try {
         const controller = new AbortController();
@@ -239,10 +241,13 @@ export async function generateImage(
             // Rate limited, try next endpoint
             continue;
           }
+          allRateLimited = false;
           const errorText = await response.text();
           return { success: false, error: `HTTP ${response.status}: ${errorText.slice(0, 200)}` };
         }
 
+        allRateLimited = false;
+
         // Parse SSE response
         const text = await response.text();
         const result = parseSSEResponse(text);
@@ -264,6 +269,7 @@ export async function generateImage(
 
         return result;
       } catch (err) {
+        allRateLimited = false;
         if (err instanceof Error && err.name === "AbortError") {
           continue; // Timeout, try next endpoint
         }
@@ -272,7 +278,7 @@ export async function generateImage(
       }
     }
 
-    return { success: false, error: "All endpoints failed" };
+    return { success: false, error: "All endpoints failed", isRateLimited: allRateLimited };
   } catch (error) {
     return {
       success: false,

package/src/constants.ts

@@ -40,13 +40,31 @@ export const CONFIG_PATHS = [
   join(homedir(), ".opencode", "antigravity-accounts.json"),
 ];
 
-// Command file for opencode discovery
-export const COMMAND_DIR = join(getConfigDir(), "commands");
+// Command files for opencode discovery (opencode uses "command" singular)
+export const COMMAND_DIR = join(getConfigDir(), "command");
+
 export const COMMAND_FILE = join(COMMAND_DIR, "generate-image.md");
-export const COMMAND_CONTENT = `# Generate Image
+export const COMMAND_CONTENT = `---
+description: Generate an image using Gemini 3 Pro Image model
+---
 
 Generate an image using Gemini 3 Pro Image model.
 
 Prompt: $PROMPT
 Output filename (optional): $FILENAME
 `;
+
+export const QUOTA_COMMAND_FILE = join(COMMAND_DIR, "antigravity-quota-img.md");
+export const QUOTA_COMMAND_CONTENT = `---
+description: Check Antigravity image generation quota for all configured accounts
+---
+
+Use the \`image_quota\` tool to check the current image generation quota status.
+
+This will show:
+- Gemini 3 Pro Image quota remaining per account
+- Visual progress bars for each account
+- Time until quota reset
+
+IMPORTANT: Display the tool output EXACTLY as it is returned. Do not summarize, reformat, or modify the output in any way.
+`;

package/src/index.ts

@@ -1,10 +1,11 @@
 import { type Plugin, tool } from "@opencode-ai/plugin";
 import * as fs from "fs/promises";
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
-import { CONFIG_PATHS, COMMAND_DIR, COMMAND_FILE, COMMAND_CONTENT, IMAGE_MODEL } from "./constants";
+import { CONFIG_PATHS, COMMAND_DIR, COMMAND_FILE, COMMAND_CONTENT, QUOTA_COMMAND_FILE, QUOTA_COMMAND_CONTENT, IMAGE_MODEL } from "./constants";
 import type { AccountsConfig, Account, ImageGenerationOptions, AspectRatio, ImageSize } from "./types";
 import { generateImage, getImageModelQuota } from "./api";
+import { selectAccount, markUsed, markRateLimited, MAX_RETRIES, RATE_LIMIT_COOLDOWN_MS } from "./accounts";
 
 // Create command file for opencode discovery
 try {
@@ -14,10 +15,16 @@ try {
   if (!existsSync(COMMAND_FILE)) {
     writeFileSync(COMMAND_FILE, COMMAND_CONTENT, "utf-8");
   }
+  if (!existsSync(QUOTA_COMMAND_FILE)) {
+    writeFileSync(QUOTA_COMMAND_FILE, QUOTA_COMMAND_CONTENT, "utf-8");
+  }
 } catch {
   // Non-fatal if command file creation fails
 }
 
+// Track which config file was loaded so we can write back to it
+let loadedConfigPath: string | null = null;
+
 /**
  * Load accounts from config file
  */
@@ -26,6 +33,7 @@ async function loadAccounts(): Promise<AccountsConfig | null> {
     if (existsSync(configPath)) {
       try {
         const content = await fs.readFile(configPath, "utf-8");
+        loadedConfigPath = configPath;
         return JSON.parse(content) as AccountsConfig;
       } catch {
         continue;
@@ -36,12 +44,31 @@ async function loadAccounts(): Promise<AccountsConfig | null> {
 }
 
 /**
- * Get the first available account
+ * Save accounts config back to the file it was loaded from
  */
-async function getAccount(): Promise<Account | null> {
-  const config = await loadAccounts();
-  if (!config?.accounts?.length) return null;
-  return config.accounts[0] || null;
+async function saveAccounts(config: AccountsConfig): Promise<void> {
+  const savePath = loadedConfigPath || CONFIG_PATHS[0];
+  const dirPath = dirname(savePath);
+  if (!existsSync(dirPath)) {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+  await fs.writeFile(savePath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+/**
+ * Mark an account as recently used and persist to disk
+ */
+async function markAccountUsed(config: AccountsConfig, email: string): Promise<void> {
+  markUsed(config, email);
+  await saveAccounts(config);
+}
+
+/**
+ * Mark an account as rate-limited with a cooldown and persist to disk
+ */
+async function markAccountRateLimited(config: AccountsConfig, email: string): Promise<void> {
+  markRateLimited(config, email);
+  await saveAccounts(config);
 }
 
 /**
@@ -100,9 +127,9 @@ export const plugin: Plugin = async (ctx) => {
             return "Error: Please provide a prompt describing the image to generate.";
           }
 
-          // Get account
-          const account = await getAccount();
-          if (!account) {
+          // Load all accounts
+          const config = await loadAccounts();
+          if (!config?.accounts?.length) {
             return (
               "Error: No Antigravity account found.\n\n" +
               "Please install and configure opencode-antigravity-auth first:\n" +
@@ -118,51 +145,87 @@ export const plugin: Plugin = async (ctx) => {
           const options: ImageGenerationOptions = {};
           if (aspect_ratio) options.aspectRatio = aspect_ratio as AspectRatio;
           if (image_size) options.imageSize = image_size as ImageSize;
+          const genOptions = Object.keys(options).length > 0 ? options : undefined;
 
-          // Generate image
-          const result = await generateImage(account, prompt, Object.keys(options).length > 0 ? options : undefined);
+          // Retry loop: rotate through accounts on any failure
+          const excludeEmails: string[] = [];
+          const errors: string[] = [];
 
-          if (!result.success || !result.imageData) {
-            return `Error generating image: ${result.error || "Unknown error"}`;
-          }
+          for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            const account = selectAccount(config, excludeEmails);
+            if (!account) break;
 
-          // Determine output path (always JPEG regardless of extension)
-          const dir = output_dir || ctx.directory;
-          const name = filename || `generated_${Date.now()}.jpg`;
-          const outputPath = join(dir, name);
+            const result = await generateImage(account, prompt, genOptions);
 
-          // Ensure directory exists
-          const dirPath = dirname(outputPath);
-          if (!existsSync(dirPath)) {
-            await fs.mkdir(dirPath, { recursive: true });
-          }
+            if (result.success && result.imageData) {
+              // Mark account as used for round-robin rotation
+              await markAccountUsed(config, account.email);
 
-          // Decode and save image
-          const imageBuffer = Buffer.from(result.imageData, "base64");
-          await fs.writeFile(outputPath, imageBuffer);
+              // Determine output path (always JPEG regardless of extension)
+              const dir = output_dir || ctx.directory;
+              const name = filename || `generated_${Date.now()}.jpg`;
+              const outputPath = join(dir, name);
 
-          const sizeStr = formatSize(imageBuffer.length);
+              // Ensure directory exists
+              const outDir = dirname(outputPath);
+              if (!existsSync(outDir)) {
+                await fs.mkdir(outDir, { recursive: true });
+              }
 
-          context.metadata({
-            title: "Image generated",
-            metadata: {
-              path: outputPath,
-              size: sizeStr,
-              format: result.mimeType,
-            },
-          });
+              // Decode and save image
+              const imageBuffer = Buffer.from(result.imageData, "base64");
+              await fs.writeFile(outputPath, imageBuffer);
+
+              const sizeStr = formatSize(imageBuffer.length);
+              const totalAccounts = config.accounts.length;
+              const usedLabel = totalAccounts > 1 ? ` (account: ${account.email})` : "";
+
+              context.metadata({
+                title: "Image generated",
+                metadata: {
+                  path: outputPath,
+                  size: sizeStr,
+                  format: result.mimeType,
+                },
+              });
 
-          // Build response
-          let response = `Image generated successfully!\n\n`;
-          response += `Path: ${outputPath}\n`;
-          response += `Size: ${sizeStr}\n`;
-          response += `Format: ${result.mimeType}\n`;
+              // Build response
+              let response = `Image generated successfully!${usedLabel}\n\n`;
+              response += `Path: ${outputPath}\n`;
+              response += `Size: ${sizeStr}\n`;
+              response += `Format: ${result.mimeType}\n`;
 
-          if (result.quota) {
-            response += `\nQuota: ${formatQuota(result.quota.remainingPercent)} remaining`;
+              if (result.quota) {
+                response += `\nQuota: ${formatQuota(result.quota.remainingPercent)} remaining`;
+              }
+
+              return response;
+            }
+
+            // Rate-limited: mark with cooldown so future calls skip it too
+            if (result.isRateLimited) {
+              await markAccountRateLimited(config, account.email);
+            }
+
+            // Any failure: log it and try the next account
+            const reason = result.isRateLimited ? "rate-limited" : (result.error || "unknown error");
+            errors.push(`${account.email}: ${reason}`);
+            excludeEmails.push(account.email);
           }
 
-          return response;
+          // All accounts failed -- build a helpful summary
+          let msg = "Error: Image generation failed.\n\n";
+          if (errors.length > 0) {
+            msg += "Accounts tried:\n";
+            msg += errors.map((e) => `  - ${e}`).join("\n") + "\n\n";
+          } else {
+            msg += "No accounts available to try.\n\n";
+          }
+          msg += "Possible fixes:\n";
+          msg += "  - If rate-limited, wait a few minutes for quota to reset\n";
+          msg += "  - If project ID errors, open the Antigravity IDE once with that Google account\n";
+          msg += "  - Run image_quota to check account status";
+          return msg;
         },
       }),
 
@@ -175,8 +238,8 @@ export const plugin: Plugin = async (ctx) => {
           "Shows percentage remaining and time until reset.",
         args: {},
         async execute(args, context) {
-          const account = await getAccount();
-          if (!account) {
+          const config = await loadAccounts();
+          if (!config?.accounts?.length) {
             return (
               "Error: No Antigravity account found.\n" +
               "Please configure opencode-antigravity-auth first."
@@ -185,35 +248,62 @@ export const plugin: Plugin = async (ctx) => {
 
           context.metadata({ title: "Checking quota..." });
 
-          const quota = await getImageModelQuota(account);
+          const accounts = config.accounts;
+          const isSingle = accounts.length === 1;
 
-          if (!quota) {
-            return "Error: Could not fetch quota information.";
-          }
+          // Single account: keep the original compact output
+          if (isSingle) {
+            const quota = await getImageModelQuota(accounts[0]);
+            if (!quota) return "Error: Could not fetch quota information.";
 
-          context.metadata({
-            title: "Quota",
-            metadata: {
-              remaining: `${quota.remainingPercent.toFixed(0)}%`,
-              resetIn: quota.resetIn,
-            },
-          });
+            context.metadata({
+              title: "Quota",
+              metadata: {
+                remaining: `${quota.remainingPercent.toFixed(0)}%`,
+                resetIn: quota.resetIn,
+              },
+            });
+
+            const barWidth = 20;
+            const filled = Math.round((quota.remainingPercent / 100) * barWidth);
+            const bar = "#".repeat(filled) + ".".repeat(barWidth - filled);
+
+            let response = `${quota.modelName}\n\n`;
+            response += `[${bar}] ${quota.remainingPercent.toFixed(0)}% remaining\n`;
+            response += `Resets in: ${quota.resetIn}`;
+            if (quota.resetTime) {
+              const resetDate = new Date(quota.resetTime);
+              response += ` (at ${resetDate.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })})`;
+            }
+            return response;
+          }
 
-          // Visual progress bar
-          const barWidth = 20;
-          const filled = Math.round((quota.remainingPercent / 100) * barWidth);
-          const empty = barWidth - filled;
-          const bar = "#".repeat(filled) + ".".repeat(empty);
+          // Multi-account: show per-account breakdown
+          let response = `Image quota -- ${accounts.length} accounts\n\n`;
+          const now = Date.now();
 
-          let response = `${quota.modelName}\n\n`;
-          response += `[${bar}] ${quota.remainingPercent.toFixed(0)}% remaining\n`;
-          response += `Resets in: ${quota.resetIn}`;
+          for (const account of accounts) {
+            const quota = await getImageModelQuota(account);
+            const rateLimited = account.rateLimitedUntil && account.rateLimitedUntil > now;
 
-          if (quota.resetTime) {
-            const resetDate = new Date(quota.resetTime);
-            response += ` (at ${resetDate.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })})`;
+            if (quota) {
+              const barWidth = 20;
+              const filled = Math.round((quota.remainingPercent / 100) * barWidth);
+              const bar = "#".repeat(filled) + ".".repeat(barWidth - filled);
+              const flag = rateLimited ? " [rate-limited]" : "";
+              response += `${account.email}${flag}\n`;
+              response += `  [${bar}] ${quota.remainingPercent.toFixed(0)}% -- resets in ${quota.resetIn}\n`;
+            } else {
+              response += `${account.email}\n`;
+              response += `  [error fetching quota]\n`;
+            }
           }
 
+          context.metadata({
+            title: "Quota",
+            metadata: { accounts: String(accounts.length) },
+          });
+
           return response;
         },
       }),

package/src/types.ts

@@ -5,6 +5,8 @@ export interface Account {
   accessToken?: string;
   projectId?: string;
   managedProjectId?: string;
+  lastUsed?: number;
+  rateLimitedUntil?: number;
 }
 
 export interface AccountsConfig {
@@ -105,6 +107,7 @@ export interface ImageGenerationResult {
   mimeType?: string;
   sizeBytes?: number;
   error?: string;
+  isRateLimited?: boolean;
   quota?: {
     remainingPercent: number;
     resetTime: string;