@hanzo/rooms 0.1.0

package/dist/lib/plans.js

@@ -0,0 +1,310 @@
+/**
+ * The subscription catalog, in one place, for every pricing surface.
+ *
+ * THERE ARE TWO CATALOGS AND THEY ARE DIFFERENT PRODUCTS. Confusing them is
+ * what this module exists to prevent:
+ *
+ *   GET /v1/billing/plans   THIS ONE. commerce's subscription authority — the
+ *                           same rows that charge. 17 plans across categories
+ *                           personal/team/enterprise/world/social/dns, each
+ *                           with `features`. Bare ARRAY, `slug`, `price` in
+ *                           CENTS.
+ *   GET /v1/plans           Cloud VM tiers — vcpus, memoryGB, diskGB. 11 rows,
+ *                           NO `features` on any of them. Shaped `{plans:[…]}`.
+ *
+ * They collide on the words "pro" and "enterprise" and on nothing else: `pro`
+ * the subscription is $20/mo, `pro` the VM tier is $25/mo for 2 vCPU. Reading
+ * the VM catalog to render subscriptions is not a wrong number, it is a wrong
+ * product — and it crashed this page. The team/enterprise view filtered /v1/plans
+ * for `category === "enterprise"`, matched the $429 VM row, replaced the real
+ * Team/Enterprise cards with it, and handed a card `features: undefined`. The
+ * `.map()` over it took the whole pricing page down to "Something went wrong."
+ * for anyone who clicked the tab.
+ *
+ * So the catalog is named once, mapped once, and guarded once, here.
+ *
+ * A SuperAdmin edits these rows at admin.hanzo.ai (/v1/commerce/plans/entries),
+ * and every reader here follows: the build bakes the authority's answer into the
+ * pricing snapshot for the first paint, and the page replaces it with the live
+ * read. No price in this repo is typed; @hanzo/plans is read only for what the
+ * wire does not carry — a plan's name for a slug, and the Free row's models.
+ */
+import { useEffect, useMemo, useState } from "react";
+import { subscriptionPlans } from "@hanzo/plans";
+import { where } from "../where.js";
+import { api } from "./api.js";
+import { org } from "./session.js";
+/**
+ * Where money changes hands: the checkout, mounted at hanzo.ai/pay so a buyer
+ * never leaves the site. It is hanzo-inc/pay, served from the same export
+ * pay.hanzo.ai was; that host now redirects here.
+ *
+ * billing.hanzo.ai has no route at the edge and answers 404, and /billing on
+ * this site is the Billing PRODUCT's page — a reader sent there to buy a plan
+ * lands on marketing. /pay takes `?plan=`, `?interval=`, `?returnUrl=` and
+ * `?org=`, and comes back. Every "add credit" and "billing" link reads this one
+ * address. Absolute, because this export also serves cloud.hanzo.ai and
+ * hanzo.bot, and the checkout lives on hanzo.ai.
+ */
+const BILLING_URL = "https://hanzo.ai/pay";
+/**
+ * The checkout address, opened on a plan when one is named, and returning to
+ * `back` once the buyer has paid. Without `back` a paid buyer lands on the pay
+ * site's receipt with no way into what they bought.
+ *
+ * ONE writer for this address. It was spelled out in three places — the
+ * personal ladder, the business strip and the /account hand-off — and a plan id
+ * only selects the card a reader clicked if every writer spells the query the
+ * same way.
+ */
+export function checkoutUrl(id, back) {
+    return payUrl(id ? "/cart" : "/", { plan: id, returnUrl: back });
+}
+/**
+ * A page on the pay site, for the organization this browser works in.
+ *
+ * pay charges and reads the ledger it is named, and it can only offer the ones
+ * the token lists; which of them this workspace is in is a fact only this site
+ * holds. `?org=` carries it across, and pay honours it only while the token
+ * offers it. Call it at the moment of leaving: the organization lives in this
+ * browser and moves with the switcher.
+ */
+export function payPage(path = "/") {
+    return payUrl(path, { org: org() });
+}
+/** The pay address with its query, written in one place for both callers above. */
+function payUrl(path, query) {
+    const q = new URLSearchParams();
+    for (const [k, v] of Object.entries(query))
+        if (v)
+            q.set(k, v);
+    const s = q.toString();
+    if (path === "/" && !s)
+        return BILLING_URL;
+    return `${BILLING_URL}${path}${s ? `?${s}` : ""}`;
+}
+/**
+ * The checkout a plan's CTA opens.
+ *
+ * A catalog row may carry its own link, and then that link wins; otherwise the
+ * id is the whole address. The id is also what `plan_clicked` reports, so the
+ * plan the event names and the plan the checkout opens cannot disagree.
+ */
+export function planCheckoutUrl(plan, back) {
+    return plan.checkoutUrl || checkoutUrl(plan.checkoutId || plan.id, back);
+}
+/**
+ * A checkout address for a term: a year adds `interval=year`, a month leaves the
+ * address as it is. pay reads the parameter; until it sells a year, its cart
+ * states the monthly charge, and the buyer reads that before paying. A relative
+ * address is read against the pay site, where every checkout is.
+ */
+export function term(href, interval) {
+    if (interval === "month")
+        return href;
+    const url = new URL(href, BILLING_URL);
+    url.searchParams.set("interval", "year");
+    return url.toString();
+}
+/**
+ * The cart for `seats` of a per-seat plan, for a term, charged to `org` and
+ * returning to `back` once paid. `quantity` is the seat count checkout sells.
+ */
+export function cartUrl(plan, seats, interval, org, back) {
+    return term(payUrl("/cart", { plan, quantity: String(seats), org, returnUrl: back }), interval);
+}
+/**
+ * Billing speaks CENTS; these pages render dollars. Converting here, once, at
+ * the boundary — a price that is 100x wrong on a checkout page is the worst
+ * possible rounding bug, so it converts in exactly one place and nowhere else.
+ *
+ * `features` defaults to [] because a card maps over it. A plan that arrives
+ * without features should render as a plan with no features listed, never as a
+ * blank page.
+ */
+function fromBillingPlan(p) {
+    return {
+        id: p.slug,
+        name: p.name,
+        description: p.description,
+        priceMonthly: p.price == null ? null : p.price / 100,
+        priceAnnual: p.priceAnnual == null ? null : p.priceAnnual / 100,
+        annualTotal: p.annualTotal ? p.annualTotal / 100 : null,
+        category: p.category,
+        popular: p.popular,
+        contactSales: p.contactSales,
+        pricePerUser: p.perSeat,
+        features: p.features ?? [],
+        limits: p.limits,
+        checkoutUrl: p.checkoutUrl,
+        checkoutId: p.checkoutId,
+    };
+}
+/**
+ * The authority's rows as the build last read them — scripts/sync-pricing.mjs
+ * takes GET /v1/billing/plans into lib/data/plans.json on every build. It is the
+ * first paint, and the whole answer wherever the live read fails: a preview host
+ * the API does not admit, a reader offline, an outage. The SAME rows as the live
+ * read, so the two can differ only by what a SuperAdmin changed since the build.
+ */
+const baked = () => where().plans ?? [];
+/**
+ * The catalog, live — or null when commerce did not answer.
+ *
+ * The difference is the whole point. Commerce is where a plan is listed or
+ * archived, so "this category sells nothing right now" is a real answer an admin
+ * can produce, and it has to reach the page: archiving the last rung in a
+ * category should empty it, not leave the build-time copy standing in as if
+ * nothing had changed. A transport error or a non-2xx is null, and a caller keeps
+ * the snapshot for it — a commerce outage must not blank the pricing page.
+ *
+ * ONE READ PER PAGE. Every hook below asks for the whole catalog and filters it,
+ * so a page drawing four categories costs one request, not four.
+ */
+let reading = null;
+function live() {
+    reading ??= fetch(`${api()}/v1/billing/plans`)
+        .then(async (res) => {
+        if (!res.ok)
+            return null;
+        const body = await res.json();
+        // The catalog answers with a bare array. Tolerate {plans:[…]} so a proxy
+        // that wraps it cannot silently yield zero rows. Anything else is not a
+        // catalog, and reading it as an empty one would blank the page on a shape
+        // change rather than on a decision.
+        return Array.isArray(body) ? body : Array.isArray(body?.plans) ? body.plans : null;
+    })
+        .catch(() => null);
+    return reading;
+}
+/** The plans in one category, live — or null when commerce did not answer. */
+export async function loadPlans(category) {
+    const rows = await live();
+    return rows === null ? null : rows.filter((p) => p?.category === category).map(fromBillingPlan);
+}
+/** The plans in one category as the build last read them. */
+export function fallbackPlans(category) {
+    return baked().filter((p) => p.category === category).map(fromBillingPlan);
+}
+/**
+ * Every row the authority serves, in catalog order: painted from the snapshot,
+ * replaced by the live read. This is how an edit made at admin.hanzo.ai reaches
+ * a reader with no build in between.
+ */
+export function useCatalog() {
+    const [rows, setRows] = useState(() => baked().map(fromBillingPlan));
+    useEffect(() => {
+        let open = true;
+        live().then((got) => {
+            if (open && got)
+                setRows(got.map(fromBillingPlan));
+        });
+        return () => {
+            open = false;
+        };
+    }, []);
+    return rows;
+}
+/** Dollars as a price is written: two places, always, so a card and a button agree. */
+const dollars = (n) => `$${n.toFixed(2)}`;
+/**
+ * Which plan an organization runs on, and what it costs. A plan is a
+ * subscription with usage limits; it mints no credit, so nothing here says it does.
+ *
+ * ONE ANSWER FOR TWO SURFACES. /pricing states the offer and the workspace gate
+ * asks a member to buy it; those were two readings of one row, each with its own
+ * copy of "the first personal row that charges" and its own money formatter. A
+ * marketing page and a subscribe screen quoting different numbers for the same
+ * plan is the failure that costs a sale, and it needs only for one of the two
+ * copies to be edited.
+ *
+ * It is the FIRST ROW THAT CHARGES in a category: `personal` is the plan a
+ * personal organization runs on, `team` the per-seat plan a team organization
+ * runs on, whatever commerce currently prices each at. Neither surface holds the
+ * figure, so neither can be wrong on its own.
+ *
+ * Painted from the snapshot and replaced by the live catalog, which is the
+ * contract every reader in this module keeps.
+ */
+export function usePlan(category = "personal") {
+    return priced(usePlans(category).find((p) => (p.priceMonthly ?? 0) > 0) ?? null);
+}
+/**
+ * A category's rows a reader can buy on their own, in catalog order: the
+ * personal ladder from Free up, or the Team plan. Rows sold through a
+ * conversation are left out. Painted from the snapshot, replaced by the catalog.
+ */
+export function usePlans(category) {
+    const all = useCatalog();
+    return useMemo(() => all.filter((p) => p.category === category && !p.contactSales), [all, category]);
+}
+/** A row priced the way every surface writes it. */
+export function priced(plan) {
+    return { plan, price: plan ? dollars(plan.priceMonthly ?? 0) : "—" };
+}
+/** Money as a sentence says it: whole dollars bare, anything else to the cent — $20, $16.67. */
+export const money = (n) => (Number.isInteger(n) ? `$${n.toLocaleString("en-US")}` : dollars(n));
+/**
+ * What one term of a plan charges, in dollars, or null where the catalog sells
+ * no such term. A month is `priceMonthly`. A year is the total the catalog
+ * states, or twelve of `priceAnnual` where it states only the monthly figure.
+ */
+export function charge(plan, interval) {
+    const n = interval === "month"
+        ? plan.priceMonthly
+        : (plan.annualTotal ?? (plan.priceAnnual ? Math.round(plan.priceAnnual * 1200) / 100 : null));
+    return n && n > 0 ? n : null;
+}
+/**
+ * A term's price as a button quotes it — "$20/month", "$200/year" — or null.
+ * A year is quoted as the total where the catalog states one, and otherwise as
+ * the monthly figure the catalog does state, never as a total derived here.
+ */
+export function quote(plan, interval) {
+    if (interval === "month")
+        return plan.priceMonthly ? `${money(plan.priceMonthly)}/month` : null;
+    if (plan.annualTotal)
+        return `${money(plan.annualTotal)}/year`;
+    return plan.priceAnnual ? `${money(plan.priceAnnual)}/month, billed yearly` : null;
+}
+/** What a year saves against twelve months, as a whole percent: 1 − year ÷ (12 × month). Null where it saves nothing. */
+export function saving(plan) {
+    const month = charge(plan, "month");
+    const year = charge(plan, "year");
+    if (!month || !year || year >= 12 * month)
+        return null;
+    return Math.round((1 - year / (12 * month)) * 100);
+}
+/** The models the Free plan runs, as @hanzo/plans states them: `ai.models` on the `free` row. */
+const FREE_MODELS = new Set(subscriptionPlans.find((p) => p.id === "free")?.entitlements?.["ai.models"] ?? []);
+/** Whether the Free plan runs a model: one its row names, or any `:free` route. */
+export function onFree(model) {
+    return FREE_MODELS.has(model) || model.endsWith(":free");
+}
+/**
+ * The catalog's own name for a plan slug — "max-20x" reads as "Max 20x" —
+ * or null where the slug is empty or the catalog does not carry it.
+ *
+ * Read off the published package: a plan's name does not move between a build and the next release the way
+ * its price can, so the bundled copy is not a stale answer here the way it
+ * would be for money. A reader of `GET /v1/billing/tier`'s `plan` field
+ * needs a name and nothing else, so no live fetch is spent proving what the
+ * package already states.
+ */
+export function planName(slug) {
+    if (!slug)
+        return null;
+    const row = subscriptionPlans.find((p) => p.id === slug);
+    return row?.name ?? null;
+}
+/**
+ * A usage rate as money. A sub-dollar rate needs at least two decimals to read as
+ * a price at all — 0.1 is $0.10, not $0.1 — while keeping the precision the
+ * catalog states, so $0.015/1K vectors does not round away to a cent.
+ */
+export function formatUsageRate(v) {
+    if (v >= 1)
+        return `$${v.toLocaleString("en-US")}`;
+    const decimals = (String(v).split(".")[1] ?? "").length;
+    return `$${v.toFixed(Math.max(2, decimals))}`;
+}

