@rizal72/oc-models-pro 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,53 @@
-# Temporary Holding Version
+# @rizal72/oc-models-pro
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A model picker for OpenCode v2 that shows what a request costs, not just a list of names.
+
+It lists every model with its input and output price, context window, intelligence index, `tok/s`
+when a source has it, the Go credit multiplier, and the effective price per request; it sorts by
+what a request actually costs and switches the model on Enter.
+
+## Install
+
+```sh
+opencode plugin add @rizal72/oc-models-pro
+```
+
+Or by hand, one line in `~/.config/opencode/opencode.jsonc`:
+
+```jsonc
+"plugins": ["@rizal72/oc-models-pro"]
+```
+
+## Use
+
+`/models-pro`, the `<leader>p` keybind, or the command palette — inside a session.
+
+| key | does |
+|---|---|
+| `↑` `↓` | move the selection |
+| `Invio` | switch to the model and close |
+| `ctrl+o` | sort: effective, in, out, in+out, ctx, int, speed, recent, name |
+| `ctrl+s` | scope: all → favourites → paying |
+| `ctrl+g` | provider groups on/off |
+| `ctrl+f` | favourite on/off |
+| `ctrl+u` | clear the search |
+| `esc` | clear the search, else close |
+
+## What it reads
+
+- prices and context from the host's own catalogue;
+- the intelligence index from `catalog.stencil.so`, cached six hours;
+- the Go credit from OpenCode's Go plan page, cached one day — `opencode-go` models only;
+- favourites and recent models from the app's own `~/.local/state/opencode/model.json`, so they are
+  the same ones the native picker keeps.
+
+No API key is needed, and nothing leaves the machine except those two public fetches.
+
+## One caveat
+
+A plugin still cannot pick the model directly, so the panel switches it the long way: it borrows the
+app's own switch command and restores what it borrowed a moment later. There is an open issue upstream
+([anomalyco/opencode#57771](https://github.com/anomalyco/opencode/issues/57771)) that would let a plugin
+do it in one call — when it lands, the workaround goes and nothing else changes.
+
+Requires OpenCode v2. TypeScript, no build step, no runtime dependencies.

package/bench.ts

@@ -0,0 +1,142 @@
+// oc-models-pro: intelligence per model, from the stencil.so catalog.
+//
+// The catalog is keyed by gateway and its ids are qualified (`alibaba/deepseek-v4.1-flash`), so the
+// comparison uses the last segment — and the key is built from *our* model's display name, never its
+// id. That is what makes the aliases meet: the same model is `deepseek/deepseek-flash` here and
+// "DeepSeek V4.1 Flash 1017" to the eye, while stencil calls it `deepseek-v4.1-flash`. The name is
+// stripped of the labels a catalogue attaches (`latest`, `contributor`, `free`, `preview`) and of
+// snapshot stamps (`1017`, `0731`); the model id is the fallback when the name finds nothing.
+//
+// `int` is on 4612 of 9050 entries; `tps` is on none of them today (measured 2026-10-19), so the
+// speed column stands empty until a source carries it. A figure that is not there is never guessed.
+//
+// Runnable standalone for its self-check: node plugins/oc-models-pro/bench.ts --self-check
+
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+
+export const CATALOG = "https://catalog.stencil.so/models.json"
+
+const CACHE = join(homedir(), ".cache", "oc-models-pro", "bench.json")
+const GRACE_MS = 6 * 60 * 60 * 1000
+
+export interface Bench {
+	int: number
+	tps?: number
+}
+
+interface Cached {
+	fetched: number
+	index: Record<string, Bench>
+}
+
+/** Labels a catalogue attaches to a model that are not part of its name. */
+const LABELS = "-(?:latest|contributor|free|preview|exp|thinking)$"
+
+/**
+ * "DeepSeek V4.1 Flash 1017" and `deepseek-v4.1-flash` have to meet somewhere: this is the meeting
+ * point. Labels and snapshot stamps come off in two rounds, since one can hide the other.
+ */
+export function benchKey(name: string): string {
+	let key = name
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/-+/g, "-")
+		.replace(/^-|-$/g, "")
+	for (let round = 0; round < 2; round++) {
+		key = key.replace(new RegExp(LABELS, "g"), "")
+		// Four-digit floor, and never below four characters left: a real model number must survive.
+		key = key.replace(/-\d{4,6}$/, (stamp) => (key.length - stamp.length >= 4 ? "" : stamp))
+	}
+	return key.replace(/^-|-$/g, "")
+}
+
+export function buildIndex(catalog: Record<string, any>): Map<string, Bench> {
+	const index = new Map<string, Bench>()
+	for (const provider of Object.values(catalog)) {
+		for (const [id, meta] of Object.entries((provider as any)?.models ?? {})) {
+			const int = (meta as any)?.int
+			if (typeof int !== "number") continue
+			const key = benchKey(String(id).split("/").pop() ?? "")
+			if (!key) continue
+			const tps = (meta as any)?.tps
+			// A key met twice keeps the first row's int but takes the first speed that exists: the same
+			// model on several gateways is scored once, and the score without the figure must not hide it.
+			const previous = index.get(key)
+			if (!previous) index.set(key, { int, tps: typeof tps === "number" ? tps : undefined })
+			else if (previous.tps === undefined && typeof tps === "number")
+				index.set(key, { int: previous.int, tps })
+		}
+	}
+	return index
+}
+
+function indexOf(cached: Cached): Map<string, Bench> {
+	return new Map(Object.entries(cached.index ?? {}))
+}
+
+async function cached(): Promise<Cached | undefined> {
+	try {
+		return JSON.parse(await readFile(CACHE, "utf8")) as Cached
+	} catch {
+		return undefined
+	}
+}
+
+/** Six hours of grace: a benchmark does not move between two coffee breaks. */
+export async function benchIndex(): Promise<Map<string, Bench>> {
+	const previous = await cached()
+	if (previous && Date.now() - previous.fetched < GRACE_MS) return indexOf(previous)
+	try {
+		const response = await fetch(CATALOG, { headers: { "user-agent": "oc-models-pro" } })
+		if (!response.ok) throw new Error("HTTP " + response.status)
+		const built = buildIndex(await response.json())
+		if (built.size === 0) throw new Error("catalog shape changed")
+		await mkdir(dirname(CACHE), { recursive: true })
+		await writeFile(CACHE + ".tmp", JSON.stringify({ fetched: Date.now(), index: Object.fromEntries(built) }))
+		await rename(CACHE + ".tmp", CACHE)
+		return built
+	} catch (error) {
+		console.error(
+			`[oc-models-pro] benchmarks not refreshed: ${error instanceof Error ? error.message : String(error)}`,
+		)
+		return previous ? indexOf(previous) : new Map()
+	}
+}
+
+/** Name first, id second: the name carries the model, the id carries the provider's label for it. */
+export function benchFor(index: Map<string, Bench>, name: string, id: string): Bench | undefined {
+	return index.get(benchKey(name)) ?? index.get(benchKey(id))
+}
+
+// Self-check: node plugins/oc-models-pro/bench.ts --self-check
+if (process.argv[2] === "--self-check") {
+	const run = async () => {
+		const response = await fetch(CATALOG)
+		if (!response.ok) throw new Error("self-check: HTTP " + response.status)
+		const index = buildIndex(await response.json())
+		if (index.size < 200) throw new Error("self-check: only " + index.size + " models keyed")
+		const cases: Array<[string, string, number]> = [
+			["DeepSeek V4.1 Flash 1017", "deepseek-flash", 39.5],
+			["DeepSeek V4 Flash Latest", "deepseek-v4-flash-latest", 34.3],
+			["Muse Spark 1.3 Contributor", "muse-spark-1.3-contributor", 48.1],
+			["Gemini 4 Argon Contributor", "gemini-4-argon-contributor", 52.6],
+		]
+		const misses = cases.filter(([name, id, int]) => benchFor(index, name, id)?.int !== int)
+		if (misses.length) {
+			throw new Error("self-check: " + misses.map(([name]) => name).join(", ") + " did not match")
+		}
+		// The label must not swallow a model that is only labelled: the contributor shares the
+		// underlying model's score, but a different model must not inherit one.
+		if (benchFor(index, "MiMo V2.5", "mimo-v2.5")) throw new Error("self-check: MiMo V2.5 matched something")
+		console.log(
+			"self-check ok: " + index.size + " models keyed, DeepSeek -> " +
+				benchFor(index, "DeepSeek V4.1 Flash 1017", "deepseek-flash")!.int,
+		)
+	}
+	run().catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})
+}

