pi-openrouter-provider-picker 0.1.1 → 0.1.2

package/README.md

@@ -17,6 +17,29 @@ pi install npm:pi-openrouter-provider-picker
 
 1. In Pi, use `/model` to select an OpenRouter model.
 2. Run `/or-provider` and choose one of the endpoints listed for that model.
+
+   Each entry shows the provider name, its routing tag, and that endpoint's
+   current price, for example:
+
+   ```text
+   OpenAI — openai · in $30/M · out $60/M · cache $7.50/M
+   ```
+
+   `in` and `out` are USD per million input and output tokens. `cache` is the
+   discounted rate for cached input tokens and only appears when it is cheaper
+   than the regular input rate. Endpoints that publish no price (for example
+   free tiers) show no price at all.
+
+   Endpoints that have recently stopped responding are flagged with their
+   uptime over the most recent window that carries traffic:
+
+   ```text
+   Chutes — chutes · in $0.05/M · out $0.1/M · ⚠ up 62%
+   ```
+
+   Endpoints at or above 95% uptime are not flagged. A `null` uptime means no
+   traffic was observed, not an outage, so it is never shown.
+
 3. The selected endpoint is pinned for that model; provider fallback is disabled.
 4. When you switch models, this extension clears its selection. The new model uses its normal routing.
 

package/extensions/openrouter-provider.ts

@@ -5,10 +5,144 @@ const AUTO_LABEL = "Automatic — use model/OpenRouter routing settings";
 const CUSTOM_LABEL = "Enter a provider slug…";
 const STATUS_KEY = "openrouter-provider";
 
