Rate Limits

class RateLimitManager {
  constructor() {
    this.limits = {};
  }
  
  updateLimits(response) {
    this.limits = {
      limit: parseInt(response.headers.get('X-RateLimit-Limit')),
      remaining: parseInt(response.headers.get('X-RateLimit-Remaining')),
      reset: parseInt(response.headers.get('X-RateLimit-Reset')),
      window: parseInt(response.headers.get('X-RateLimit-Window'))
    };
  }
  
  shouldThrottle() {
    if (!this.limits.remaining) return false;
    
    // If less than 10% of requests remaining, slow down
    const usagePercent = (this.limits.limit - this.limits.remaining) / this.limits.limit;
    return usagePercent > 0.9;
  }
  
  getThrottleDelay() {
    if (!this.shouldThrottle()) return 0;
    
    const now = Math.floor(Date.now() / 1000);
    const timeUntilReset = this.limits.reset - now;
    
    // Distribute remaining requests evenly over remaining time
    return (timeUntilReset / this.limits.remaining) * 1000;
  }
}

// Usage
const rateLimitManager = new RateLimitManager();

async function makeRequest(url, options) {
  // Check if we should throttle
  const delay = rateLimitManager.getThrottleDelay();
  if (delay > 0) {
    await sleep(delay);
  }
  
  const response = await fetch(url, options);
  rateLimitManager.updateLimits(response);
  
  return response;
}

class APIQueue {
  constructor(requestsPerMinute = 100) {
    this.queue = [];
    this.processing = false;
    this.requestsPerMinute = requestsPerMinute;
    this.minInterval = (60 * 1000) / requestsPerMinute; // ms between requests
    this.lastRequestTime = 0;
  }
  
  async enqueue(requestFunction) {
    return new Promise((resolve, reject) => {
      this.queue.push({
        request: requestFunction,
        resolve,
        reject
      });
      
      this.processQueue();
    });
  }
  
  async processQueue() {
    if (this.processing || this.queue.length === 0) {
      return;
    }
    
    this.processing = true;
    
    while (this.queue.length > 0) {
      const { request, resolve, reject } = this.queue.shift();
      
      try {
        // Ensure minimum interval between requests
        const now = Date.now();
        const timeSinceLastRequest = now - this.lastRequestTime;
        const delay = Math.max(0, this.minInterval - timeSinceLastRequest);
        
        if (delay > 0) {
          await sleep(delay);
        }
        
        const result = await request();
        this.lastRequestTime = Date.now();
        resolve(result);
        
      } catch (error) {
        reject(error);
      }
    }
    
    this.processing = false;
  }
}

// Usage
const apiQueue = new APIQueue(90); // 90 requests per minute (under the limit)

// Queue requests instead of making them directly
const sendMessage = (messageData) => {
  return apiQueue.enqueue(async () => {
    const response = await fetch('https://api.amanahagent.cloud/v1/messages', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(messageData)
    });
    
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
    
    return response.json();
  });
};

GET https://api.amanahagent.cloud/v1/usage/rate-limits

{
  "current_limits": {
    "requests_per_minute": {
      "limit": 100,
      "used": 23,
      "remaining": 77,
      "reset_time": "2024-01-15T10:31:00Z"
    },
    "requests_per_hour": {
      "limit": 1000,
      "used": 847,
      "remaining": 153,
      "reset_time": "2024-01-15T11:00:00Z"
    },
    "messages_per_month": {
      "limit": 25000,
      "used": 12458,
      "remaining": 12542,
      "reset_time": "2024-02-01T00:00:00Z"
    }
  },
  "plan": "pro",
  "usage_history": {
    "last_24h": 2847,
    "last_7d": 18945,
    "last_30d": 12458
  }
}