package/dist/lib/prose.d.ts

@@ -0,0 +1,13 @@
+import { type Token, type Tokens } from 'marked';
+export type { Token, Tokens };
+/** One message's text as marked's block tokens. Empty in, empty out — a caller
+ *  rendering a streaming turn asks this on every token and the first is nothing. */
+export declare function read(text: string): Token[];
+/** The href a link may carry, or null when it may carry none. Parsed with URL,
+ *  so the scheme judged is the scheme a browser would follow, and a link is
+ *  away whenever it would leave the page's origin — `//host`, `/\host` and
+ *  `https:host` included, however the address is spelled. */
+export declare function destination(href: string): {
+    href: string;
+    away: boolean;
+} | null;

package/dist/lib/prose.js

@@ -0,0 +1,62 @@
+// What a message says, as it was written.
+//
+// A model answers in markdown — fences, lists, emphasis, tables — and this app
+// drew that as literal characters: an answer arrived reading "```ts" and three
+// backticks stayed on screen. Three surfaces then each grew their own half of a
+// renderer, and all three were the same regex pair (fences, newlines) with no
+// escaping inside the fence, so a code block containing a tag lost the tag.
+//
+// One reader, and `marked` is the one the site already parses its legal
+// documents with — same engine, same dialect, so a fence means the same thing
+// wherever it is written. This file READS: it turns a message into marked's
+// tokens. `components/workspace/Prose.tsx` draws them in gui elements.
+//
+// SAFE BY CONSTRUCTION RATHER THAN BY CLEANUP. Nothing here or in the drawing
+// produces markup from the text: every leaf is a string React escapes, raw HTML
+// is shown as the text somebody typed, and a link keeps only a scheme a message
+// is allowed to carry. The same tokens come out on the server and in the
+// browser, which is also what keeps hydration quiet.
+import { Lexer } from 'marked';
+/** GitHub's dialect, and a single newline is a line break: a model breaks a
+ *  line where it means one. */
+const DIALECT = { gfm: true, breaks: true };
+/** One message's text as marked's block tokens. Empty in, empty out — a caller
+ *  rendering a streaming turn asks this on every token and the first is nothing. */
+export function read(text) {
+    if (!text)
+        return [];
+    return Lexer.lex(text, DIALECT);
+}
+/** Schemes a message may link to. Anything else — `javascript:`, `data:`,
+ *  `vbscript:` — is a script delivered as a destination, so the text stays and
+ *  the link does not. A relative or fragment href resolves to this page's own
+ *  scheme and is kept. */
+const SCHEMES = new Set(['http:', 'https:', 'mailto:', 'tel:']);
+/** An href read the way a browser reads it: every tab, newline and carriage
+ *  return removed wherever it stands, and control characters and spaces removed
+ *  from both ends (WHATWG URL parsing). `\x01javascript:` is `javascript:` to a
+ *  browser, so it has to be `javascript:` to the allowlist too. */
+const TAB_OR_NEWLINE = /[\t\n\r]/g;
+const EDGES = /^[\u0000- ]+|[\u0000- ]+$/g;
+/** The page a relative href is resolved against. Its origin is no site's, so an
+ *  href that stays on it is one that stays on whatever site renders it. */
+const HERE = new URL('https://here.invalid/');
+/** The href a link may carry, or null when it may carry none. Parsed with URL,
+ *  so the scheme judged is the scheme a browser would follow, and a link is
+ *  away whenever it would leave the page's origin — `//host`, `/\host` and
+ *  `https:host` included, however the address is spelled. */
+export function destination(href) {
+    const bare = href.replace(TAB_OR_NEWLINE, '').replace(EDGES, '');
+    if (/[\u0000-\u001f\u007f]/.test(bare))
+        return null;
+    let url;
+    try {
+        url = new URL(bare, HERE);
+    }
+    catch {
+        return null;
+    }
+    if (!SCHEMES.has(url.protocol))
+        return null;
+    return { href: bare, away: url.origin !== HERE.origin };
+}

