Modern JavaScript and TypeScript for AI Engineers

type TextBlock = { type: "text"; text: string };
type ToolUseBlock = { type: "tool_use"; id: string; name: string; input: unknown };
type ThinkingBlock = { type: "thinking"; thinking: string };
type ContentBlock = TextBlock | ToolUseBlock | ThinkingBlock;
 
function describe(block: ContentBlock): string {
  switch (block.type) {
    case "text":
      return `Text: ${block.text.slice(0, 40)}`; // block is TextBlock here
    case "tool_use":
      return `Tool call: ${block.name}`; // block is ToolUseBlock here
    case "thinking":
      return "Reasoning block";
    default: {
      // If a new block type is added to the union, this line stops compiling.
      const unreachable: never = block;
      return unreachable;
    }
  }
}
 
const response: ContentBlock[] = [
  { type: "thinking", thinking: "" },
  { type: "text", text: "Let me look up that order." },
  { type: "tool_use", id: "toolu_1", name: "get_order_status", input: { order_id: "4821" } },
];
 
console.log(response.map(describe));

import { z } from "zod";
 
export const CreateNote = z.object({
  title: z.string().trim().min(1).max(120),
  body: z.string().max(10_000),
  tags: z.array(z.string()).max(10).default([]),
});
export type CreateNote = z.infer<typeof CreateNote>;
 
type Result<T> = { ok: true; value: T } | { ok: false; errors: string[] };
 
export function parseCreateNote(input: unknown): Result<CreateNote> {
  const result = CreateNote.safeParse(input);
  if (!result.success) {
    return {
      ok: false,
      errors: result.error.issues.map((i) => `${i.path.map(String).join(".") || "(root)"}: ${i.message}`),
    };
  }
  return { ok: true, value: result.data };
}
 
console.log(parseCreateNote(JSON.parse('{"title":"  Ship the RAG demo  ","body":"Friday"}')));
// { ok: true, value: { title: "Ship the RAG demo", body: "Friday", tags: [] } }
 
console.log(parseCreateNote({ title: "", body: 42 }));
// { ok: false, errors: ["title: Too small: ...", "body: Invalid input: expected string, received number"] }

const sleep = (ms: number, signal?: AbortSignal) =>
  new Promise<void>((resolve, reject) => {
    const timer = setTimeout(resolve, ms);
    signal?.addEventListener(
      "abort",
      () => {
        clearTimeout(timer);
        reject(signal.reason);
      },
      { once: true },
    );
  });
 
// Stand-ins for real database and API calls.
async function getUser() {
  await sleep(300);
  return { id: "u_1", name: "Ada" };
}
async function getOrders() {
  await sleep(450);
  return [{ id: "o_1" }, { id: "o_2" }];
}
async function getPlan() {
  await sleep(250);
  return "pro";
}
 
let start = performance.now();
const user = await getUser();
const orders = await getOrders();
const plan = await getPlan();
console.log(`sequential: ${Math.round(performance.now() - start)} ms`, user.name, orders.length, plan);
 
start = performance.now();
const [user2, orders2, plan2] = await Promise.all([getUser(), getOrders(), getPlan()]);
console.log(`parallel: ${Math.round(performance.now() - start)} ms`, user2.name, orders2.length, plan2);
 
// A deadline: give up on a slow operation after 200 ms.
try {
  await sleep(1_000, AbortSignal.timeout(200));
} catch (error) {
  console.log("timed out:", (error as Error).name); // "TimeoutError"
}
 
// Partial failure: keep the results that succeeded.
const settled = await Promise.allSettled([getPlan(), Promise.reject(new Error("search is down"))]);
for (const r of settled) console.log(r.status === "fulfilled" ? `ok: ${r.value}` : `failed: ${(r.reason as Error).message}`);

node concurrency.ts
# sequential: 1003 ms Ada 2 pro
# parallel: 452 ms Ada 2 pro
# timed out: TimeoutError
# ok: pro
# failed: search is down

async function* fakeTokenStream(text: string, delayMs = 60) {
  for (const word of text.split(" ")) {
    await new Promise((resolve) => setTimeout(resolve, delayMs));
    yield `${word} `;
  }
}
 
let received = "";
for await (const token of fakeTokenStream("Streaming is just an async iterable of small chunks.")) {
  process.stdout.write(token);
  received += token;
}
console.log(`\n${received.trim().split(" ").length} chunks`);