from auriko import Client, AsyncClient

client = Client(
    api_key="ak_...",                   # or AURIKO_API_KEY env var
    base_url="https://api.auriko.ai/v1",   # default
    timeout=60.0,                           # seconds, default 60
    max_retries=2,                          # default 2 (0 disables)
)

# Non-streaming
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
    max_tokens=100,
)

# Streaming
stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
    stream=True,
)

from auriko import Client
from auriko.route_types import GatewayOptions

client = Client()
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
    gateway=GatewayOptions(
        metadata={
            "user_id": "user_123",
            "trace_id": "req-abc",
            "custom_fields": {"env": "prod", "team": "backend"}
        }
    ),
)

class ChatCompletion:
    id: str
    created: int
    model: str
    object: str  # "chat.completion"
    system_fingerprint: Optional[str]  # not all models include this
    choices: list[Choice]
    usage: Optional[Usage]
    routing_metadata: Optional[RoutingMetadata]
    service_tier: Optional[str]           # processing tier (OpenAI-routed models)
    response_headers: Optional[ResponseHeaders]

class ChoiceMessage:
    role: str
    content: Optional[str]
    reasoning_content: Optional[str]  # chain-of-thought text (plain string)
    reasoning: Optional[list[ThinkingReasoningBlock | RedactedReasoningBlock]]  # structured reasoning blocks with signatures
    refusal: Optional[str]            # model refusal content (OpenAI passthrough)
    tool_calls: Optional[list[ToolCall]]
    annotations: Optional[list[Any]]      # URL citations and model annotations (OpenAI-routed models)

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
    stream=True,
)

for chunk in stream:
    chunk.choices[0].delta.content                  # incremental content
    chunk.choices[0].delta.reasoning_content        # incremental reasoning text (if enabled)
    chunk.choices[0].delta.reasoning_signature      # signature for current thinking block
    chunk.choices[0].delta.reasoning_redacted_data  # encrypted redacted thinking data

stream.usage            # available after iteration
stream.routing_metadata # available after iteration
stream.response_headers # available immediately
stream.close()          # manual cleanup (or use context manager)

# Non-streaming
response = client.responses.create(
    model="gpt-4o",
    input="Hello!",
)

# Streaming
stream = client.responses.create(
    model="gpt-4o",
    input="Hello!",
    stream=True,
)

class Response:
    id: str
    object: str                              # "response"
    created_at: int
    model: str
    status: str                              # "completed", "failed", "incomplete", "in_progress"
    output: list[ResponseOutputItem]
    output_text: str                         # concatenated text output
    parallel_tool_calls: bool
    tool_choice: Any
    tools: list[Any]
    usage: Optional[ResponseUsage]
    error: Optional[dict]
    incomplete_details: Optional[dict]
    metadata: Optional[dict[str, str]]
    routing_metadata: Optional[RoutingMetadata]
    response_headers: Optional[ResponseHeaders]  # property, set by SDK after parsing

stream = client.responses.create(
    model="gpt-4o",
    input="Hello!",
    stream=True,
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="")

# After iteration, the terminal event's response is available:
final = stream.completed_response  # Response object from the terminal event
final.usage                        # token usage
final.routing_metadata             # routing details

stream.response_headers            # available immediately (before iteration)
stream.close()                     # manual cleanup (or use context manager)

models = client.models.list()                # GET /v1/models
model = client.models.retrieve("gpt-4o")     # GET /v1/models/{model_id}
directory = client.models.list_directory()    # GET /v1/directory/models
registry = client.models.list_registry()      # GET /v1/registry/models
providers = client.models.list_providers()    # GET /v1/registry/providers

identity = client.me.get()  # GET /v1/me
# Returns: ApiKeyIdentity { object, user_id, workspace_id, tier, rate_limit_rpm }

from auriko import RateLimitError, AuthenticationError

try:
    client.chat.completions.create(...)
except RateLimitError as e:
    print(f"retry after {e.retry_after_seconds}s (request_id={e.request_id})")
except AuthenticationError as e:
    print(f"{e.message} (request_id={e.request_id})")

response.response_headers.request_id                 # X-Request-ID
response.response_headers.rate_limit_remaining        # X-RateLimit-Remaining-Requests
response.response_headers.rate_limit_limit            # X-RateLimit-Limit-Requests
response.response_headers.rate_limit_reset            # X-RateLimit-Reset-Requests
response.response_headers.credits_balance_microdollars # X-Credits-Balance-Microdollars
response.response_headers.get("x-custom-header")      # any header by name

pip install "auriko[openai-compat]"

class AurikoAsyncOpenAI(AsyncOpenAI):
    def __init__(
        self,
        *,
        api_key: str | None = None,
        base_url: str = "https://api.auriko.ai/v1",
        on_response: Callable[[RoutingMetadata], Any] | None = None,
        **kwargs: Any,
    ) -> None: ...

from auriko.route_types import RoutingMetadata

import asyncio
import auriko
from auriko import AurikoAsyncOpenAI

async def main():
    client = AurikoAsyncOpenAI()
    try:
        response = await client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": "Hello!"}],
        )
    except auriko.RateLimitError as e:  # also catchable as openai.RateLimitError
        print(f"Rate limited: {e.message}")

asyncio.run(main())

from auriko import Client, AsyncClient, ResponseStream, AsyncResponseStream

from auriko.models.chat import (
    ChatCompletion, ChatCompletionChunk, Choice, ChoiceMessage,
    StreamChoice, Delta, ToolCall, ToolCallFunction,
    ToolCallDelta, ToolCallDeltaFunction,
    ThinkingReasoningBlock, RedactedReasoningBlock,
)

from auriko.models.responses import Response, ResponseStreamEvent, ResponseUsage, UnknownStreamEvent

from auriko.models.common import Usage, PromptTokensDetails, CompletionTokensDetails, ApiKeyIdentity

from auriko.route_types import (
    RoutingOptions, RoutingMetadata, CostInfo, StructuredWarning, StructuredWarningType,
    Optimize, Mode, DataPolicy,
)

from auriko.models.extensions import Extensions

from auriko.models.providers import (
    ModelsListResponse, CanonicalModel,
    DirectoryResponse, DirectoryModel, ProviderEntry, TierEntry,
    ProviderList, ProviderInfo,
)

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

from auriko import ResponseHeaders, map_openai_error
from auriko.route_types import parse_routing_metadata
from auriko.errors import map_error_from_code