Everything in the box

Four coercion levels, one API

Every coercion produces a diagnostic — what happened, the risk level, and a suggestion for tightening.

Lenient, Absorbing, Strict

A mode sets four switches at once. It's a type parameter, so the choice is visible in the type and checked at compile time — Strict carries a residual of Infallible, making a strict result a compile-time proof that nothing was coerced or left over.

When the mode comes from config rather than code, a DynamicMode enum parses from the strings lenient, absorbing, and strict.

Every adjustment, recorded

Each coercion, default, drop, and preservation becomes a Diagnostic { path, kind, risk, suggestion }. Risk levels are ordered Info < Warning < Risky, so gating a production path on “no Risky diagnostics” is a one-liner.

Diagnostics route through a DiagnosticSink: collect into a Vec, print to stderr, forward only at or above a risk threshold, or drop them.

20 data types from raw strings

guess_type() identifies types with confidence scores. Multiple types can match — the full ranked list is returned.

Built-in parsers for real-world data

Anthropic, OpenAI, Ollama — one struct

Parse responses from any provider into a unified NormalizedResponse:

// Same struct regardless of provider
let response = parse_openai_response(&raw_body)?;  // or anthropic / ollama
let text = response.text();
let tools = response.tool_uses();
let usage = response.usage; // input_tokens, output_tokens,
                            // cache_read_tokens, cache_creation_tokens

// Model wrapped its JSON in prose or a code fence? Pull it out first (0.4.1):
let data = FlexValue::from_llm_response(model_text)?;

Round-trip: parse -> emit -> re-parse preserves all data. from_llm_response extracts a JSON payload from markdown-fenced or prose-wrapped model output before parsing, while from_json stays strict. Token usage is normalized across providers, including cache_read_tokens from OpenAI and Anthropic prompt caching.

Push bytes, get events

The streaming parser is push-style: feed it chunks as they arrive, and it returns parse events incrementally. SSE and newline-delimited JSON both ride on top of it.

use laminate::{FlexStream, StreamConfig};

let mut stream = FlexStream::new(StreamConfig::default());
for chunk in byte_chunks {
    for event in stream.feed(chunk) {   // feed(&[u8]) -> Vec<StreamEvent>
        handle(event);
    }
}
for event in stream.finish() {          // flush anything still buffered
    handle(event);
}

Struct shaping with compile-time safety

#[derive(Laminate)]
struct Config {
    #[laminate(coerce)]          // auto-convert string -> number
    port: u16,
    #[laminate(coerce, default)] // missing -> false, "yes" -> true
    debug: bool,
    #[laminate(rename = "apiKey")]
    api_key: String,
    #[laminate(overflow)]        // unknown fields -> HashMap
    extra: HashMap<String, Value>,
}

Three shaping modes

Beyond the core library

Infer structure from data, then audit against it

• Per-field type detection (dominant type, mixed-type flag)
• Fill rate and null tracking
• Required field inference
• External constraints (override inferred types/nullability)
• Violation reporting (TypeMismatch, UnexpectedNull, MissingRequired, UnknownField, ConstraintViolation)

Context-aware coercion defaults

Tell laminate where the data came from, and it adjusts coercion defaults: