from auriko import Client, AsyncClient

client = Client(
    api_key="sk_ia_...",                   # 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,
)

class ChatCompletion:
    id: str
    created: int
    model: str
    object: str  # "chat.completion"
    system_fingerprint: Optional[str]
    choices: list[Choice]
    usage: Optional[Usage]
    routing_metadata: Optional[RoutingMetadata]
    response_headers: Optional[ResponseHeaders]

class ChoiceMessage:
    role: str
    content: Optional[str]
    reasoning_content: Optional[str]  # populated by Anthropic, DeepSeek, Google, Fireworks AI
    tool_calls: Optional[list[ToolCall]]

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 (if enabled)

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

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

workspaces = client.workspaces.list()          # GET /v1/workspaces
workspace = client.workspaces.get("ws-123")    # GET /v1/workspaces/{id}

budgets = client.budgets.list("ws-123")                  # GET /v1/workspaces/{id}/budgets
budget = client.budgets.get("ws-123", "budget-456")      # GET /v1/workspaces/{id}/budgets/{bid}

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(e.response_headers.rate_limit_reset)
except AuthenticationError as e:
    print(e.message)

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.provider_used               # X-Provider-Used
response.response_headers.routing_strategy            # X-Routing-Strategy
response.response_headers.get("x-custom-header")      # any header by name

from auriko import Client, AsyncClient
from auriko._streaming import Stream, AsyncStream  # internal module; type-annotation use only

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

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

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

from auriko.models.extensions import Extensions, ThinkingConfig

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

from auriko.models.workspaces import Workspace, WorkspaceList
from auriko.models.budgets import Budget, BudgetList, Period, ScopeType

from auriko import (
    AurikoAPIError, AuthenticationError, RateLimitError,
    InsufficientCreditsError, BudgetExceededError, ModelNotFoundError,
    InvalidRequestError, ProviderError, ProviderAuthError,
    ServiceUnavailableError, InternalError,
)

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