opencode-gemini-auth 1.3.11 → 1.4.1

package/README.md

@@ -47,6 +47,12 @@ Add the plugin to your Opencode configuration file
 
 Once authenticated, Opencode will use your Google account for Gemini requests.
 
+To check your current Gemini Code Assist quota buckets at any time, run:
+
+```bash
+/gquota
+```
+
 ## Configuration
 
 ### Google Cloud Project

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-gemini-auth",
   "module": "index.ts",
-  "version": "1.3.11",
+  "version": "1.4.1",
   "author": "jenslys",
   "repository": "https://github.com/jenslys/opencode-gemini-auth",
   "files": [
@@ -14,7 +14,7 @@
     "update:gemini-cli": "git -C .local/gemini-cli pull --ff-only"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "^1.1.48",
+    "@opencode-ai/plugin": "^1.2.10",
     "@types/bun": "latest"
   },
   "peerDependencies": {

package/src/plugin/project/api.ts

@@ -4,6 +4,7 @@ import {
   FREE_TIER_ID,
   type LoadCodeAssistPayload,
   type OnboardUserPayload,
+  type RetrieveUserQuotaResponse,
   ProjectIdRequiredError,
 } from "./types";
 import { buildMetadata, isVpcScError, parseJsonSafe, wait } from "./utils";
@@ -131,14 +132,6 @@ export async function onboardManagedProject(
   return undefined;
 }
 
-interface RetrieveUserQuotaBucket {
-  modelId?: string;
-}
-
-interface RetrieveUserQuotaResponse {
-  buckets?: RetrieveUserQuotaBucket[];
-}
-
 /**
  * Retrieves Code Assist quota buckets, which include model IDs visible to the current account/project.
  */

package/src/plugin/project/types.ts

@@ -43,6 +43,18 @@ export interface OnboardUserPayload {
   };
 }
 
+export interface RetrieveUserQuotaBucket {
+  remainingAmount?: string;
+  remainingFraction?: number;
+  resetTime?: string;
+  tokenType?: string;
+  modelId?: string;
+}
+
+export interface RetrieveUserQuotaResponse {
+  buckets?: RetrieveUserQuotaBucket[];
+}
+
 /**
  * Error raised when a required Google Cloud project is missing during Gemini onboarding.
  */

