Comparing AI SDK

1
import { generateObject } from 'ai';
2
import { openai } from '@ai-sdk/openai';
3
import { z } from 'zod';
4
5
const Resume = z.object({
6
  name: z.string(),
7
  skills: z.array(z.string())
8
});
9
10
const { object } = await generateObject({
11
  model: openai('gpt-4o'),
12
  schema: Resume,
13
  prompt: 'John Doe, Python, Rust'
14
});

1
// How do you debug what went wrong?
2
const { object } = await generateObject({
3
  model: openai('gpt-4o'),
4
  schema: Resume,
5
  prompt: complexResumeText
6
});
7
8
// You can't see:
9
// - The actual prompt sent to the model
10
// - The schema format used
11
// - Why certain fields were missed

1
const SeniorityLevel = z.enum(['junior', 'mid', 'senior', 'staff']);
2
3
const Resume = z.object({
4
  name: z.string(),
5
  skills: z.array(z.string()),
6
  education: z.array(Education),
7
  seniority: SeniorityLevel
8
});

1
// You can't add descriptions to enum values!
2
// How does the model know junior = 0-2 years experience?
3
4
// You try adding a comment...
5
const SeniorityLevel = z.enum([
6
  'junior',  // 0-2 years
7
  'mid',     // 2-5 years  
8
  'senior',  // 5-10 years
9
  'staff'    // 10+ years
10
]);
11
// But comments aren't sent to the model!
12
13
// So you end up doing this hack:
14
const { object } = await generateObject({
15
  model: openai('gpt-4o'),
16
  schema: Resume,
17
  prompt: `Extract resume information.
18
  
19
Seniority levels:
20
- junior: 0-2 years experience
21
- mid: 2-5 years experience
22
- senior: 5-10 years experience  
23
- staff: 10+ years experience
24
25
Resume:
26
${resumeText}`
27
});

1
// First, install a bunch of packages
2
npm install @ai-sdk/openai @ai-sdk/anthropic @ai-sdk/google @ai-sdk/mistral
3
4
// Import from different packages
5
import { openai } from '@ai-sdk/openai';
6
import { anthropic } from '@ai-sdk/anthropic';
7
import { google } from '@ai-sdk/google';
8
9
// Now you need provider detection logic
10
function getModel(provider: string) {
11
  switch(provider) {
12
    case 'openai': return openai('gpt-4o');
13
    case 'anthropic': return anthropic('claude-3-opus-20240229');
14
    case 'google': return google('gemini-pro');
15
    // Don't forget to handle errors...
16
  }
17
}
18
19
// And manage different API keys
20
const providers = {
21
  openai: process.env.OPENAI_API_KEY,
22
  anthropic: process.env.ANTHROPIC_API_KEY,
23
  google: process.env.GOOGLE_API_KEY,
24
  // More environment variables to manage...
25
};

1
// How do you test this without API calls?
2
const { object } = await generateObject({
3
  model: openai('gpt-4o'),
4
  schema: Resume,
5
  prompt: testResumeText
6
});
7
8
// Mock the entire AI SDK?
9
jest.mock('ai', () => ({
10
  generateObject: jest.fn().mockResolvedValue({
11
    object: { name: 'Test', skills: ['JS'] }
12
  })
13
}));
14
15
// But you're not testing your schema or prompt...
16
// Just that your mocks return the right shape

1
class ResumeExtractor {
2
  private tokenCounter: TokenCounter;
3
  private promptTemplates: Map<string, string>;
4
  private retryConfig: RetryConfig;
5
  
6
  async extract(text: string, options?: ExtractOptions) {
7
    const model = this.selectModel(options);
8
    const prompt = this.buildPrompt(text, options);
9
    
10
    return this.withRetry(async () => {
11
      const start = Date.now();
12
      const tokens = this.tokenCounter.estimate(prompt);
13
      
14
      try {
15
        const result = await generateObject({
16
          model,
17
          schema: Resume,
18
          prompt
19
        });
20
        
21
        this.logUsage({ tokens, duration: Date.now() - start });
22
        return result;
23
      } catch (error) {
24
        this.handleError(error);
25
      }
26
    });
27
  }
28
  
29
  // ... dozens more methods
30
}

1
import { b } from '@/baml_client';
2
3
// Use default model
4
const resume = await b.ExtractResume(resumeText);
5
6
// Switch models based on your needs
7
const complexResume = await b.ExtractResume(complexText, { client: "Claude" });
8
const simpleResume = await b.ExtractResume(simpleText, { client: "Llama" });
9
10
// Everything is fully typed!
11
console.log(resume.seniority); // TypeScript knows this is SeniorityLevel