10 TypeScript Patterns Every AI Developer Should Know

async function* streamCompletion(prompt: string) {
  const response = await fetch("/api/chat", {
    method: "POST",
    body: JSON.stringify({ prompt }),
  });

  const reader = response.body!.getReader();
  const decoder = new TextDecoder();

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    yield decoder.decode(value);
  }
}

// Usage
for await (const chunk of streamCompletion("Explain TypeScript generics")) {
  process.stdout.write(chunk);
}

import { z } from "zod";
import { tool } from "ai";

const weatherTool = tool({
  description: "Get current weather for a location",
  parameters: z.object({
    city: z.string().describe("City name"),
    units: z.enum(["celsius", "fahrenheit"]).default("celsius"),
  }),
  execute: async ({ city, units }) => {
    const data = await fetchWeather(city, units);
    return { temperature: data.temp, condition: data.condition };
  },
});

import { generateObject } from "ai";
import { z } from "zod";

const ProductReview = z.object({
  sentiment: z.enum(["positive", "negative", "neutral"]),
  score: z.number().min(0).max(10),
  keyPoints: z.array(z.string()).max(5),
  recommendation: z.boolean(),
});

type ProductReview = z.infer<typeof ProductReview>;

const { object } = await generateObject({
  model: anthropic("claude-sonnet-4-6"),
  schema: ProductReview,
  prompt: `Analyze this review: "${reviewText}"`,
});

// object is fully typed as ProductReview
console.log(object.sentiment, object.score);

async function withRetry<T>(
  fn: () => Promise<T>,
  maxRetries = 3,
  baseDelay = 1000
): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (attempt === maxRetries) throw error;

      const isRetryable =
        error instanceof Error &&
        (error.message.includes("429") ||
          error.message.includes("503") ||
          error.message.includes("timeout"));

      if (!isRetryable) throw error;

      const delay = baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }
  throw new Error("Unreachable");
}

// Usage
const result = await withRetry(() =>
  generateText({ model: anthropic("claude-sonnet-4-6"), prompt })
);

type AgentAction =
  | { type: "search"; query: string }
  | { type: "write_file"; path: string; content: string }
  | { type: "run_command"; command: string; cwd?: string }
  | { type: "ask_user"; question: string }
  | { type: "done"; result: string };

function executeAction(action: AgentAction): Promise<string> {
  switch (action.type) {
    case "search":
      return searchWeb(action.query);
    case "write_file":
      return writeFile(action.path, action.content);
    case "run_command":
      return exec(action.command, { cwd: action.cwd });
    case "ask_user":
      return prompt(action.question);
    case "done":
      return Promise.resolve(action.result);
  }
}

interface Message<Role extends string = string> {
  role: Role;
  content: string;
  metadata?: Record<string, unknown>;
}

type ChatMessage = Message<"user" | "assistant" | "system">;

class Conversation {
  private messages: ChatMessage[] = [];

  system(content: string): this {
    this.messages.push({ role: "system", content });
    return this;
  }

  user(content: string): this {
    this.messages.push({ role: "user", content });
    return this;
  }

  assistant(content: string): this {
    this.messages.push({ role: "assistant", content });
    return this;
  }

  toArray(): ChatMessage[] {
    return [...this.messages];
  }

  get lastAssistant(): string | undefined {
    return this.messages.findLast((m) => m.role === "assistant")?.content;
  }
}

interface AIProvider {
  generate(prompt: string, options?: GenerateOptions): Promise<string>;
  stream(prompt: string, options?: GenerateOptions): AsyncIterable<string>;
}

interface GenerateOptions {
  maxTokens?: number;
  temperature?: number;
  systemPrompt?: string;
}

function createProvider(name: "anthropic" | "openai"): AIProvider {
  const providers: Record<string, AIProvider> = {
    anthropic: {
      generate: async (prompt, opts) => {
        const { text } = await generateText({
          model: anthropic("claude-sonnet-4-6"),
          prompt,
          maxTokens: opts?.maxTokens,
          temperature: opts?.temperature,
          system: opts?.systemPrompt,
        });
        return text;
      },
      stream: (prompt, opts) => streamProvider("anthropic", prompt, opts),
    },
    openai: {
      generate: async (prompt, opts) => {
        const { text } = await generateText({
          model: openai("gpt-5"),
          prompt,
          maxTokens: opts?.maxTokens,
        });
        return text;
      },
      stream: (prompt, opts) => streamProvider("openai", prompt, opts),
    },
  };
  return providers[name];
}

interface TokenBudget {
  maxInput: number;
  maxOutput: number;
  used: { input: number; output: number };
}

function createBudget(maxInput = 100_000, maxOutput = 4_096): TokenBudget {
  return { maxInput, maxOutput, used: { input: 0, output: 0 } };
}

function checkBudget(budget: TokenBudget, inputTokens: number): boolean {
  return budget.used.input + inputTokens <= budget.maxInput;
}

function recordUsage(
  budget: TokenBudget,
  input: number,
  output: number
): TokenBudget {
  return {
    ...budget,
    used: {
      input: budget.used.input + input,
      output: budget.used.output + output,
    },
  };
}

// Usage in an agent loop
let budget = createBudget();
while (checkBudget(budget, estimatedTokens)) {
  const result = await generateText({ model, prompt });
  budget = recordUsage(budget, result.usage.promptTokens, result.usage.completionTokens);
}

import { z } from "zod";

const envSchema = z.object({
  ANTHROPIC_API_KEY: z.string().min(1),
  OPENAI_API_KEY: z.string().min(1),
  DATABASE_URL: z.string().url(),
  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
  MAX_TOKENS: z.coerce.number().default(4096),
  ENABLE_STREAMING: z.coerce.boolean().default(true),
});

export const env = envSchema.parse(process.env);

// Now fully typed
console.log(env.ANTHROPIC_API_KEY); // string
console.log(env.MAX_TOKENS); // number
console.log(env.ENABLE_STREAMING); // boolean

type Result<T, E = Error> =
  | { ok: true; value: T }
  | { ok: false; error: E };

function ok<T>(value: T): Result<T, never> {
  return { ok: true, value };
}

function err<E>(error: E): Result<never, E> {
  return { ok: false, error };
}

async function safeGenerate(prompt: string): Promise<Result<string>> {
  try {
    const { text } = await generateText({
      model: anthropic("claude-sonnet-4-6"),
      prompt,
    });
    return ok(text);
  } catch (e) {
    return err(e instanceof Error ? e : new Error(String(e)));
  }
}

// Usage - no try/catch needed
const result = await safeGenerate("Explain monads");
if (result.ok) {
  console.log(result.value);
} else {
  console.error("Failed:", result.error.message);
}