Managing AI API Keys, Rate Limits & Costs

import { createClient } from "@supabase/supabase-js";

const supabase = createClient(
  Deno.env.get("SUPABASE_URL")!,
  Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!
);

async function checkRateLimit(userId: string, maxRequests = 20, windowMinutes = 60) {
  const windowStart = new Date(Date.now() - windowMinutes * 60 * 1000).toISOString();

  // Count requests in the sliding window
  const { count } = await supabase
    .from("api_usage")
    .select("*", { count: "exact", head: true })
    .eq("user_id", userId)
    .gte("created_at", windowStart);

  if ((count ?? 0) >= maxRequests) {
    return { allowed: false, remaining: 0 };
  }

  // Log this request
  await supabase.from("api_usage").insert({
    user_id: userId,
    tokens_used: 0, // updated after AI call completes
    estimated_cost: 0,
  });

  return { allowed: true, remaining: maxRequests - (count ?? 0) - 1 };
}

import anthropic
import openai
import time

def call_ai_with_retry(prompt: str, max_retries: int = 3) -> str:
    """Call Claude first, fall back to GPT, with exponential backoff."""

    providers = [
        ("claude", lambda: anthropic.Anthropic().messages.create(
            model="claude-sonnet-4-6",
            max_tokens=1024,
            messages=[{"role": "user", "content": prompt}]
        ).content[0].text),
        ("gpt", lambda: openai.OpenAI().chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}]
        ).choices[0].message.content),
    ]

    for name, call_fn in providers:
        for attempt in range(max_retries):
            try:
                result = call_fn()
                print(f"✅ {name} responded (attempt {attempt + 1})")
                return result
            except Exception as e:
                wait = 2 ** attempt  # 1s, 2s, 4s
                print(f"⚠️ {name} failed (attempt {attempt + 1}): {e}")
                if attempt < max_retries - 1:
                    time.sleep(wait)

    return "All AI providers unavailable. Please try again later."

interface AIProvider {
  name: string;
  call: (prompt: string, maxTokens: number) => Promise<string>;
  costPerInputToken: number;
  costPerOutputToken: number;
  healthy: boolean;
  errorCount: number;
}

class AIRouter {
  private providers: AIProvider[];
  private circuitBreakerThreshold = 3;
  private resetIntervalMs = 60_000;

  constructor(providers: AIProvider[]) {
    this.providers = providers;
    // Reset circuit breakers every minute
    setInterval(() => {
      this.providers.forEach(p => {
        p.errorCount = 0;
        p.healthy = true;
      });
    }, this.resetIntervalMs);
  }

  async route(prompt: string, maxTokens = 1024): Promise<{
    response: string;
    provider: string;
    estimatedCost: number;
  }> {
    const healthy = this.providers.filter(p => p.healthy);
    if (healthy.length === 0) {
      throw new Error("All AI providers are down");
    }

    for (const provider of healthy) {
      try {
        const response = await provider.call(prompt, maxTokens);
        const inputTokens = Math.ceil(prompt.length / 4);
        const outputTokens = Math.ceil(response.length / 4);
        const cost = (inputTokens * provider.costPerInputToken)
                   + (outputTokens * provider.costPerOutputToken);

        return { response, provider: provider.name, estimatedCost: cost };
      } catch (error) {
        provider.errorCount++;
        if (provider.errorCount >= this.circuitBreakerThreshold) {
          provider.healthy = false;
          console.warn(`Circuit breaker tripped for ${provider.name}`);
        }
      }
    }
    throw new Error("All healthy providers failed");
  }
}

CREATE TABLE ai_api_calls (
  id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
  created_at TIMESTAMPTZ DEFAULT now(),
  user_id UUID REFERENCES auth.users(id),
  feature TEXT NOT NULL,          -- 'chat', 'search', 'analysis'
  provider TEXT NOT NULL,         -- 'anthropic', 'openai'
  model TEXT NOT NULL,            -- 'claude-sonnet-4-6', 'gpt-4o'
  input_tokens INTEGER NOT NULL,
  output_tokens INTEGER NOT NULL,
  latency_ms INTEGER NOT NULL,
  estimated_cost NUMERIC(10, 6) NOT NULL,
  cached BOOLEAN DEFAULT false,
  status TEXT DEFAULT 'success'   -- 'success', 'error', 'timeout'
);

-- Index for cost analysis queries
CREATE INDEX idx_ai_calls_daily ON ai_api_calls (created_at, provider);
CREATE INDEX idx_ai_calls_user ON ai_api_calls (user_id, created_at);

-- Daily cost summary view
CREATE VIEW daily_cost_summary AS
SELECT
  date_trunc('day', created_at) AS day,
  provider,
  model,
  COUNT(*) AS total_calls,
  SUM(input_tokens) AS total_input_tokens,
  SUM(output_tokens) AS total_output_tokens,
  SUM(estimated_cost) AS total_cost,
  AVG(latency_ms)::INTEGER AS avg_latency_ms,
  COUNT(*) FILTER (WHERE cached) AS cache_hits,
  COUNT(*) FILTER (WHERE status = 'error') AS errors
FROM ai_api_calls
GROUP BY 1, 2, 3
ORDER BY 1 DESC;