+/** Endpoints at or above this uptime are not worth flagging in the menu. */
+const UPTIME_WARNING_THRESHOLD = 95;
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+function asNumber(value: unknown): number {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return value.trim() === "" ? Number.NaN : Number(value);
+  return Number.NaN;
+}
+
+/** Render a USD amount without trailing zeros (e.g. 30, 0.025, 0.001). */
+function formatUsd(amount: number): string {
+  const text = amount >= 1 ? amount.toFixed(2) : amount.toPrecision(3);
+  return text.includes(".") ? text.replace(/\.?0+$/, "") : text;
+}
+
+/**
+ * OpenRouter prices `prompt`/`completion` per token (USD), while `request` is
+ * charged per request. Returns "" when the endpoint publishes no pricing.
+ */
+function formatPriceSuffix(pricing: unknown): string {
+  if (!isRecord(pricing)) return "";
+
+  const parts: string[] = [];
+  const addPerToken = (label: string, raw: unknown): void => {
+    const perToken = asNumber(raw);
+    if (!Number.isFinite(perToken) || perToken <= 0) return;
+    parts.push(`${label} $${formatUsd(perToken * 1_000_000)}/M`);
+  };
+
+  addPerToken("in", pricing.prompt);
+  addPerToken("out", pricing.completion);
+
+  // Cached input is billed at its own (cheaper) rate; only mention a real discount.
+  const cache = asNumber(pricing.input_cache_read);
+  const input = asNumber(pricing.prompt);
+  const cheaperCache =
+    Number.isFinite(cache) &&
+    cache > 0 &&
+    !(Number.isFinite(input) && input > 0 && cache >= input);
+  if (cheaperCache) {
+    parts.push(`cache $${formatUsd(cache * 1_000_000)}/M`);
+  }
+
+  const perRequest = asNumber(pricing.request);
+  if (Number.isFinite(perRequest) && perRequest > 0) {
+    parts.push(`$${formatUsd(perRequest)}/req`);
+  }
+
+  return parts.length > 0 ? ` · ${parts.join(" · ")}` : "";
+}
+
+/**
+ * Prefer the freshest window that actually carries traffic. `null` means no
+ * traffic was observed, which is not the same as being down.
+ */
+function firstUptime(endpoint: Record<string, unknown>): number | undefined {
+  for (const key of ["uptime_last_5m", "uptime_last_30m", "uptime_last_1d"]) {
+    const uptime = asNumber(endpoint[key]);
+    if (Number.isFinite(uptime)) return uptime;
+  }
+  return undefined;
+}
+
+/** Flag a degraded endpoint only; healthy ones stay out of the way. */
+function formatUptimeWarning(endpoint: unknown): string {
+  if (!isRecord(endpoint)) return "";
+  const uptime = firstUptime(endpoint);
+  if (uptime === undefined || uptime >= UPTIME_WARNING_THRESHOLD) return "";
+  return ` · ⚠ up ${Math.floor(uptime)}%`;
+}
+
+/**
+ * East Asian wide/fullwidth ranges. Provider names are normally ASCII, so this
+ * only matters when a name carries CJK text.
+ */
+const WIDE_RANGES: ReadonlyArray<readonly [number, number]> = [
+  [0x1100, 0x115f], [0x2e80, 0x303e], [0x3041, 0x33ff], [0x3400, 0x4dbf],
+  [0x4e00, 0x9fff], [0xa000, 0xa4cf], [0xac00, 0xd7a3], [0xf900, 0xfaff],
+  [0xfe10, 0xfe19], [0xfe30, 0xfe6f], [0xff00, 0xff60], [0xffe0, 0xffe6],
+  [0x1f300, 0x1f64f], [0x1f900, 0x1f9ff], [0x20000, 0x3fffd],
+];
+
+/** Terminal columns a string occupies, so menu columns can be aligned. */
+function displayWidth(text: string): number {
+  let width = 0;
+  for (const character of text) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    width += WIDE_RANGES.some(([low, high]) => codePoint >= low && codePoint <= high)
+      ? 2
+      : 1;
+  }
+  return width;
+}
+
+function padEndWidth(text: string, target: number): string {
+  const missing = target - displayWidth(text);
+  return missing > 0 ? text + " ".repeat(missing) : text;
+}
+
+type EndpointChoice = {
+  slug: string;
+  base: string;
+  price: string;
+  health: string;
+};
+
+function buildChoice(endpoint: unknown, tag: string, providerName: string): EndpointChoice {
+  const value = isRecord(endpoint) ? endpoint : {};
+  return {
+    slug: tag,
+    base: `${providerName} — ${tag}`,
+    price: formatPriceSuffix(value.pricing),
+    health: formatUptimeWarning(value),
+  };
+}
+
+/**
+ * Pad the name and price blocks to their widest entry so every price starts at
+ * the same column and the health flag lines up at the end.
+ */
+function alignChoices(choices: EndpointChoice[]): Array<{ slug: string; label: string }> {
+  const baseWidth = Math.max(0, ...choices.map((c) => displayWidth(c.base)));
+  const priceWidth = Math.max(0, ...choices.map((c) => displayWidth(c.price)));
+
+  return choices.map((choice) => ({
+    slug: choice.slug,
+    label: (
+      padEndWidth(choice.base, baseWidth) +
+      padEndWidth(choice.price, priceWidth) +
+      choice.health
+    ).trimEnd(),
+  }));
+}
+
 async function getEndpointChoices(modelId: string, apiKey: string) {
   const slash = modelId.indexOf("/");
   if (slash <= 0 || slash === modelId.length - 1) {
@@ -34,15 +168,15 @@ async function getEndpointChoices(modelId: string, apiKey: string) {
   const endpoints = Array.isArray(data?.endpoints) ? data.endpoints : undefined;
   if (!endpoints) throw new Error("OpenRouter returned an unexpected endpoint-list response.");
 
-  const byTag = new Map<string, string>();
+  const byTag = new Map<string, EndpointChoice>();
   for (const value of endpoints) {
     if (!isRecord(value) || typeof value.tag !== "string" || !value.tag) continue;
     const tag = value.tag;
     const providerName = typeof value.provider_name === "string" ? value.provider_name : tag;
-    byTag.set(tag, `${providerName} — ${tag}`);
+    byTag.set(tag, buildChoice(value, tag, providerName));
   }
 
-  return [...byTag.entries()].map(([slug, label]) => ({ slug, label }));
+  return alignChoices([...byTag.values()]);
 }
 
 export default function openRouterProviderExtension(pi: ExtensionAPI) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-openrouter-provider-picker",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Choose an upstream provider for OpenRouter models in Pi",
   "author": "soubell",
   "repository": {