Errors & limits

research_with_retry() {
  local query="$1"
  local key="$2"
  local max_retries=3
  for ((attempt=1; attempt<=max_retries; attempt++)); do
    response=$(curl -s -i -N -X POST https://api.bahith.dev/v1/research \
      -H "Content-Type: application/json" \
      -H "X-API-Key: $key" \
      -d "{\"query\": \"$query\"}")
    
    status_code=$(echo "$response" | grep "HTTP/" | awk '{print $2}')
    
    if [ "$status_code" -eq 429 ]; then
      retry_after=$(echo "$response" | grep -i "Retry-After" | awk '{print $2}' | tr -d '\r')
      retry_after=${retry_after:-5}
      echo "Rate limited. Retrying in $retry_after seconds..."
      sleep "$retry_after"
      continue
    fi
    echo "$response"
    return 0
  done
  echo "Failed after $max_retries attempts" >&2
  return 1
}

async function researchWithRetry(body: any, key: string, maxRetries = 3): Promise<Response> {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const resp = await fetch("https://api.bahith.dev/v1/research", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "X-API-Key": key,
      },
      body: JSON.stringify(body),
    });
 
    if (resp.status === 429) {
      const retryAfter = parseInt(resp.headers.get("Retry-After") || "5", 10);
      console.warn(`Rate limited. Waiting ${retryAfter}s before retry...`);
      await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
      continue;
    }
 
    if (!resp.ok) {
      throw new Error(`HTTP Error: ${resp.status}`);
    }
 
    return resp;
  }
  throw new Error("Rate limited after maximum retries");
}

import time
import requests
 
def research_with_retry(body, key, max_retries=3):
    for attempt in range(max_retries):
        resp = requests.post(
            "https://api.bahith.dev/v1/research",
            headers={"X-API-Key": key, "Content-Type": "application/json"},
            json=body, stream=True,
        )
        if resp.status_code == 429:
            time.sleep(int(resp.headers.get("Retry-After", "5")))
            continue
        resp.raise_for_status()
        return resp
    raise RuntimeError("rate limited after retries")

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
 
public class BahithRetryClient {
    public static HttpResponse<String> researchWithRetry(String jsonBody, String apiKey, int maxRetries) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.bahith.dev/v1/research"))
            .header("Content-Type", "application/json")
            .header("X-API-Key", apiKey)
            .POST(HttpRequest.BodyPublishers.ofString(jsonBody))
            .build();
 
        for (int attempt = 0; attempt < maxRetries; attempt++) {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
            if (response.statusCode() == 429) {
                String retryAfterStr = response.headers().firstValue("Retry-After").orElse("5");
                int retryAfter = Integer.parseInt(retryAfterStr);
                System.out.println("Rate limited. Retrying in " + retryAfter + "s...");
                Thread.sleep(retryAfter * 1000L);
                continue;
            }
            if (response.statusCode() >= 400) {
                throw new RuntimeException("HTTP Error: " + response.statusCode());
            }
            return response;
        }
        throw new RuntimeException("Rate limited after maximum retries");
    }
}