Rate Limits

async function makeAPIRequest(endpoint: string, options: RequestInit) {
  const response = await fetch(endpoint, options);
  
  const remaining = parseInt(response.headers.get('X-RateLimit-Remaining') || '0');
  const limit = parseInt(response.headers.get('X-RateLimit-Limit') || '0');
  
  // Slow down when approaching limit
  if (remaining < limit * 0.1) {
    console.warn(`Approaching rate limit: ${remaining}/${limit} remaining`);
    await sleep(1000); // Add 1s delay
  }
  
  return response;
}

async function retryWithBackoff<T>(
  fn: () => Promise<T>,
  maxRetries: number = 5
): Promise<T> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (error.status === 429 && attempt < maxRetries - 1) {
        const retryAfter = parseInt(error.headers.get('Retry-After') || '1');
        const jitter = Math.random() * 1000; // 0-1000ms jitter
        const delay = (retryAfter * 1000) + jitter;
        
        console.log(`Rate limited. Retrying after ${delay}ms...`);
        await sleep(delay);
      } else {
        throw error;
      }
    }
  }
  throw new Error('Max retries exceeded');
}

class RateLimitedQueue {
  private queue: Array<() => Promise<any>> = [];
  private processing = false;
  private requestsPerMinute: number;
  private lastRequest: number = 0;
  
  constructor(requestsPerMinute: number) {
    this.requestsPerMinute = requestsPerMinute;
  }
  
  async enqueue<T>(fn: () => Promise<T>): Promise<T> {
    return new Promise((resolve, reject) => {
      this.queue.push(async () => {
        try {
          const result = await fn();
          resolve(result);
        } catch (error) {
          reject(error);
        }
      });
      
      if (!this.processing) {
        this.process();
      }
    });
  }
  
  private async process() {
    this.processing = true;
    
    while (this.queue.length > 0) {
      const now = Date.now();
      const timeSinceLastRequest = now - this.lastRequest;
      const minInterval = 60000 / this.requestsPerMinute;
      
      if (timeSinceLastRequest < minInterval) {
        await sleep(minInterval - timeSinceLastRequest);
      }
      
      const task = this.queue.shift();
      if (task) {
        this.lastRequest = Date.now();
        await task();
      }
    }
    
    this.processing = false;
  }
}

// Usage
const queue = new RateLimitedQueue(300); // 300 req/min for Professional tier

await queue.enqueue(() => 
  fetch('https://api.so1.io/v1/agents/execute', { ... })
);

// ❌ Bad: Multiple individual requests
for (const agentId of agentIds) {
  await fetch(`https://api.so1.io/v1/agents/${agentId}`);
}

// ✅ Good: Single batch request
const response = await fetch('https://api.so1.io/v1/agents/batch', {
  method: 'POST',
  body: JSON.stringify({ agentIds }),
  headers: { 'Content-Type': 'application/json' }
});

const cache = new Map<string, { data: any; expiry: number }>();

async function cachedRequest(url: string, ttl: number = 60000) {
  const cached = cache.get(url);
  
  if (cached && Date.now() < cached.expiry) {
    return cached.data;
  }
  
  const response = await fetch(url);
  const data = await response.json();
  
  cache.set(url, {
    data,
    expiry: Date.now() + ttl
  });
  
  return data;
}