package/dist/lib/reach.d.ts

@@ -0,0 +1,17 @@
+/**
+ * What the server said about a failed call, or undefined when it said nothing.
+ *
+ * The platform refuses in RFC 9457 problem documents — `{title, status,
+ * detail}` — and `@hanzo/ai` 0.6.16 reads only `msg` and `error`, so a refusal
+ * with a reason reaches the page as `HTTP 400`. The reason is in the body the
+ * error carries, and this reads it: `detail`, then `message`, then `title`.
+ */
+export declare function told(error: unknown): string | undefined;
+/**
+ * The sentence to show for a failed call.
+ *
+ * Anything the SERVER said is passed through untouched — a refusal in the
+ * platform's own words is better than any rewording of it. Only the silence
+ * gets replaced, because silence is the case with nothing in it to show.
+ */
+export declare function reach(error: unknown): string;

package/dist/lib/reach.js

@@ -0,0 +1,70 @@
+// What went wrong, in words that name something you can act on.
+//
+// A browser reports a request that never got an answer as `TypeError: Load
+// failed` (Safari) or `Failed to fetch` (Chrome). Both are the SAME event and
+// neither says which address failed or why — so a form that shows the message
+// verbatim reads as "the app is broken" for a cause that is usually one line of
+// configuration. There is no status to report because no response arrived.
+//
+// The cause is nearly always one of two, and both are about WHERE the page is
+// open rather than about the request: the API is not running at the address the
+// page was built with, or it is running and does not allow this page's origin,
+// which the browser refuses BEFORE the request and reports identically.
+// `localhost` and `127.0.0.1` are different origins to a browser and the same
+// machine to a person, which is why this is worth a sentence rather than a
+// shrug.
+import { api } from './api.js';
+/** A browser's word for "no answer arrived", per engine. */
+const silent = (message) => /load failed|failed to fetch|networkerror|network request failed/i.test(message);
+/**
+ * What the server said about a failed call, or undefined when it said nothing.
+ *
+ * The platform refuses in RFC 9457 problem documents — `{title, status,
+ * detail}` — and `@hanzo/ai` 0.6.16 reads only `msg` and `error`, so a refusal
+ * with a reason reaches the page as `HTTP 400`. The reason is in the body the
+ * error carries, and this reads it: `detail`, then `message`, then `title`.
+ */
+export function told(error) {
+    const body = error?.body;
+    if (body && typeof body === 'object') {
+        const b = body;
+        for (const key of ['detail', 'message', 'msg', 'error', 'title']) {
+            const v = b[key];
+            if (typeof v === 'string' && v.trim())
+                return v.trim();
+            if (key === 'error' && v && typeof v === 'object') {
+                const m = v.message;
+                if (typeof m === 'string' && m.trim())
+                    return m.trim();
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * The sentence to show for a failed call.
+ *
+ * Anything the SERVER said is passed through untouched — a refusal in the
+ * platform's own words is better than any rewording of it. Only the silence
+ * gets replaced, because silence is the case with nothing in it to show.
+ */
+export function reach(error) {
+    const message = told(error) ?? (error instanceof Error ? error.message : String(error ?? ''));
+    // Named at call time, so it is the address the page in front of the reader
+    // actually used rather than the one the build was made with.
+    const where = api();
+    if (!message)
+        return `No answer from ${where}.`;
+    if (!silent(message))
+        return message;
+    const here = typeof window === 'undefined' ? '' : window.location.origin;
+    // SAME ORIGIN IS NOT A CORS REFUSAL. On the dev server the platform's address
+    // IS this page's, because `/v1` is proxied there — so silence means whatever
+    // the proxy points at is not up, and the second half below would send the
+    // reader after an allowlist that was never in the way.
+    if (where === here)
+        return `No answer from ${here}/v1 — the address it proxies to is not running.`;
+    return (`No answer from ${where}. It is either not running, or it is not open to ` +
+        `pages served from ${here || 'this address'} ` +
+        `— a browser treats localhost and 127.0.0.1 as different places.`);
+}

package/dist/lib/rooms.json

@@ -0,0 +1,23 @@
+[
+    "/beluga",
+    "/board",
+    "/bots",
+    "/cal",
+    "/chat",
+    "/chat/shared",
+    "/contacts",
+    "/dashboard",
+    "/dev",
+    "/drive",
+    "/home",
+    "/inbox",
+    "/meet",
+    "/settings",
+    "/settings/organization",
+    "/settings/organization/billing",
+    "/settings/organization/keys",
+    "/settings/organization/members",
+    "/settings/organization/usage",
+    "/vibe",
+    "/work"
+]

package/dist/lib/served.d.ts

@@ -0,0 +1,20 @@
+/**
+ * WHICH MODEL ANSWERED A TURN, as the gateway says it.
+ *
+ * The gateway may answer a pinned model from another when a provider refuses,
+ * and it names the one that answered twice: the `X-Hanzo-Served` header and
+ * the `model` field of the reply's own frames. `@hanzo/ai` 0.6.16 reads
+ * neither, so the site's client is built on `observed(fetch)`, which reads
+ * them off each completion as it passes and tells the listeners — the header
+ * when the gateway exposes it, else the first frame that names a model. Every
+ * byte is passed through untouched.
+ */
+/** A completion's asked and answering models. */
+export interface Served {
+    asked: string;
+    served: string;
+}
+/** Hears every served completion from now on; answers the unsubscribe. */
+export declare function onServed(listener: (heard: Served) => void): () => void;
+/** A fetch that tells `onServed` listeners which model answered each completion. */
+export declare function observed(base: typeof fetch): typeof fetch;

package/dist/lib/served.js

@@ -0,0 +1,92 @@
+/**
+ * WHICH MODEL ANSWERED A TURN, as the gateway says it.
+ *
+ * The gateway may answer a pinned model from another when a provider refuses,
+ * and it names the one that answered twice: the `X-Hanzo-Served` header and
+ * the `model` field of the reply's own frames. `@hanzo/ai` 0.6.16 reads
+ * neither, so the site's client is built on `observed(fetch)`, which reads
+ * them off each completion as it passes and tells the listeners — the header
+ * when the gateway exposes it, else the first frame that names a model. Every
+ * byte is passed through untouched.
+ */
+const listeners = new Set();
+/** Hears every served completion from now on; answers the unsubscribe. */
+export function onServed(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+const tell = (heard) => {
+    for (const listener of listeners)
+        listener(heard);
+};
+/** The completion route, whatever host the client was built for. */
+const COMPLETION = /\/v1\/chat\/completions(?:[?#]|$)/;
+/** A fetch that tells `onServed` listeners which model answered each completion. */
+export function observed(base) {
+    return async (input, init) => {
+        const res = await base(input, init);
+        const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+        if (!COMPLETION.test(url) || !res.ok)
+            return res;
+        let asked = '';
+        try {
+            const body = typeof init?.body === 'string' ? JSON.parse(init.body) : null;
+            if (typeof body?.model === 'string')
+                asked = body.model;
+        }
+        catch {
+            /* a body that is not JSON names no model */
+        }
+        const header = res.headers.get('x-hanzo-served');
+        if (header) {
+            tell({ asked, served: header });
+            return res;
+        }
+        if (!res.body || !(res.headers.get('content-type') ?? '').includes('text/event-stream')) {
+            res
+                .clone()
+                .json()
+                .then((d) => {
+                if (typeof d?.model === 'string' && d.model)
+                    tell({ asked, served: d.model });
+            })
+                .catch(() => { });
+            return res;
+        }
+        const decoder = new TextDecoder();
+        let heard = false;
+        let carry = '';
+        const watch = new TransformStream({
+            transform(chunk, out) {
+                out.enqueue(chunk);
+                if (heard)
+                    return;
+                carry += decoder.decode(chunk, { stream: true });
+                let at = carry.indexOf('\n');
+                while (!heard && at >= 0) {
+                    const line = carry.slice(0, at).trim();
+                    carry = carry.slice(at + 1);
+                    at = carry.indexOf('\n');
+                    if (!line.startsWith('data:'))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (!data || data === '[DONE]')
+                        continue;
+                    try {
+                        const frame = JSON.parse(data);
+                        if (typeof frame.model === 'string' && frame.model) {
+                            heard = true;
+                            tell({ asked, served: frame.model });
+                        }
+                    }
+                    catch {
+                        /* a frame split across chunks is read whole on the next line */
+                    }
+                }
+            },
+        });
+        return new Response(res.body.pipeThrough(watch), { status: res.status, statusText: res.statusText, headers: res.headers });
+    };
+}