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

const client = new Client({
  apiKey: "sk_ia_...",                   // or AURIKO_API_KEY env var
  baseUrl: "https://api.auriko.ai/v1",  // default
  timeout: 60_000,                       // ms, default 60s
  maxRetries: 2,                         // default 2 (0 disables)
});

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

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

interface ChatCompletion {
  id: string;
  created: number;
  model: string;
  object: "chat.completion";
  system_fingerprint?: string;
  choices: Choice[];
  usage?: Usage;
  routing_metadata?: RoutingMetadata;
  responseHeaders: ResponseHeaders;  // SDK-added
}

interface ChoiceMessage {
  role: string;
  content: string | null;
  reasoning_content?: string;  // populated by Anthropic, DeepSeek, Google, Fireworks AI
  tool_calls?: ToolCall[];
}

const stream = await client.chat.completions.create({ stream: true, ... });

for await (const chunk of 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.responseHeaders;  // available immediately
stream.isClosed;         // boolean
stream.close();          // manual cleanup

const directory = await client.models.listDirectory();    // GET /v1/directory/models
const registry = await client.models.listRegistry();      // GET /v1/registry/models
const providers = await client.models.listProviders();    // GET /v1/registry/providers

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

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

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

import { Client, RateLimitError, AuthenticationError } from "@auriko/sdk";

try {
  await client.chat.completions.create({ ... });
} catch (e) {
  if (e instanceof RateLimitError) {
    console.log(e.responseHeaders.rateLimitReset);
  }
}

response.responseHeaders.requestId;                  // X-Request-ID
response.responseHeaders.rateLimitRemaining;          // X-RateLimit-Remaining-Requests
response.responseHeaders.rateLimitLimit;              // X-RateLimit-Limit-Requests
response.responseHeaders.rateLimitReset;              // X-RateLimit-Reset-Requests
response.responseHeaders.creditsBalanceMicrodollars;  // X-Credits-Balance-Microdollars
response.responseHeaders.providerUsed;                // X-Provider-Used
response.responseHeaders.routingStrategy;             // X-Routing-Strategy
response.responseHeaders.get("x-custom-header");      // any header by name
response.responseHeaders.getAll("x-multi-header");    // string[] for multi-value headers

import { Optimize, Mode, DataPolicy } from "@auriko/sdk";

// Optimize strategy
Optimize.COST       // "cost"
Optimize.TTFT       // "ttft"
Optimize.SPEED      // "speed"
Optimize.THROUGHPUT  // "throughput"
Optimize.BALANCED   // "balanced"
Optimize.CHEAPEST   // "cheapest"

// Routing mode
Mode.POOL           // "pool"
Mode.FALLBACK       // "fallback"

// Data policy
DataPolicy.NONE         // "none"
DataPolicy.NO_TRAINING  // "no_training"
DataPolicy.ZDR          // "zdr"

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

import type {
  ChatCompletion, ChatCompletionChunk, Choice, ChoiceMessage,
  StreamChoice, Delta, ToolCall, ToolCallFunction,
  ToolCallDelta, ToolCallDeltaFunction,
} from "@auriko/sdk";

import type { Usage, PromptTokensDetails, CompletionTokensDetails, ApiKeyIdentity } from "@auriko/sdk";

import type { RoutingOptions, RoutingMetadata, CostInfo, FallbackChainEntry } from "@auriko/sdk";

import type { Extensions, ThinkingConfig } from "@auriko/sdk";

import type { DirectoryResponse, ModelsListResponse, ProviderList } from "@auriko/sdk";

import type { Workspace, WorkspaceList, Budget, BudgetList } from "@auriko/sdk";

import type { ChatCompletionCreateParams, ClientOptions } from "@auriko/sdk";

import { Optimize, Mode, DataPolicy, ResponseHeaders } from "@auriko/sdk";

import {
  AurikoAPIError, AuthenticationError, RateLimitError,
  InsufficientCreditsError, BudgetExceededError, ModelNotFoundError,
  InvalidRequestError, ProviderError, ProviderAuthError,
  ServiceUnavailableError, InternalError,
} from "@auriko/sdk";