import { SDKRouterClient, Model } from '@sdkrouter/client';

const client = new SDKRouterClient({ apiKey: 'your-api-key' });

const response = await client.chat.create({
  model: Model.cheap(),
  messages: [{ role: 'user', content: 'Hello!' }],
});
console.log(response.choices[0]?.message?.content);

import { Model } from '@sdkrouter/client';

Model.cheap()                    // Lowest cost
Model.smart()                    // Highest quality
Model.balanced()                 // Best value
Model.fast()                     // Fastest

// With capabilities
Model.cheap({ vision: true })    // + vision
Model.smart({ tools: true })     // + function calling
Model.balanced({ json: true })   // + JSON mode

// Categories
Model.smart({ code: true })      // Coding
Model.cheap({ reasoning: true }) // Problem solving

// Buffered
const response = await client.chat.create({
  model: Model.balanced({ tools: true }),
  messages: [
    { role: 'system', content: 'You are helpful.' },
    { role: 'user', content: 'Hello!' },
  ],
});

// Streaming
for await (const chunk of client.chat.stream({
  model: Model.fast(),
  messages: [{ role: 'user', content: 'Tell me a story' }],
})) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

import { z } from 'zod';

const Sentiment = z.object({
  sentiment: z.enum(['positive', 'negative', 'neutral']),
  confidence: z.number(),
  keywords: z.array(z.string()),
});

const result = await client.parse({
  model: Model.balanced({ json: true }),
  messages: [{ role: 'user', content: 'Analyze: "This product is amazing!"' }],
  responseFormat: Sentiment,
});

console.log(result.parsed);
// { sentiment: 'positive', confidence: 0.95, keywords: ['amazing'] }

import { AudioModel } from '@sdkrouter/client';

// Text-to-Speech (buffered)
const { audioEl, analysis } = await client.audio.speech({
  model: AudioModel.quality(),
  input: 'Hello world!',
  voice: 'nova',
});
audioEl.play();

// Text-to-Speech (real-time streaming)
const audioEl = await client.audio.speechStreamRealtime({
  model: AudioModel.quality({ streaming: true }),
  input: 'Hello world!',
  voice: 'nova',
});

// Speech-to-Text
const result = await client.audio.transcribe({
  file: audioBlob,
  model: AudioModel.cheap(),
});
console.log(result.text);

// Streaming STT (WebSocket)
const stream = client.audio.transcribeStream(
  { model: 'whisper-1', language: 'en' },
  {
    onInterim: (text) => console.log('...', text),
    onFinal: (text) => console.log('Final:', text),
  },
);
stream.sendAudio(pcmChunk);
stream.stop();

const result = await client.vision.analyzeCreate({
  image_url: 'https://example.com/photo.jpg',
  prompt: 'Describe this image',
});
console.log(result.description);

// OCR
const ocr = await client.vision.ocrCreate({
  image_url: 'https://example.com/document.jpg',
});
console.log(ocr.text);

// Web search
const results = await client.search.queryCreate({
  query: 'TypeScript best practices 2025',
});
console.log(results.answer);

// Fetch & analyze URL
const page = await client.search.fetchCreate({
  url: 'https://example.com/article',
  prompt: 'Summarize this article',
});

// Upload file
const file = await client.cdn.create({ file: blob });
console.log(file.url);

// List files
const files = await client.cdn.list();

// Delete
await client.cdn.destroy('uuid');

// Client-level — all requests go through this provider
const client = new SDKRouterClient({
  apiKey: 'your-key',
  provider: 'openrouter',
});

// Per-request override
const response = await client.chat.create({
  model: 'qwen3-max',
  messages: [{ role: 'user', content: 'Hi' }],
  provider: 'alibaba', // overrides client-level
});

// Works with streaming too
for await (const chunk of client.chat.stream({
  model: 'qwen3-max',
  messages: [{ role: 'user', content: 'Hi' }],
  provider: 'alibaba',
})) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

const client = new SDKRouterClient({
  apiKey: 'your-key',
  llmUrl: 'https://...',      // default: https://llm.sdkrouter.com/v1
  apiUrl: 'https://...',      // default: https://api.sdkrouter.com
  audioUrl: 'https://...',    // default: https://audio.sdkrouter.com/v1
  env: 'development',         // use localhost URLs for local dev
  timeout: 60_000,
});

// Environment variables
// SDKROUTER_API_KEY
// SDKROUTER_LLM_URL
// SDKROUTER_API_URL
// SDKROUTER_AUDIO_URL

import {
  SDKRouterError,
  AuthenticationError,
  RateLimitError,
  NotFoundError,
} from '@sdkrouter/client';

try {
  await client.chat.create({ ... });
} catch (err) {
  if (err instanceof AuthenticationError) {
    // 401 — invalid or missing API key
  } else if (err instanceof RateLimitError) {
    // 429 — too many requests
  } else if (err instanceof SDKRouterError) {
    console.log(err.status, err.body);
  }
}