antigravity-auth 1.6.0 → 1.7.0

package/dist/plugin/rotation.d.ts

@@ -1,182 +0,0 @@
-/**
- * Account Rotation System
- *
- * Implements advanced account selection algorithms:
- * - Health Score: Track account wellness based on success/failure
- * - LRU Selection: Prefer accounts with longest rest periods
- * - Jitter: Add random variance to break predictable patterns
- *
- * Used by 'hybrid' strategy for improved ban prevention and load distribution.
- */
-export interface HealthScoreConfig {
-    /** Initial score for new accounts (default: 70) */
-    initial: number;
-    /** Points added on successful request (default: 1) */
-    successReward: number;
-    /** Points removed on rate limit (default: -10) */
-    rateLimitPenalty: number;
-    /** Points removed on failure (auth, network, etc.) (default: -20) */
-    failurePenalty: number;
-    /** Points recovered per hour of rest (default: 2) */
-    recoveryRatePerHour: number;
-    /** Minimum score to be considered usable (default: 50) */
-    minUsable: number;
-    /** Maximum score cap (default: 100) */
-    maxScore: number;
-}
-export declare const DEFAULT_HEALTH_SCORE_CONFIG: HealthScoreConfig;
-/**
- * Tracks health scores for accounts.
- * Higher score = healthier account = preferred for selection.
- */
-export declare class HealthScoreTracker {
-    private readonly scores;
-    private readonly config;
-    constructor(config?: Partial<HealthScoreConfig>);
-    /**
-     * Get current health score for an account, applying time-based recovery.
-     */
-    getScore(accountIndex: number): number;
-    /**
-     * Record a successful request - improves health score.
-     */
-    recordSuccess(accountIndex: number): void;
-    /**
-     * Record a rate limit hit - moderate penalty.
-     */
-    recordRateLimit(accountIndex: number): void;
-    /**
-     * Record a failure (auth, network, etc.) - larger penalty.
-     */
-    recordFailure(accountIndex: number): void;
-    /**
-     * Check if account is healthy enough to use.
-     */
-    isUsable(accountIndex: number): boolean;
-    /**
-     * Get consecutive failure count for an account.
-     */
-    getConsecutiveFailures(accountIndex: number): number;
-    /**
-     * Reset health state for an account (e.g., after removal).
-     */
-    reset(accountIndex: number): void;
-    /**
-     * Get all scores for debugging/logging.
-     */
-    getSnapshot(): Map<number, {
-        score: number;
-        consecutiveFailures: number;
-    }>;
-}
-/**
- * Add random jitter to a delay value.
- * Helps break predictable timing patterns.
- *
- * @param baseMs - Base delay in milliseconds
- * @param jitterFactor - Fraction of base to vary (default: 0.3 = ±30%)
- * @returns Jittered delay in milliseconds
- */
-export declare function addJitter(baseMs: number, jitterFactor?: number): number;
-/**
- * Generate a random delay within a range.
- *
- * @param minMs - Minimum delay in milliseconds
- * @param maxMs - Maximum delay in milliseconds
- * @returns Random delay between min and max
- */
-export declare function randomDelay(minMs: number, maxMs: number): number;
-export interface AccountWithMetrics {
-    index: number;
-    lastUsed: number;
-    healthScore: number;
-    isRateLimited: boolean;
-    isCoolingDown: boolean;
-}
-/**
- * Sort accounts by LRU (least recently used first) with health score tiebreaker.
- *
- * Priority:
- * 1. Filter out rate-limited and cooling-down accounts
- * 2. Filter out unhealthy accounts (score < minUsable)
- * 3. Sort by lastUsed ascending (oldest first = most rested)
- * 4. Tiebreaker: higher health score wins
- */
-export declare function sortByLruWithHealth(accounts: AccountWithMetrics[], minHealthScore?: number): AccountWithMetrics[];
-/**
- * Select account using hybrid strategy with stickiness:
- * 1. Filter available accounts (not rate-limited, not cooling down, healthy, has tokens)
- * 2. Calculate priority score: health (2x) + tokens (5x) + freshness (0.1x)
- * 3. Apply stickiness bonus to current account
- * 4. Only switch if another account beats current by SWITCH_THRESHOLD
- *
- * @param accounts - All accounts with their metrics
- * @param tokenTracker - Token bucket tracker for token balances
- * @param currentAccountIndex - Currently active account index (for stickiness)
- * @param minHealthScore - Minimum health score to be considered
- * @returns Best account index, or null if none available
- */
-export declare function selectHybridAccount(accounts: AccountWithMetrics[], tokenTracker: TokenBucketTracker, currentAccountIndex?: number | null, minHealthScore?: number): number | null;
-export interface TokenBucketConfig {
-    /** Maximum tokens per account (default: 50) */
-    maxTokens: number;
-    /** Tokens regenerated per minute (default: 6) */
-    regenerationRatePerMinute: number;
-    /** Initial tokens for new accounts (default: 50) */
-    initialTokens: number;
-}
-export declare const DEFAULT_TOKEN_BUCKET_CONFIG: TokenBucketConfig;
-/**
- * Client-side rate limiting using Token Bucket algorithm.
- * Helps prevent hitting server 429s by tracking "cost" of requests.
- */
-export declare class TokenBucketTracker {
-    private readonly buckets;
-    private readonly config;
-    constructor(config?: Partial<TokenBucketConfig>);
-    /**
-     * Get current token balance for an account, applying regeneration.
-     */
-    getTokens(accountIndex: number): number;
-    /**
-     * Check if account has enough tokens for a request.
-     * @param cost Cost of the request (default: 1)
-     */
-    hasTokens(accountIndex: number, cost?: number): boolean;
-    /**
-     * Consume tokens for a request.
-     * @returns true if tokens were consumed, false if insufficient
-     */
-    consume(accountIndex: number, cost?: number): boolean;
-    /**
-     * Refund tokens (e.g., if request wasn't actually sent).
-     */
-    refund(accountIndex: number, amount?: number): void;
-    getMaxTokens(): number;
-}
-export declare function getTokenTracker(): TokenBucketTracker;
-export declare function initTokenTracker(config: Partial<TokenBucketConfig>): TokenBucketTracker;
-/**
- * Get the global health score tracker instance.
- * Creates one with default config if not initialized.
- */
-export declare function getHealthTracker(): HealthScoreTracker;
-/**
- * Initialize the global health tracker with custom config.
- * Call this at plugin startup if custom config is needed.
- */
-export declare function initHealthTracker(config: Partial<HealthScoreConfig>): HealthScoreTracker;
-export declare class LeaseTracker {
-    private leasedAccounts;
-    lease(accountIndex: number): void;
-    release(accountIndex: number): void;
-    isLeased(accountIndex: number): boolean;
-}
-export declare class ProxyManager {
-    private proxyCooldowns;
-    markCooldown(proxy: string, cooldownMs?: number): void;
-    isCoolingDown(proxy: string): boolean;
-    selectBestProxy(proxies?: string[]): string | undefined;
-}
-export declare function getLeaseTracker(): LeaseTracker;
-export declare function getProxyManager(): ProxyManager;

