Turn one error into a permanent
improvement — automatically.

See it work

A lead scoring call. The model returns valid JSON — but the domain logic is wrong. llm-contract catches it and gets the model to fix it. No prompt changes.

{
  "company":    "TechVentures Inc",
  "score":      25,
  "tier":       "hot",
  "qualified":  true,
  "signals":    ["visited pricing", "downloaded whitepaper"],
  "nextAction": "close"
}

{
  "company":    "TechVentures Inc",
  "score":      25,
  "tier":       "cold",
  "qualified":  false,
  "signals":    ["visited pricing", "downloaded whitepaper"],
  "nextAction": "nurture"
}

Without vs. with

The problem

LLMs are good — but not perfect. When a structured response comes back wrong, there's no good path from error to fix.

What this does

llm-contract wraps your existing LLM call with a deterministic contract:

1. 1. Generate structural instructions from your schema
2. 2. Call your model (any provider, any SDK)
3. 3. Clean raw output into JSON
4. 4. Validate against the schema (types, fields, enums, invariants)
5. 5. On failure, feed the exact violation back to the model
6. 6. Retry with targeted repair (bounded)

The model is probabilistic. The boundary is not.

Quick example

import { enforce } from "llm-contract";
import { z } from "zod";

const result = await enforce(
  z.object({
    sentiment: z.enum(["positive", "negative", "neutral"]),
    confidence: z.number().min(0).max(1),
  }),
  async (attempt) => {
    const res = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [
        { role: "system", content: attempt.prompt },
        { role: "user", content: "Analyze: 'I love this product'" },
        ...attempt.fixes,
      ],
    });
    return res.choices[0].message.content;
  },
  {
    invariants: [
      (data) => data.confidence > 0.5 || `confidence too low: ${data.confidence}`,
    ],
  },
);

if (result.ok) {
  result.data; // { sentiment: "positive", confidence: 0.95 } — fully typed
}

• attempt.prompt — auto-generated from the schema, no hand-written format instructions
• attempt.fixes — on retry, the exact violation fed back to the model
• result.data — typed, validated at runtime, no casts
• Markdown fences, prose wrapping, string-typed numbers — cleaned automatically

Why this works

LLMs correct themselves reliably when you tell them exactly what went wrong. Not "return valid JSON" — the specific constraint that failed:

Each message becomes the repair directive. The model doesn't change. Your prompt doesn't change. The boundary enforces correctness — on every call, for every error in that class, permanently.

One invariant. Every future occurrence of that error. Automatic repair. Zero prompt changes.

When to use this

Use llm-contract when LLM output feeds downstream logic and bad structure has cost:

Not designed for free-form chat, creative writing, or tasks where structure doesn't matter.

Explore