@rizal72/oc-models-pro 0.1.5 → 0.3.0

package/rows.ts

@@ -0,0 +1,301 @@
+// oc-models-pro/rows.ts — the facts both surfaces read the same way.
+//
+// The terminal draws a monospace table and the desktop draws a grid, but what a row *means* is not the
+// renderer's business: the effective price, what counts as free, and the ten orders are one definition
+// here. Two copies would drift the way they already did once — the terminal kept free models out of the
+// price order and the desktop did not.
+//
+// Runnable standalone for its self-check: node plugins/oc-models-pro/rows.ts --self-check
+
+export interface Row {
+	name: string
+	providerID: string
+	modelID: string
+	provider: string
+	/** Two letters from `tags.ts`: the provider's, unique in the catalogue. */
+	tag: string
+	/** Undefined when the catalogue has no price for the model: an unknown figure, not a free one. */
+	input?: number
+	output?: number
+	/** Undefined when the model carries no limit. */
+	context?: number
+	/** Monthly limit ÷ the $10 plan: the ordering multiplier, shown so the order explains itself. */
+	credit: number
+	/** Allowance ÷ its normal one, when the page marks a promotion. */
+	promo?: number
+	/** Peak price ÷ off-peak price, for a model with two tariffs. */
+	peak?: number
+	/** Stencil's intelligence score and its speed; absent when the catalogue has no row for the model. */
+	int?: number
+	tps?: number
+	/** Tokens per second measured here, on this provider. Outranks `tps` and carries no tilde. */
+	measured?: number
+	enabled: boolean
+}
+
+/** What the Go plan makes a model cost: the figure the effective order sorts by. An unknown price is
+ *  `undefined`, not infinity, so an order can tell "not measured" from "very expensive". */
+export function effective(row: Row): number | undefined {
+	if (row.input === undefined) return undefined
+	return row.input / (row.credit || 1)
+}
+
+/** A missing price is not a free one: both figures must be there, and be zero. */
+export function isFree(row: Row): boolean {
+	return row.input === 0 && row.output === 0
+}
+
+/** The speed to sort and print: what this machine measured first, the borrowed figure after. */
+export function speedOf(row: Row): number | undefined {
+	return row.measured ?? row.tps
+}
+
+export type SortKey =
+	| "effective"
+	| "input"
+	| "output"
+	| "inputSum"
+	| "context"
+	| "int"
+	| "speed"
+	| "recent"
+	| "provider"
+	| "name"
+
+export interface SortContext {
+	/** `providerID/modelID` → its place in the recent list; smaller is more recent. */
+	recent: Map<string, number>
+}
+
+export interface Order {
+	/** The long name: a footer, a menu, a title. */
+	label: string
+	/** The short name the terminal prints in its title bar. */
+	short: string
+	/** True when more is better, so the first row is the largest figure. */
+	desc?: true
+	/** `undefined` when the order cannot measure this row — the caller sorts it last, in either direction. */
+	value(row: Row, context: SortContext): number | undefined
+}
+
+/** Whatever an order cannot measure sorts last, never first, and in either direction: an unknown price is
+ *  not the cheapest thing on the list, and a missing score is not the highest. */
+
+export const ORDERS: Record<SortKey, Order> = {
+	effective: { label: "effective price", short: "effective↑", value: effective },
+	input: { label: "input price", short: "in↑", value: (row) => row.input },
+	output: { label: "output price", short: "out↑", value: (row) => row.output },
+	inputSum: {
+		label: "input + output",
+		short: "in+out↑",
+		value: (row) =>
+			row.input === undefined || row.output === undefined ? undefined : (row.input + row.output) / (row.credit || 1),
+	},
+	context: { label: "context window", short: "ctx↓", desc: true, value: (row) => row.context },
+	// A missing score sorts last, never first: Pi's rule, and the honest one.
+	int: { label: "intelligence", short: "int↓", desc: true, value: (row) => row.int },
+	speed: { label: "speed", short: "speed↓", desc: true, value: (row) => speedOf(row) },
+	recent: {
+		label: "recently used",
+		short: "recent",
+		value: (row, context) => context.recent.get(row.providerID + "/" + row.modelID),
+	},
+	provider: { label: "provider", short: "provider", value: () => 0 },
+	name: { label: "name", short: "name", value: () => 0 },
+}
+
+/** The orders in the cycle the terminal walks with `ctrl+o`, in the same sequence. */
+export const ORDER: SortKey[] = [
+	"effective",
+	"input",
+	"output",
+	"inputSum",
+	"context",
+	"int",
+	"speed",
+	"recent",
+	"provider",
+	"name",
+]
+
+/** The direction an order reads in when nothing else says otherwise. */
+export function direction(key: SortKey): 1 | -1 {
+	return ORDERS[key].desc ? -1 : 1
+}
+
+const id = (row: Row) => row.providerID + "/" + row.modelID
+
+/**
+ * The comparator both surfaces sort with. The two label orders compare text; every other order compares
+ * a number, and the direction is passed in because the desktop lets the reader flip it. Ties fall back to
+ * the name so the list never reshuffles between two reads of the same data.
+ */
+export function compare(key: SortKey, a: Row, b: Row, context: SortContext, sign: 1 | -1 = direction(key)): number {
+	if (key === "name" || key === "provider") {
+		const left = key === "name" ? a.name : a.provider
+		const right = key === "name" ? b.name : b.provider
+		const delta = left.localeCompare(right)
+		return delta !== 0 ? delta * sign : id(a).localeCompare(id(b))
+	}
+	const left = ORDERS[key].value(a, context)
+	const right = ORDERS[key].value(b, context)
+	// The direction flips what can be measured, never what cannot: an unknown figure goes last when the
+	// arrow points up and when it points down, or flipping a column would head the list with blanks.
+	if (left === undefined || right === undefined) {
+		if (left === right) return a.name.localeCompare(b.name)
+		return left === undefined ? 1 : -1
+	}
+	if (left === right) return a.name.localeCompare(b.name)
+	return (left < right ? -1 : 1) * sign
+}
+
+/** What a list of rows looks like once it is drawn: one section per provider, or the flat blocks. */
+export interface Section {
+	/** The provider's name, or `Free` for the free bucket. `undefined` when the block needs no label: the
+	 *  leading one, and the paying block after it in the flat layout. */
+	title?: string
+	rows: Row[]
+}
+
+/**
+ * The order the surfaces draw, which is not the order they sort: free models never enter a price order,
+ * so they follow their provider's paying rows; and the model in use is never buried — it leads its
+ * provider, and its provider leads the list. Both surfaces held a copy of this (`gui.tsx` and
+ * `tui.tsx`), and the copies drifted the moment a filter was added.
+ */
+export function arrange(list: Row[], options: { inUse?: string; grouped: boolean }): Section[] {
+	const used = options.inUse === undefined ? undefined : list.find((row) => id(row) === options.inUse)
+
+	if (!options.grouped) {
+		const rest = used ? list.filter((row) => row !== used) : list
+		const paying = rest.filter((row) => !isFree(row))
+		const free = rest.filter((row) => isFree(row))
+		return [
+			...(used ? [{ rows: [used] }] : []),
+			...(paying.length ? [{ rows: paying }] : []),
+			...(free.length ? [{ title: "Free", rows: free }] : []),
+		]
+	}
+
+	// Built from the whole list, the in-use row included: leaving it out left its provider with no group
+	// at all when it was the only row a filter kept, and the row surfaced under the first header.
+	const groups = new Map<string, Section>()
+	for (const row of list) {
+		const group = groups.get(row.providerID) ?? { title: row.provider, rows: [] }
+		// Paying first, then free: `isFree` sorts false before true.
+		const at = group.rows.findIndex((entry) => isFree(entry) && !isFree(row))
+		if (at === -1) group.rows.push(row)
+		else group.rows.splice(at, 0, row)
+		groups.set(row.providerID, group)
+	}
+	// By name, and by id when two providers share one: the id decides, the name only labels.
+	const sections = [...groups.entries()]
+		.sort(([idA, a], [idB, b]) => (a.title ?? "").localeCompare(b.title ?? "") || idA.localeCompare(idB))
+		.map(([, section]) => section)
+	if (used) {
+		// The in-use provider leads, and its model leads inside it.
+		const at = sections.indexOf(groups.get(used.providerID)!)
+		if (at > 0) sections.unshift(...sections.splice(at, 1))
+		const first = sections[0]
+		if (first) first.rows = [used, ...first.rows.filter((row) => row !== used)]
+	}
+	return sections
+}
+
+// Self-check: node plugins/oc-models-pro/rows.ts --self-check
+// Guarded: this module is also bundled into the desktop window, where `process` does not exist.
+if (typeof process !== "undefined" && process.argv?.[2] === "--self-check") {
+	const row = (over: Partial<Row> = {}): Row => ({
+		name: "Model",
+		providerID: "p",
+		modelID: "m",
+		provider: "Provider",
+		tag: "PR",
+		credit: 1,
+		enabled: true,
+		...over,
+	})
+	const context: SortContext = { recent: new Map([["p/m", 0]]) }
+	const check = (ok: boolean, message: string) => {
+		if (!ok) throw new Error("self-check: " + message)
+	}
+
+	check(effective(row()) === undefined, "an unknown input price is not zero")
+	check(effective(row({ input: 0.8, credit: 8 })) === 0.1, "the credit divides the input price")
+	check(effective(row({ input: 0.8, credit: 0 })) === 0.8, "a zero credit must not divide by zero")
+	check(!isFree(row()), "a missing price is not free")
+	check(!isFree(row({ input: 0, output: 2 })), "a zero input with a paid output is not free")
+	check(isFree(row({ input: 0, output: 0 })), "both at zero is free")
+	check(speedOf(row({ tps: 40, measured: 12 })) === 12, "a measured speed outranks a borrowed one")
+	check(speedOf(row()) === undefined, "no speed is no speed")
+
+	// The price orders put an unknown figure last, and the descending ones put a missing figure last too.
+	const sorts = (key: SortKey, rows: Row[]) => [...rows].sort((a, b) => compare(key, a, b, context))
+	const cheap = row({ name: "cheap", input: 1, output: 1 })
+	const dear = row({ name: "dear", input: 10, output: 10 })
+	const unknown = row({ name: "unknown" })
+	check(sorts("input", [unknown, dear, cheap]).map((r) => r.name)[0] === "cheap", "in↑ starts at the cheapest")
+	check(sorts("input", [unknown, dear, cheap]).map((r) => r.name)[2] === "unknown", "an unknown price sorts last")
+	const winning: Row[] = [row({ name: "few", context: 1000, int: 10 }), row({ name: "many", context: 100_000, int: 50 }), unknown]
+	check(sorts("context", winning)[0].name === "many", "ctx↓ starts at the widest window")
+	check(sorts("context", winning)[2].name === "unknown", "a missing window sorts last, not first")
+	check(sorts("int", winning)[0].name === "many", "int↓ starts at the highest score")
+	check(sorts("int", winning)[2].name === "unknown", "a missing score sorts last, not first")
+	check(sorts("speed", winning)[2].name === "unknown", "a missing speed sorts last, not first")
+	// Flipping a column is the reader's right, and it must never bring the blanks to the top: this is the
+	// state two clicks reach, and the one the sentinels used to get wrong.
+	const flipped = (key: SortKey, rows: Row[]) => [...rows].sort((a, b) => compare(key, a, b, context, -1))
+	check(flipped("input", [unknown, dear, cheap])[2].name === "unknown", "in↓ puts an unknown price last too")
+	check(flipped("input", [unknown, dear, cheap])[0].name === "dear", "in↓ starts at the dearest")
+	check(flipped("context", winning)[2].name === "unknown", "ctx↑ puts a missing window last too")
+	check(flipped("int", winning)[2].name === "unknown", "int↑ puts a missing score last too")
+	check(flipped("speed", winning)[2].name === "unknown", "speed↑ puts a missing speed last too")
+	check(flipped("effective", [unknown, dear, cheap])[2].name === "unknown", "effective↓ puts an unknown price last too")
+	const recentContext: SortContext = { recent: new Map([["p/fresh", 0]]) }
+	const fresh = row({ name: "fresh", modelID: "fresh" })
+	const stale = row({ name: "stale", modelID: "stale" })
+	check(
+		[stale, fresh].sort((a, b) => compare("recent", a, b, recentContext))[0].name === "fresh",
+		"the recent list orders by its index",
+	)
+	check(compare("input", cheap, dear, context, -1) > 0, "the sign the caller passes flips the order")
+	check(compare("name", row({ name: "a" }), row({ name: "b" }), context) < 0, "name compares text")
+	check(compare("provider", row({ provider: "a" }), row({ provider: "b" }), context) < 0, "provider compares text")
+	check(direction("effective") === 1 && direction("int") === -1, "the default direction follows the order")
+
+	// The order the surfaces draw: the cases that each cost a bug.
+	const a = row({ name: "a", modelID: "a", providerID: "pa", provider: "A", input: 2, output: 2 })
+	const b = row({ name: "b", modelID: "b", providerID: "pa", provider: "A", input: 0, output: 0 })
+	const c = row({ name: "c", modelID: "c", providerID: "pb", provider: "B", input: 3, output: 3 })
+
+	const grouped = arrange([a, b, c], { inUse: "pb/c", grouped: true })
+	check(grouped.map((s) => s.title).join() === "B,A", "the provider in use leads the list")
+	check(grouped[0].rows[0] === c, "and its model leads inside it")
+	check(grouped[1].rows.map((r) => r.name).join() === "a,b", "paying before free inside a group")
+
+	// The in-use row shares its group here: hoisting the provider is not enough, the row itself must move,
+	// and this is the shape the panel depends on (its sort does not pre-hoist, unlike the terminal's).
+	const inner = arrange([a, b, c], { inUse: "pa/b", grouped: true })
+	check(inner[0].title === "A" && inner[0].rows[0] === b, "the in-use row leads inside a group that has others")
+	check(inner[0].rows.map((r) => r.name).join() === "b,a", "and the rest of the group keeps its order")
+
+	// Free in use: it leads the list in both layouts, and never falls into the free bucket.
+	const freeUsed = arrange([a, b, c], { inUse: "pa/b", grouped: false })
+	check(freeUsed[0].rows[0] === b, "flat: a free model in use still leads")
+	check(!freeUsed.some((s) => s.title === "Free"), "flat: and is not repeated in the free bucket")
+
+	const solo = arrange([c], { inUse: "pb/c", grouped: true })
+	check(solo.length === 1 && solo[0].title === "B", "the only row a filter kept still has its own group")
+
+	const flat = arrange([b, c, a], { inUse: "pb/c", grouped: false })
+	check(flat[0].rows[0] === c, "flat: the model in use leads the list")
+	check(flat[flat.length - 1].title === "Free", "flat: the free bucket is last")
+	check(flat[flat.length - 1].rows[0] === b, "flat: and holds the free row")
+
+	const twin = row({ name: "twin", modelID: "twin", providerID: "p2", provider: "A", input: 4, output: 4 })
+	const twins = arrange([a, twin], { inUse: "p2/twin", grouped: true })
+	check(twins.length === 2, "two providers sharing a display name stay two groups")
+	check(twins[0].rows[0] === twin, "and the one in use leads by id, not by the shared name")
+
+	console.log("self-check ok: " + ORDER.length + " orders, unknown figures last in every one of them")
+}

