LLM APIs: a first request to Claude and OpenAI

mkdir llm-first-request
cd llm-first-request
npm init -y
npm pkg set type=module
npm install @anthropic-ai/sdk openai
npm install -D typescript @types/node@24
mkdir src

{
  "compilerOptions": {
    "target": "es2024",
    "module": "nodenext",
    "strict": true,
    "noEmit": true,
    "allowImportingTsExtensions": true,
    "erasableSyntaxOnly": true,
    "verbatimModuleSyntax": true,
    "skipLibCheck": true,
    "types": ["node"]
  },
  "include": ["src"]
}

# Copy to .env and put your own keys there. Never commit .env.
ANTHROPIC_API_KEY=YOUR_ANTHROPIC_API_KEY
OPENAI_API_KEY=YOUR_OPENAI_API_KEY

import Anthropic from "@anthropic-ai/sdk";

// The SDK reads ANTHROPIC_API_KEY from the environment; fail fast with a clear message.
if (!process.env.ANTHROPIC_API_KEY) {
  throw new Error("ANTHROPIC_API_KEY is not set: copy .env.example to .env");
}

const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 2048,
  system: "You are a concise assistant for a web studio. Answer in two sentences.",
  messages: [{ role: "user", content: "What is an HTTP 429 status code?" }],
});

// content is an array of blocks (text, thinking, tool_use...): take only text blocks.
const text = message.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);
console.log("stop_reason:", message.stop_reason);
console.log("tokens in/out:", message.usage.input_tokens, message.usage.output_tokens);

npx tsc -p .
node --env-file=.env src/anthropic-hello.ts
node --env-file=.env src/openai-hello.ts

import OpenAI from "openai";

// The SDK reads OPENAI_API_KEY from the environment; fail fast with a clear message.
if (!process.env.OPENAI_API_KEY) {
  throw new Error("OPENAI_API_KEY is not set: copy .env.example to .env");
}

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  reasoning: { effort: "low" },
  instructions: "You are a concise assistant for a web studio. Answer in two sentences.",
  input: "What is an HTTP 429 status code?",
});

// output_text joins every text item from response.output into one string.
console.log(response.output_text);
console.log("status:", response.status);
console.log("tokens in/out:", response.usage?.input_tokens, response.usage?.output_tokens);

import Anthropic from "@anthropic-ai/sdk";
import OpenAI from "openai";

type Turn = { role: "user" | "assistant"; content: string };

const system = "You are a support assistant of a coffee shop. Answer briefly.";

// The API is stateless: every request carries the whole conversation.
const history: Turn[] = [
  { role: "user", content: "Do you have oat milk?" },
  { role: "assistant", content: "Yes, oat and almond milk are available." },
  { role: "user", content: "Is it extra?" },
];

const anthropic = new Anthropic();
const claude = await anthropic.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 2048,
  system, // Anthropic: the system prompt is a separate top-level field
  messages: history,
});
const claudeText = claude.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");
console.log("Claude:", claudeText);

const openai = new OpenAI();
const gpt = await openai.responses.create({
  model: "gpt-6-astra",
  instructions: system, // OpenAI: instructions outrank messages in input
  input: history,
});
console.log("GPT:", gpt.output_text);

import Anthropic from "@anthropic-ai/sdk";
import OpenAI from "openai";

const question = "List three checks before deploying a website.";

// Anthropic: the stream helper emits text chunks and assembles the final message.
const anthropic = new Anthropic();
const stream = anthropic.messages
  .stream({
    model: "claude-opus-5-5",
    max_tokens: 2048,
    messages: [{ role: "user", content: question }],
  })
  .on("text", (chunk) => process.stdout.write(chunk));

const final = await stream.finalMessage();
console.log("\n[claude] stop_reason:", final.stop_reason, "output tokens:", final.usage.output_tokens);

// OpenAI: stream: true returns an async iterable of typed events.
const openai = new OpenAI();
const events = await openai.responses.create({
  model: "gpt-6-astra",
  input: question,
  stream: true,
});

for await (const event of events) {
  if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);
  } else if (event.type === "response.completed") {
    console.log("\n[gpt] status:", event.response.status, "output tokens:", event.response.usage?.output_tokens);
  } else if (event.type === "error") {
    console.error("\n[gpt] stream error:", event.message);
  }
}

import Anthropic from "@anthropic-ai/sdk";
import OpenAI from "openai";

export type Provider = "anthropic" | "openai";

export type AskInput = {
  system: string;
  prompt: string;
  maxOutputTokens?: number;
};

export type AskResult = {
  provider: Provider;
  model: string;
  text: string;
  inputTokens: number;
  outputTokens: number;
  complete: boolean; // false when the answer was cut off by the token limit
};

export class LLMError extends Error {
  readonly provider: Provider;
  readonly status: number | undefined;
  readonly retryable: boolean; // temporary problem: try later or put the job in a queue

  constructor(provider: Provider, message: string, options: { status?: number; retryable: boolean; cause?: unknown }) {
    super(message, { cause: options.cause });
    this.name = "LLMError";
    this.provider = provider;
    this.status = options.status;
    this.retryable = options.retryable;
  }
}

// Model IDs: copy them from the providers' model pages, do not guess.
const MODELS = { anthropic: "claude-opus-5-5", openai: "gpt-6-astra" } as const;

// SDK-level retries with exponential backoff (429, 408, 409, 5xx, network) and a request timeout.
const CLIENT_OPTIONS = { maxRetries: 3, timeout: 60_000 };

function requireKey(name: "ANTHROPIC_API_KEY" | "OPENAI_API_KEY"): string {
  const value = process.env[name];
  if (!value) throw new Error(`${name} is not set: copy .env.example to .env`);
  return value;
}

