@stablekernel/opencode-bifrost 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stablekernel/opencode-bifrost",
-  "version": "0.2.0",
+  "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[];
@@ -153,6 +157,27 @@ describe("config hook", () => {
     ).toEqual({ input: 1, output: 5, cache_read: 0.1, cache_write: 1.25 });
   });
 
+  test("omits headers when resolve reports none", async () => {
+    const noHeaders: Record<string, unknown> = { ...RESOLUTION };
+    delete noHeaders.headers;
+    const cfg = await applyConfig({
+      ...OK_SHELL,
+      "resolve --json": JSON.stringify(noHeaders),
+    });
+    expect(cfg.provider.bifrost.options.headers).toBeUndefined();
+  });
+
+  test("treats an empty header map the same as no headers", async () => {
+    // Go-side mergeHeaders returns nil for an empty merge and the JSON tag
+    // omits it, so `{}` cannot reach the plugin in practice. This pins the
+    // behavior anyway so a future CLI change cannot quietly flip it.
+    const cfg = await applyConfig({
+      ...OK_SHELL,
+      "resolve --json": JSON.stringify({ ...RESOLUTION, headers: {} }),
+    });
+    expect(cfg.provider.bifrost.options.headers).toBeUndefined();
+  });
+
   test("does not read the key: discovery goes through the CLI", async () => {
     // The CLI holds the credential and returns only non-secret metadata.
     const calls: string[] = [];
@@ -234,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 = {
@@ -319,6 +358,17 @@ describe("auth.loader", () => {
     expect(opts.baseURL).toBe("https://gw.example/openai/v1");
   });
 
+  test("forwards the resolved headers alongside the key", async () => {
+    // The config hook sets headers at startup, but auth.loader also returns
+    // provider options at request time; both must carry the gateway headers.
+    const hooks = await load(OK_SHELL);
+    const opts = await hooks.auth!.loader!(
+      async () => ({ type: "api", key: "stored" }) as never,
+      {} as never,
+    );
+    expect(opts.headers).toEqual({ "X-Org-Route": "prod" });
+  });
+
   test("falls back to the stored credential without gateway-cli", async () => {
     const hooks = await load({});
     const opts = await hooks.auth!.loader!(
@@ -362,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] = {
@@ -150,7 +299,9 @@ export const BifrostGateway: Plugin = async ({ directory, $ }) => {
         ...existing,
         options: {
           baseURL: info.openai_base_url,
-          ...(info.headers ? { headers: info.headers } : {}),
+          ...(info.headers && Object.keys(info.headers).length > 0
+            ? { headers: info.headers }
+            : {}),
           ...(existing.options ?? {}),
         },
         models: { ...models, ...(existing.models ?? {}) },
@@ -176,7 +327,9 @@ export const BifrostGateway: Plugin = async ({ directory, $ }) => {
         return {
           apiKey,
           ...(info ? { baseURL: info.openai_base_url } : {}),
-          ...(info?.headers ? { headers: info.headers } : {}),
+          ...(info?.headers && Object.keys(info.headers).length > 0
+            ? { headers: info.headers }
+            : {}),
         };
       },
 
@@ -222,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}`,