deepgram-rate-limits

# Deepgram Rate Limits

## Overview
Implement proper rate limiting and backoff strategies for Deepgram API integration.

## Deepgram Rate Limits

| Plan | Concurrent Requests | Requests/Minute | Audio Hours/Month |
|------|---------------------|-----------------|-------------------|
| Pay As You Go | 100 | 1000 | Unlimited |
| Growth | 200 | 2000 | Included hours |
| Enterprise | Custom | Custom | Custom |

## Instructions

### Step 1: Implement Request Queue
Create a queue to manage concurrent request limits.

### Step 2: Add Exponential Backoff
Handle rate limit responses with intelligent retry.

### Step 3: Monitor Usage
Track request counts and audio duration.

### Step 4: Implement Circuit Breaker
Prevent cascade failures during rate limiting.

## Output
- Rate-limited request queue
- Exponential backoff handler
- Usage monitoring dashboard
- Circuit breaker implementation

## Examples

### TypeScript Rate Limiter
```typescript
// lib/rate-limiter.ts
interface RateLimiterConfig {
  maxConcurrent: number;
  maxPerMinute: number;
  retryAttempts: number;
  baseDelay: number;
}

export class DeepgramRateLimiter {
  private queue: Array<{
    fn: () => Promise<unknown>;
    resolve: (value: unknown) => void;
    reject: (error: Error) => void;
  }> = [];
  private activeRequests = 0;
  private requestsThisMinute = 0;
  private minuteStart = Date.now();
  private config: RateLimiterConfig;

  constructor(config: Partial<RateLimiterConfig> = {}) {
    this.config = {
      maxConcurrent: config.maxConcurrent ?? 50,
      maxPerMinute: config.maxPerMinute ?? 500,
      retryAttempts: config.retryAttempts ?? 3,
      baseDelay: config.baseDelay ?? 1000,
    };
  }

  async execute<T>(fn: () => Promise<T>): Promise<T> {
    return new Promise((resolve, reject) => {
      this.queue.push({
        fn,
        resolve: resolve as (value: unknown) => void,
        reject,
      });
      this.processQueue();
    });
  }

  private async processQueue() {
    // Reset minute