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

const client = new Client({
  apiKey: "ak_...",                   // 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,
});

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

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

interface ChatCompletion {
  id: string;
  created: number;
  model: string;
  object: "chat.completion";
  system_fingerprint?: string;  // not all models include this
  choices: Choice[];
  usage?: Usage;
  routing_metadata?: RoutingMetadata;
  service_tier?: string | null;          // processing tier (OpenAI-routed models)
  responseHeaders: ResponseHeaders;  // SDK-added
}

interface ChoiceMessage {
  role: string;
  content: string | null;
  reasoning_content?: string;       // chain-of-thought text (plain string)
  reasoning?: ReasoningBlock[];     // structured reasoning blocks with signatures
  refusal?: string | null;          // model refusal content (OpenAI passthrough)
  tool_calls?: ToolCall[];
  annotations?: unknown[];               // URL citations and model annotations (OpenAI-routed models)
}

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

// Non-streaming
const response = await client.responses.create({
  model: "gpt-4o",
  input: "Hello!",
});

// Streaming
const stream = await client.responses.create({
  model: "gpt-4o",
  input: "Hello!",
  stream: true,
});

interface ResponseObject {
  id: string;
  object: "response";
  created_at: number;
  model: string;
  status: "completed" | "failed" | "incomplete" | "in_progress";
  output: ResponseOutputItem[];
  output_text: string;
  parallel_tool_calls: boolean;
  tool_choice: unknown;
  tools: unknown[];
  usage?: ResponseUsage | null;
  error?: ResponseError | null;
  incomplete_details?: Record<string, string> | null;
  metadata?: Record<string, string> | null;
  routing_metadata?: RoutingMetadata | null;
  responseHeaders: ResponseHeaders;
}

const stream = await client.responses.create({
  model: "gpt-4o",
  input: "Hello!",
  stream: true,
});

for await (const event of stream) {
  if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);
  }
}

// After iteration, the terminal event's response is available:
const final = stream.completedResponse;  // ResponseObject from the terminal event
final?.usage;                            // token usage
final?.routing_metadata;                 // routing details

stream.responseHeaders;                  // available immediately (before iteration)
stream.close();                          // manual cleanup

const models = await client.models.list();                // GET /v1/models
const model = await client.models.retrieve("gpt-4o");     // GET /v1/models/{model_id}
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 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(`retry after ${e.retryAfterSeconds}s (requestId=${e.requestId})`);
  } else if (e instanceof AuthenticationError) {
    console.log(`${e.message} (requestId=${e.requestId})`);
  }
}

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

const err = mapErrorFromCode("rate_limit_error", "Too many requests", responseHeaders);
if (err instanceof RateLimitError) {
  console.log(err.retryAfterSeconds);
}

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.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.COST_FOCUS  // "cost-focus"
Optimize.TTFT        // "ttft"
Optimize.TTFT_FOCUS  // "ttft-focus"
Optimize.TPS         // "tps"
Optimize.TPS_FOCUS   // "tps-focus"
Optimize.BALANCED    // "balanced"

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

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

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

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

import type {
  ResponseObject, ResponseObjectBase, ResponseUsage, ResponseError,
  ResponseOutputItem, ResponseMessageOutputItem,
  ResponseFunctionCallOutputItem, ResponseReasoningOutputItem,
  ResponseOutputContentPart, ResponseReasoningSummary,
  ResponseStreamEvent, ResponseCreateParams,
  ResponseInputItemParam, ResponseToolParam, ResponseReasoningParam,
} from "@auriko/sdk";

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

import type { GatewayOptions, RoutingOptions, RoutingMetadata, CostInfo, StructuredWarning, StructuredWarningType } from "@auriko/sdk";

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

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

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

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

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