package/rpc.ts

@@ -0,0 +1,108 @@
+// What the desktop's panel reads: a plugin window has no Node built-ins, so every file and every fetch
+// stays in the server half and the window asks for the finished table.
+import { Rpc } from "@opencode/plugin/rpc"
+
+import type { Row } from "./rows.ts"
+
+const Count = { type: "number" }
+
+const Row = {
+	type: "object",
+	properties: {
+		providerID: { type: "string" },
+		modelID: { type: "string" },
+		name: { type: "string" },
+		/** The provider's display name, account first as the host writes it. */
+		provider: { type: "string" },
+		/** Two letters from `tags.ts`. */
+		tag: { type: "string" },
+		/** Prices per million tokens; absent when the catalogue has none — an unknown figure, not a free one. */
+		input: Count,
+		output: Count,
+		context: Count,
+		/** Monthly limit ÷ the $10 plan. 1 when the plan is unknown. */
+		credit: Count,
+		promo: Count,
+		peak: Count,
+		int: Count,
+		/** Borrowed from Artificial Analysis, or the catalogue's own when it still carries one. */
+		tps: Count,
+		/** Measured on this machine, on this provider. Outranks `tps` and carries no tilde. */
+		measured: Count,
+		enabled: { type: "boolean" },
+	},
+	required: ["providerID", "modelID", "name", "provider", "tag", "credit", "enabled"],
+	additionalProperties: false,
+} as const
+
+const Snapshot = {
+	type: "object",
+	properties: {
+		rows: { type: "array", items: Row },
+		/** `providerID/modelID` of the models the host keeps as favourites, from `model.json`. */
+		favorites: { type: "array", items: { type: "string" } },
+		/** How many offers the catalogue holds, and how many came out with a speed — the pair that tells a
+		 *  thin source from a broken key. */
+		offers: Count,
+		withSpeed: Count,
+		/** False when the Go plan could not be read and no cache was there: every credit is 1. */
+		credits: { type: "boolean" },
+		/** What failed, in the words the panel shows. Empty when everything came back. */
+		problems: { type: "array", items: { type: "string" } },
+	},
+	required: ["rows", "favorites", "offers", "withSpeed", "credits"],
+	additionalProperties: false,
+} as const
+
+export const Models = Rpc.define({
+	id: "models",
+	methods: {
+		snapshot: {
+			input: {
+				type: "object",
+				properties: { force: { type: "boolean" } },
+				additionalProperties: false,
+			},
+			output: Snapshot,
+		},
+		setFavorite: {
+			input: {
+				type: "object",
+				properties: {
+					providerID: { type: "string" },
+					modelID: { type: "string" },
+					/** Absent toggles. */
+					on: { type: "boolean" },
+				},
+				required: ["providerID", "modelID"],
+				additionalProperties: false,
+			},
+			output: {
+				type: "object",
+				properties: {
+					/** False when the file could not be read or written: the panel says so instead of pretending. */
+					ok: { type: "boolean" },
+					favorites: { type: "array", items: { type: "string" } },
+				},
+				required: ["ok", "favorites"],
+				additionalProperties: false,
+			},
+		},
+	},
+	// Present (empty) on purpose: a missing events map fails the whole plugin.
+	events: {},
+})
+
+/** The wire form is the row both surfaces sort: one shape, declared once. */
+export type ModelRow = Row
+
+export interface ModelsSnapshot {
+	rows: ModelRow[]
+	favorites: string[]
+	offers: number
+	withSpeed: number
+	credits: boolean
+	problems?: string[]
+}
+
+export default Models