package/src/plugin/quota.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { formatGeminiQuotaOutput, formatRelativeResetTime } from "./quota";
+import type { RetrieveUserQuotaBucket } from "./project/types";
+
+const REAL_DATE_NOW = Date.now;
+const FIXED_NOW = Date.parse("2026-02-21T00:00:00.000Z");
+
+describe("formatRelativeResetTime", () => {
+  beforeEach(() => {
+    Date.now = () => FIXED_NOW;
+  });
+
+  afterEach(() => {
+    Date.now = REAL_DATE_NOW;
+  });
+
+  it("formats future reset times as relative labels", () => {
+    const reset = new Date(FIXED_NOW + 90 * 60 * 1000).toISOString();
+    expect(formatRelativeResetTime(reset)).toBe("resets in 1h 30m");
+  });
+
+  it("returns reset pending when reset time is in the past", () => {
+    const reset = new Date(FIXED_NOW - 60 * 1000).toISOString();
+    expect(formatRelativeResetTime(reset)).toBe("reset pending");
+  });
+});
+
+describe("formatGeminiQuotaOutput", () => {
+  beforeEach(() => {
+    Date.now = () => FIXED_NOW;
+  });
+
+  afterEach(() => {
+    Date.now = REAL_DATE_NOW;
+  });
+
+  it("renders grouped progress bars, groups by version, and hides token type when all are REQUESTS", () => {
+    const buckets: RetrieveUserQuotaBucket[] = [
+      {
+        modelId: "gemini-2.5-pro_vertex",
+        tokenType: "requests",
+        remainingFraction: 0.5,
+        remainingAmount: "100",
+        resetTime: new Date(FIXED_NOW + 60 * 60 * 1000).toISOString(),
+      },
+      {
+        modelId: "gemini-2.5-flash",
+        remainingAmount: "20",
+      },
+      {
+        modelId: "gemini-2.5-pro",
+        tokenType: "requests",
+        remainingFraction: 0.7,
+        remainingAmount: "140",
+        resetTime: new Date(FIXED_NOW + 2 * 60 * 60 * 1000).toISOString(),
+      },
+      {
+        modelId: "gemini-3-pro-preview",
+        tokenType: "requests",
+        remainingFraction: 0.95,
+      },
+      {
+        modelId: "gemini-2.0-flash",
+        tokenType: "requests",
+        remainingFraction: 0.8,
+      },
+    ];
+
+    const output = formatGeminiQuotaOutput("test-project", buckets);
+    expect(output).toContain("Gemini quota usage for project `test-project`");
+    expect(output).toContain("Variant");
+    expect(output).toContain("Remaining");
+    expect(output).toContain("Reset");
+    expect(output).not.toContain("Type");
+    expect(output).toContain("gemini-2.5-flash\n  ↳ default");
+    expect(output).toContain("gemini-2.5-pro\n  ↳ default");
+    expect(output).toContain("  ↳ vertex");
+    expect(output).toContain("Gemini 3 (1 model, 1 bucket)");
+    expect(output).toContain("Gemini 2.5 (2 models, 3 buckets)");
+    expect(output).toContain("Gemini 2.0 (1 model, 1 bucket)");
+    expect(output).toContain("▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░ 70.0% (140 left)");
+    expect(output).toContain(
+      "▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░ 50.0% (100 left)",
+    );
+    expect(output.indexOf("Gemini 3 (1 model, 1 bucket)")).toBeLessThan(
+      output.indexOf("Gemini 2.5 (2 models, 3 buckets)"),
+    );
+    expect(output.indexOf("Gemini 2.5 (2 models, 3 buckets)")).toBeLessThan(
+      output.indexOf("Gemini 2.0 (1 model, 1 bucket)"),
+    );
+    expect(output).toContain("\n\nGemini 2.5 (2 models, 3 buckets)");
+    expect(output.indexOf("gemini-2.0-flash")).toBeGreaterThan(
+      output.indexOf("gemini-2.5-pro"),
+    );
+    expect(output.indexOf("gemini-2.5-flash")).toBeLessThan(
+      output.indexOf("gemini-2.5-pro"),
+    );
+  });
+
+  it("shows token type column when multiple token types are present", () => {
+    const buckets: RetrieveUserQuotaBucket[] = [
+      {
+        modelId: "gemini-2.5-pro_vertex",
+        tokenType: "REQUESTS",
+        remainingFraction: 0.9,
+      },
+      {
+        modelId: "gemini-2.5-pro",
+        tokenType: "TOKENS",
+        remainingFraction: 0.8,
+      },
+    ];
+
+    const output = formatGeminiQuotaOutput("test-project", buckets);
+    expect(output).toContain("Type");
+    expect(output).toContain("Gemini 2.5 (1 model, 2 buckets)");
+    expect(output).toContain("REQUESTS");
+    expect(output).toContain("TOKENS");
+    expect(output).toContain("  ↳ vertex");
+  });
+});

package/src/plugin/quota.ts

