A high-level language and platform for AI workflows and agents.

::demo::agents ns

::store ::hot::store

LeadQualifier
meta {
    doc: "Qualifies inbound leads, scores them, and routes to sales or nurture.",
    agent: {
        name: "Lead Qualifier",
        tags: ["sales", "ai"],
    },
}
type { threshold: Dec, model: Str }

qualifier LeadQualifier({threshold: 0.7, model: "claude-sonnet"})
leads ::store/Map({name: "demo:leads"})

on-signup
meta {
    doc: "Accepts inbound signups via webhook and queues them for qualification",
    agent: LeadQualifier,
    webhook: {service: "leads", path: "/signup"},
}
fn (request) {
    lead or(request.body, request.data)
    ::store/put(leads, or(lead.email, Uuid()), lead)
    send("lead:new", lead)
    {ok: true}
}

qualify-lead
meta {
    doc: "Scores a lead and routes to sales if qualified, nurture otherwise",
    agent: LeadQualifier,
    on-event: "lead:new",
}
fn (event) {
    lead event.data
    score add(mul(rand(), 0.6), 0.3)

    if(gte(score, qualifier.threshold),
        send("lead:qualified", {email: lead.email, score: score}),
        send("lead:nurture", {email: lead.email, score: score}))
}

notify-sales
meta {
    doc: "Posts a Slack alert when a lead scores above threshold",
    agent: LeadQualifier,
    on-event: "lead:qualified",
}
fn (event) {
    send("slack:post", {
        channel: "#sales",
        text: `Hot lead: ${event.data.email} (score ${round(mul(event.data.score, 100))})`,
    })
}

weekly-pipeline
meta {
    doc: "Generates a weekly pipeline summary and posts it to Slack",
    agent: LeadQualifier,
    schedule: "every monday at 9am",
}
fn (event) {
    total add(20, rand-int(30))
    qualified add(5, rand-int(10))
    send("slack:post", {
        channel: "#sales",
        text: `Pipeline: ${total} leads, ${qualified} qualified this week`,
    })
}

::demo::mcp ns

::store ::hot::store

lookup-order
meta {
    mcp: {service: "support"},
    doc: "Look up order by ID"
}
fn (order-id: Str): Map {
    ::store/get("orders", order-id)
}

cancel-order
meta {
    mcp: {service: "support"},
    doc: "Cancel an order if not yet shipped"
}
fn (order-id: Str): Map {
    order ::store/get("orders", order-id)
    if(eq(order.status, "shipped"), fail("Cannot cancel shipped order"))
    ::store/put("orders", order-id, {...order, status: "cancelled"})
    {id: order-id, status: "cancelled"}
}

::demo::events ns

on-order-placed
meta {on-event: "order:placed"}
fn (event) {
    order event.data

    parallel {
        inventory send("inventory:reserve", {items: order.items})
        receipt send("email:send", {
            to: order.customer.email,
            subject: `Order #${order.id} confirmed`,
        })
        notify send("slack:post", {
            channel: "#orders",
            text: `New order #${order.id} from ${order.customer.name}`,
        })
    }
}

::demo::box ns

::box ::hot::box

run-analysis
meta {on-event: "data:analyze"}
fn (event) {
    csv-path or(event.data.file, "hot://demo/orders.csv")
    escaped-csv-path replace(csv-path, "'", "'\\''")
    script ```
        hotbox cp '${escaped-csv-path}' /data/data.csv
        python3 -c "
        import csv, json, statistics
        rows = list(csv.DictReader(open('/data/data.csv')))
        a = [float(r['amount']) for r in rows]
        print(json.dumps({k: round(v, 2) for k, v in {
            'rows': len(rows), 'total': sum(a),
            'mean': statistics.mean(a), 'median': statistics.median(a)
        }.items()}))
        "
        ```
    result ::box/start({
        image: "python:3.12-alpine",
        script,
        timeout: 60,
        size: "small",
    })
    ::hot::task/await(result.id)
    from-json(trim(or(result.stdout, "{}")))
}

::demo::tasks ns

::box ::hot::box
::task ::hot::task

process-upload
meta {on-event: "demo:process-file"}
fn (event) {
    jobs parallel {
        info ::box/start({
            image: "alpine:latest",
            script: "echo '{\"width\":1920,\"height\":1080}'",
            timeout: 30,
            size: "nano",
        })
        hash ::box/start({
            image: "alpine:latest",
            script: "echo -n 'demo' | sha256sum | cut -d' ' -f1",
            timeout: 30,
            size: "nano",
        })
    }

    results parallel {
        info ::task/await(jobs.info.id)
        hash ::task/await(jobs.hash.id)
    }

    {
        metadata: from-json(trim(or(results.info.stdout, "{}"))),
        hash: trim(or(results.hash.stdout, "")),
    }
}

::demo::video ns

on-video-upload
meta {on-event: "video:uploaded"}
fn (event) {
    path or(event.data.path, "hot://demo/test.mp4")
    parallel {
        probe ::ffmpeg/probe(path)
        thumb ::ffmpeg/thumbnail(path)
        audio ::ffmpeg/extract-audio(path)
    }
}

::demo::screenshot ns

capture
meta {on-event: "page:capture"}
fn (event) {
    url or(event.data.url, "https://hot.dev/docs")
    results parallel {
        shot ::playwright/screenshot(url)
        page ::playwright/scrape(url)
    }
    {
        url: url,
        screenshot: results.shot.url,
        title: results.page.title,
        text: slice(results.page.text, 0, 500),
    }
}

::demo::schedules ns

daily-report
meta {
    schedule: "daily at 6am",
    on-event: "demo:daily-report"
}
fn (event) {
    stats {
        users: {total: add(1000, rand-int(500)), new_today: add(10, rand-int(40))},
        revenue: {today: add(5000, rand-int(3000)), mrr: add(42000, rand-int(8000))},
    }

    send("slack:post", {
        channel: "#metrics",
        text: `Users: ${stats.users.total} (+${stats.users.new_today} new) | Revenue: $${stats.revenue.today} | MRR: $${stats.revenue.mrr}`,
    })
}

::demo::files ns

generate-report
meta {on-event: "report:generate"}
fn (event) {
    orders event.data.orders
    header "id,customer,amount,status"
    rows orders |> map((o) { `${o.id},${o.customer},${o.amount},${o.status}` })
    csv join([header, ...rows], "\n")

    path `hot://reports/orders-${::hot::time/format(::hot::time/now(), "yyyy-MM-dd")}.csv`
    write-file(path, csv)
    {file: path, rows: length(orders)}
}

::demo::webhooks ns

on-webhook
meta {
    webhook: {service: "demo", path: "/demo-hook"},
    on-event: "demo:webhook"
}
fn (request) {
    event-type or(request.body.type, request.data.type)
    payload or(request.body.data.object, request.data.data.object)

    cond {
        eq(event-type, "payment_intent.succeeded") => {
            send("payment:received", {customer: payload.customer, amount: payload.amount})
        }

        eq(event-type, "payment_intent.payment_failed") => {
            send("payment:failed", {customer: payload.customer})
        }
        => { {status: "ignored", type: event-type} }
    }
}

::demo::retries ns

::http ::hot::http

fetch-data
meta {
    on-event: "demo:fetch-data",
    retry: {attempts: 5, delay: 2000}
}
fn (event) {
    result ::http/get(or(event.data.url, "https://hot.dev/status"))
    if(not(::http/is-ok-response(result)), fail(`Request failed: ${result.status}`))
    {
        status: result.status,
        bytes: length(to-json(result.body)),
    }
}