Error Responses

import { HydraDBError } from "@hydradb/sdk";

async function withRetry<T>(
  operation: () => Promise<T>,
  maxRetries = 3
): Promise<T> {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      if (error instanceof HydraDBError) {
        const status = error.statusCode;
        const isRetryable = [429, 500, 503].includes(status);

        if (!isRetryable || attempt === maxRetries) {
          throw error;
        }

        const delay = Math.pow(2, attempt) * 1000;
        await new Promise(resolve => setTimeout(resolve, delay));
      } else {
        throw error;
      }
    }
  }
  throw new Error("unreachable");
}

// Usage:
const result = await withRetry(() =>
  client.recall.fullRecall({
    tenant_id: "my_tenant",
    query: "..."
  })
);

import time

from hydra_db import HydraDBError

def with_retry(operation, max_retries=3):
    for attempt in range(1, max_retries + 1):
        try:
            return operation()
        except HydraDBError as e:
            status = e.status_code
            is_retryable = status in (429, 500, 503)

            if not is_retryable or attempt == max_retries:
                raise

            delay = 2 ** attempt
            time.sleep(delay)

# Usage:
result = with_retry(lambda: client.recall.full_recall(
    tenant_id="my_tenant",
    query="...",
))

async function retryRequest(url, options, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    const response = await fetch(url, options);

    // Success or non-retryable error
    if (response.ok || ![429, 500, 503].includes(response.status)) {
      return response;
    }

    if (attempt === maxRetries) {
      throw new Error(`Request failed after ${maxRetries} attempts`);
    }

    // Exponential backoff
    const delay = Math.pow(2, attempt) * 1000;
    await new Promise(resolve => setTimeout(resolve, delay));
  }
}

import { HydraDBError } from "@hydradb/sdk";

try {
  const result = await client.recall.fullRecall({
    tenant_id: "my_tenant",
    query: "What's our refund policy?"
  });
} catch (error) {
  if (error instanceof HydraDBError) {
    switch (error.body?.detail?.error_code) {
      case "TENANT_NOT_FOUND":
        // Tenant doesn't exist - prompt user to create it
        break;
      case "RATE_LIMITED":
        // Back off and retry
        break;
      case "UNAUTHORIZED":
        // Refresh API key
        break;
      default:
        // Generic error handling
        throw error;
    }
  } else {
    throw error;
  }
}

from hydra_db import HydraDBError

try:
    result = client.recall.full_recall(
        tenant_id="my_tenant",
        query="What's our refund policy?",
    )
except HydraDBError as e:
    if e.error_code == "TENANT_NOT_FOUND":
        # Tenant doesn't exist - prompt user to create it
        pass
    elif e.error_code == "RATE_LIMITED":
        # Back off and retry
        pass
    elif e.error_code == "UNAUTHORIZED":
        # Refresh API key
        pass
    else:
        raise