@@ -0,0 +1,382 @@
+import { tool } from "@opencode-ai/plugin";
+import { accessTokenExpired, isOAuthAuth } from "./auth";
+import { resolveCachedAuth } from "./cache";
+import { ensureProjectContext, retrieveUserQuota } from "./project";
+import type { RetrieveUserQuotaBucket } from "./project/types";
+import { refreshAccessToken } from "./token";
+import type { GetAuth, PluginClient } from "./types";
+
+export const GEMINI_QUOTA_TOOL_NAME = "gemini_quota";
+
+interface GeminiQuotaToolDependencies {
+  client: PluginClient;
+  getAuthResolver: () => GetAuth | undefined;
+  getConfiguredProjectId: () => string | undefined;
+}
+
+export function createGeminiQuotaTool({
+  client,
+  getAuthResolver,
+  getConfiguredProjectId,
+}: GeminiQuotaToolDependencies) {
+  return tool({
+    description:
+      "Retrieve current Gemini Code Assist quota usage for the authenticated user and project.",
+    args: {},
+    async execute() {
+      const getAuth = getAuthResolver();
+      if (!getAuth) {
+        return "Gemini quota is unavailable before Google auth is initialized. Authenticate with the Google provider and retry.";
+      }
+
+      const auth = await getAuth();
+      if (!isOAuthAuth(auth)) {
+        return "Gemini quota requires OAuth with Google. Run `opencode auth login` and choose `OAuth with Google (Gemini CLI)`.";
+      }
+
+      let authRecord = resolveCachedAuth(auth);
+      if (accessTokenExpired(authRecord)) {
+        const refreshed = await refreshAccessToken(authRecord, client);
+        if (!refreshed?.access) {
+          return "Gemini quota lookup failed because the access token could not be refreshed. Re-authenticate and retry.";
+        }
+        authRecord = refreshed;
+      }
+
+      if (!authRecord.access) {
+        return "Gemini quota lookup failed because no access token is available. Re-authenticate and retry.";
+      }
+
+      try {
+        const projectContext = await ensureProjectContext(
+          authRecord,
+          client,
+          getConfiguredProjectId(),
+        );
+        if (!projectContext.effectiveProjectId) {
+          return "Gemini quota lookup failed because no Google Cloud project could be resolved.";
+        }
+
+        const quota = await retrieveUserQuota(
+          authRecord.access,
+          projectContext.effectiveProjectId,
+        );
+        if (!quota?.buckets?.length) {
+          return `No Gemini quota buckets were returned for project \`${projectContext.effectiveProjectId}\`.`;
+        }
+
+        return formatGeminiQuotaOutput(
+          projectContext.effectiveProjectId,
+          quota.buckets,
+        );
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        return `Gemini quota lookup failed: ${message}`;
+      }
+    },
+  });
+}
+
+export function formatGeminiQuotaOutput(
+  projectId: string,
+  buckets: RetrieveUserQuotaBucket[],
+): string {
+  const sortedBuckets = [...buckets].sort(compareQuotaBuckets);
+  const groupedRows = groupQuotaRows(sortedBuckets);
+  const versionGroups = groupByVersion(groupedRows);
+  const variantWidth = Math.max(
+    "Variant".length,
+    ...versionGroups.flatMap((group) =>
+      group.models.flatMap((model) => model.rows.map((row) => row.variant.length))
+    ),
+  );
+  const tokenTypeValues = [...new Set(versionGroups.flatMap((group) =>
+    group.models.flatMap((model) => model.rows.map((row) => row.tokenType))
+  ))];
+  const showTokenType = tokenTypeValues.length > 1 || tokenTypeValues[0] !== "REQUESTS";
+  const lines = [
+    `Gemini quota usage for project \`${projectId}\``,
+    "",
+    showTokenType
+      ? `  ↳ ${pad("Variant", variantWidth)}  Remaining                   Reset      Type`
+      : `  ↳ ${pad("Variant", variantWidth)}  Remaining                   Reset`,
+  ];
+
+  for (let index = 0; index < versionGroups.length; index += 1) {
+    const versionGroup = versionGroups[index];
+    if (!versionGroup) {
+      continue;
+    }
+    if (index > 0) {
+      lines.push("");
+    }
+    lines.push(formatVersionGroupTitle(versionGroup));
+    for (const model of versionGroup.models) {
+      lines.push(model.baseModel);
+      for (const row of model.rows) {
+        lines.push(
+          showTokenType
+            ? `  ↳ ${pad(row.variant, variantWidth)}  ${pad(row.usageRemaining, 27)} ${pad(row.resetValue, 8)} ${row.tokenType}`
+            : `  ↳ ${pad(row.variant, variantWidth)}  ${pad(row.usageRemaining, 27)} ${row.resetValue}`,
+        );
+      }
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function compareQuotaBuckets(
+  left: RetrieveUserQuotaBucket,
+  right: RetrieveUserQuotaBucket,
+): number {
+  const leftModel = left.modelId ?? "";
+  const rightModel = right.modelId ?? "";
+  if (leftModel !== rightModel) {
+    return leftModel.localeCompare(rightModel);
+  }
+
+  const leftTokenType = left.tokenType ?? "";
+  const rightTokenType = right.tokenType ?? "";
+  if (leftTokenType !== rightTokenType) {
+    return leftTokenType.localeCompare(rightTokenType);
+  }
+
+  return (left.resetTime ?? "").localeCompare(right.resetTime ?? "");
+}
+
+function formatUsageRemaining(bucket: RetrieveUserQuotaBucket): string {
+  const remainingAmount = formatRemainingAmount(bucket.remainingAmount);
+  const remainingFraction = bucket.remainingFraction;
+  const hasFraction =
+    typeof remainingFraction === "number" && Number.isFinite(remainingFraction);
+
+  if (hasFraction) {
+    const clamped = clamp(remainingFraction, 0, 1);
+    const percent = (clamped * 100).toFixed(1);
+    const bar = buildProgressBar(clamped);
+    return remainingAmount
+      ? `${bar} ${percent}% (${remainingAmount} left)`
+      : `${bar} ${percent}%`;
+  }
+
+  if (remainingAmount) {
+    return remainingAmount;
+  }
+
+  return "unknown";
+}
+
+function formatRemainingAmount(value: string | undefined): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) {
+    return value;
+  }
+  return parsed.toLocaleString("en-US");
+}
+
+export function formatRelativeResetTime(resetTime: string | undefined): string | undefined {
+  if (!resetTime) {
+    return undefined;
+  }
+
+  const resetAt = new Date(resetTime).getTime();
+  if (Number.isNaN(resetAt)) {
+    return undefined;
+  }
+
+  const diffMs = resetAt - Date.now();
+  if (diffMs <= 0) {
+    return "reset pending";
+  }
+
+  const totalMinutes = Math.ceil(diffMs / (1000 * 60));
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+
+  if (hours > 0 && minutes > 0) {
+    return `resets in ${hours}h ${minutes}m`;
+  }
+  if (hours > 0) {
+    return `resets in ${hours}h`;
+  }
+  return `resets in ${minutes}m`;
+}
+
+function buildProgressBar(fraction: number, width = 20): string {
+  const clamped = clamp(fraction, 0, 1);
+  const filled = clamped >= 1
+    ? width
+    : Math.max(0, Math.min(width, Math.max(clamped > 0 ? 1 : 0, Math.floor(clamped * width))));
+  const empty = width - filled;
+  return `${"▓".repeat(filled)}${"░".repeat(empty)}`;
+}
+
+function pad(value: string, width: number): string {
+  if (value.length >= width) {
+    return value;
+  }
+  return value.padEnd(width, " ");
+}
+
+function clamp(value: number, min: number, max: number): number {
+  if (value < min) {
+    return min;
+  }
+  if (value > max) {
+    return max;
+  }
+  return value;
+}
+
+function normalizeTokenType(bucket: RetrieveUserQuotaBucket): string {
+  const value = bucket.tokenType?.trim();
+  return value ? value.toUpperCase() : "REQUESTS";
+}
+
+interface GroupedQuotaRow {
+  variant: string;
+  usageRemaining: string;
+  resetValue: string;
+  tokenType: string;
+}
+
+interface GroupedQuotaModel {
+  baseModel: string;
+  version: string | undefined;
+  rows: GroupedQuotaRow[];
+}
+
+function groupQuotaRows(sortedBuckets: RetrieveUserQuotaBucket[]): GroupedQuotaModel[] {
+  const groups = new Map<string, GroupedQuotaModel>();
+
+  for (const bucket of sortedBuckets) {
+    const modelId = bucket.modelId?.trim() || "unknown-model";
+    const { baseModel, variant } = splitModelVariant(modelId);
+    const usageRemaining = formatUsageRemaining(bucket);
+    const resetLabel = formatRelativeResetTime(bucket.resetTime);
+    const resetValue = resetLabel?.replace("resets in ", "") ?? "-";
+    const tokenType = normalizeTokenType(bucket);
+
+    const existing = groups.get(baseModel);
+    if (existing) {
+      existing.rows.push({
+        variant,
+        usageRemaining,
+        resetValue,
+        tokenType,
+      });
+      continue;
+    }
+
+    groups.set(baseModel, {
+      baseModel,
+      version: extractModelVersion(baseModel),
+      rows: [{
+        variant,
+        usageRemaining,
+        resetValue,
+        tokenType,
+      }],
+    });
+  }
+
+  return [...groups.values()];
+}
+
+interface VersionQuotaGroup {
+  title: string;
+  version: string | undefined;
+  models: GroupedQuotaModel[];
+}
+
+function groupByVersion(models: GroupedQuotaModel[]): VersionQuotaGroup[] {
+  const groups = new Map<string, VersionQuotaGroup>();
+
+  for (const model of models) {
+    const key = model.version ?? "__unknown__";
+    const existing = groups.get(key);
+    if (existing) {
+      existing.models.push(model);
+      continue;
+    }
+
+    groups.set(key, {
+      title: model.version ? `Gemini ${model.version}` : "Other",
+      version: model.version,
+      models: [model],
+    });
+  }
+
+  const ordered = [...groups.values()].sort((left, right) =>
+    compareVersionDesc(left.version, right.version),
+  );
+
+  for (const group of ordered) {
+    group.models.sort((left, right) => left.baseModel.localeCompare(right.baseModel));
+  }
+
+  return ordered;
+}
+
+function extractModelVersion(modelId: string): string | undefined {
+  const match = modelId.match(/^gemini-([0-9]+(?:\.[0-9]+)*)-/i);
+  return match?.[1];
+}
+
+function compareVersionDesc(left: string | undefined, right: string | undefined): number {
+  if (!left && !right) {
+    return 0;
+  }
+  if (!left) {
+    return 1;
+  }
+  if (!right) {
+    return -1;
+  }
+
+  const leftSegments = left.split(".").map((part) => Number.parseInt(part, 10));
+  const rightSegments = right.split(".").map((part) => Number.parseInt(part, 10));
+  const max = Math.max(leftSegments.length, rightSegments.length);
+
+  for (let index = 0; index < max; index += 1) {
+    const l = leftSegments[index] ?? 0;
+    const r = rightSegments[index] ?? 0;
+    if (Number.isNaN(l) || Number.isNaN(r)) {
+      break;
+    }
+    if (l > r) {
+      return -1;
+    }
+    if (l < r) {
+      return 1;
+    }
+  }
+
+  return right.localeCompare(left);
+}
+
+function formatVersionGroupTitle(group: VersionQuotaGroup): string {
+  const modelCount = group.models.length;
+  const bucketCount = group.models.reduce((count, model) => count + model.rows.length, 0);
+  const modelLabel = modelCount === 1 ? "model" : "models";
+  const bucketLabel = bucketCount === 1 ? "bucket" : "buckets";
+  return `${group.title} (${modelCount} ${modelLabel}, ${bucketCount} ${bucketLabel})`;
+}
+
+function splitModelVariant(modelId: string): { baseModel: string; variant: string } {
+  const vertexSuffix = "_vertex";
+  if (modelId.endsWith(vertexSuffix)) {
+    return {
+      baseModel: modelId.slice(0, -vertexSuffix.length),
+      variant: "vertex",
+    };
+  }
+  return {
+    baseModel: modelId,
+    variant: "default",
+  };
+}

package/src/plugin/types.ts

@@ -1,4 +1,6 @@
 import type { GeminiTokenExchangeResult } from "../gemini/oauth";
+import type { Config } from "@opencode-ai/sdk";
+import type { ToolDefinition } from "@opencode-ai/plugin";
 
 export interface OAuthAuthDetails {
   type: "oauth";
@@ -57,6 +59,8 @@ export interface PluginContext {
 }
 
 export interface PluginResult {
+  config?: (config: Config) => Promise<void>;
+  tool?: Record<string, ToolDefinition>;
   auth: {
     provider: string;
     loader: (getAuth: GetAuth, provider: Provider) => Promise<LoaderResult | null>;

package/src/plugin.ts

@@ -3,6 +3,10 @@ import { createOAuthAuthorizeMethod } from "./plugin/oauth-authorize";
 import { accessTokenExpired, isOAuthAuth } from "./plugin/auth";
 import { resolveCachedAuth } from "./plugin/cache";
 import { ensureProjectContext, retrieveUserQuota } from "./plugin/project";
+import {
+  createGeminiQuotaTool,
+  GEMINI_QUOTA_TOOL_NAME,
+} from "./plugin/quota";
 import { isGeminiDebugEnabled, logGeminiDebugMessage, startGeminiDebugRequest } from "./plugin/debug";
 import {
   isGenerativeLanguageRequest,
@@ -21,6 +25,15 @@ import type {
   Provider,
 } from "./plugin/types";
 
+const GEMINI_QUOTA_COMMAND = "gquota";
+const GEMINI_QUOTA_COMMAND_TEMPLATE = `Retrieve Gemini Code Assist quota usage for the current authenticated account.
+
+Immediately call \`${GEMINI_QUOTA_TOOL_NAME}\` with no arguments and return its output verbatim.
+Do not call other tools.
+`;
+let latestGeminiAuthResolver: GetAuth | undefined;
+let latestGeminiConfiguredProjectId: string | undefined;
+
 /**
  * Registers the Gemini OAuth provider for Opencode, handling auth, request rewriting,
  * debug logging, and response normalization for Gemini Code Assist endpoints.
@@ -28,15 +41,31 @@ import type {
 export const GeminiCLIOAuthPlugin = async (
   { client }: PluginContext,
 ): Promise<PluginResult> => ({
+  config: async (config) => {
+    config.command = config.command || {};
+    config.command[GEMINI_QUOTA_COMMAND] = {
+      description: "Show Gemini Code Assist quota usage",
+      template: GEMINI_QUOTA_COMMAND_TEMPLATE,
+    };
+  },
+  tool: {
+    [GEMINI_QUOTA_TOOL_NAME]: createGeminiQuotaTool({
+      client,
+      getAuthResolver: () => latestGeminiAuthResolver,
+      getConfiguredProjectId: () => latestGeminiConfiguredProjectId,
+    }),
+  },
   auth: {
     provider: GEMINI_PROVIDER_ID,
     loader: async (getAuth: GetAuth, provider: Provider): Promise<LoaderResult | null> => {
+      latestGeminiAuthResolver = getAuth;
       const auth = await getAuth();
       if (!isOAuthAuth(auth)) {
         return null;
       }
 
       const configuredProjectId = resolveConfiguredProjectId(provider);
+      latestGeminiConfiguredProjectId = configuredProjectId;
       normalizeProviderModelCosts(provider);
 
       return {