Errors

import os
from auriko import Client
from auriko.errors import (
    AurikoAPIError,
    APIConnectionError,
    AuthenticationError,
    PermissionDeniedError,
    BadRequestError,
    ConflictError,
    NotFoundError,
    RateLimitError,
    InternalServerError,
    APIStatusError,
)

client = Client(api_key=os.environ["AURIKO_API_KEY"])

try:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": "Hello!"}],
    )
except AuthenticationError as e:
    print(f"Check your API key. request_id={e.request_id}")
except PermissionDeniedError as e:
    print(f"Not allowed: {e.message} (code={e.code})")
except RateLimitError as e:
    print(f"Rate limited, retry after {e.retry_after_seconds}s")
except NotFoundError as e:
    print(f"Not found: {e.message} (param={e.param})")
except BadRequestError as e:
    print(f"Bad request: {e.message} (param={e.param})")
except ConflictError as e:
    print(f"Conflict: {e.message} (code={e.code})")
except InternalServerError as e:
    print(f"Server error. request_id={e.request_id}")
except APIStatusError as e:
    print(f"Upstream error ({e.status_code}): {e.message}")
except APIConnectionError as e:
    print(f"Network error: {e.message}")
except AurikoAPIError as e:
    print(f"API error ({e.status_code}): {e.message}")

import {
  Client,
  AurikoAPIError,
  APIConnectionError,
  AuthenticationError,
  PermissionDeniedError,
  BadRequestError,
  ConflictError,
  NotFoundError,
  RateLimitError,
  InternalServerError,
  APIStatusError,
} from "@auriko/sdk";

const client = new Client({ apiKey: process.env.AURIKO_API_KEY });

try {
  const response = await client.chat.completions.create({
    model: "gpt-4o",
    messages: [{ role: "user", content: "Hello!" }],
  });
} catch (e) {
  if (e instanceof AuthenticationError) {
    console.log(`Check your API key. requestId=${e.requestId}`);
  } else if (e instanceof PermissionDeniedError) {
    console.log(`Not allowed: ${e.message} (code=${e.code})`);
  } else if (e instanceof RateLimitError) {
    console.log(`Rate limited, retry after ${e.retryAfterSeconds}s`);
  } else if (e instanceof NotFoundError) {
    console.log(`Not found: ${e.message} (param=${e.param})`);
  } else if (e instanceof BadRequestError) {
    console.log(`Bad request: ${e.message} (param=${e.param})`);
  } else if (e instanceof ConflictError) {
    console.log(`Conflict: ${e.message} (code=${e.code})`);
  } else if (e instanceof InternalServerError) {
    console.log(`Server error. requestId=${e.requestId}`);
  } else if (e instanceof APIStatusError) {
    console.log(`Upstream error (${e.statusCode}): ${e.message}`);
  } else if (e instanceof APIConnectionError) {
    console.log(`Network error: ${e.message}`);
  } else if (e instanceof AurikoAPIError) {
    console.log(`API error (${e.statusCode}): ${e.message}`);
  }
}

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AURIKO_API_KEY"],
    base_url="https://api.auriko.ai/v1",
    max_retries=2,
)

# Disable retries
client = OpenAI(
    api_key=os.environ["AURIKO_API_KEY"],
    base_url="https://api.auriko.ai/v1",
    max_retries=0,
)

import OpenAI from "openai";

const client = new OpenAI({
    apiKey: process.env.AURIKO_API_KEY,
    baseURL: "https://api.auriko.ai/v1",
    maxRetries: 2,
});

// Disable retries
const noRetry = new OpenAI({
    apiKey: process.env.AURIKO_API_KEY,
    baseURL: "https://api.auriko.ai/v1",
    maxRetries: 0,
});

import os
from auriko import Client

client = Client(
    api_key=os.environ["AURIKO_API_KEY"],
    max_retries=2,
)

client = Client(
    api_key=os.environ["AURIKO_API_KEY"],
    max_retries=0,
)

import { Client } from "@auriko/sdk";

const client = new Client({
    apiKey: process.env.AURIKO_API_KEY,
    maxRetries: 2,
});

// Disable retries
const noRetry = new Client({
    apiKey: process.env.AURIKO_API_KEY,
    maxRetries: 0,
});