package/fit.ts

@@ -0,0 +1,98 @@
+// oc-models-pro — how a row and the footer fit a panel of a given width, in columns.
+//
+// The host hands `session.panel` a `width` in columns (pixels on the very first frame, which the
+// clamp absorbs). Everything that depends on it lives here, so the thresholds sit in one place:
+//   node plugins/oc-models-pro/fit.ts --self-check
+
+/** The name column at its widest: 32 + the fixed 53 is the 85-character table. */
+export const NAME = 32
+/** ...and at its narrowest. Below this a model name is unreadable, and a column is worth more. */
+export const NAME_MIN = 24
+/** The cells that never go: marker 2, tag 4, in 6, out 6, cred 4 and the nine separators. */
+const FIXED = 53
+
+export type Fit = { name: number; ctx: boolean; int: boolean; tkps: boolean; note: boolean }
+
+/** Columns dropped as the panel narrows: one with no data, then the note, then context, then int. */
+const DROPS = [
+	{ key: "tkps", width: 7 },
+	{ key: "note", width: 7 },
+	{ key: "ctx", width: 6 },
+	{ key: "int", width: 6 },
+] as const
+
+/** The width of a row in columns, for a given fit. */
+export function rowWidth(f: Fit): number {
+	let width = f.name + FIXED
+	if (!f.tkps) width -= 7
+	if (!f.note) width -= 7
+	if (!f.ctx) width -= 6
+	if (!f.int) width -= 6
+	return width
+}
+
+export function fit(width: number): Fit {
+	// A missing width (and the pixel value of the first frame) is "unknown", not "tiny": the wide
+	// layout is the safe answer. Anything positive is a real column count and takes the ladder.
+	const w = Number.isFinite(width) && width > 0 ? Math.floor(width) : Infinity
+	const out: Fit = { name: NAME, ctx: true, int: true, tkps: true, note: true }
+	let fixed = FIXED
+	for (const drop of DROPS) {
+		// Stop as soon as the name can give the rest: it shrinks before anything else goes.
+		if (Math.min(NAME, w - fixed) >= NAME_MIN) break
+		out[drop.key] = false
+		fixed -= drop.width
+	}
+	out.name = Math.max(NAME_MIN, Math.min(NAME, w - fixed))
+	return out
+}
+
+/** The panel width below which the legend shortens rather than being cut mid-sentence. */
+export const LEGEND_MIN = 72
+
+/** The footer hints, in the order they are read. Splitting on these keeps the line data-driven. */
+const HINTS = ["↑↓ enter", "ctrl+o sort", "ctrl+s scope", "ctrl+g groups", "ctrl+r recent", "ctrl+f fav", "ctrl+y full", "esc"]
+
+/** The same hints wrapped to `width` columns: one line when they fit, and never truncated. */
+export function hintLines(width: number): string[] {
+	const w = Number.isFinite(width) && width > 0 ? Math.floor(width) : Infinity
+	const lines: string[] = []
+	let line = ""
+	for (const hint of HINTS) {
+		const next = line ? line + " · " + hint : hint
+		if (line && next.length >= w) {
+			lines.push(" " + line)
+			line = hint
+		} else line = next
+	}
+	if (line) lines.push(" " + line)
+	return lines
+}
+
+// Self-check: node plugins/oc-models-pro/fit.ts --self-check
+if (process.argv[2] === "--self-check") {
+	const check = (ok: boolean, message: string) => {
+		if (!ok) throw new Error("self-check: " + message)
+	}
+	const wide = fit(200)
+	check(wide.name === NAME && wide.tkps && wide.note && wide.ctx && wide.int, "200 columns keeps every column")
+	check(rowWidth(wide) === 85, "the full table is 85 characters, got " + rowWidth(wide))
+	check(fit(1400).name === NAME, "a pixel width on the first frame resolves to the wide layout")
+	check(hintLines(200).length === 1 && hintLines(200)[0].length === 103, "the footer is one 103-column line when it fits")
+	check(hintLines(102).length === 2 && hintLines(102).every((l) => l.length <= 102), "at 102 the footer wraps to two lines")
+	check(hintLines(40).every((l) => l.length <= 40), "at 40 no line exceeds the panel")
+	check(fit(76).name === 30 && !fit(76).tkps, "at 76 tok/s goes and the name grows into its space")
+	check(!fit(70).tkps && fit(70).note && fit(70).name === 24, "at 70 tok/s alone frees enough and the note stays")
+	check(!fit(69).note && fit(69).name === 30, "at 69 the note column goes and the name grows into its space")
+	check(!fit(62).ctx && fit(62).int, "at 62 context is gone and int is still there")
+	check(!fit(56).int && fit(56).name >= NAME_MIN, "at 56 int is the last to go")
+	check(fit(5).name === NAME_MIN && !fit(5).int, "a genuinely tiny width takes the narrowest rung, not the wide one")
+	for (let w = 51; w <= 140; w++) {
+		check(fit(w).name >= NAME_MIN, "name floor holds at " + w)
+		check(rowWidth(fit(w)) <= w, "the row fits " + w + " columns, got " + rowWidth(fit(w)))
+	}
+	// A single hint longer than the panel cannot be split; nothing may overflow beyond that.
+	const longest = Math.max(...HINTS.map((hint) => hint.length)) + 1
+	for (let w = 12; w <= 60; w++) check(hintLines(w).every((l) => l.length <= Math.max(w, longest)), "the footer fits " + w)
+	console.log("self-check ok: 85 wide, " + hintLines(102).length + " footer lines at 102, rows fit 51..140")
+}

