Resolve Quota & Billing Errors

import { ParrotRouter } from 'parrotrouter-sdk';

class UsageMonitor {
  constructor(apiKey, limits) {
    this.client = new ParrotRouter(apiKey);
    this.limits = limits;
    this.usage = { requests: 0, tokens: 0, cost: 0 };
  }

  async makeRequest(prompt, model) {
    // Check limits before making request
    if (this.usage.requests >= this.limits.maxRequests) {
      throw new Error('Daily request limit reached');
    }
    
    if (this.usage.cost >= this.limits.maxCost) {
      throw new Error('Daily cost limit reached');
    }

    try {
      const response = await this.client.chat.completions.create({
        model: model,
        messages: [{ role: 'user', content: prompt }],
        max_tokens: 500
      });

      // Update usage tracking
      this.usage.requests++;
      this.usage.tokens += response.usage.total_tokens;
      this.usage.cost += this.calculateCost(model, response.usage);

      // Send alert if approaching limits
      if (this.usage.cost > this.limits.maxCost * 0.8) {
        this.sendAlert('Approaching 80% of daily cost limit');
      }

      return response;
    } catch (error) {
      if (error.status === 429) {
        console.error('Quota exceeded:', error.message);
        this.handleQuotaExceeded();
      }
      throw error;
    }
  }

  calculateCost(model, usage) {
    const pricing = {
      'gpt-4': { input: 0.03, output: 0.06 },
      'gpt-3.5-turbo': { input: 0.0005, output: 0.0015 },
      'claude-3-opus': { input: 0.015, output: 0.075 }
    };

    const modelPricing = pricing[model] || pricing['gpt-3.5-turbo'];
    return (usage.prompt_tokens * modelPricing.input + 
            usage.completion_tokens * modelPricing.output) / 1000;
  }

  handleQuotaExceeded() {
    // Implement fallback strategy
    console.log('Switching to backup provider or cheaper model');
    // Notify administrators
    this.sendAlert('Quota exceeded - switching to fallback');
  }

  sendAlert(message) {
    // Implement your alert mechanism
    console.warn('[USAGE ALERT]:', message);
  }
}

// Usage
const monitor = new UsageMonitor('your-api-key', {
  maxRequests: 1000,
  maxCost: 50.00
});

import { RateLimiter } from 'limiter';

class APIRateLimiter {
  constructor() {
    // Create different rate limiters for different tiers
    this.limiters = {
      free: new RateLimiter({
        tokensPerInterval: 3,
        interval: 'minute',
        fireImmediately: true
      }),
      paid: new RateLimiter({
        tokensPerInterval: 60,
        interval: 'minute',
        fireImmediately: true
      }),
      enterprise: new RateLimiter({
        tokensPerInterval: 3000,
        interval: 'minute',
        fireImmediately: true
      })
    };
  }

  async throttledRequest(tier, requestFn) {
    const limiter = this.limiters[tier] || this.limiters.free;
    
    // Wait for rate limit token
    await limiter.removeTokens(1);
    
    try {
      return await requestFn();
    } catch (error) {
      if (error.status === 429) {
        // Extract retry-after header
        const retryAfter = error.headers?.['retry-after'] || 60;
        console.log(`Rate limited. Retrying after ${retryAfter} seconds`);
        
        // Wait and retry
        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
        return await this.throttledRequest(tier, requestFn);
      }
      throw error;
    }
  }
}

// Usage with token bucket algorithm
class TokenBucket {
  constructor(capacity, refillRate) {
    this.capacity = capacity;
    this.tokens = capacity;
    this.refillRate = refillRate; // tokens per second
    this.lastRefill = Date.now();
  }

  async getToken() {
    // Refill tokens based on time passed
    const now = Date.now();
    const timePassed = (now - this.lastRefill) / 1000;
    this.tokens = Math.min(
      this.capacity,
      this.tokens + timePassed * this.refillRate
    );
    this.lastRefill = now;

    if (this.tokens < 1) {
      // Calculate wait time
      const waitTime = (1 - this.tokens) / this.refillRate * 1000;
      await new Promise(resolve => setTimeout(resolve, waitTime));
      return this.getToken();
    }

    this.tokens -= 1;
    return true;
  }
}

// Initialize with 10 requests per minute capacity
const bucket = new TokenBucket(10, 10/60);

async function rateLimitedAPICall(prompt) {
  await bucket.getToken();
  return makeAPICall(prompt);
}