Error Responses

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

async function withRetry<T>(
  operation: () => Promise<T>,
  maxRetries = 3
): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      if (!(error instanceof HydraDBError)) throw error;

      const retryable = [429, 500, 503].includes(error.statusCode);
      if (!retryable || attempt === maxRetries) throw error;

      const baseDelayMs = 2 ** attempt * 1000;
      const jitterMs = Math.floor(Math.random() * 250);
      await new Promise((resolve) => setTimeout(resolve, baseDelayMs + jitterMs));
    }
  }

  throw new Error("unreachable");
}

const result = await withRetry(() =>
  client.query({
        database: "my_first_database",
        query: "What are the pricing tiers?",
        type: "knowledge",
  })
);

import random
import time

from hydra_db.core.api_error import ApiError

def with_retry(operation, max_retries=3):
    for attempt in range(max_retries + 1):
        try:
            return operation()
        except ApiError as exc:
            retryable = exc.status_code in (429, 500, 503)
            if not retryable or attempt == max_retries:
                raise

            delay = (2 ** attempt) + random.uniform(0, 0.25)
            time.sleep(delay)

result = with_retry(lambda: client.query(
    database="my_first_database",
    query="What are the pricing tiers?",
    type="knowledge",
))

async function hydraRequest(url: string, options: RequestInit, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const response = await fetch(url, options);
    if (response.ok) return response.json();

    const retryable = [429, 500, 503].includes(response.status);
    if (!retryable || attempt === maxRetries) {
      throw await response.json();
    }

    const baseDelayMs = 2 ** attempt * 1000;
    const jitterMs = Math.floor(Math.random() * 250);
    await new Promise((resolve) => setTimeout(resolve, baseDelayMs + jitterMs));
  }
}

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

try {
  await client.context.ingest({
    type: "knowledge",
    database: "my_first_database",
    documents: [{ path: "policy.pdf", filename: "policy.pdf" }],
  });
} catch (error) {
  if (error instanceof HydraDBError) {
    // error.body is typed `unknown`; it holds the raw snake_case error envelope.
    const body = error.body as
      | { error?: { code?: string }; meta?: { request_id?: string } }
      | undefined;
    const code = body?.error?.code;
    const requestId = body?.meta?.request_id;

    if (code === "DATABASE_NOT_FOUND") {
      // Create or select a valid database before ingesting.
    } else if (error.statusCode === 429) {
      // Retry with backoff.
    } else {
      console.error({ code, requestId });
      throw error;
    }
  } else {
    throw error;
  }
}

from hydra_db.core.api_error import ApiError

try:
    client.context.ingest(
        type="knowledge",
        database="my_first_database",
        documents=[("policy.pdf", open("policy.pdf", "rb"), "application/pdf")],
    )
except ApiError as exc:
    # The machine-readable code lives in the response envelope, not on the
    # exception: ApiError carries status_code, headers and the parsed body.
    error_code = (exc.body or {}).get("error", {}).get("code")

    if error_code == "DATABASE_NOT_FOUND":
        # Create or select a valid database before ingesting.
        pass
    elif exc.status_code == 429:
        # Retry with backoff.
        pass
    else:
        raise