M02 — Structured Output

// The one shape, reused by the Anthropic + OpenAI JS SDKs (Zod).
import { z } from "zod";

export const OrderStatus = z.object({
  order_id: z.string(),
  status: z.enum(["processing", "shipped", "delivered", "cancelled"]), // enum!
  carrier: z.string().describe('Carrier name, or "unknown" if none yet'),
  eta: z.string(),
  summary: z.string().describe("One friendly sentence for the customer"),
});

// structured_anthropic.mjs
import Anthropic from "@anthropic-ai/sdk";
import { z } from "zod";
import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";

const OrderStatus = z.object({
  order_id: z.string(),
  status: z.enum(["processing", "shipped", "delivered", "cancelled"]),
  carrier: z.string(),
  eta: z.string(),
  summary: z.string(),
});

const client = new Anthropic();
const RAW = "AC-1042 went out with UPS, should land Tuesday, all good on our end";

const resp = await client.messages.parse({
  model: "claude-sonnet-5", max_tokens: 512,
  system: "You are Acme Support. Turn raw order notes into a clean OrderStatus.",
  messages: [{ role: "user", content: `Raw note: ${RAW}` }],
  output_config: { format: zodOutputFormat(OrderStatus) }, // <-- inside output_config
});

const order = resp.parsed_output;     // <-- typed (nullable — guard in prod)
console.log(order.status, "|", order.summary);

# structured_gemini.py
from google import genai
from google.genai import types
from pydantic import BaseModel, Field
from typing import Literal

class OrderStatus(BaseModel):
    order_id: str
    status: Literal["processing", "shipped", "delivered", "cancelled"]
    carrier: str = Field(description='Carrier name, or "unknown" if none yet')
    eta: str
    summary: str = Field(description="One friendly sentence for the customer")

client = genai.Client()
RAW = "AC-1042 went out with UPS, should land Tuesday, all good on our end"

resp = client.models.generate_content(
    model="gemini-2.5-flash",
    contents=f"Turn this raw order note into a clean OrderStatus: {RAW}",
    config=types.GenerateContentConfig(
        system_instruction="You are Acme Support.",
        response_mime_type="application/json",   # <-- required
        response_schema=OrderStatus,             # <-- Pydantic model
    ),
)

order = resp.parsed                   # <-- a validated OrderStatus (resp.text = raw JSON)
print(order.status, "|", order.summary)

// structured_gemini.mjs
// Gemini's JS SDK has no typed parse helper — you supply a raw schema with the
// Type enum and JSON.parse the text yourself.
import { GoogleGenAI, Type } from "@google/genai";

const ai = new GoogleGenAI({});
const RAW = "AC-1042 went out with UPS, should land Tuesday, all good on our end";

const resp = await ai.models.generateContent({
  model: "gemini-2.5-flash",
  contents: `Turn this raw order note into a clean OrderStatus: ${RAW}`,
  config: {
    systemInstruction: "You are Acme Support.",
    responseMimeType: "application/json",
    responseSchema: {
      type: Type.OBJECT,
      properties: {
        order_id: { type: Type.STRING },
        status: { type: Type.STRING, enum: ["processing", "shipped", "delivered", "cancelled"] },
        carrier: { type: Type.STRING },
        eta: { type: Type.STRING },
        summary: { type: Type.STRING },
      },
      required: ["order_id", "status", "carrier", "eta", "summary"],
      propertyOrdering: ["order_id", "status", "carrier", "eta", "summary"],
    },
  },
});

const order = JSON.parse(resp.text);  // <-- plain object, guaranteed to fit the schema
console.log(order.status, "|", order.summary);

# structured_openai.py  (Responses API)
from openai import OpenAI
from pydantic import BaseModel, Field
from typing import Literal

class OrderStatus(BaseModel):
    order_id: str
    status: Literal["processing", "shipped", "delivered", "cancelled"]
    carrier: str = Field(description='Carrier name, or "unknown" if none yet')
    eta: str
    summary: str = Field(description="One friendly sentence for the customer")

client = OpenAI()
RAW = "AC-1042 went out with UPS, should land Tuesday, all good on our end"

resp = client.responses.parse(
    model="gpt-5.5",
    instructions="You are Acme Support. Turn raw order notes into a clean OrderStatus.",
    input=f"Raw note: {RAW}",
    text_format=OrderStatus,          # <-- Pydantic model goes in text_format
)

order = resp.output_parsed            # <-- a validated OrderStatus instance
print(order.status, "|", order.summary)

// structured_openai.mjs  (Responses API)
import OpenAI from "openai";
import { z } from "zod";
import { zodTextFormat } from "openai/helpers/zod";

const OrderStatus = z.object({
  order_id: z.string(),
  status: z.enum(["processing", "shipped", "delivered", "cancelled"]),
  carrier: z.string(),
  eta: z.string(),
  summary: z.string(),
});

const client = new OpenAI();
const RAW = "AC-1042 went out with UPS, should land Tuesday, all good on our end";

const resp = await client.responses.parse({
  model: "gpt-5.5",
  instructions: "You are Acme Support. Turn raw order notes into a clean OrderStatus.",
  input: `Raw note: ${RAW}`,
  text: { format: zodTextFormat(OrderStatus, "order_status") }, // <-- text.format
});

const order = resp.output_parsed;     // <-- typed OrderStatus
console.log(order.status, "|", order.summary);