package/dist/plugin/rotation.js

@@ -1,364 +0,0 @@
-/**
- * Account Rotation System
- *
- * Implements advanced account selection algorithms:
- * - Health Score: Track account wellness based on success/failure
- * - LRU Selection: Prefer accounts with longest rest periods
- * - Jitter: Add random variance to break predictable patterns
- *
- * Used by 'hybrid' strategy for improved ban prevention and load distribution.
- */
-export const DEFAULT_HEALTH_SCORE_CONFIG = {
-    initial: 70,
-    successReward: 1,
-    rateLimitPenalty: -10,
-    failurePenalty: -20,
-    recoveryRatePerHour: 2,
-    minUsable: 50,
-    maxScore: 100,
-};
-/**
- * Tracks health scores for accounts.
- * Higher score = healthier account = preferred for selection.
- */
-export class HealthScoreTracker {
-    scores = new Map();
-    config;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_HEALTH_SCORE_CONFIG, ...config };
-    }
-    /**
-     * Get current health score for an account, applying time-based recovery.
-     */
-    getScore(accountIndex) {
-        const state = this.scores.get(accountIndex);
-        if (!state) {
-            return this.config.initial;
-        }
-        const now = Date.now();
-        const hoursSinceUpdate = (now - state.lastUpdated) / (1000 * 60 * 60);
-        const recoveredPoints = Math.floor(hoursSinceUpdate * this.config.recoveryRatePerHour);
-        return Math.min(this.config.maxScore, state.score + recoveredPoints);
-    }
-    /**
-     * Record a successful request - improves health score.
-     */
-    recordSuccess(accountIndex) {
-        const now = Date.now();
-        const current = this.getScore(accountIndex);
-        this.scores.set(accountIndex, {
-            score: Math.min(this.config.maxScore, current + this.config.successReward),
-            lastUpdated: now,
-            lastSuccess: now,
-            consecutiveFailures: 0,
-        });
-    }
-    /**
-     * Record a rate limit hit - moderate penalty.
-     */
-    recordRateLimit(accountIndex) {
-        const now = Date.now();
-        const state = this.scores.get(accountIndex);
-        const current = this.getScore(accountIndex);
-        this.scores.set(accountIndex, {
-            score: Math.max(0, current + this.config.rateLimitPenalty),
-            lastUpdated: now,
-            lastSuccess: state?.lastSuccess ?? 0,
-            consecutiveFailures: (state?.consecutiveFailures ?? 0) + 1,
-        });
-    }
-    /**
-     * Record a failure (auth, network, etc.) - larger penalty.
-     */
-    recordFailure(accountIndex) {
-        const now = Date.now();
-        const state = this.scores.get(accountIndex);
-        const current = this.getScore(accountIndex);
-        this.scores.set(accountIndex, {
-            score: Math.max(0, current + this.config.failurePenalty),
-            lastUpdated: now,
-            lastSuccess: state?.lastSuccess ?? 0,
-            consecutiveFailures: (state?.consecutiveFailures ?? 0) + 1,
-        });
-    }
-    /**
-     * Check if account is healthy enough to use.
-     */
-    isUsable(accountIndex) {
-        return this.getScore(accountIndex) >= this.config.minUsable;
-    }
-    /**
-     * Get consecutive failure count for an account.
-     */
-    getConsecutiveFailures(accountIndex) {
-        return this.scores.get(accountIndex)?.consecutiveFailures ?? 0;
-    }
-    /**
-     * Reset health state for an account (e.g., after removal).
-     */
-    reset(accountIndex) {
-        this.scores.delete(accountIndex);
-    }
-    /**
-     * Get all scores for debugging/logging.
-     */
-    getSnapshot() {
-        const result = new Map();
-        for (const [index] of this.scores) {
-            result.set(index, {
-                score: this.getScore(index),
-                consecutiveFailures: this.getConsecutiveFailures(index),
-            });
-        }
-        return result;
-    }
-}
-// ============================================================================
-// ============================================================================
-/**
- * Add random jitter to a delay value.
- * Helps break predictable timing patterns.
- *
- * @param baseMs - Base delay in milliseconds
- * @param jitterFactor - Fraction of base to vary (default: 0.3 = ±30%)
- * @returns Jittered delay in milliseconds
- */
-export function addJitter(baseMs, jitterFactor = 0.3) {
-    const jitterRange = baseMs * jitterFactor;
-    const jitter = (Math.random() * 2 - 1) * jitterRange; // -jitterRange to +jitterRange
-    return Math.max(0, Math.round(baseMs + jitter));
-}
-/**
- * Generate a random delay within a range.
- *
- * @param minMs - Minimum delay in milliseconds
- * @param maxMs - Maximum delay in milliseconds
- * @returns Random delay between min and max
- */
-export function randomDelay(minMs, maxMs) {
-    return Math.round(minMs + Math.random() * (maxMs - minMs));
-}
-/**
- * Sort accounts by LRU (least recently used first) with health score tiebreaker.
- *
- * Priority:
- * 1. Filter out rate-limited and cooling-down accounts
- * 2. Filter out unhealthy accounts (score < minUsable)
- * 3. Sort by lastUsed ascending (oldest first = most rested)
- * 4. Tiebreaker: higher health score wins
- */
-export function sortByLruWithHealth(accounts, minHealthScore = 50) {
-    return accounts
-        .filter(acc => !acc.isRateLimited && !acc.isCoolingDown && acc.healthScore >= minHealthScore)
-        .sort((a, b) => {
-        const lruDiff = a.lastUsed - b.lastUsed;
-        if (lruDiff !== 0)
-            return lruDiff;
-        return b.healthScore - a.healthScore;
-    });
-}
-/** Stickiness bonus added to current account's score to prevent unnecessary switching */
-const STICKINESS_BONUS = 150;
-/** Minimum score advantage required to switch away from current account */
-const SWITCH_THRESHOLD = 100;
-/**
- * Select account using hybrid strategy with stickiness:
- * 1. Filter available accounts (not rate-limited, not cooling down, healthy, has tokens)
- * 2. Calculate priority score: health (2x) + tokens (5x) + freshness (0.1x)
- * 3. Apply stickiness bonus to current account
- * 4. Only switch if another account beats current by SWITCH_THRESHOLD
- *
- * @param accounts - All accounts with their metrics
- * @param tokenTracker - Token bucket tracker for token balances
- * @param currentAccountIndex - Currently active account index (for stickiness)
- * @param minHealthScore - Minimum health score to be considered
- * @returns Best account index, or null if none available
- */
-export function selectHybridAccount(accounts, tokenTracker, currentAccountIndex = null, minHealthScore = 50) {
-    const candidates = accounts
-        .filter(acc => !getLeaseTracker().isLeased(acc.index) &&
-        !acc.isRateLimited &&
-        !acc.isCoolingDown &&
-        acc.healthScore >= minHealthScore &&
-        tokenTracker.hasTokens(acc.index))
-        .map(acc => ({
-        ...acc,
-        tokens: tokenTracker.getTokens(acc.index)
-    }));
-    if (candidates.length === 0) {
-        return null;
-    }
-    const maxTokens = tokenTracker.getMaxTokens();
-    const scored = candidates
-        .map(acc => {
-        const baseScore = calculateHybridScore(acc, maxTokens);
-        const stickinessBonus = acc.index === currentAccountIndex ? STICKINESS_BONUS : 0;
-        return {
-            index: acc.index,
-            baseScore,
-            score: baseScore + stickinessBonus,
-            isCurrent: acc.index === currentAccountIndex
-        };
-    })
-        .sort((a, b) => b.score - a.score);
-    const best = scored[0];
-    if (!best) {
-        return null;
-    }
-    const currentCandidate = scored.find(s => s.isCurrent);
-    if (currentCandidate && !best.isCurrent) {
-        // (compare base scores to avoid circular stickiness bonus comparison)
-        const advantage = best.baseScore - currentCandidate.baseScore;
-        if (advantage < SWITCH_THRESHOLD) {
-            return currentCandidate.index;
-        }
-    }
-    return best.index;
-}
-function calculateHybridScore(account, maxTokens) {
-    const healthComponent = account.healthScore * 2; // 0-200
-    const tokenComponent = (account.tokens / maxTokens) * 100 * 5; // 0-500
-    const secondsSinceUsed = (Date.now() - account.lastUsed) / 1000;
-    const freshnessComponent = Math.min(secondsSinceUsed, 3600) * 0.1; // 0-360
-    return Math.max(0, healthComponent + tokenComponent + freshnessComponent);
-}
-export const DEFAULT_TOKEN_BUCKET_CONFIG = {
-    maxTokens: 50,
-    regenerationRatePerMinute: 6,
-    initialTokens: 50,
-};
-/**
- * Client-side rate limiting using Token Bucket algorithm.
- * Helps prevent hitting server 429s by tracking "cost" of requests.
- */
-export class TokenBucketTracker {
-    buckets = new Map();
-    config;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_TOKEN_BUCKET_CONFIG, ...config };
-    }
-    /**
-     * Get current token balance for an account, applying regeneration.
-     */
-    getTokens(accountIndex) {
-        const state = this.buckets.get(accountIndex);
-        if (!state) {
-            return this.config.initialTokens;
-        }
-        const now = Date.now();
-        const minutesSinceUpdate = (now - state.lastUpdated) / (1000 * 60);
-        const recoveredTokens = minutesSinceUpdate * this.config.regenerationRatePerMinute;
-        return Math.min(this.config.maxTokens, state.tokens + recoveredTokens);
-    }
-    /**
-     * Check if account has enough tokens for a request.
-     * @param cost Cost of the request (default: 1)
-     */
-    hasTokens(accountIndex, cost = 1) {
-        return this.getTokens(accountIndex) >= cost;
-    }
-    /**
-     * Consume tokens for a request.
-     * @returns true if tokens were consumed, false if insufficient
-     */
-    consume(accountIndex, cost = 1) {
-        const current = this.getTokens(accountIndex);
-        if (current < cost) {
-            return false;
-        }
-        this.buckets.set(accountIndex, {
-            tokens: current - cost,
-            lastUpdated: Date.now(),
-        });
-        return true;
-    }
-    /**
-     * Refund tokens (e.g., if request wasn't actually sent).
-     */
-    refund(accountIndex, amount = 1) {
-        const current = this.getTokens(accountIndex);
-        this.buckets.set(accountIndex, {
-            tokens: Math.min(this.config.maxTokens, current + amount),
-            lastUpdated: Date.now(),
-        });
-    }
-    getMaxTokens() {
-        return this.config.maxTokens;
-    }
-}
-// ============================================================================
-// ============================================================================
-let globalTokenTracker = null;
-export function getTokenTracker() {
-    if (!globalTokenTracker) {
-        globalTokenTracker = new TokenBucketTracker();
-    }
-    return globalTokenTracker;
-}
-export function initTokenTracker(config) {
-    globalTokenTracker = new TokenBucketTracker(config);
-    return globalTokenTracker;
-}
-let globalHealthTracker = null;
-/**
- * Get the global health score tracker instance.
- * Creates one with default config if not initialized.
- */
-export function getHealthTracker() {
-    if (!globalHealthTracker) {
-        globalHealthTracker = new HealthScoreTracker();
-    }
-    return globalHealthTracker;
-}
-/**
- * Initialize the global health tracker with custom config.
- * Call this at plugin startup if custom config is needed.
- */
-export function initHealthTracker(config) {
-    globalHealthTracker = new HealthScoreTracker(config);
-    return globalHealthTracker;
-}
-// ============================================================================
-// ============================================================================
-export class LeaseTracker {
-    leasedAccounts = new Set();
-    lease(accountIndex) { this.leasedAccounts.add(accountIndex); }
-    release(accountIndex) { this.leasedAccounts.delete(accountIndex); }
-    isLeased(accountIndex) { return this.leasedAccounts.has(accountIndex); }
-}
-export class ProxyManager {
-    proxyCooldowns = new Map();
-    markCooldown(proxy, cooldownMs = 60000) {
-        this.proxyCooldowns.set(proxy, Date.now() + cooldownMs);
-    }
-    isCoolingDown(proxy) {
-        const expiresAt = this.proxyCooldowns.get(proxy);
-        if (!expiresAt)
-            return false;
-        if (Date.now() > expiresAt) {
-            this.proxyCooldowns.delete(proxy);
-            return false;
-        }
-        return true;
-    }
-    selectBestProxy(proxies) {
-        if (!proxies || proxies.length === 0)
-            return undefined;
-        const available = proxies.filter(p => !this.isCoolingDown(p));
-        if (available.length === 0)
-            return proxies[Math.floor(Math.random() * proxies.length)]; // fallback
-        return available[Math.floor(Math.random() * available.length)];
-    }
-}
-let globalLeaseTracker = null;
-export function getLeaseTracker() {
-    if (!globalLeaseTracker)
-        globalLeaseTracker = new LeaseTracker();
-    return globalLeaseTracker;
-}
-let globalProxyManager = null;
-export function getProxyManager() {
-    if (!globalProxyManager)
-        globalProxyManager = new ProxyManager();
-    return globalProxyManager;
-}

package/dist/plugin/search.d.ts

@@ -1,31 +0,0 @@
-/**
- * Google Search Tool Implementation
- *
- * Due to Gemini API limitations, native search tools (googleSearch, urlContext)
- * cannot be combined with function declarations. This module implements a
- * wrapper that makes separate API calls with only the grounding tools enabled.
- */
-export interface SearchArgs {
-    query: string;
-    urls?: string[];
-    thinking?: boolean;
-}
-export interface SearchResult {
-    text: string;
-    sources: Array<{
-        title: string;
-        url: string;
-    }>;
-    searchQueries: string[];
-    urlsRetrieved: Array<{
-        url: string;
-        status: string;
-    }>;
-}
-/**
- * Execute a Google Search using the Gemini grounding API.
- *
- * This makes a SEPARATE API call with only googleSearch/urlContext tools,
- * which is required because these tools cannot be combined with function declarations.
- */
-export declare function executeSearch(args: SearchArgs, accessToken: string, projectId: string, abortSignal?: AbortSignal): Promise<string>;