// Clients are created on first use, so a missing key of one provider does not break the other.
let anthropic: Anthropic | undefined;
let openai: OpenAI | undefined;

async function askAnthropic(input: AskInput): Promise<AskResult> {
  anthropic ??= new Anthropic({ apiKey: requireKey("ANTHROPIC_API_KEY"), ...CLIENT_OPTIONS });
  const message = await anthropic.messages.create({
    model: MODELS.anthropic,
    max_tokens: input.maxOutputTokens ?? 2048,
    system: input.system,
    messages: [{ role: "user", content: input.prompt }],
  });
  if (message.stop_reason === "refusal") {
    throw new LLMError("anthropic", "anthropic: the model declined the request", { retryable: false });
  }
  return {
    provider: "anthropic",
    model: message.model,
    text: message.content
      .filter((block) => block.type === "text")
      .map((block) => block.text)
      .join(""),
    inputTokens: message.usage.input_tokens,
    outputTokens: message.usage.output_tokens,
    complete: message.stop_reason !== "max_tokens",
  };
}

async function askOpenAI(input: AskInput): Promise<AskResult> {
  openai ??= new OpenAI({ apiKey: requireKey("OPENAI_API_KEY"), ...CLIENT_OPTIONS });
  const response = await openai.responses.create({
    model: MODELS.openai,
    reasoning: { effort: "low" },
    instructions: input.system,
    input: input.prompt,
    max_output_tokens: input.maxOutputTokens ?? 2048,
  });
  return {
    provider: "openai",
    model: response.model,
    text: response.output_text,
    inputTokens: response.usage?.input_tokens ?? 0,
    outputTokens: response.usage?.output_tokens ?? 0,
    complete: response.status === "completed",
  };
}

const QUOTA_CODES = new Set([
  "credit_balance_exhausted",
  "organization_spend_limit_exceeded",
  "project_spend_limit_exceeded",
  "organization_usage_limit_exceeded",
]);

// Both SDKs throw the same family of typed errors: check specific classes first.
function toLLMError(provider: Provider, err: unknown): unknown {
  if (err instanceof Anthropic.AuthenticationError || err instanceof OpenAI.AuthenticationError) {
    return new LLMError(provider, `${provider}: invalid or revoked API key`, { status: 401, retryable: false, cause: err });
  }
  if (err instanceof Anthropic.RateLimitError || err instanceof OpenAI.RateLimitError) {
    const wait = err.headers.get("retry-after");
    // A spend or quota limit is not temporary: Anthropic sends that 429 without retry-after,
    // OpenAI marks it with a code such as credit_balance_exhausted.
    const quota = err instanceof OpenAI.RateLimitError ? QUOTA_CODES.has(err.code ?? "") : wait === null;
    const message = quota ? `${provider}: spend or quota limit reached` : `${provider}: rate limit, retry after ${wait ?? "?"} s`;
    return new LLMError(provider, message, { status: 429, retryable: !quota, cause: err });
  }
  if (err instanceof Anthropic.APIConnectionError || err instanceof OpenAI.APIConnectionError) {
    return new LLMError(provider, `${provider}: network error or timeout`, { retryable: true, cause: err });
  }
  if (err instanceof Anthropic.APIError || err instanceof OpenAI.APIError) {
    const status = err.status;
    return new LLMError(provider, `${provider}: HTTP ${status}, request ${err.requestID ?? "-"}`, {
      status,
      retryable: status !== undefined && status >= 500,
      cause: err,
    });
  }
  return err;
}

export async function ask(provider: Provider, input: AskInput): Promise<AskResult> {
  try {
    return provider === "anthropic" ? await askAnthropic(input) : await askOpenAI(input);
  } catch (err) {
    throw toLLMError(provider, err);
  }
}

import { ask, LLMError, type Provider } from "./llm.ts";

const providers: Provider[] = ["anthropic", "openai"];
const input = {
  system: "You are a concise assistant for a web studio. Answer in two sentences.",
  prompt: "Why should an API key never be stored in frontend code?",
};

for (const provider of providers) {
  try {
    const result = await ask(provider, input);
    console.log(`[${result.provider}] ${result.model}: ${result.text}`);
    console.log(`  tokens in/out: ${result.inputTokens}/${result.outputTokens}${result.complete ? "" : " (cut off)"}`);
  } catch (err) {
    if (!(err instanceof LLMError)) throw err;
    console.error(`[${provider}] ${err.message} (retryable: ${err.retryable})`);
    process.exitCode = 1;
  }
}

// Prices change: take them from the provider's pricing page and keep them in config, not in code.
export type Price = {
  inputPerMTok: number; // USD per 1M input tokens
  outputPerMTok: number; // USD per 1M output tokens (reasoning tokens are billed as output too)
};

export type Usage = { inputTokens: number; outputTokens: number };

export function costUSD(usage: Usage, price: Price): number {
  return (usage.inputTokens * price.inputPerMTok + usage.outputTokens * price.outputPerMTok) / 1_000_000;
}

// Running total for a batch of requests, e.g. one night of ticket triage.
export function totalUsage(items: Usage[]): Usage {
  return items.reduce(
    (sum, u) => ({ inputTokens: sum.inputTokens + u.inputTokens, outputTokens: sum.outputTokens + u.outputTokens }),
    { inputTokens: 0, outputTokens: 0 },
  );
}

$ node --env-file=.env.mock src/compare.ts
[anthropic] claude-opus-5-5: MOCK CLAUDE: Why should an API key never be stored in frontend code?
  tokens in/out: 24/13
[openai] gpt-6-astra: MOCK GPT: Why should an API key never be stored in frontend code?
  tokens in/out: 24/13