M07 — Production

// Anthropic — messages.stream(); the "text" event gives you each delta.
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();

const stream = client.messages.stream({
  model: "claude-sonnet-5", max_tokens: 512,
  messages: [{ role: "user", content: "Summarize our return policy." }],
});
stream.on("text", (delta) => process.stdout.write(delta));  // each token
const final = await stream.finalMessage();                  // full message once done

# Gemini — generate_content_stream(); iterate chunks, read chunk.text.
from google import genai
client = genai.Client()

for chunk in client.models.generate_content_stream(
    model="gemini-2.5-flash",
    contents="Summarize our return policy.",
):
    print(chunk.text, end="", flush=True)     # each chunk as it arrives
# usage_metadata is populated on the final chunk

// Gemini — generateContentStream() returns an async iterable directly.
import { GoogleGenAI } from "@google/genai";
const ai = new GoogleGenAI({});

const stream = await ai.models.generateContentStream({
  model: "gemini-2.5-flash",
  contents: "Summarize our return policy.",
});
for await (const chunk of stream) {
  process.stdout.write(chunk.text ?? "");     // each chunk as it arrives
}

# OpenAI (Responses) — stream=True yields typed events; filter text deltas.
from openai import OpenAI
client = OpenAI()

stream = client.responses.create(
    model="gpt-5.5", input="Summarize our return policy.", stream=True,
)
for event in stream:
    if event.type == "response.output_text.delta":  # the text-delta event
        print(event.delta, end="", flush=True)

// OpenAI (Responses) — stream: true; filter the text-delta event type.
import OpenAI from "openai";
const client = new OpenAI();

const stream = await client.responses.create({
  model: "gpt-5.5", input: "Summarize our return policy.", stream: true,
});
for await (const event of stream) {
  if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);        // each text delta
  }
}

import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({ maxRetries: 3 });  // auto-retries 429/5xx (default 2)

try {
  await client.messages.create({ model: "claude-sonnet-5", max_tokens: 512,
    messages: [{ role: "user", content: "Hi" }] });
} catch (err) {
  if (err instanceof Anthropic.RateLimitError) console.log("rate limited:", err.status);
  else if (err instanceof Anthropic.APIError)  console.log("API error:", err.status);
}

# Gemini — exceptions live in google.genai.errors. NOTE: field is .code, not .status_code.
from google import genai
from google.genai import errors, types

client = genai.Client(http_options=types.HttpOptions(   # set retries explicitly (see note)
    retry_options=types.HttpRetryOptions(attempts=5)))

try:
    resp = client.models.generate_content(model="gemini-2.5-flash", contents="Hi")
except errors.ClientError as e:        # 4xx (e.g. 429)
    print("client error:", e.code, e.message)
except errors.ServerError as e:        # 5xx
    print("server error:", e.code)

// Gemini — ApiError from @google/genai; status on .status.
import { GoogleGenAI, ApiError } from "@google/genai";

const ai = new GoogleGenAI({
  httpOptions: { retryOptions: { attempts: 5 } },   // set retries explicitly
});

try {
  await ai.models.generateContent({ model: "gemini-2.5-flash", contents: "Hi" });
} catch (err) {
  if (err instanceof ApiError) console.log("API error:", err.status, err.message);
}

import openai
client = openai.OpenAI(max_retries=3)             # auto-retries 429/5xx (default 2)

try:
    resp = client.responses.create(model="gpt-5.5", input="Hi")
except openai.RateLimitError as e:
    print("rate limited:", e.status_code)
except openai.APIStatusError as e:
    print("API error:", e.status_code)
except openai.APIConnectionError as e:
    print("network:", e.__cause__)                # SDK already retried

import OpenAI from "openai";
const client = new OpenAI({ maxRetries: 3 });     // auto-retries 429/5xx (default 2)

try {
  await client.responses.create({ model: "gpt-5.5", input: "Hi" });
} catch (err) {
  if (err instanceof OpenAI.RateLimitError) console.log("rate limited:", err.status);
  else if (err instanceof OpenAI.APIError)  console.log("API error:", err.status);
}