Extract structured data from text

ai:
  driver: anthropic
  key: secret:ANTHROPIC_API_KEY        # a secret reference, never a literal
  models: [anthropic/claude-*]
  data: { training: never, retention: zero }
  limits:
    per-feature: { invoice-intake: $50/month }
    total: $200/month

import { s, type Infer } from "mainsdk/schema";

export const Invoice = s.object({
  number: s.string().min(1).max(40),
  vendor: s.string().min(1).max(80),
  currency: s.enum(["USD", "EUR", "INR"]),
  total: s.number().min(0),
  due: s.date(),                                      // ISO 8601 date, returned as the same string
}).refine((i) => i.total > 0, "Total must be above zero");

export type Invoice = Infer<typeof Invoice>;

import { ai, MainError } from "mainsdk";
import { parse } from "mainsdk/parse";
import { s, type Infer } from "mainsdk/schema";

// The schema from lib/invoice.ts
const Invoice = s.object({
  number: s.string().min(1).max(40),
  vendor: s.string().min(1).max(80),
  currency: s.enum(["USD", "EUR", "INR"]),
  total: s.number().min(0),
  due: s.date(),
}).refine((i) => i.total > 0, "Total must be above zero");
type Invoice = Infer<typeof Invoice>;

// Template: "Invoice INV-2026-0042 from Acme Ltd for USD 1250.00 due 2026-11-30."
const TEMPLATE = /Invoice (?<number>[A-Z0-9-]{1,40}) from (?<vendor>[^\n.]{1,80}) for (?<currency>[A-Z]{3}) (?<total>\d+(?:\.\d{1,2})?) due (?<due>\d{4}-\d{2}-\d{2})/;

export type Found = { invoice: Invoice; via: "pattern" | "model"; cost?: string };

function noMatch(err: unknown): boolean {
  return err instanceof MainError && (err.code === "MAIN-SCHEMA-0004" || err.code === "MAIN-SCHEMA-0001");
}

export async function readInvoice(email: { body: string }): Promise<Found> {
  const body = parse.text(email.body, { maxLength: 20_000 });   // trims and normalises; MAIN-SCHEMA-0002 above the limit

  try {
    const invoice = parse.regex(body, TEMPLATE, Invoice);        // MAIN-SCHEMA-0004 if the template misses
    return { invoice, via: "pattern" };                          // no model call, so no cost
  } catch (err) {
    if (!noMatch(err)) throw err;                                // any other error stops here
  }

  // Fall back to the model with the same schema.
  const found = await ai.extract({
    input: body,
    schema: Invoice,
    model: "anthropic/claude-sonnet-4-5",
    feature: "invoice-intake",
    repairs: 1,                                                  // one repair after an invalid reply; the default
  });
  return { invoice: found.value, via: found.via, cost: found.cost };
}

declare function readInvoice(email: { body: string }): Promise<{ invoice: unknown; via: "pattern" | "model"; cost?: string }>;   // lib/read-invoice.ts

export async function POST(req: Request) {
  // Check the mail provider's signature before you read the body. See the webhooks interface.
  const email = (await req.json()) as { body: string };
  const { invoice, via, cost } = await readInvoice(email);

  return Response.json({ invoice, via, cost: cost ?? null });   // via says which path ran
}

npx mainsdk check --json --agent

Goal: turn inbound invoice emails into typed invoices. Try the template with parse.regex first; use ai.extract only when it misses.
Read: docs/specs/schema.md, docs/specs/ai.md (ai.AC11 to ai.AC12), this page, main.yaml.
Touch only: main.yaml (the ai block), lib/invoice.ts, lib/read-invoice.ts, the inbound route.
Do: define Invoice with s; keep one schema for both paths; catch only MAIN-SCHEMA-0001 and MAIN-SCHEMA-0004 around parse.regex; return via and cost.
Verify: npx mainsdk check --json --agent, and the three sample emails in Verify.
Never parse model text by hand, never skip the schema on the model path, never raise a limit to pass a test.