@stablekernel/opencode-bifrost 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stablekernel/opencode-bifrost",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "OpenCode plugin that routes models through the Bifrost gateway, resolving per-project virtual keys via gateway-cli.",
   "type": "module",
   "main": "src/index.ts",

package/src/index.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 import {
   BifrostGateway,
   isAllowedGatewayUrl,
+  isStale,
   toConfigModels,
 } from "./index.js";
 
@@ -30,6 +31,9 @@ type CliModel = {
   };
   limits_source: string;
   cost_source?: string;
+  /** True when the gateway lists the model but it rejects completion on
+   * this key (not entitled, needs provisioned throughput, retired). */
+  disabled?: boolean;
   /** Reasoning capability and applicable efforts, from the catalog. */
   reasoning?: boolean;
   reasoning_efforts?: string[];
@@ -255,6 +259,20 @@ describe("unpriced models", () => {
   });
 });
 
+describe("disabled models", () => {
+  test("omits models the CLI marks disabled", () => {
+    const models = toConfigModels({
+      models: [{ ...NOVA, disabled: true }],
+    });
+    expect(models["bedrock/amazon.nova-lite-v1:0"]).toBeUndefined();
+  });
+
+  test("keeps models the CLI does not mark disabled", () => {
+    const models = toConfigModels({ models: [NOVA] });
+    expect(models["bedrock/amazon.nova-lite-v1:0"]).toBeDefined();
+  });
+});
+
 describe("reasoning", () => {
   /** A reasoning model with a discrete effort set, like Fireworks kimi-k3. */
   const REASONING: CliModel = {
@@ -394,3 +412,19 @@ describe("gateway URL allowlist", () => {
     expect(isAllowedGatewayUrl("not a url")).toBe(false);
   });
 });
+
+describe("stale-plugin notice", () => {
+  test("warns only when the registry is ahead", () => {
+    expect(isStale("0.1.0", "0.2.1")).toBe(true);
+    expect(isStale("0.2.0", "0.2.1")).toBe(true);
+    expect(isStale("0.2.1", "0.2.1")).toBe(false);
+    // A dev build ahead of the registry is not stale.
+    expect(isStale("0.3.0", "0.2.1")).toBe(false);
+    expect(isStale("0.2.2", "0.2.1")).toBe(false);
+  });
+
+  test("treats unparseable differences as stale rather than guessing", () => {
+    expect(isStale("dev", "0.2.1")).toBe(true);
+    expect(isStale("dev", "dev")).toBe(false);
+  });
+});

package/src/index.ts

@@ -33,6 +33,15 @@ type Resolution = {
   reasoning_effort?: string;
 };
 
+/** One entry in OpenCode's `provider` config map, as this plugin writes it. */
+type ProviderEntry = {
+  options?: Record<string, unknown>;
+  models?: Record<string, ConfigModel>;
+  // OpenCode's provider config carries more fields than this plugin sets;
+  // user overrides are preserved verbatim via the spread in the config hook.
+  [key: string]: unknown;
+};
+
 /** The model shape OpenCode reads from `provider.<id>.models`. */
 type ConfigModel = {
   name: string;
@@ -67,6 +76,9 @@ type CliModel = {
   };
   limits_source: string;
   cost_source?: string;
+  /** True when the gateway lists the model but it rejects completion on
+   * this key (not entitled, needs provisioned throughput, retired). */
+  disabled?: boolean;
   /** Reasoning capability and applicable efforts, from the catalog. */
   reasoning?: boolean;
   reasoning_efforts?: string[];
@@ -91,7 +103,129 @@ type CliModels = { models?: CliModel[] };
  * the picker. The v2 `provider.models` hook is not used because the v2
  * catalog is not active in this version.
  */
-export const BifrostGateway: Plugin = async ({ directory, $ }) => {
+/**
+ * How long a "plugin is current" answer is trusted before the registry is
+ * asked again. Kept on disk so the once-daily check costs nothing on the
+ * frequent path (every opencode startup constructs this plugin).
+ */
+const VERSION_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+
+/** npm registry endpoint for the published package's latest version. */
+const REGISTRY_URL =
+  "https://registry.npmjs.org/@stablekernel/opencode-bifrost/latest";
+
+/** The version of this build, read from the package's own package.json. */
+function ownVersion(): string | null {
+  try {
+    const pkg = require("../package.json") as { version?: string };
+    return pkg.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+type VersionCheckCache = { checkedAt: number; latest: string };
+
+/** opencode's plugin cache root; matches where the host itself caches. */
+function versionCheckPath(): string | null {
+  const home = process.env.HOME;
+  if (!home) return null;
+  const base = process.env.XDG_CACHE_HOME ?? `${home}/.cache`;
+  return `${base}/opencode/bifrost-version-check.json`;
+}
+
+/**
+ * The latest published version, from a fresh-enough cache file when present
+ * and the npm registry otherwise. Null means unknown — offline, timeout, or
+ * an unreadable cache — and never warns.
+ */
+async function latestPublishedVersion(): Promise<string | null> {
+  const path = versionCheckPath();
+  if (path) {
+    try {
+      const cached = JSON.parse(
+        await Bun.file(path).text(),
+      ) as VersionCheckCache;
+      if (
+        typeof cached.latest === "string" &&
+        Date.now() - cached.checkedAt < VERSION_CHECK_TTL_MS
+      ) {
+        return cached.latest;
+      }
+    } catch {
+      // Missing or corrupt cache: fall through to the registry.
+    }
+  }
+  let latest: string | null = null;
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: AbortSignal.timeout(1500),
+    });
+    if (res.ok) {
+      const body = (await res.json()) as { version?: string };
+      latest = typeof body.version === "string" ? body.version : null;
+    }
+  } catch {
+    return null; // offline or slow registry: stay silent
+  }
+  if (latest && path) {
+    try {
+      const { mkdirSync, writeFileSync } = await import("node:fs");
+      const { dirname } = await import("node:path");
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(
+        path,
+        JSON.stringify({
+          checkedAt: Date.now(),
+          latest,
+        } satisfies VersionCheckCache),
+      );
+    } catch {
+      // A failed cache write just means the next start asks again.
+    }
+  }
+  return latest;
+}
+
+/**
+ * Whether the installed build should warn about a newer release. Dev builds
+ * ahead of the registry (installed > latest) are not stale.
+ */
+export function isStale(installed: string, latest: string): boolean {
+  if (installed === latest) return false;
+  // Strict semver core only: parseInt would silently accept "0.3.0-dev" as
+  // 0.3.0 and misjudge the comparison. Odd shapes (prereleases, two-part
+  // versions) fall back to "warn on any difference" rather than a guess.
+  const SEMVER = /^(\d+)\.(\d+)\.(\d+)$/;
+  const a = SEMVER.exec(installed);
+  const b = SEMVER.exec(latest);
+  if (!a || !b) return true;
+  for (let i = 1; i <= 3; i++) {
+    const av = Number(a[i]);
+    const bv = Number(b[i]);
+    if (bv > av) return true;
+    if (bv < av) return false;
+  }
+  return false;
+}
+
+/**
+ * Report a newer published plugin exactly once per version via the host's
+ * log. Fire-and-forget from the config hook: version drift must never block
+ * or fail provider registration.
+ */
+async function announceIfStale(log: (message: string) => void): Promise<void> {
+  const installed = ownVersion();
+  if (!installed) return;
+  const latest = await latestPublishedVersion();
+  if (!latest || !isStale(installed, latest)) return;
+  log(
+    `opencode-bifrost ${latest} is available (installed ${installed}). ` +
+      "Run `gateway-cli update` to refresh.",
+  );
+}
+
+export const BifrostGateway: Plugin = async ({ client, directory, $ }) => {
   async function cli(args: string[]): Promise<string | null> {
     try {
       const out = await $`${CLI} ${args}`.cwd(directory).quiet().text();
@@ -136,11 +270,26 @@ export const BifrostGateway: Plugin = async ({ directory, $ }) => {
      * writes only to the in-memory config object.
      */
     config: async (cfg) => {
+      // Stale-plugin notice runs beside registration, never inside it.
+      void announceIfStale((message) => {
+        void client.app
+          .log({
+            body: {
+              service: "opencode-bifrost",
+              level: "warn",
+              message,
+            },
+          })
+          .catch(() => {});
+      }).catch(() => {});
+
       const info = await resolve();
       if (!info) return;
 
-      const providers = ((cfg as Record<string, any>).provider ??= {});
-      const existing = providers[PROVIDER_ID] ?? {};
+      const providers = ((
+        cfg as { provider?: Record<string, ProviderEntry> }
+      ).provider ??= {});
+      const existing: ProviderEntry = providers[PROVIDER_ID] ?? {};
       const models = toConfigModels(await listModels(), info.reasoning_effort);
 
       providers[PROVIDER_ID] = {
@@ -226,6 +375,7 @@ export function toConfigModels(
   const out: Record<string, ConfigModel> = {};
   for (const m of payload?.models ?? []) {
     if (!m?.id) continue;
+    if (m.disabled) continue; // unavailable on this key: never offer it
     const efforts = m.reasoning_efforts ?? [];
     const entry: ConfigModel = {
       name: m.cost ? m.name : `${m.name}${UNPRICED_SUFFIX}`,