LLM 응답을 타입 안전한 객체로 받아내는 법: Vercel AI SDK의 `streamText`와 `generateObject` 사이에서

npm install ai @ai-sdk/openai @ai-sdk/anthropic zod

import { z } from 'zod';
 
const LeadSchema = z.object({
  name: z.string().describe('고객 이름'),
  email: z.string().email().describe('이메일 주소'),
  company: z.string().optional().describe('회사명'),
  intent: z.enum(['purchase', 'demo', 'inquiry']).describe('문의 의도'),
  urgency: z.number().min(1).max(10).describe('긴급도 1-10'),
});
 
type Lead = z.infer<typeof LeadSchema>;

import { generateObject } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';
 
const LeadSchema = z.object({
  name: z.string().describe('고객 이름'),
  email: z.string().email().describe('이메일 주소'),
  company: z.string().optional().describe('회사명'),
  intent: z.enum(['purchase', 'demo', 'inquiry']).describe('문의 의도'),
  urgency: z.number().min(1).max(10).describe('긴급도 1-10'),
});
 
async function extractLead(rawInput: string) {
  const { object } = await generateObject({
    model: openai('gpt-4o'),
    schema: LeadSchema,
    prompt: `다음 문의 내용에서 리드 정보를 추출하세요:\n\n${rawInput}`,
  });
 
  console.log(object.intent);
  console.log(object.urgency);
 
  return object;
}

import { anthropic } from '@ai-sdk/anthropic';
 
const { object } = await generateObject({
  model: anthropic('claude-opus-5'),
  schema: LeadSchema,
  prompt: `...`,
});

// app/api/chat/route.ts
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
 
export const runtime = 'edge';
 
export async function POST(req: Request) {
  const { messages } = await req.json();
 
  const result = streamText({
    model: openai('gpt-4o'),
    messages,
    system: '당신은 친절한 고객 지원 담당자입니다.',
    onError: ({ error }) => {
      console.error('스트리밍 에러:', error);
    },
  });
 
  return result.toDataStreamResponse();
}

// app/chat/page.tsx
'use client';
import { useChat } from 'ai/react';
 
export default function ChatPage() {
  const { messages, input, handleInputChange, handleSubmit } = useChat({
    api: '/api/chat',
  });
 
  return (
    <div>
      {messages.map(m => (
        <div key={m.id}>
          <strong>{m.role}:</strong> {m.content}
        </div>
      ))}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} />
        <button type="submit">전송</button>
      </form>
    </div>
  );
}

// 서버 사이드 (API Route)
import { streamObject } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';
 
const ProductAnalysisSchema = z.object({
  summary: z.string().describe('제품 요약'),
  strengths: z.array(z.string()).describe('강점 목록'),
  weaknesses: z.array(z.string()).describe('약점 목록'),
  targetAudience: z.string().describe('타깃 고객층'),
  pricePoint: z.enum(['budget', 'mid-range', 'premium']).describe('가격대'),
});
 
export async function POST(req: Request) {
  const { productDescription } = await req.json();
 
  const result = streamObject({
    model: openai('gpt-4o'),
    schema: ProductAnalysisSchema,
    prompt: `다음 제품을 분석하세요:\n\n${productDescription}`,
  });
 
  return result.toTextStreamResponse();
}

'use client';
import { experimental_useObject as useObject } from 'ai/react';
import { z } from 'zod';
 
const ProductAnalysisSchema = z.object({
  summary: z.string(),
  strengths: z.array(z.string()),
  weaknesses: z.array(z.string()),
  targetAudience: z.string(),
  pricePoint: z.enum(['budget', 'mid-range', 'premium']),
});
 
export default function ProductAnalysis() {
  const { object, submit, isLoading } = useObject({
    api: '/api/analyze',
    schema: ProductAnalysisSchema,
  });
 
  return (
    <div>
      <button onClick={() => submit({ productDescription: '...' })}>
        분석 시작
      </button>
 
      {object?.summary && <p>{object.summary}</p>}
      {object?.strengths?.map((s, i) => <li key={i}>{s}</li>)}
      {object?.pricePoint && <span>가격대: {object.pricePoint}</span>}
    </div>
  );
}

