@sunerpy/opencode-kiro-auth 0.7.0 → 0.9.0

package/README.md

@@ -101,6 +101,17 @@ mapping) lives in `~/.config/opencode/kiro.json`. See
 [docs/CONFIGURATION.md](docs/CONFIGURATION.md) for the full example and every
 option.
 
+New default keys are backfilled into an existing `kiro.json` automatically when
+the plugin loads (additive only — your existing values are never changed). For
+multi-account or long-idle setups, enable
+[token keep-alive](docs/CONFIGURATION.md#token-keep-alive)
+(`token_keepalive_enabled: true`) to keep idle accounts' tokens fresh while
+OpenCode is running.
+
+Paid-overage protection is on by default; see
+[Overage protection](docs/CONFIGURATION.md#overage-protection) before disabling
+`stop_on_overage`.
+
 ## Multiple accounts & rotation
 
 You can register more than one Kiro account and let the plugin spread
@@ -113,10 +124,11 @@ requests across them for combined quota and automatic failover.
    AWS identity is stored separately in `kiro.db`. Re-running login for the
    same identity updates it in place; logging in with a different identity
    adds a new account.
-2. Auto-sync from Kiro CLI: with `auto_sync_kiro_cli: true` (the default),
-   the plugin imports credentials from your local `kiro-cli` database.
-   Switching or adding accounts via `kiro-cli login` flows into the plugin
-   automatically, no extra step needed.
+2. Auto-sync from Kiro CLI: with `auto_sync_kiro_cli: true` (opt-in, default
+   `false`), the plugin imports credentials from your local `kiro-cli`
+   database. Note `kiro-cli` stores only one token per auth method, so it
+   cannot represent multiple accounts — manual `opencode auth login` per
+   account (option 1) is the supported multi-account path.
 
 **Rotation strategy** — set `account_selection_strategy` in
 `~/.config/opencode/kiro.json`:

package/dist/core/account/account-selector.js

@@ -26,6 +26,9 @@ export class AccountSelector {
         let acc = this.accountManager.getCurrentOrNext();
         if (!acc) {
             this.circuitBreakerTrips++;
+            if (this.accountManager.allSelectableBlockedByOverage()) {
+                throw new Error('All accounts have exceeded their free quota and entered paid overage. Set "stop_on_overage": false in ~/.config/opencode/kiro.json to continue with paid overage, or wait for the quota to reset.');
+            }
             const wait = this.accountManager.getMinWaitTime();
             if (wait > 0 && wait < 30000) {
                 if (this.accountManager.shouldShowToast()) {

package/dist/plugin/accounts.d.ts

@@ -10,24 +10,33 @@ export declare class AccountManager {
     private stickyId?;
     private quotaAvoidanceEnabled;
     private quotaReserveThreshold;
+    private stopOnOverage;
+    private overageThreshold;
     constructor(accounts: ManagedAccount[], strategy?: AccountSelectionStrategy, opts?: {
         quotaAvoidanceEnabled?: boolean;
         quotaReserveThreshold?: number;
+        stopOnOverage?: boolean;
+        overageThreshold?: number;
     });
     static loadFromDisk(strategy?: AccountSelectionStrategy, opts?: {
         quotaAvoidanceEnabled?: boolean;
         quotaReserveThreshold?: number;
+        stopOnOverage?: boolean;
+        overageThreshold?: number;
     }): Promise<AccountManager>;
     getAccountCount(): number;
     getAccounts(): ManagedAccount[];
     shouldShowToast(debounce?: number): boolean;
     shouldShowUsageToast(debounce?: number): boolean;
     getMinWaitTime(): number;
+    allSelectableBlockedByOverage(): boolean;
     getCurrentOrNext(): ManagedAccount | null;
     updateUsage(id: string, meta: {
         usedCount: number;
         limitCount: number;
+        overageCount?: number;
         email?: string;
+        lastSync?: number;
     }): void;
     addAccount(a: ManagedAccount): void;
     removeAccount(a: ManagedAccount): void;
@@ -36,4 +45,5 @@ export declare class AccountManager {
     markUnhealthy(a: ManagedAccount, reason: string, recovery?: number): void;
     saveToDisk(): Promise<void>;
     toAuthDetails(a: ManagedAccount): KiroAuthDetails;
+    private isOverageBlocked;
 }

package/dist/plugin/accounts.js

@@ -19,12 +19,16 @@ export class AccountManager {
     stickyId;
     quotaAvoidanceEnabled;
     quotaReserveThreshold;
+    stopOnOverage;
+    overageThreshold;
     constructor(accounts, strategy = 'sticky', opts) {
         this.accounts = accounts;
         this.cursor = 0;
         this.strategy = strategy;
         this.quotaAvoidanceEnabled = opts?.quotaAvoidanceEnabled ?? true;
         this.quotaReserveThreshold = opts?.quotaReserveThreshold ?? 0.95;
+        this.stopOnOverage = opts?.stopOnOverage ?? true;
+        this.overageThreshold = opts?.overageThreshold ?? 0;
     }
     static async loadFromDisk(strategy, opts) {
         const rows = kiroDb.getAccounts();
@@ -48,7 +52,9 @@ export class AccountManager {
             failCount: r.fail_count || 0,
             lastUsed: r.last_used,
             usedCount: r.used_count,
-            limitCount: r.limit_count
+            limitCount: r.limit_count,
+            overageCount: r.overage_count || 0,
+            lastSync: r.last_sync
         }));
         return new AccountManager(accounts, strategy || 'sticky', opts);
     }
@@ -75,9 +81,31 @@ export class AccountManager {
         const waits = this.accounts.map((a) => (a.rateLimitResetTime || 0) - now).filter((t) => t > 0);
         return waits.length > 0 ? Math.min(...waits) : 0;
     }
+    allSelectableBlockedByOverage() {
+        if (!this.stopOnOverage)
+            return false;
+        const now = Date.now();
+        const healthEligible = (a) => {
+            if (isPermanentError(a.unhealthyReason))
+                return false;
+            if (a.isHealthy)
+                return true;
+            if (isAccessTokenError(a.unhealthyReason))
+                return true;
+            return a.failCount < 10;
+        };
+        const rateLimited = (a) => !!(a.rateLimitResetTime && now < a.rateLimitResetTime);
+        const hasOverageBlockedEligible = this.accounts.some((a) => healthEligible(a) && this.isOverageBlocked(a));
+        const hasCleanRateLimited = this.accounts.some((a) => healthEligible(a) && rateLimited(a) && !this.isOverageBlocked(a));
+        const hasHealthySelectable = this.accounts.some((a) => a.isHealthy && !rateLimited(a) && !this.isOverageBlocked(a));
+        return hasOverageBlockedEligible && !hasCleanRateLimited && !hasHealthySelectable;
+    }
     getCurrentOrNext() {
         const now = Date.now();
+        const overageBlocked = (a) => this.isOverageBlocked(a);
         const available = this.accounts.filter((a) => {
+            if (overageBlocked(a))
+                return false;
             if (!a.isHealthy) {
                 if (isPermanentError(a.unhealthyReason)) {
                     return false;
@@ -129,7 +157,10 @@ export class AccountManager {
         }
         if (!selected) {
             const fallback = this.accounts
-                .filter((a) => !a.isHealthy && a.failCount < 10 && !isPermanentError(a.unhealthyReason))
+                .filter((a) => !a.isHealthy &&
+                a.failCount < 10 &&
+                !isPermanentError(a.unhealthyReason) &&
+                !overageBlocked(a))
                 .sort((a, b) => (a.usedCount || 0) - (b.usedCount || 0) || (a.lastUsed || 0) - (b.lastUsed || 0))[0];
             if (fallback) {
                 fallback.isHealthy = true;
@@ -139,6 +170,8 @@ export class AccountManager {
             }
         }
         if (selected) {
+            if (overageBlocked(selected))
+                return null;
             selected.lastUsed = now;
             selected.usedCount = (selected.usedCount || 0) + 1;
             return selected;
@@ -150,6 +183,8 @@ export class AccountManager {
         if (a) {
             a.usedCount = meta.usedCount;
             a.limitCount = meta.limitCount;
+            a.overageCount = meta.overageCount ?? 0;
+            a.lastSync = meta.lastSync ?? a.lastSync;
             if (meta.email)
                 a.email = meta.email;
             if (!isPermanentError(a.unhealthyReason)) {
@@ -290,4 +325,7 @@ export class AccountManager {
             email: a.email
         };
     }
+    isOverageBlocked(a) {
+        return this.stopOnOverage && (a.overageCount ?? 0) > this.overageThreshold;
+    }
 }

package/dist/plugin/config/loader.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import * as logger from '../logger.js';
@@ -30,6 +30,53 @@ function ensureUserConfigTemplate() {
 export function getProjectConfigPath(directory) {
     return join(directory, '.opencode', 'kiro.json');
 }
+// Additively write any DEFAULT_CONFIG key missing from an existing user
+// kiro.json so new-version keys become visible/toggleable. Additive-only,
+// parse-safe, atomic, idempotent, user-config-only. See plan config-backfill.md.
+function backfillUserConfig(path) {
+    if (!existsSync(path)) {
+        return;
+    }
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return;
+    }
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        return;
+    }
+    const obj = raw;
+    const defaultKeys = Object.keys(DEFAULT_CONFIG);
+    const missing = defaultKeys.filter((key) => !(key in obj));
+    if (missing.length === 0) {
+        return;
+    }
+    const next = { ...obj };
+    for (const key of missing) {
+        next[key] = DEFAULT_CONFIG[key];
+    }
+    const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    try {
+        writeFileSync(tmp, `${JSON.stringify(next, null, 2)}\n`, 'utf-8');
+        try {
+            renameSync(tmp, path);
+        }
+        catch (renameError) {
+            try {
+                if (existsSync(tmp))
+                    unlinkSync(tmp);
+            }
+            catch { }
+            throw renameError;
+        }
+        logger.log(`Backfilled ${missing.length} new config key(s) into ${path}: ${missing.join(', ')}`);
+    }
+    catch (error) {
+        logger.warn(`Config backfill failed for ${path}: ${String(error)}`);
+    }
+}
 function loadConfigFile(path) {
     try {
         if (!existsSync(path)) {
@@ -109,6 +156,7 @@ function applyEnvOverrides(config) {
 }
 export function loadConfig(directory) {
     ensureUserConfigTemplate();
+    backfillUserConfig(getUserConfigPath());
     let config = { ...DEFAULT_CONFIG };
     const userConfigPath = getUserConfigPath();
     const userConfig = loadConfigFile(userConfigPath);

package/dist/plugin/config/schema.d.ts

@@ -32,6 +32,15 @@ export declare const KiroConfigSchema: z.ZodObject<{
      * near-full and softly avoided. Default 0.95 (95%).
      */
     quota_reserve_threshold: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Exclude accounts that have entered AWS paid overage from selection.
+     */
+    stop_on_overage: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Paid-overage invocations tolerated before stopping an account. 0 means
+     * stop on any overage.
+     */
+    overage_threshold: z.ZodDefault<z.ZodNumber>;
     default_region: z.ZodDefault<z.ZodEnum<["us-east-1", "us-east-2", "us-west-1", "us-west-2", "af-south-1", "ap-east-1", "ap-south-2", "ap-southeast-3", "ap-southeast-5", "ap-southeast-4", "ap-south-1", "ap-southeast-6", "ap-northeast-3", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-east-2", "ap-southeast-7", "ap-northeast-1", "ca-central-1", "ca-west-1", "eu-central-1", "eu-west-1", "eu-west-2", "eu-south-1", "eu-west-3", "eu-south-2", "eu-north-1", "eu-central-2", "il-central-1", "mx-central-1", "me-south-1", "me-central-1", "sa-east-1"]>>;
     rate_limit_retry_delay_ms: z.ZodDefault<z.ZodNumber>;
     rate_limit_max_retries: z.ZodDefault<z.ZodNumber>;
@@ -77,6 +86,8 @@ export declare const KiroConfigSchema: z.ZodObject<{
     account_selection_strategy: "sticky" | "round-robin" | "lowest-usage";
     quota_avoidance_enabled: boolean;
     quota_reserve_threshold: number;
+    stop_on_overage: boolean;
+    overage_threshold: number;
     default_region: "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-east-1" | "ap-south-2" | "ap-southeast-3" | "ap-southeast-5" | "ap-southeast-4" | "ap-south-1" | "ap-southeast-6" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-east-2" | "ap-southeast-7" | "ap-northeast-1" | "ca-central-1" | "ca-west-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-south-1" | "eu-west-3" | "eu-south-2" | "eu-north-1" | "eu-central-2" | "il-central-1" | "mx-central-1" | "me-south-1" | "me-central-1" | "sa-east-1";
     rate_limit_retry_delay_ms: number;
     rate_limit_max_retries: number;
@@ -106,6 +117,8 @@ export declare const KiroConfigSchema: z.ZodObject<{
     account_selection_strategy?: "sticky" | "round-robin" | "lowest-usage" | undefined;
     quota_avoidance_enabled?: boolean | undefined;
     quota_reserve_threshold?: number | undefined;
+    stop_on_overage?: boolean | undefined;
+    overage_threshold?: number | undefined;
     default_region?: "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-east-1" | "ap-south-2" | "ap-southeast-3" | "ap-southeast-5" | "ap-southeast-4" | "ap-south-1" | "ap-southeast-6" | "ap-northeast-3" | "ap-northeast-2" | "ap-southeast-1" | "ap-southeast-2" | "ap-east-2" | "ap-southeast-7" | "ap-northeast-1" | "ca-central-1" | "ca-west-1" | "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-south-1" | "eu-west-3" | "eu-south-2" | "eu-north-1" | "eu-central-2" | "il-central-1" | "mx-central-1" | "me-south-1" | "me-central-1" | "sa-east-1" | undefined;
     rate_limit_retry_delay_ms?: number | undefined;
     rate_limit_max_retries?: number | undefined;

package/dist/plugin/config/schema.js

@@ -64,6 +64,15 @@ export const KiroConfigSchema = z.object({
      * near-full and softly avoided. Default 0.95 (95%).
      */
     quota_reserve_threshold: z.number().min(0).max(1).default(0.95),
+    /**
+     * Exclude accounts that have entered AWS paid overage from selection.
+     */
+    stop_on_overage: z.boolean().default(true),
+    /**
+     * Paid-overage invocations tolerated before stopping an account. 0 means
+     * stop on any overage.
+     */
+    overage_threshold: z.number().min(0).default(0),
     default_region: RegionSchema.default('us-east-1'),
     rate_limit_retry_delay_ms: z.number().min(1000).max(60000).default(5000),
     rate_limit_max_retries: z.number().min(0).max(10).default(3),
@@ -110,6 +119,8 @@ export const DEFAULT_CONFIG = {
     account_selection_strategy: 'lowest-usage',
     quota_avoidance_enabled: true,
     quota_reserve_threshold: 0.95,
+    stop_on_overage: true,
+    overage_threshold: 0,
     default_region: 'us-east-1',
     rate_limit_retry_delay_ms: 5000,
     rate_limit_max_retries: 3,

package/dist/plugin/storage/locked-operations.js

@@ -139,6 +139,7 @@ export function mergeAccounts(existing, incoming) {
             // in-memory token triple from another process must not clobber a newer
             // persisted token triple during this cross-process merge.
             const tokenWinner = (acc.expiresAt || 0) >= (existingAcc.expiresAt || 0) ? acc : existingAcc;
+            const usageWinner = (acc.lastSync || 0) >= (existingAcc.lastSync || 0) ? acc : existingAcc;
             accountMap.set(acc.id, {
                 ...existingAcc,
                 ...acc,
@@ -146,8 +147,9 @@ export function mergeAccounts(existing, incoming) {
                 accessToken: tokenWinner.accessToken,
                 expiresAt: tokenWinner.expiresAt,
                 lastUsed: Math.max(existingAcc.lastUsed || 0, acc.lastUsed || 0),
-                usedCount: Math.max(existingAcc.usedCount || 0, acc.usedCount || 0),
-                limitCount: Math.max(existingAcc.limitCount || 0, acc.limitCount || 0),
+                usedCount: usageWinner.usedCount ?? 0,
+                limitCount: usageWinner.limitCount ?? 0,
+                overageCount: usageWinner.overageCount ?? 0,
                 rateLimitResetTime: Math.max(existingAcc.rateLimitResetTime || 0, acc.rateLimitResetTime || 0),
                 isHealthy: incomingRecovered
                     ? true

package/dist/plugin/storage/migrations.js

@@ -6,6 +6,7 @@ export function runMigrations(db) {
     migrateOidcRegionColumn(db);
     migrateDropRefreshTokenUniqueIndex(db);
     migrateRemovedAccountsTable(db);
+    migrateOverageColumn(db);
 }
 function migrateToUniqueRefreshToken(db) {
     const hasIndex = db
@@ -159,3 +160,10 @@ function migrateRemovedAccountsTable(db) {
     // so kiro-cli auto-sync does not silently re-import them. Cleared only on deliberate login.
     db.exec('CREATE TABLE IF NOT EXISTS removed_accounts (id TEXT PRIMARY KEY, removed_at INTEGER NOT NULL)');
 }
+function migrateOverageColumn(db) {
+    const columns = db.prepare('PRAGMA table_info(accounts)').all();
+    const names = new Set(columns.map((c) => c.name));
+    if (!names.has('overage_count')) {
+        db.exec('ALTER TABLE accounts ADD COLUMN overage_count INTEGER DEFAULT 0');
+    }
+}

package/dist/plugin/storage/sqlite.js

@@ -33,7 +33,8 @@ export class KiroDatabase {
         refresh_token TEXT NOT NULL, access_token TEXT NOT NULL, expires_at INTEGER NOT NULL,
         rate_limit_reset INTEGER DEFAULT 0, is_healthy INTEGER DEFAULT 1, unhealthy_reason TEXT,
         recovery_time INTEGER, fail_count INTEGER DEFAULT 0, last_used INTEGER DEFAULT 0,
-        used_count INTEGER DEFAULT 0, limit_count INTEGER DEFAULT 0, last_sync INTEGER DEFAULT 0
+        used_count INTEGER DEFAULT 0, limit_count INTEGER DEFAULT 0,
+        overage_count INTEGER DEFAULT 0, last_sync INTEGER DEFAULT 0
       )
     `);
         runMigrations(this.db);
@@ -56,8 +57,8 @@ export class KiroDatabase {
         id, email, auth_method, region, oidc_region, client_id, client_secret,
         profile_arn, start_url, refresh_token, access_token, expires_at, rate_limit_reset,
         is_healthy, unhealthy_reason, recovery_time, fail_count, last_used,
-        used_count, limit_count, last_sync
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        used_count, limit_count, overage_count, last_sync
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(id) DO UPDATE SET
         id=excluded.id, email=excluded.email, auth_method=excluded.auth_method,
         region=excluded.region, oidc_region=excluded.oidc_region, client_id=excluded.client_id, client_secret=excluded.client_secret,
@@ -66,9 +67,10 @@ export class KiroDatabase {
         rate_limit_reset=excluded.rate_limit_reset, is_healthy=excluded.is_healthy,
         unhealthy_reason=excluded.unhealthy_reason, recovery_time=excluded.recovery_time,
         fail_count=excluded.fail_count, last_used=excluded.last_used,
-        used_count=excluded.used_count, limit_count=excluded.limit_count, last_sync=excluded.last_sync
+        used_count=excluded.used_count, limit_count=excluded.limit_count,
+        overage_count=excluded.overage_count, last_sync=excluded.last_sync
     `)
-            .run(acc.id, acc.email, acc.authMethod, acc.region, acc.oidcRegion || null, acc.clientId || null, acc.clientSecret || null, acc.profileArn || null, acc.startUrl || null, acc.refreshToken, acc.accessToken, acc.expiresAt, acc.rateLimitResetTime || 0, acc.isHealthy ? 1 : 0, acc.unhealthyReason || null, acc.recoveryTime || null, acc.failCount || 0, acc.lastUsed || 0, acc.usedCount || 0, acc.limitCount || 0, acc.lastSync || 0);
+            .run(acc.id, acc.email, acc.authMethod, acc.region, acc.oidcRegion || null, acc.clientId || null, acc.clientSecret || null, acc.profileArn || null, acc.startUrl || null, acc.refreshToken, acc.accessToken, acc.expiresAt, acc.rateLimitResetTime || 0, acc.isHealthy ? 1 : 0, acc.unhealthyReason || null, acc.recoveryTime || null, acc.failCount || 0, acc.lastUsed || 0, acc.usedCount || 0, acc.limitCount || 0, acc.overageCount || 0, acc.lastSync || 0);
     }
     isRemovedSync(id) {
         return !!this.db.prepare('SELECT id FROM removed_accounts WHERE id = ?').get(id);
@@ -233,6 +235,7 @@ export class KiroDatabase {
             lastUsed: row.last_used,
             usedCount: row.used_count,
             limitCount: row.limit_count,
+            overageCount: row.overage_count || 0,
             lastSync: row.last_sync
         };
     }

package/dist/plugin/types.d.ts

@@ -42,6 +42,7 @@ export interface ManagedAccount {
     failCount: number;
     usedCount?: number;
     limitCount?: number;
+    overageCount?: number;
     lastSync?: number;
     lastUsed?: number;
 }

package/dist/plugin/usage.d.ts

@@ -1,3 +1,16 @@
-import { KiroAuthDetails, ManagedAccount } from './types.js';
-export declare function fetchUsageLimits(auth: KiroAuthDetails): Promise<any>;
-export declare function updateAccountQuota(account: ManagedAccount, usage: any, accountManager?: any): void;
+import type { KiroAuthDetails, ManagedAccount } from './types.js';
+interface UsageSnapshot {
+    usedCount: number;
+    limitCount: number;
+    overageCount: number;
+    email?: string;
+}
+interface UsageUpdateMeta extends UsageSnapshot {
+    lastSync: number;
+}
+interface AccountUsageManager {
+    updateUsage(id: string, meta: UsageUpdateMeta): void;
+}
+export declare function fetchUsageLimits(auth: KiroAuthDetails): Promise<UsageSnapshot>;
+export declare function updateAccountQuota(account: ManagedAccount, usage: Partial<UsageSnapshot>, accountManager?: AccountUsageManager): void;
+export {};

package/dist/plugin/usage.js

@@ -1,3 +1,26 @@
+import { z } from 'zod';
+const UsageLimitsResponseSchema = z
+    .object({
+    usageBreakdownList: z
+        .array(z
+        .object({
+        currentUsage: z.number().optional(),
+        usageLimit: z.number().optional(),
+        currentOverages: z.number().optional(),
+        freeTrialInfo: z
+            .object({
+            currentUsage: z.number().optional(),
+            usageLimit: z.number().optional()
+        })
+            .passthrough()
+            .nullable()
+            .optional()
+    })
+        .passthrough())
+        .optional(),
+    userInfo: z.object({ email: z.string().optional() }).passthrough().optional()
+})
+    .passthrough();
 export async function fetchUsageLimits(auth) {
     // Try different parameter combinations
     const attempts = [
@@ -42,8 +65,8 @@ export async function fetchUsageLimits(auth) {
                 lastError = new Error(`Status: ${res.status}${errType ? ` (${errType})` : ''}${requestId ? ` [${requestId}]` : ''}: ${msg}`);
                 continue;
             }
-            const data = await res.json();
-            let usedCount = 0, limitCount = 0;
+            const data = UsageLimitsResponseSchema.parse(await res.json());
+            let usedCount = 0, limitCount = 0, overageCount = 0;
             if (Array.isArray(data.usageBreakdownList)) {
                 for (const s of data.usageBreakdownList) {
                     if (s.freeTrialInfo) {
@@ -52,9 +75,10 @@ export async function fetchUsageLimits(auth) {
                     }
                     usedCount += s.currentUsage || 0;
                     limitCount += s.usageLimit || 0;
+                    overageCount += s.currentOverages || 0;
                 }
             }
-            return { usedCount, limitCount, email: data.userInfo?.email };
+            return { usedCount, limitCount, overageCount, email: data.userInfo?.email };
         }
         catch (e) {
             lastError = e instanceof Error ? e : new Error(String(e));
@@ -68,10 +92,14 @@ export function updateAccountQuota(account, usage, accountManager) {
     const meta = {
         usedCount: usage.usedCount || 0,
         limitCount: usage.limitCount || 0,
+        overageCount: usage.overageCount || 0,
+        lastSync: Date.now(),
         email: usage.email
     };
     account.usedCount = meta.usedCount;
     account.limitCount = meta.limitCount;
+    account.overageCount = meta.overageCount;
+    account.lastSync = meta.lastSync;
     if (usage.email)
         account.email = usage.email;
     if (accountManager)

package/dist/plugin.js

@@ -43,7 +43,9 @@ export const createKiroPlugin = (id) => async ({ client, directory }) => {
     const authHandler = new AuthHandler(config, repository);
     const accountManager = await AccountManager.loadFromDisk(config.account_selection_strategy, {
         quotaAvoidanceEnabled: config.quota_avoidance_enabled,
-        quotaReserveThreshold: config.quota_reserve_threshold
+        quotaReserveThreshold: config.quota_reserve_threshold,
+        stopOnOverage: config.stop_on_overage,
+        overageThreshold: config.overage_threshold
     });
     authHandler.setAccountManager(accountManager);
     const requestHandler = new RequestHandler(accountManager, config, repository, client);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sunerpy/opencode-kiro-auth",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "OpenCode plugin for AWS Kiro (CodeWhisperer) providing access to Claude models",
   "type": "module",
   "main": "dist/index.js",