Call an uncensored LLM API from Node.js

mkdir llm-demo && cd llm-demo
npm init -y
npm pkg set type=module
npm install openai

export LLM_BASE_URL="https://api.venice.ai/api/v1"
export LLM_API_KEY="your-key-here"
export LLM_MODEL="venice-uncensored-1-2"

// One chat completion against any OpenAI-compatible API.
// Set LLM_BASE_URL, LLM_API_KEY and LLM_MODEL in the environment first.
import OpenAI from 'openai'

const client = new OpenAI({
  baseURL: process.env.LLM_BASE_URL,
  apiKey: process.env.LLM_API_KEY,
  timeout: 60_000, // milliseconds for the whole request
  maxRetries: 2, // the SDK retries 408, 409, 429 and 5xx with backoff
})

try {
  const reply = await client.chat.completions.create({
    model: process.env.LLM_MODEL,
    messages: [
      { role: 'system', content: 'You are a concise assistant for developers.' },
      { role: 'user', content: 'Explain what a race condition is in two sentences.' },
    ],
    max_tokens: 300,
  })
  const choice = reply.choices[0]
  console.log(choice.message.content)
  console.log(`finish_reason=${choice.finish_reason}`)
  if (reply.usage) console.log(`tokens: ${reply.usage.prompt_tokens} in, ${reply.usage.completion_tokens} out`)
} catch (err) {
  if (err instanceof OpenAI.APIError && err.status) {
    // 401 bad key, 404 wrong base URL or model, 413 prompt too long, 429 rate limit
    console.error(`The API returned ${err.status}: ${err.message}`)
  } else {
    console.error(`Request failed: ${err.message}`)
  }
  process.exitCode = 1
}

// Stream a reply with the OpenAI SDK, with a timeout that cancels the request.
import OpenAI from 'openai'

const client = new OpenAI({ baseURL: process.env.LLM_BASE_URL, apiKey: process.env.LLM_API_KEY })
const controller = new AbortController()
const timer = setTimeout(() => controller.abort(), 30_000) // give up after 30 s

let text = ''
let usage = null
try {
  const stream = await client.chat.completions.create(
    {
      model: process.env.LLM_MODEL,
      messages: [{ role: 'user', content: 'Write a haiku about version control.' }],
      max_tokens: 200,
      stream: true,
      stream_options: { include_usage: true }, // some servers ignore this
    },
    { signal: controller.signal },
  )
  for await (const chunk of stream) {
    if (chunk.usage) usage = chunk.usage
    const piece = chunk.choices[0]?.delta?.content
    if (piece) {
      text += piece
      process.stdout.write(piece)
    }
  }
  process.stdout.write('\n')
  if (usage) console.log(`tokens: ${usage.prompt_tokens} in, ${usage.completion_tokens} out`)
  console.log(`characters received: ${text.length}`)
} catch (err) {
  console.error(controller.signal.aborted ? 'Timed out and cancelled.' : `Stream failed: ${err.message}`)
  process.exitCode = 1
} finally {
  clearTimeout(timer)
}