ai is a
keyword,
not an import

# Your types are the schema - no SDK, no JSON Schema hand-write
type Intent = Demo | Pricing | Support
type Lead = Hot { company: String, seats: Int } | Warm { company: String } | Cold

inbound = """
    From: sam@acme.io
    Hey - evaluating for ~40 seats. Can we book a demo next week?
"""

lead = ai[Lead] "Parse into a Lead: {inbound}"
# Majority vote when confidence matters
intent = ai[Intent] 5 "Classify intent: {inbound}"

print(lead)
print(intent)

type Priority = P0 | P1 | P2
type Plan = Plan { order_id: String, issue: String, tier: String, priority: Priority, next: List }

ticket = """
    Order #4821 arrived damaged. Customer wants refund or
    replacement. Account: enterprise. Priority unclear.
"""

# Messy text → extract → plan → prioritise - one pipe
plan = ticket
    |> ai "Extract order_id, issue, account_tier"
    |> ai "Draft a resolution plan with next steps"
    |> ai[Plan] "Assign P0 | P1 | P2 for an enterprise account and return the full plan"

print(plan)

# Boolean + natural-language contracts on the call path
# Fail → runtime re-prompts with the failure (bounded, not silent)
@requires(len(text) > 0)
@ensures("result is a valid ISO-8601 date")
@ensures("result is not in the future")
fn extract_deadline(text) = ai "Extract the hard deadline from: {text}"

deadline = extract_deadline("Need this shipped by end of next Friday - no later.")
print("deadline: " + deadline)

import std.http

type Reply = Answer { body: String }
    | Escalate { reason: String }

# Typed model output on the request path - one binary, no framework
http.serve(8080, fn(req) {
    match [req.method, req.path] {
        ["POST", "/support"] => {
            reply = ai[Reply] "Handle this support email: {req.body}"
            match reply {
                Answer(body) => http.json({ ok: true, body: body })
                Escalate(reason) => http.json({ ok: false, reason: reason })
            }
        }
        _ => http.not_found()
    }
})

# ecko test discovers *_test.ecko and forces mock mode - offline, free, CI-ready
import std.test

fn slugify(title) = lower(title) |> replace(" ", "-")

test.case("slugify lowercases and dashes", fn() {
    test.eq(slugify("Hello World"), "hello-world")
})

type Sentiment = Positive | Negative | Neutral

test.case("typed ai is mock-testable", fn() {
    # No API key: ai returns schema-valid mocks - pipelines test without spend
    mood = ai[Sentiment] "Classify: I love this"
    test.ok(match mood {
        Positive => true
        Negative => true
        Neutral => true
    })
})

test.case("assertions on errors", fn() {
    test.err(fn() error("boom town"), "boom")
})