@mcowger/opencode-plexus 1.3.8 → 1.3.10

package/README.md

@@ -244,6 +244,47 @@ Both adapters also accept pi-style environment interpolation in configured strin
 
 ---
 
+## Model suppression
+
+All plugin packages support suppressing models by name or pattern so undesired models do not appear in model selectors or cache restored lists.
+
+### Pattern matching syntax
+
+- **Exact match** (case-insensitive): Matches model `id`, `name`, or short ID (suffix after `/` or `:`). Example: `"gpt-4o"`, `"Claude 3.5 Sonnet"`.
+- **Glob wildcards**: Supports `*` (0+ characters) and `?` (1 character). Example: `"gpt-3.5*"`, `"*deprecated*"`, `"anthropic/*"`.
+- **Regex patterns**: Prefix with `regex:`. Example: `"regex:^gpt-[34]"`.
+
+### Configuration methods
+
+- **Environment variables**:
+  ```sh
+  export PLEXUS_SUPPRESS_MODELS="gpt-3.5*, *deprecated*, whisper"
+  ```
+  `PLEXUS_EXCLUDE_MODELS` is also accepted. Values can be comma-, semicolon-, or newline-separated.
+
+- **pi / Oh My Pi config**: Add `suppressModels` (or `suppress`) to `config.json`:
+  ```json
+  {
+    "baseUrl": "https://plexus.example.com",
+    "suppressModels": ["gpt-3.5*", "*deprecated*"]
+  }
+  ```
+
+- **OpenCode config**: Add `suppressModels` (or `suppress`) under `provider.plexus.options` in `opencode.json`:
+  ```json
+  {
+    "provider": {
+      "plexus": {
+        "options": {
+          "suppressModels": ["gpt-3.5*", "claude-2*"]
+        }
+      }
+    }
+  }
+  ```
+
+---
+
 ## Package layout
 
 ```
@@ -252,6 +293,7 @@ packages/
     src/
       types.ts          # wire types (PlexusApiModel, PlexusModelDescriptor, etc.)
       convert.ts        # model fetching, conversion, compat detection
+      suppress.ts       # model pattern suppression / exclusion matching
       index.ts          # barrel export
   plexus-pi/            # pi host adapter
     src/

package/dist/index.js

@@ -9,12 +9,66 @@ var PLEXUS_BASE_URL_OPTION = "plexusBaseURL";
 var ENV_BASE_URL = "PLEXUS_BASE_URL";
 var ENV_API_URL = "PLEXUS_API_URL";
 var ENV_API_KEY = "PLEXUS_API_KEY";
+var ENV_SUPPRESS_MODELS = "PLEXUS_SUPPRESS_MODELS";
+var ENV_SUPPRESSED_MODELS = "PLEXUS_SUPPRESSED_MODELS";
+var ENV_EXCLUDE_MODELS = "PLEXUS_EXCLUDE_MODELS";
+var ENV_IGNORE_MODELS = "PLEXUS_IGNORE_MODELS";
+var PLEXUS_SUPPRESS_MODELS_OPTION = "suppressModels";
 var MODELS_FETCH_TIMEOUT_MS = 1e4;
 var REFRESH_TTL_MS = 60000;
 var CONFIG_HOOK_REFRESH_BUDGET_MS = 3000;
 var PLACEHOLDER_MODEL_ID = "plexus-unconfigured";
 var PLEXUS_REFRESH_COMMAND = "plexus-refresh";
 
+// ../plexus-models/src/suppress.ts
+function parseSuppressionPatterns(raw) {
+  if (!raw)
+    return [];
+  const items = Array.isArray(raw) ? raw : raw.split(/[\n,;]+/);
+  return items.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function getEnvSuppressedModels() {
+  const env = typeof process !== "undefined" && process?.env ? process.env : {};
+  const raw = env.PLEXUS_SUPPRESS_MODELS ?? env.PLEXUS_EXCLUDE_MODELS;
+  return parseSuppressionPatterns(raw);
+}
+function isModelSuppressed(model, patterns) {
+  const envPatterns = getEnvSuppressedModels();
+  const explicitPatterns = parseSuppressionPatterns(patterns);
+  const allPatterns = [...envPatterns, ...explicitPatterns];
+  if (allPatterns.length === 0)
+    return false;
+  const id = model.id.toLowerCase();
+  const name = (model.name ?? "").toLowerCase();
+  const shortId = id.includes("/") ? id.split("/").pop() : id.includes(":") ? id.split(":").pop() : id;
+  for (const pattern of allPatterns) {
+    if (matchesPattern(id, name, shortId, pattern)) {
+      return true;
+    }
+  }
+  return false;
+}
+function matchesPattern(id, name, shortId, pattern) {
+  const p = pattern.toLowerCase();
+  if (p.startsWith("regex:")) {
+    try {
+      const re = new RegExp(pattern.slice(6), "i");
+      return re.test(id) || re.test(name) || re.test(shortId);
+    } catch {
+      return false;
+    }
+  }
+  if (p.includes("*") || p.includes("?")) {
+    const regexStr = "^" + p.replace(/([.+^${}()|[\]\\])/g, "\\$1").replace(/\*/g, ".*").replace(/\?/g, ".") + "$";
+    try {
+      const re = new RegExp(regexStr, "i");
+      return re.test(id) || re.test(name) || re.test(shortId);
+    } catch {
+      return false;
+    }
+  }
+  return id === p || name === p || shortId === p;
+}
 // ../plexus-models/src/convert.ts
 var REASONING_PARAMS = new Set(["reasoning", "include_reasoning", "reasoning_effort"]);
 var NON_CHAT_PATTERN = /(?:^|[\W_])(?:embed(?:ding|dings)?|transcri(?:be[ds]?|ptions?)|whisper|speech[\W_]*to[\W_]*text|stt|text[\W_]*to[\W_]*speech|tts|image[\W_]*(?:gen(?:eration)?|\d+)|diffusion|dall[\W_]*e|stable[\W_]*diffusion|sdxl|dream)(?:$|[\W_])/i;
@@ -66,22 +120,28 @@ function isChatModel(model) {
   return !NON_CHAT_PATTERN.test(`${model.id} ${model.name ?? ""} ${apiHints}`);
 }
 var DEFAULT_MODELS_FETCH_TIMEOUT_MS = 1e4;
-async function fetchPlexusModels(apiKey, modelsUrl, timeoutMs = DEFAULT_MODELS_FETCH_TIMEOUT_MS) {
+async function fetchPlexusModels(apiKey, modelsUrl, timeoutMs = DEFAULT_MODELS_FETCH_TIMEOUT_MS, etag) {
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
     const headers = { Accept: "application/json" };
     if (apiKey)
       headers.Authorization = `Bearer ${apiKey}`;
+    if (etag)
+      headers["If-None-Match"] = etag;
     const res = await fetch(modelsUrl, {
       headers,
       signal: controller.signal
     });
+    if (res.status === 304) {
+      return { models: [], notModified: true };
+    }
     if (!res.ok) {
       throw new Error(`Plexus models fetch failed: ${res.status} ${res.statusText}`);
     }
     const raw = await res.json();
-    return { models: raw.data ?? [], raw };
+    const responseEtag = res.headers.get("etag") ?? undefined;
+    return { models: raw.data ?? [], raw, etag: responseEtag };
   } catch (err) {
     if (err instanceof Error && err.name === "AbortError") {
       throw new Error(`Plexus models fetch timed out after ${timeoutMs}ms`);
@@ -104,34 +164,41 @@ function fallbackDir() {
 function getDir() {
   return fallbackDir();
 }
-function filterCachedModels(models) {
-  return Object.fromEntries(Object.entries(models).filter(([, model]) => isChatModel({
-    id: model.id,
-    name: model.name,
-    architecture: {
-      input_modalities: model.modalities.input,
-      output_modalities: model.modalities.output
-    }
-  })));
+function filterCachedModels(models, suppress) {
+  return Object.fromEntries(Object.entries(models).filter(([, model]) => {
+    if (isModelSuppressed({ id: model.id, name: model.name }, suppress))
+      return false;
+    return isChatModel({
+      id: model.id,
+      name: model.name,
+      architecture: {
+        input_modalities: model.modalities.input,
+        output_modalities: model.modalities.output
+      }
+    });
+  }));
 }
-async function readCachedModels(_client) {
+async function readCachedModels(_client, suppress) {
   try {
     const dir = getDir();
     const content = await readFile(join(dir, CACHE_FILE), "utf8");
     const parsed = JSON.parse(content);
     if (parsed && typeof parsed.models === "object" && !Array.isArray(parsed.models)) {
-      return filterCachedModels(parsed.models);
+      return {
+        models: filterCachedModels(parsed.models, suppress),
+        etag: typeof parsed.etag === "string" ? parsed.etag : undefined
+      };
     }
     return null;
   } catch {
     return null;
   }
 }
-async function writeCache(_client, models, raw) {
+async function writeCache(_client, models, raw, etag) {
   try {
     const dir = getDir();
     await mkdir(dir, { recursive: true });
-    const cache = { models, timestamp: Date.now() };
+    const cache = { models, timestamp: Date.now(), etag };
     await writeFile(join(dir, CACHE_FILE), JSON.stringify(cache, null, 2) + `
 `, "utf8");
     if (raw !== undefined) {
@@ -249,9 +316,24 @@ function resolveConfig(provider, authMetadata) {
   const optBaseURL = resolveStringOption(provider?.options?.[PLEXUS_BASE_URL_OPTION]);
   const legacyBaseURL = resolveStringOption(provider?.options?.baseURL);
   const optApiKey = resolveStringOption(provider?.options?.apiKey);
+  const optSuppress = provider?.options?.["suppressModels"] ?? provider?.options?.["suppress"] ?? provider?.options?.["suppress_models"];
+  const envSuppress = getEnvSuppressedModels();
+  const configSuppress = parseSuppressionPatterns(optSuppress);
+  const suppressModels = [...envSuppress, ...configSuppress];
   const baseURL = (envBaseURL ? rootURL(envBaseURL) : undefined) || (authBaseURL ? rootURL(authBaseURL) : undefined) || (optBaseURL ? rootURL(optBaseURL) : undefined) || (legacyBaseURL ? rootURL(legacyBaseURL) : undefined) || undefined;
   const apiKey = (envApiKey ? envApiKey.trim() : undefined) || optApiKey || undefined;
-  return { baseURL: baseURL || undefined, apiKey: apiKey || undefined };
+  return {
+    baseURL: baseURL || undefined,
+    apiKey: apiKey || undefined,
+    ...suppressModels.length > 0 ? { suppressModels } : {}
+  };
+}
+function getSuppressedModels(provider) {
+  const envSuppressed = getEnvSuppressedModels();
+  const providerObj = provider ?? {};
+  const providerOptions = typeof providerObj["options"] === "object" && providerObj["options"] !== null ? providerObj["options"] : {};
+  const optSuppressed = parseSuppressionPatterns(providerOptions["suppressModels"] ?? providerOptions["suppress"] ?? providerObj["suppressModels"] ?? providerObj["suppress"]);
+  return [...envSuppressed, ...optSuppressed];
 }
 
 // src/log.ts
@@ -353,11 +435,13 @@ function buildOutputModalities(model) {
   }
   return ["text"];
 }
-function buildModels(models, baseURL) {
+function buildModels(models, baseURL, suppress) {
   const result = {};
   for (const m of models) {
     if (!isChatModel(m))
       continue;
+    if (isModelSuppressed(m, suppress))
+      continue;
     const outputModalities = buildOutputModalities(m);
     if (outputModalities === null)
       continue;
@@ -497,7 +581,7 @@ function raceWithTimeout(promise, timeoutMs) {
     });
   });
 }
-function refreshModels(client, baseURL, log, apiKey, force = false) {
+function refreshModels(client, baseURL, log, apiKey, force = false, suppress) {
   if (!force && lastRefresh && Date.now() - lastRefresh.at < REFRESH_TTL_MS) {
     log.info(`Using in-memory plexus model cache (${Object.keys(lastRefresh.models).length} models)`);
     return Promise.resolve(lastRefresh.models);
@@ -506,15 +590,21 @@ function refreshModels(client, baseURL, log, apiKey, force = false) {
     return inFlightRefresh;
   const run = async () => {
     const url = modelsUrl(baseURL);
-    const { models: apiModels, raw } = await fetchPlexusModels(apiKey ?? "", url);
-    const built = buildModels(apiModels, apiBase(baseURL));
+    const cached = await readCachedModels(client, suppress);
+    const { models: apiModels, raw, etag, notModified } = await fetchPlexusModels(apiKey ?? "", url, undefined, cached?.etag);
+    if (notModified && cached?.models) {
+      log.info(`Plexus models not modified (etag: ${cached.etag})`);
+      lastRefresh = { at: Date.now(), models: cached.models };
+      return cached.models;
+    }
+    const built = buildModels(apiModels, apiBase(baseURL), suppress);
     for (const [id, model] of Object.entries(built)) {
       const providerNpm = model.provider?.npm ?? OPENAI_COMPATIBLE_NPM;
       const providerApi = model.provider?.api ?? "(missing)";
       log.info(`Model mapping ${id}: npm=${providerNpm} api=${providerApi}`);
     }
     lastRefresh = { at: Date.now(), models: built };
-    writeCache(client, built, raw).catch(() => {});
+    writeCache(client, built, raw, etag).catch(() => {});
     return built;
   };
   inFlightRefresh = run().finally(() => {
@@ -531,15 +621,17 @@ var PlexusProviderPlugin = async (ctx) => {
       const existing = cfg.provider[PLEXUS_PROVIDER_ID] ?? {};
       const existingOptions = typeof existing["options"] === "object" && existing["options"] !== null ? existing["options"] : {};
       const existingModels = typeof existing["models"] === "object" && existing["models"] !== null ? existing["models"] : null;
+      const suppress = getSuppressedModels(existing);
       const { baseURL, apiKey } = resolveConfig(existing);
       log.info(`Resolved plexus config: baseURL=${baseURL ?? "(missing)"} apiKey=${apiKey ? "present" : "missing"}`);
       if (typeof existingOptions["baseURL"] === "string") {
         log.warn(`Ignoring legacy provider.options.baseURL=${String(existingOptions["baseURL"])}`);
       }
-      const cachedAsync = await readCachedModels(client);
+      const cachedAsync = await readCachedModels(client, suppress);
       if (cachedAsync) {
-        log.info(`Loaded plexus cache with ${Object.keys(cachedAsync).length} models`);
+        log.info(`Loaded plexus cache with ${Object.keys(cachedAsync.models).length} models`);
       }
+      const effectiveExistingModels = existingModels ? filterCachedModels(existingModels, suppress) : null;
       const merged = {
         ...existing,
         name: existing["name"] ?? PLEXUS_PROVIDER_NAME,
@@ -549,7 +641,7 @@ var PlexusProviderPlugin = async (ctx) => {
           ...baseURL ? { [PLEXUS_BASE_URL_OPTION]: baseURL } : {},
           ...apiKey ? { apiKey } : {}
         },
-        models: existingModels ?? (cachedAsync ? toConfigModels(cachedAsync) : null) ?? {
+        models: (effectiveExistingModels && Object.keys(effectiveExistingModels).length > 0 ? effectiveExistingModels : null) ?? (cachedAsync ? toConfigModels(cachedAsync.models) : null) ?? {
           [PLACEHOLDER_MODEL_ID]: {
             id: PLACEHOLDER_MODEL_ID,
             name: "Plexus (run /connect to configure)",
@@ -584,21 +676,22 @@ var PlexusProviderPlugin = async (ctx) => {
     provider: {
       id: PLEXUS_PROVIDER_ID,
       models: async (provider, hookCtx) => {
+        const suppress = getSuppressedModels(provider);
         const authKey = hookCtx.auth?.type === "api" ? hookCtx.auth.key : undefined;
         const { baseURL, apiKey } = resolveConfig(provider, authMetadata(hookCtx.auth));
         const key = authKey ?? apiKey;
         if (!baseURL) {
           log.info("Provider hook skipped live refresh; baseURL missing");
-          const cached2 = await readCachedModels(client);
-          return cached2 ? toRuntimeModels(cached2, provider) : {};
+          const cached2 = await readCachedModels(client, suppress);
+          return cached2 ? toRuntimeModels(cached2.models, provider) : {};
         }
-        const refreshPromise = refreshModels(client, baseURL, log, key);
+        const refreshPromise = refreshModels(client, baseURL, log, key, false, suppress);
         const race = await raceWithTimeout(refreshPromise, CONFIG_HOOK_REFRESH_BUDGET_MS);
         if (race.status === "resolved") {
           log.info(`Provider hook loaded ${Object.keys(race.value).length} plexus models from ${baseURL}`);
           return toRuntimeModels(race.value, provider);
         }
-        const cached = await readCachedModels(client);
+        const cached = await readCachedModels(client, suppress);
         if (race.status === "rejected") {
           log.warn(`Provider hook live refresh failed, using cache: ${String(race.error)}`);
         } else {
@@ -607,7 +700,7 @@ var PlexusProviderPlugin = async (ctx) => {
             log.warn(`Background plexus model refresh failed: ${String(e)}`);
           });
         }
-        return cached ? toRuntimeModels(cached, provider) : {};
+        return cached ? toRuntimeModels(cached.models, provider) : {};
       }
     },
     "command.execute.before": async (input) => {
@@ -615,6 +708,7 @@ var PlexusProviderPlugin = async (ctx) => {
         return;
       const configResponse = await client.config.get();
       const provider = configResponse.data?.provider?.[PLEXUS_PROVIDER_ID];
+      const suppress = getSuppressedModels(provider);
       const storedAuth = await readStoredAuth();
       const { baseURL, apiKey } = resolveConfig(provider, storedAuth?.metadata);
       const key = storedAuth?.key ?? apiKey;
@@ -623,7 +717,7 @@ var PlexusProviderPlugin = async (ctx) => {
       }
       let models;
       try {
-        models = await refreshModels(client, baseURL, log, key, true);
+        models = await refreshModels(client, baseURL, log, key, true, suppress);
       } catch (e) {
         throw new Error(`Plexus refresh failed: ${String(e)}. Existing cache left untouched.`);
       }
@@ -692,6 +786,7 @@ export {
   buildModels,
   REFRESH_TTL_MS,
   PlexusProviderPlugin,
+  PLEXUS_SUPPRESS_MODELS_OPTION,
   PLEXUS_REFRESH_COMMAND,
   PLEXUS_PROVIDER_NAME,
   PLEXUS_PROVIDER_ID,
@@ -701,6 +796,10 @@ export {
   PLACEHOLDER_MODEL_ID,
   OPENAI_COMPATIBLE_NPM,
   MODELS_FETCH_TIMEOUT_MS,
+  ENV_SUPPRESS_MODELS,
+  ENV_SUPPRESSED_MODELS,
+  ENV_IGNORE_MODELS,
+  ENV_EXCLUDE_MODELS,
   ENV_BASE_URL,
   ENV_API_URL,
   ENV_API_KEY,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mcowger/opencode-plexus",
-	"version": "1.3.8",
+	"version": "1.3.10",
 	"description": "OpenCode plugin: Plexus provider with dynamic model discovery",
 	"type": "module",
 	"module": "./dist/index.js",