opencode-model-price-intel 1.0.0 → 1.2.0

package/src/aa.ts

@@ -2,9 +2,10 @@
  * Live Artificial Analysis Intelligence Index fetcher.
  *
  * Scores change as Artificial Analysis publishes new evaluations (the index is
- * versioned — currently v5.0), so this runs whenever the plugin refreshes,
- * with a cached copy kept in plugin storage and periodic refresh while the
- * session is open.
+ * versioned — v5.0.1 at the time of writing), so this runs whenever the plugin
+ * refreshes, with a cached copy kept in plugin storage and periodic refresh
+ * while the session is open. The version is read from the live payload rather
+ * than pinned, so a new release is adopted automatically.
  *
  * Two sources, in order:
  *
@@ -15,12 +16,14 @@
  *    accepts any valid key (Free, Pro or Commercial). Attribution:
  *    https://artificialanalysis.ai/
  *
- * 2. The public model-list page (https://artificialanalysis.ai/models), whose
- *    embedded dataset (`initialModels` records in the RSC payload) carries the
- *    `intelligenceIndex` score per model variant. Requires no key.
+ * 2. The public model leaderboard page
+ *    (https://artificialanalysis.ai/leaderboards/models), whose embedded
+ *    dataset carries the `intelligenceIndex` score per model variant. It is a
+ *    superset of the model-list page and publishes the current index version.
+ *    Requires no key.
  *
  * The bundled snapshot in `aa-snapshot.ts` is only used when both fail, and
- * only when its major index version matches the live data.
+ * only when its index version exactly matches the live data.
  */
 
 import {
@@ -33,7 +36,7 @@ import {
   type AAScore,
 } from "./aa-snapshot.ts"
 
-export const AA_MODELS_URL = "https://artificialanalysis.ai/models"
+export const AA_MODELS_URL = "https://artificialanalysis.ai/leaderboards/models"
 /** Free-tier endpoint: accepts any valid API key; Pro-only route is not needed. */
 export const AA_API_URL = "https://artificialanalysis.ai/api/v2/language/models/free"
 /** Hard safety cap on API pagination (the Free quota is 100 requests/day). */
@@ -90,7 +93,7 @@ export interface AAAPIFetch {
 export interface AAPageFetch {
   records: AARecord[]
   version: string
-  /** True when the page did not publish a version and 5.0 was assumed. */
+  /** True when the page did not publish a version and the bundled version was assumed. */
   versionAssumed: boolean
 }
 
@@ -144,15 +147,17 @@ function finiteNonNegative(value: unknown): number | null {
   return Number.isFinite(number) && number >= 0 ? number : null
 }
 
-/** Normalize AA's numeric (`5` / `5.1`) or string (`"5.0"`, `"v5"`) version. */
+/** Normalize AA's numeric (`5` / `5.1`) or string (`"5.0"`, `"v5"`, `"5.0.1"`) version. */
 export function normalizeVersion(value: unknown, fallback = AA_INDEX_VERSION): string {
   if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
     const text = String(value)
     return text.includes(".") ? text : `${text}.0`
   }
   if (typeof value === "string") {
-    const match = value.trim().match(/^v?(\d+)(?:\.(\d+))?/i)
-    if (match) return `${match[1]}.${match[2] ?? "0"}`
+    const match = value.trim().match(/^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?/i)
+    if (match) {
+      return `${match[1]}.${match[2] ?? "0"}${match[3] !== undefined ? `.${match[3]}` : ""}`
+    }
   }
   return fallback
 }
@@ -160,26 +165,34 @@ export function normalizeVersion(value: unknown, fallback = AA_INDEX_VERSION): s
 function optionalVersion(value: unknown): string | undefined {
   if (value === undefined || value === null || value === "") return undefined
   if (typeof value === "number" && (!Number.isFinite(value) || value < 0)) return undefined
-  if (typeof value === "string" && !/^v?\d+(?:\.\d+)?/i.test(value.trim())) return undefined
+  if (typeof value === "string" && !/^v?\d+(?:\.\d+){0,2}/i.test(value.trim())) return undefined
   return normalizeVersion(value)
 }
 
-function majorOf(version: string): string {
-  return version.split(".")[0] ?? version
-}
-
 function countNumericScores(scores: Readonly<Record<string, AAScore>>): number {
   let count = 0
   for (const entry of Object.values(scores)) if (entry.score != null) count++
   return count
 }
 
+/** Compare normalized index versions segment by segment (`5.0.1` > `5.0`). */
+function compareVersions(a: string, b: string): number {
+  const left = normalizeVersion(a).split(".").map(Number)
+  const right = normalizeVersion(b).split(".").map(Number)
+  const length = Math.max(left.length, right.length)
+  for (let index = 0; index < length; index++) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0)
+    if (difference !== 0) return difference
+  }
+  return 0
+}
+
 // ------------------------------------------------------------------ page
 
 /**
  * Company aggregate rows on AA's evaluations pages are shaped like model
- * records. The fallback only reads the model-list page, but filter these
- * explicitly as a second line of defence.
+ * records. The shared parser filters these explicitly as a second line of
+ * defence.
  */
 const COMPANY_AGGREGATES = new Set([
   "google",
@@ -338,9 +351,14 @@ export function parseAARecords(payload: string): AARecord[] {
 export function parsePageVersion(payload: string): string | undefined {
   const decoded = payload.includes("self.__next_f.push") ? decodeRSC(payload) : payload
   const patterns = [
-    /"intelligenceIndexVersion"\s*:\s*"?v?(\d+(?:\.\d+)?)"?/i,
-    /"intelligence_index_version"\s*:\s*"?v?(\d+(?:\.\d+)?)"?/i,
-    /"indexVersion"\s*:\s*"?v?(\d+(?:\.\d+)?)"?/i,
+    /"intelligenceIndexVersion"\s*:\s*"?v?(\d+(?:\.\d+){0,2})"?/i,
+    /"intelligence_index_version"\s*:\s*"?v?(\d+(?:\.\d+){0,2})"?/i,
+    /"indexVersion"\s*:\s*"?v?(\d+(?:\.\d+){0,2})"?/i,
+    // Rendered copy and JSON-LD metadata say "Artificial Analysis
+    // Intelligence Index v5.0.1"; use it when no machine-readable version key
+    // is present.
+    /Artificial Analysis Intelligence Index\s+v?(\d+(?:\.\d+){0,2})/i,
+    /Intelligence Index\s+v(\d+(?:\.\d+){0,2})/i,
   ]
   for (const pattern of patterns) {
     const match = decoded.match(pattern)
@@ -461,18 +479,34 @@ export function lookupScore(
   modelName: string,
 ): AAScore | undefined {
   const keys = [...new Set([matchKey(modelID), matchKey(modelName)].filter((key) => key.length > 0))]
-  const exactEntries: AAScore[] = []
+  const exactEntries: { key: string; entry: AAScore }[] = []
   for (const key of keys) {
     const entry = index[key]
     if (!entry) continue
     const duplicate = exactEntries.some(
-      (existing) => existing === entry || (existing.name === entry.name && existing.score === entry.score),
+      ({ entry: existing }) =>
+        existing === entry || (existing.name === entry.name && existing.score === entry.score),
     )
-    if (!duplicate) exactEntries.push(entry)
+    if (!duplicate) exactEntries.push({ key, entry })
+  }
+  // ID and display name can legitimately resolve to two entries, e.g. a
+  // checkpoint-scored model whose ID normalizes to the unscored base name
+  // ("deepseek-v4.1-flash") while the display name normalizes to the scored
+  // checkpoint ("DeepSeek V4.1 Flash 1017"). When exactly one of them carries
+  // a score and the keys are versions of the same name, use it; unrelated
+  // names or two distinct scores stay ambiguous.
+  if (exactEntries.length > 1) {
+    const scored = exactEntries.filter(({ entry }) => entry.score != null)
+    if (scored.length === 1) {
+      const winner = scored[0]
+      const related = exactEntries.every(
+        ({ key }) => key === winner.key || winner.key.startsWith(key) || key.startsWith(winner.key),
+      )
+      if (related) return winner.entry
+    }
+    return undefined
   }
-  // ID and display name disagreeing is ambiguous: show AA n/a rather than guess.
-  if (exactEntries.length > 1) return undefined
-  const exact = exactEntries[0]
+  const exact = exactEntries[0]?.entry
   if (exact?.score != null) return exact
 
   const candidates = new Map<string, AAScore>()
@@ -490,6 +524,18 @@ export function lookupScore(
       candidates.set(candidate, entry)
     }
   }
+  // Some AA entries carry the vendor in the display name ("Tencent Hy4") while
+  // the OpenCode catalog uses the short name ("Hy4"). Accept a vendor-prefixed
+  // exact match too, but only for a known company prefix so unrelated model
+  // families cannot absorb each other's scores.
+  for (const key of keys) {
+    if (key.length < 3) continue
+    for (const [candidate, entry] of Object.entries(index)) {
+      if (candidate.length <= key.length || !candidate.endsWith(key)) continue
+      const prefix = candidate.slice(0, candidate.length - key.length)
+      if (COMPANY_AGGREGATES.has(prefix)) candidates.set(candidate, entry)
+    }
+  }
   // Multiple possible siblings are ambiguous: prefer no score over a guess.
   if (candidates.size > 1) return undefined
   const suffixed = [...candidates.values()][0]
@@ -535,7 +581,7 @@ function mergeWithSnapshot(
   let live = 0
   for (const entry of Object.values(index)) if (entry.score != null) live++
   let snapshot = 0
-  if (majorOf(version) === majorOf(AA_SNAPSHOT_VERSION)) {
+  if (normalizeVersion(version) === normalizeVersion(AA_SNAPSHOT_VERSION)) {
     for (const [key, entry] of Object.entries(snapshotIndex())) {
       const existing = merged[key]
       if (existing?.score != null) continue
@@ -553,8 +599,10 @@ function mergeWithSnapshot(
 
 /**
  * Use the bundled snapshot to fill gaps the live data does not cover, but only
- * when the live index has the same major version. Live non-null scores always
- * win; snapshot-derived entries carry a `[snapshot]` note.
+ * when the live index is exactly the snapshot's version. Scores change between
+ * index updates (including patch releases), so older snapshot values must not
+ * be presented as current. Live non-null scores always win; snapshot-derived
+ * entries carry a `[snapshot]` note.
  */
 export function withSnapshotFallback(
   index: Readonly<Record<string, AAScore>>,
@@ -799,9 +847,10 @@ export async function fetchFromAPI(
 }
 
 /**
- * Scrape the embedded dataset from the public model-list page (no key needed).
- * Only the model-list page is used: the evaluations page contains company
- * aggregate rows and must never be treated as a model source.
+ * Scrape the embedded dataset from the public model leaderboard page (no key
+ * needed). The leaderboard is a superset of the model-list page: it carries
+ * every scored variant and the current index version. Company aggregate rows
+ * are filtered during parsing.
  */
 export async function fetchFromPages(
   fetchImpl: typeof fetch = fetch,
@@ -813,7 +862,7 @@ export async function fetchFromPages(
     retryDelayMs: options?.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,
   }
   const response = await fetchWithRetry(fetchImpl, AA_MODELS_URL, {}, settings)
-  if (!response.ok) throw new Error(`Artificial Analysis model page returned ${response.status}`)
+  if (!response.ok) throw new Error(`Artificial Analysis leaderboard page returned ${response.status}`)
   const html = await response.text()
   const decoded = decodeRSC(html)
   const records = parseAARecords(decoded)
@@ -827,9 +876,9 @@ export async function fetchFromPages(
 
 /**
  * Fetch current Intelligence Index scores. Tries the Free API when a key is
- * configured, then the public model-list page, then falls back to the bundled
+ * configured, then the public leaderboard page, then falls back to the bundled
  * snapshot. Every source completes before the snapshot is used, so a stalled
- * API cannot consume the page fallback's abort budget.
+ * API cannot consume the leaderboard fallback's abort budget.
  */
 export async function fetchAAScores(options?: AAFetchOptions): Promise<AAFetched> {
   const fetchImpl = options?.fetchImpl ?? fetch
@@ -844,7 +893,7 @@ export async function fetchAAScores(options?: AAFetchOptions): Promise<AAFetched
   if (apiKey) {
     try {
       const { records, version, pages } = await fetchFromAPI(apiKey, fetchImpl, settings)
-      if (records.length > 0) {
+      if (records.length > 0 && compareVersions(version, AA_INDEX_VERSION) >= 0) {
         const { scores, coverage } = mergeWithSnapshot(indexRecords(records), version)
         log(
           `[model-price-intel] AA API (${pages} page${pages === 1 ? "" : "s"}): ${coverage.live} live + ${coverage.snapshot} snapshot scores`,
@@ -857,10 +906,16 @@ export async function fetchAAScores(options?: AAFetchOptions): Promise<AAFetched
           coverage,
         }
       }
-      log("[model-price-intel] AA API returned no usable model records; falling back to the model page")
+      if (records.length > 0) {
+        log(
+          `[model-price-intel] AA API returned v${version}, older than the latest known v${AA_INDEX_VERSION}; falling back to the leaderboard page`,
+        )
+      } else {
+        log("[model-price-intel] AA API returned no usable model records; falling back to the leaderboard page")
+      }
     } catch (error) {
       log(
-        `[model-price-intel] AA API failed (${error instanceof Error ? error.message : String(error)}); falling back to the model page`,
+        `[model-price-intel] AA API failed (${error instanceof Error ? error.message : String(error)}); falling back to the leaderboard page`,
       )
     }
   }
@@ -870,10 +925,10 @@ export async function fetchAAScores(options?: AAFetchOptions): Promise<AAFetched
     if (page.records.length > 0) {
       const { scores, coverage } = mergeWithSnapshot(indexRecords(page.records), page.version)
       const source = page.versionAssumed
-        ? `artificialanalysis.ai model pages; assumed ${page.version} (page)`
-        : "artificialanalysis.ai model pages"
+        ? `artificialanalysis.ai leaderboard page; assumed ${page.version}`
+        : "artificialanalysis.ai leaderboard page"
       log(
-        `[model-price-intel] AA model page (v${page.version}${page.versionAssumed ? " assumed" : ""}): ${coverage.live} live + ${coverage.snapshot} snapshot scores`,
+        `[model-price-intel] AA leaderboard page (v${page.version}${page.versionAssumed ? " assumed" : ""}): ${coverage.live} live + ${coverage.snapshot} snapshot scores`,
       )
       return {
         scores,
@@ -883,10 +938,10 @@ export async function fetchAAScores(options?: AAFetchOptions): Promise<AAFetched
         coverage,
       }
     }
-    log("[model-price-intel] AA model page contained no model records")
+    log("[model-price-intel] AA leaderboard page contained no model records")
   } catch (error) {
     log(
-      `[model-price-intel] AA model page failed (${error instanceof Error ? error.message : String(error)}); using bundled snapshot`,
+      `[model-price-intel] AA leaderboard page failed (${error instanceof Error ? error.message : String(error)}); using bundled snapshot`,
     )
   }
 

package/src/index.ts

@@ -16,14 +16,18 @@
  *
  * Because the built-in `/models` picker renders `Model.Info.name` as the row
  * title, the pricing/score line is attached to the display name so `/models`
- * lists it per model. `/model-pricing` (alias `/prices`) prints the complete
- * table — every price tier, cache read/write, and the AA score — into the
- * session.
+ * lists it per model.
  *
  * Note: an experimental scrolling (marquee) mode for narrow screens existed
  * here and was removed — periodic name repaints made client lists reset their
  * scroll position (both the TUI and the web UI). Names are therefore static.
  *
+ * The full table is exposed over RPC (`src/rpc.ts`). The TUI part
+ * (`src/tui.tsx`) adds `/model-pricing` and `/prices`, fetches structured rows
+ * from this server and renders them in a native dialog table. Keeping the
+ * command in the TUI avoids the old behavior where `ctx.session.synthetic`
+ * delivered the table to the model as a prompt instead of displaying it.
+ *
  * Options (opencode.jsonc `plugins` entry):
  *   - decorateNames: boolean   attach the line to model names (default true)
  *   - costFormat: "detailed" | "compact"   cost line format (default detailed)
@@ -34,11 +38,12 @@
  */
 
 import { Plugin } from "@opencode/plugin"
-import type { CommandInvocation } from "@opencode/plugin/promise/command"
 import { fetchAAScores, lookupScore, snapshotScores, type AAFetched } from "./aa.ts"
-import { formatCost, pricingSegment, type CostFormat, type CostTier } from "./pricing.ts"
+import { pricingSegment, type CostFormat } from "./pricing.ts"
+import { ModelPricing } from "./rpc.ts"
+import { pricingData, renderTable, type TableModel } from "./table.ts"
 
-const CACHE_KEY = "aa-scores/v3"
+const CACHE_KEY = "aa-scores/v4"
 const DEFAULT_REFRESH_HOURS = 12
 const MIN_REFRESH_HOURS = 1
 /** 596 h stays below the 2^31-1 ms setTimeout/setInterval ceiling. */
@@ -53,15 +58,11 @@ interface ResolvedOptions {
   refreshMs: number
 }
 
-interface TableModel {
-  readonly id: string
-  readonly modelID?: string
+function modelKey(model: {
   readonly providerID: string
-  readonly name: string
-  readonly cost: readonly CostTier[] | undefined
-}
-
-function modelKey(model: TableModel): string {
+  readonly modelID?: string
+  readonly id: string
+}): string {
   return `${model.providerID}/${model.modelID || model.id}`
 }
 
@@ -218,63 +219,6 @@ function cachePayload(value: AAFetched): JsonValue {
   }
 }
 
-function markdownCell(value: unknown): string {
-  return String(value ?? "")
-    .replace(/\\/g, "\\\\")
-    .replace(/\|/g, "\\|")
-    .replace(/\r\n|\r|\n/g, " ")
-}
-
-function buildTable(
-  models: readonly TableModel[],
-  aa: AAFetched,
-  baseNames: ReadonlyMap<string, string>,
-  decorateNames: boolean,
-): string {
-  const lines: string[] = [
-    "### Model pricing & Artificial Analysis Intelligence Index",
-    "",
-    `Prices per 1M tokens from the live OpenCode model registry. Scores: Artificial Analysis Intelligence Index v${markdownCell(aa.version)}, source ${markdownCell(aa.source)}, fetched ${markdownCell(aa.fetchedAt.slice(0, 10))}. Attribution: https://artificialanalysis.ai/`,
-    "",
-    "| Model | Provider | Tier | Input | Output | Cache read | Cache write | AA Intelligence |",
-    "| --- | --- | --- | --- | --- | --- | --- | --- |",
-  ]
-
-  for (const model of models) {
-    const baseName = decorateNames
-      ? (baseNames.get(modelKey(model)) ?? model.name)
-      : model.name
-    const score = lookupScore(aa.scores, model.id, baseName)
-    const aaCell =
-      score?.score != null
-        ? `${Math.round(score.score * 10) / 10}${score.note ? ` (${score.note})` : ""}`
-        : "n/a"
-
-    let tiers: ReturnType<typeof formatCost> = []
-    try {
-      tiers = formatCost(model.cost)
-    } catch (error) {
-      console.warn(`[model-price-intel] could not format cost for ${modelKey(model)}:`, error)
-    }
-    const rows = tiers.length > 0 ? tiers : [undefined]
-    rows.forEach((tier, index) => {
-      const cells = [
-        index === 0 ? baseName : "",
-        index === 0 ? model.providerID : "",
-        tier ? (tier.tierLabel ?? (index === 0 ? "base" : "")) : "base",
-        tier ? tier.input : "n/a",
-        tier ? tier.output : "n/a",
-        tier ? tier.cacheRead : "n/a",
-        tier ? tier.cacheWrite : "n/a",
-        index === 0 ? aaCell : "",
-      ]
-      lines.push(`| ${cells.map(markdownCell).join(" | ")} |`)
-    })
-  }
-
-  return lines.join("\n")
-}
-
 /** Remove our own decoration if a transform is replayed against a stale name. */
 function undecoratedName(name: string, price: string): string {
   const suffix = ` · ${price} · AA `
@@ -429,10 +373,10 @@ export default Plugin.define({
       })
     }
 
-    // Full table as a synthetic session message (no model call needed). The
-    // command is registered even when name decoration is disabled.
-    await ctx.command.transform((editor) => {
-      const execute = async (input: CommandInvocation): Promise<void> => {
+    // The TUI part calls this RPC to render the full table in a dialog. The
+    // server builds the rows because only it owns the live score cache.
+    await ctx.rpc.register(ModelPricing, {
+      table: async () => {
         let models: readonly TableModel[] = []
         try {
           const { data } = await ctx.model.list()
@@ -440,22 +384,9 @@ export default Plugin.define({
         } catch (error) {
           console.warn("[model-price-intel] could not list models for the pricing table:", error)
         }
-        await ctx.session.synthetic({
-          sessionID: input.sessionID,
-          text: buildTable(models, aa, baseNames, options.decorateNames),
-        })
-      }
-      editor.add({
-        name: "model-pricing",
-        description:
-          "List input/output/cache prices and Artificial Analysis intelligence scores for every model",
-        execute,
-      })
-      editor.add({
-        name: "prices",
-        description: "Alias of /model-pricing",
-        execute,
-      })
+        const data = pricingData(models, aa, baseNames, options.decorateNames)
+        return { ...data, text: renderTable(data) }
+      },
     })
 
     // Hydrate the cache and refresh live scores in the background. setup must

package/src/pricing.ts

@@ -124,8 +124,7 @@ export type CostFormat = "detailed" | "compact"
  *
  * The compact form (<in>/<out>/<read>/<write>) keeps rows readable on narrow
  * screens such as mobile web sessions. Multi-tier models show their base tier
- * and an `(N tiers)` marker; the `/model-pricing` command lists every tier
- * with its `>N` context threshold.
+ * and an `(N tiers)` marker.
  */
 export function pricingSegment(
   cost: readonly CostTier[] | undefined,

package/src/rpc.ts

@@ -0,0 +1,65 @@
+/** RPC contract shared by the server plugin and the TUI part. */
+
+import { Rpc } from "@opencode/plugin/rpc"
+
+/** One aligned table row; continuation tiers leave model/provider/aa blank. */
+export interface PricingRow {
+  readonly model: string
+  readonly provider: string
+  readonly tier: string
+  readonly input: string
+  readonly output: string
+  readonly cache: string
+  readonly aa: string
+}
+
+export const ModelPricing = Rpc.define({
+  id: "model-price-intel",
+  methods: {
+    table: {
+      input: {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+      },
+      output: {
+        type: "object",
+        properties: {
+          /** Pre-rendered fallback table (also useful to copy for support). */
+          text: { type: "string" },
+          title: { type: "string" },
+          meta: { type: "string" },
+          footnote: { type: "string" },
+          rows: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                model: { type: "string" },
+                provider: { type: "string" },
+                tier: { type: "string" },
+                input: { type: "string" },
+                output: { type: "string" },
+                cache: { type: "string" },
+                aa: { type: "string" },
+              },
+              required: ["model", "provider", "tier", "input", "output", "cache", "aa"],
+              additionalProperties: false,
+            },
+          },
+        },
+        required: ["text", "title", "meta", "footnote", "rows"],
+        additionalProperties: false,
+      },
+    },
+  },
+  events: {},
+})
+
+export interface PricingTable {
+  readonly text: string
+  readonly title: string
+  readonly meta: string
+  readonly footnote: string
+  readonly rows: readonly PricingRow[]
+}