package/index.ts

@@ -0,0 +1,7 @@
+// oc-models-pro — server half. Empty on purpose: the model list is TUI-only.
+import { Plugin } from "@opencode/plugin"
+
+export default Plugin.define({
+	id: "oc-models-pro",
+	async setup() {},
+})

package/multipliers.ts

@@ -0,0 +1,224 @@
+// oc-models-pro: what the Go plan gives per model, read from the live Go docs page.
+//
+// The table is server-rendered — no JS, no auth — so a plain fetch and a row regex are enough. The
+// mirror that would have been cleaner, the `.mdx` on GitHub, is stale by design: it carries the old
+// limits (a model at $60 where the deployed page says $80), so the page is the source and the cache
+// carries the date it was read.
+//
+// Two different figures live on that page, and confusing them was the first bug here:
+//   - the **credit multiplier**: monthly limit ÷ plan price (DeepSeek V4.1 Flash: $80 on a $10 plan =
+//     8x). Every model has one, and it is what orders the list by effective price;
+//   - the **promotion note** (`4x · Limited time`): limit ÷ the struck-through base, i.e. this model's
+//     allowance is 4x its normal one. Only a few rows carry it.
+//
+// The page has no model ids, rows match by display name; a model with two tariffs appears twice
+// (`… (Off-Peak)` / `… (Peak)`), and the table repeats per plan (`go`, `go-plus`) — the first
+// occurrence wins, so the values are the standard plan's.
+//
+// Runnable standalone for its self-check: node plugins/oc-models-pro/multipliers.ts --self-check
+
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+
+export const PAGE = "https://opencode.ai/v2/docs/console/go/"
+
+export interface GoLimit {
+	/** Display name as the page writes it; the only key it offers. */
+	name: string
+	input?: number
+	output?: number
+	cacheRead?: number
+	cacheWrite?: number
+	/** Monthly limit in dollars: the promoted value when the cell carries one. */
+	limit?: number
+	/** The struck-through value a promotion replaces. */
+	base?: number
+	/** The page's own `4x` note; `1` when it says nothing. */
+	multiplier: number
+}
+
+export interface GoPlan {
+	/** Plan price in dollars per month. */
+	price: number
+	limits: GoLimit[]
+}
+
+/** What one model is worth on the plan, for the row note and for the ordering. */
+export interface Credits {
+	/** Monthly limit ÷ plan price. */
+	credit: number
+	/** limit ÷ base, when the page marks a promotion. */
+	promo?: number
+	/** Peak input price ÷ off-peak input price, for a model with two tariffs. */
+	peak?: number
+}
+
+const CACHE = join(homedir(), ".cache", "oc-models-pro", "go-limits.json")
+
+function text(html: string): string {
+	return html
+		.replace(/<br\s*\/?>/gi, " ")
+		.replace(/<[^>]+>/g, " ")
+		.replace(/&nbsp;/g, " ")
+		.replace(/&amp;/g, "&")
+		.replace(/&gt;/g, ">")
+		.replace(/&lt;/g, "<")
+		.replace(/&#39;|&rsquo;/g, "'")
+		.replace(/&quot;/g, '"')
+		.replace(/\s+/g, " ")
+		.trim()
+}
+
+function money(html: string): number | undefined {
+	const plain = text(html)
+	// Free models print the word, not a figure.
+	if (/free/i.test(plain)) return 0
+	const found = plain.match(/\$([\d.]+)/)
+	return found ? Number(found[1]) : undefined
+}
+
+function multiplierOf(html: string): number {
+	const found = html.match(/([\d.]+)\s*[x×]/i)
+	return found ? Number(found[1]) : 1
+}
+
+export function parseGoTable(html: string): GoLimit[] {
+	const rows = html.split(/<tr[\s>]/i).slice(1)
+	const limits: GoLimit[] = []
+	const seen = new Set<string>()
+	for (const raw of rows) {
+		const row = raw.split(/<\/tr>/i)[0] ?? ""
+		const cells = row.match(/<td[^>]*>[\s\S]*?<\/td>/gi) ?? []
+		if (cells.length < 6) continue
+		const name = text(cells[0] ?? "")
+		if (!name || /^model$/i.test(name)) continue
+		// The table repeats per plan; the first panel is the standard one.
+		if (seen.has(name)) continue
+		seen.add(name)
+		const monthly = cells[5] ?? ""
+		const promoted = monthly.match(/<strong[^>]*>([\s\S]*?)<\/strong>/i)
+		const struck = monthly.match(/<del[^>]*>([\s\S]*?)<\/del>/i)
+		limits.push({
+			name,
+			input: money(cells[1] ?? ""),
+			output: money(cells[2] ?? ""),
+			cacheRead: money(cells[3] ?? ""),
+			cacheWrite: money(cells[4] ?? ""),
+			limit: money(promoted ? promoted[1] : monthly),
+			base: struck ? money(struck[1]) : undefined,
+			multiplier: multiplierOf(monthly),
+		})
+	}
+	return limits
+}
+
+/** The plan price, `$10/month` in the `Go` heading; the first such figure on the page is Go's. */
+export function parsePlanPrice(html: string): number | undefined {
+	const found = text(html).match(/\$\s?([\d.]+)\s*\/\s*month/i)
+	return found ? Number(found[1]) : undefined
+}
+
+/** "… (Off-Peak)" and "… (Peak)" are one model; the tariff is not part of its name. */
+export function baseName(name: string): string {
+	return name.replace(/\s*\((?:off-?peak|peak)\)\s*$/i, "").trim()
+}
+
+/** "GLM-5.3-Flash" and "glm-5.3-flash" have to meet somewhere: this is the meeting point. */
+export function key(name: string): string {
+	return baseName(name)
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^-+|-+$/g, "")
+}
+
+export function credits(plan: GoPlan): Map<string, Credits> {
+	const grouped = new Map<string, GoLimit[]>()
+	for (const row of plan.limits) {
+		const id = key(row.name)
+		grouped.set(id, [...(grouped.get(id) ?? []), row])
+	}
+	const result = new Map<string, Credits>()
+	for (const [id, rows] of grouped) {
+		const off = rows.find((row) => /off-?peak/i.test(row.name)) ?? rows[0]
+		const peak = rows.find((row) => /peak/i.test(row.name) && !/off-?peak/i.test(row.name))
+		if (!off?.limit || !plan.price) continue
+		result.set(id, {
+			credit: Math.round((off.limit / plan.price) * 10) / 10,
+			promo: off.base && off.base > 0 ? Math.round((off.limit / off.base) * 10) / 10 : undefined,
+			peak: peak?.input && off.input ? Math.round(((peak.input / off.input) * 10)) / 10 : undefined,
+		})
+	}
+	return result
+}
+
+function today(): string {
+	return new Date().toLocaleDateString("en-CA")
+}
+
+async function cached(): Promise<{ fetched: string; plan: GoPlan } | undefined> {
+	try {
+		return JSON.parse(await readFile(CACHE, "utf8")) as { fetched: string; plan: GoPlan }
+	} catch {
+		return undefined
+	}
+}
+
+/** A day of grace: a promotion does not change hourly, and a stale copy beats no column. */
+export async function goPlan(): Promise<GoPlan | undefined> {
+	const previous = await cached()
+	if (previous?.fetched === today()) return previous.plan
+	try {
+		const response = await fetch(PAGE, {
+			headers: { "user-agent": "oc-models-pro" },
+			signal: AbortSignal.timeout(20_000),
+		})
+		if (!response.ok) throw new Error("HTTP " + response.status)
+		const html = await response.text()
+		const limits = parseGoTable(html)
+		const price = parsePlanPrice(html)
+		if (limits.length === 0 || !price) throw new Error("page shape changed")
+		const plan = { price, limits }
+		await mkdir(dirname(CACHE), { recursive: true })
+		await writeFile(CACHE + ".tmp", JSON.stringify({ fetched: today(), plan }))
+		await rename(CACHE + ".tmp", CACHE)
+		return plan
+	} catch (error) {
+		console.error(`[oc-models-pro] Go plan not refreshed: ${error instanceof Error ? error.message : String(error)}`)
+		return previous?.plan
+	}
+}
+
+// Self-check: node plugins/oc-models-pro/multipliers.ts --self-check
+if (process.argv[2] === "--self-check") {
+	const run = async () => {
+		const response = await fetch(PAGE)
+		if (!response.ok) throw new Error("self-check: HTTP " + response.status)
+		const html = await response.text()
+		const limits = parseGoTable(html)
+		const price = parsePlanPrice(html)
+		if (limits.length < 10) throw new Error("self-check: only " + limits.length + " rows parsed")
+		if (!price) throw new Error("self-check: plan price not found")
+		if (limits.some((l) => typeof l.input !== "number" || typeof l.output !== "number")) {
+			throw new Error("self-check: a row lost its price")
+		}
+		if (new Set(limits.map((l) => l.name)).size !== limits.length) throw new Error("self-check: duplicate names")
+		const table = credits({ price, limits })
+		if (table.size < 10) throw new Error("self-check: only " + table.size + " models keyed")
+		const promoted = [...table.values()].filter((c) => c.promo)
+		if (promoted.length === 0) throw new Error("self-check: no promotion found")
+		const deepseek = table.get("deepseek-v4-1-flash") ?? table.get("deepseek-v4.1-flash")
+		if (!deepseek) throw new Error("self-check: DeepSeek V4.1 Flash not matched")
+		if (Math.round(deepseek.credit) !== 8) throw new Error("self-check: DeepSeek credit is " + deepseek.credit)
+		if (!deepseek.peak) throw new Error("self-check: DeepSeek peak tariff lost")
+		console.log(
+			"self-check ok: plan $" + price + "/month, " + table.size + " models, " + promoted.length +
+				" promoted, DeepSeek V4.1 Flash -> $" + (8 * price) + " limit = " + deepseek.credit +
+				"x, peak " + deepseek.peak + "x",
+		)
+	}
+	run().catch((error) => {
+		console.error(error)
+		process.exit(1)
+	})
+}

package/package.json

@@ -1,6 +1,14 @@
 {
-  "name": "@rizal72/oc-models-pro",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@rizal72/oc-models-pro",
+	"version": "0.1.0",
+	"type": "module",
+	"description": "OpenCode v2 model picker with prices, context, intelligence, Go credit and the cost of a request",
+	"license": "MIT",
+	"files": ["*.ts", "*.tsx", "README.md"],
+	"keywords": ["opencode", "opencode-plugin", "models", "pricing"],
+	"publishConfig": { "access": "public" },
+	"exports": {
+		".": "./index.ts",
+		"./tui": "./tui.tsx"
+	}
+}