Comparing AI SDK

import { generateObject } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';

const Resume = z.object({
  name: z.string(),
  skills: z.array(z.string())
});

const { object } = await generateObject({
  model: openai('gpt-4o'),
  schema: Resume,
  prompt: 'John Doe, Python, Rust'
});

+const Education = z.object({
+  school: z.string(),
+  degree: z.string(),
+  year: z.number()
+});

const Resume = z.object({
  name: z.string(),
  skills: z.array(z.string()),
+  education: z.array(Education)
});

const { object } = await generateObject({
  model: openai('gpt-4o'),
  schema: Resume,
  prompt: `John Doe
Python, Rust
University of California, Berkeley, B.S. in Computer Science, 2020`
});

// How do you debug what went wrong?
const { object } = await generateObject({
  model: openai('gpt-4o'),
  schema: Resume,
  prompt: complexResumeText
});

// You can't see:
// - The actual prompt sent to the model
// - The schema format used
// - Why certain fields were missed

const SeniorityLevel = z.enum(['junior', 'mid', 'senior', 'staff']);

const Resume = z.object({
  name: z.string(),
  skills: z.array(z.string()),
  education: z.array(Education),
  seniority: SeniorityLevel
});

// You can't add descriptions to enum values!
// How does the model know junior = 0-2 years experience?

// You try adding a comment...
const SeniorityLevel = z.enum([
  'junior',  // 0-2 years
  'mid',     // 2-5 years  
  'senior',  // 5-10 years
  'staff'    // 10+ years
]);
// But comments aren't sent to the model!

// So you end up doing this hack:
const { object } = await generateObject({
  model: openai('gpt-4o'),
  schema: Resume,
  prompt: `Extract resume information.
  
Seniority levels:
- junior: 0-2 years experience
- mid: 2-5 years experience
- senior: 5-10 years experience  
- staff: 10+ years experience

Resume:
${resumeText}`
});

// First, install a bunch of packages
npm install @ai-sdk/openai @ai-sdk/anthropic @ai-sdk/google @ai-sdk/mistral

// Import from different packages
import { openai } from '@ai-sdk/openai';
import { anthropic } from '@ai-sdk/anthropic';
import { google } from '@ai-sdk/google';

// Now you need provider detection logic
function getModel(provider: string) {
  switch(provider) {
    case 'openai': return openai('gpt-4o');
    case 'anthropic': return anthropic('claude-3-opus-20240229');
    case 'google': return google('gemini-pro');
    // Don't forget to handle errors...
  }
}

// And manage different API keys
const providers = {
  openai: process.env.OPENAI_API_KEY,
  anthropic: process.env.ANTHROPIC_API_KEY,
  google: process.env.GOOGLE_API_KEY,
  // More environment variables to manage...
};

// How do you test this without API calls?
const { object } = await generateObject({
  model: openai('gpt-4o'),
  schema: Resume,
  prompt: testResumeText
});

// Mock the entire AI SDK?
jest.mock('ai', () => ({
  generateObject: jest.fn().mockResolvedValue({
    object: { name: 'Test', skills: ['JS'] }
  })
}));

// But you're not testing your schema or prompt...
// Just that your mocks return the right shape

class ResumeExtractor {
  private tokenCounter: TokenCounter;
  private promptTemplates: Map<string, string>;
  private retryConfig: RetryConfig;
  
  async extract(text: string, options?: ExtractOptions) {
    const model = this.selectModel(options);
    const prompt = this.buildPrompt(text, options);
    
    return this.withRetry(async () => {
      const start = Date.now();
      const tokens = this.tokenCounter.estimate(prompt);
      
      try {
        const result = await generateObject({
          model,
          schema: Resume,
          prompt
        });
        
        this.logUsage({ tokens, duration: Date.now() - start });
        return result;
      } catch (error) {
        this.handleError(error);
      }
    });
  }
  
  // ... dozens more methods
}

class Education {
  school string
  degree string
  year int
}

enum SeniorityLevel {
  JUNIOR @description("0-2 years of experience")
  MID @description("2-5 years of experience")
  SENIOR @description("5-10 years of experience")
  STAFF @description("10+ years of experience, technical leadership")
}

class Resume {
  name string
  skills string[]
  education Education[]
  seniority SeniorityLevel
}

function ExtractResume(resume_text: string) -> Resume {
  client GPT4
  prompt #"
    Extract the following information from the resume.
    
    Resume:
    ---
    {{ resume_text }}
    ---
    
    {{ ctx.output_format }}
  "#
}

// All providers in one place
client<llm> GPT4 {
  provider openai
  options {
    model "gpt-4o"
    temperature 0.1
  }
}

client<llm> Claude {
  provider anthropic  
  options {
    model "claude-3-opus-20240229"
    temperature 0.1
  }
}

client<llm> Gemini {
  provider google
  options {
    model "gemini-pro"
  }
}

client<llm> Llama {
  provider ollama
  options {
    model "llama3"
  }
}

// Same function, any model
function ExtractResume(resume_text: string) -> Resume {
  client GPT4  // Just change this
  prompt #"..."#
}

import { b } from '@/baml_client';

// Use default model
const resume = await b.ExtractResume(resumeText);

// Switch models based on your needs
const complexResume = await b.ExtractResume(complexText, { client: "Claude" });
const simpleResume = await b.ExtractResume(simpleText, { client: "Llama" });

// Everything is fully typed!
console.log(resume.seniority); // TypeScript knows this is SeniorityLevel