package/tps.ts

@@ -0,0 +1,212 @@
+// oc-models-pro/tps.ts — tokens per second, measured on this machine.
+//
+// Not an estimate from a catalogue: it is what this provider actually did, for the models this
+// person actually ran. The number is the one the industry publishes, so it can be read next to
+// anything online: (output + reasoning tokens) over the window from the first streamed token to the
+// last, time-to-first-token excluded — Artificial Analysis' "output speed", and `completion_tokens`
+// as OpenAI, Anthropic and OpenRouter bill it, where reasoning is part of the output.
+//
+// The window is the last seven days when it holds at least three turns, and all of history when it
+// does not: a number from a provider's good week is worth less than the provider's behaviour now,
+// but an empty cell for a model used once last month is worth less still.
+//
+// Runnable standalone for its self-check: node plugins/oc-models-pro/tps.ts --self-check
+
+import { execFile } from "node:child_process"
+import { existsSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export interface Speed {
+	/** Median tokens per second for this provider/model. */
+	tps: number
+	/** How many turns the median came from. */
+	samples: number
+	/** True when the seven-day window was too thin and the whole history was used. */
+	allTime: boolean
+}
+
+interface Turn {
+	key: string
+	sid: string
+	tps: number
+	at: number
+}
+
+/** A window thinner than this is noise, not a measurement. */
+const RECENT_DAYS = 7
+const MIN_SAMPLES = 3
+/** A turn shorter than this cannot separate decode time from the rounding of the clock. */
+const MIN_SPAN_MS = 200
+const MIN_TOKENS = 20
+
+export function databasePath(): string {
+	const data = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share")
+	return process.env.OPENCODE_DB || join(data, "opencode", "opencode.db")
+}
+
+/** The host's own SQLite. Absent outside Bun, where the CLI carries the self-check. */
+async function sqlite(): Promise<typeof import("bun:sqlite") | undefined> {
+	try {
+		return await import("bun:sqlite")
+	} catch {
+		return undefined
+	}
+}
+
+async function read(database: string): Promise<Array<{ data: string; at: number; sid: string }>> {
+	if (!existsSync(database)) return []
+	const bun = await sqlite()
+	if (bun) {
+		try {
+			const db = new bun.Database(database, { readonly: true })
+			try {
+				return db
+					.query("select data, time_created as at, session_id as sid from session_message where type = 'assistant'")
+					.all() as Array<{ data: string; at: number; sid: string }>
+			} finally {
+				db.close()
+			}
+		} catch {
+			// A read-only open of a live WAL database is the one thing that differs per host.
+		}
+	}
+	return new Promise((resolve, reject) => {
+		execFile(
+			"sqlite3",
+			[
+				"file:" + database + "?mode=ro",
+				"-json",
+				"select data, time_created as at, session_id as sid from session_message where type = 'assistant'",
+			],
+			{ maxBuffer: 256 * 1024 * 1024 },
+			(error, stdout) => (error ? reject(error) : resolve(JSON.parse(stdout || "[]"))),
+		)
+	})
+}
+
+/** One assistant turn as a rate, or nothing when the clock or the token counts cannot carry one. */
+export function turn(entry: any, sid = ""): Turn | undefined {
+	if (!entry || !entry.tokens || !entry.time || !Array.isArray(entry.content)) return undefined
+	const provider = entry.model?.providerID
+	const model = entry.model?.id
+	if (typeof provider !== "string" || typeof model !== "string") return undefined
+	// The window opens at the first content part that carries a timestamp — a part without one (a file
+	// reference, say) would start the clock late and overstate the rate.
+	const first = entry.content.find((part: any) => typeof part?.time?.created === "number")?.time?.created
+	// The last streamed token; `completed` only when the host recorded nothing (it carries the same
+	// instant, and post-stream bookkeeping would drag the rate down).
+	const last = entry.time.streamed ?? entry.time.completed
+	if (typeof first !== "number" || typeof last !== "number") return undefined
+	const tokens = (entry.tokens.output ?? 0) + (entry.tokens.reasoning ?? 0)
+	const span = last - first
+	if (!(span >= MIN_SPAN_MS) || tokens < MIN_TOKENS) return undefined
+	return { key: provider + "/" + model, sid, tps: tokens / (span / 1000), at: entry.time.created ?? 0 }
+}
+
+export function median(values: number[]): number {
+	const sorted = [...values].sort((a, b) => a - b)
+	const middle = sorted.length >> 1
+	return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle]
+}
+
+/** The rates of every model, keyed `providerID/modelID` as the host writes them. */
+export async function speedIndex(database = databasePath()): Promise<{
+	speeds: Map<string, Speed>
+	turns: number
+	rows: number
+}> {
+	let rows: Array<{ data: string; at: number; sid: string }>
+	try {
+		rows = await read(database)
+	} catch {
+		return { speeds: new Map(), turns: 0, rows: 0 }
+	}
+	const turns: Turn[] = []
+	for (const row of rows) {
+		let entry: any
+		try {
+			entry = JSON.parse(row.data)
+		} catch {
+			continue
+		}
+		const measured = turn(entry, row.sid)
+		if (measured) turns.push({ ...measured, at: measured.at || row.at })
+	}
+
+	const since = Date.now() - RECENT_DAYS * 86_400_000
+	const speeds = new Map<string, Speed>()
+	for (const key of new Set(turns.map((t) => t.key))) {
+		const all = turns.filter((t) => t.key === key)
+		const recent = all.filter((t) => t.at >= since)
+		const use = recent.length >= MIN_SAMPLES ? recent : all
+		if (use.length === 0) continue
+		// One voice per session, then the median of those voices: without it a single long-running
+		// session elects the number on its own, and this person's sessions run for days.
+		const perSession = new Map<string, number[]>()
+		for (const t of use) {
+			const list = perSession.get(t.sid) ?? []
+			list.push(t.tps)
+			perSession.set(t.sid, list)
+		}
+		speeds.set(key, {
+			tps: median([...perSession.values()].map((list) => median(list))),
+			samples: use.length,
+			allTime: recent.length < MIN_SAMPLES,
+		})
+	}
+	return { speeds, turns: turns.length, rows: rows.length }
+}
+
+// Self-check: node plugins/oc-models-pro/tps.ts --self-check
+if (process.argv[2] === "--self-check") {
+	const run = async () => {
+		const started = Date.now()
+		const { speeds, turns, rows } = await speedIndex()
+		const ms = Date.now() - started
+
+		// The thresholds and the key, on turns made up here: real data cannot exercise a floor it never hits.
+		const base = {
+			model: { providerID: "p", id: "m" },
+			time: { created: 0, streamed: 1000 },
+			tokens: { output: 30, reasoning: 20 },
+			content: [{ type: "text", time: { created: 200 } }],
+		}
+		const good = turn(base, "ses_x")
+		if (!good || good.key !== "p/m" || good.sid !== "ses_x") throw new Error("self-check: a plain turn did not parse")
+		if (Math.abs(good.tps - 62.5) > 0.001) throw new Error("self-check: 50 tokens over 800 ms is not 62.5 t/s: " + good.tps)
+		const short = { ...base, time: { created: 0, streamed: 300 } }
+		if (turn(short)) throw new Error("self-check: a 100 ms window must be dropped")
+		const few = { ...base, tokens: { output: 5, reasoning: 0 } }
+		if (turn(few)) throw new Error("self-check: five tokens must be dropped")
+		if (turn({ time: {}, tokens: {}, content: [] })) throw new Error("self-check: a turn without a model must be dropped")
+		if (median([3, 1, 2]) !== 2 || median([1, 4]) !== 2.5) throw new Error("self-check: median is wrong")
+
+		if (rows === 0) {
+			console.log("self-check ok: no assistant messages on this machine, nothing to measure")
+			return
+		}
+		// Rows but no measurement is not an empty machine: it is a shape that moved, and it must fail.
+		if (turns === 0) throw new Error("self-check: " + rows + " assistant messages and none measurable, the message shape changed")
+		if (speeds.size === 0) throw new Error("self-check: " + turns + " turns but no model measured")
+		for (const [key, speed] of speeds) {
+			if (!Number.isFinite(speed.tps) || speed.tps <= 0) throw new Error("self-check: " + key + " not finite: " + speed.tps)
+			if (speed.samples < 1) throw new Error("self-check: " + key + " has no samples")
+		}
+		const best = [...speeds.entries()].sort((a, b) => b[1].samples - a[1].samples).slice(0, 3)
+		console.log(
+			"self-check ok: " +
+				turns +
+				" turns, " +
+				speeds.size +
+				" models, " +
+				ms +
+				" ms -> " +
+				best.map(([k, s]) => k + " " + s.tps.toFixed(1) + " t/s (" + s.samples + (s.allTime ? " all-time" : " 7d") + ")").join(", "),
+		)
+	}
+	run().catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})
+}