// 개념적 예시 — 실제 API명은 버전마다 다를 수 있음
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';
 
const SentimentSchema = z.object({
  sentiment: z.enum(['positive', 'neutral', 'negative']),
  confidence: z.number().min(0).max(1),
});
 
// 실험적 구조화 출력 옵션을 사용해 텍스트와 객체를 함께 얻는 그림
const result = streamText({
  model: openai('gpt-4o'),
  prompt: '오늘 새 프로젝트를 시작했는데 정말 설레네요!',
  // experimental_output: ... (SDK 버전별 정확한 형태는 공식 문서 참고)
});
 
for await (const chunk of result.textStream) {
  process.stdout.write(chunk);
}

import { streamText, tool } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';
 
// 아래 db, priceService는 개념적 예시입니다. 실제로는 프로젝트의
// 데이터 액세스 레이어와 도메인 서비스를 여기에 연결한다고 가정하세요.
declare const db: {
  products: { search(q: string, n: number): Promise<unknown[]> };
};
declare const priceService: {
  calculate(productId: string, quantity: number): Promise<number>;
};
 
const result = streamText({
  model: openai('gpt-4o'),
  maxSteps: 5,
  tools: {
    searchProducts: tool({
      description: '제품 데이터베이스 검색',
      parameters: z.object({
        query: z.string().describe('검색어'),
        maxResults: z.number().default(10),
      }),
      execute: async ({ query, maxResults }) => {
        const results = await db.products.search(query, maxResults);
        return results;
      },
    }),
    calculatePrice: tool({
      description: '가격 계산',
      parameters: z.object({
        productId: z.string(),
        quantity: z.number(),
      }),
      execute: async ({ productId, quantity }) => {
        const price = await priceService.calculate(productId, quantity);
        return { totalPrice: price };
      },
    }),
  },
  prompt: '노트북 5대의 총 가격을 알려주세요.',
});
 
for await (const chunk of result.textStream) {
  process.stdout.write(chunk);
}

import { chunk } from 'es-toolkit'; // 또는 lodash의 chunk
 
async function extractLargeList(items: string[]): Promise<Result[]> {
  const BATCH_SIZE = 10; // 프로젝트별 안정 지점을 실험으로 찾으세요
  const batches = chunk(items, BATCH_SIZE);
 
  const results = await Promise.all(
    batches.map(batch =>
      generateObject({
        model: openai('gpt-4o'),
        schema: z.object({ items: z.array(ResultSchema) }),
        prompt: `다음 항목들을 처리하세요: ${JSON.stringify(batch)}`,
      })
    )
  );
 
  return results.flatMap(r => r.object.items);
}

import { wrapLanguageModel, generateObject, type LanguageModelV1Middleware } from 'ai';
import { openai } from '@ai-sdk/openai';
 
// 개념적 예시 — 미들웨어 훅 이름과 시그니처는 사용 중인 SDK 버전 문서로 확인하세요
const telemetryMiddleware: LanguageModelV1Middleware = {
  wrapGenerate: async ({ doGenerate, params }) => {
    const started = Date.now();
    const result = await doGenerate();
 
    metrics.track({
      model: params.mode.type,
      promptTokens: result.usage.promptTokens,
      completionTokens: result.usage.completionTokens,
      totalTokens: result.usage.totalTokens,
      latencyMs: Date.now() - started,
    });
 
    return result;
  },
};
 
const observedModel = wrapLanguageModel({
  model: openai('gpt-4o'),
  middleware: telemetryMiddleware,
});
 
// 이후 모든 호출은 observedModel을 사용
const { object } = await generateObject({
  model: observedModel,
  schema: LeadSchema,
  prompt: '...',
});

// 개념적 예시 — 옵션명·파라미터명은 SDK 버전마다 다를 수 있음
const { object } = await generateObject({
  model: openai('gpt-4o'),
  schema: LeadSchema,
  prompt: '...',
  // experimental_repairText 형태의 훅이 제공되는 버전에서는
  // 텍스트를 조작해 재파싱을 시도하는 콜백을 넘길 수 있습니다.
});