@mcowger/opencode-plexus 0.7.0 → 0.8.1

package/README.md

@@ -116,10 +116,23 @@ Run inside OpenCode:
 
 Select **Plexus** and enter your base URL and API key. Models are loaded immediately and cached for fast startup on subsequent sessions.
 
+For OpenCode, enter the Plexus API base URL including the trailing `/v1`, for example:
+
+```text
+https://plexus.example.com/v1
+```
+
+The OpenCode plugin respects each model's `preferred_api` value and routes models through the matching SDK/API shape:
+
+- `chat_completions` / `openai-completions` → OpenAI-compatible chat completions
+- `responses` / `openai-responses` → OpenAI Responses API
+- `messages` / `anthropic-messages` → Anthropic Messages API
+- `gemini` / `google-generative-ai` → Google Gemini API
+
 You can also pre-configure via environment variables:
 
 ```sh
-export PLEXUS_BASE_URL=https://plexus.example.com
+export PLEXUS_BASE_URL=https://plexus.example.com/v1
 export PLEXUS_API_KEY=your-api-key
 ```
 

package/dist/index.js

@@ -5,6 +5,7 @@ var PLEXUS_PROVIDER_NAME = "Plexus";
 var PLEXUS_PLUGIN_ID = "@mcowger/opencode-plexus";
 var PLEXUS_LOG_SERVICE = "opencode-plexus";
 var OPENAI_COMPATIBLE_NPM = "@ai-sdk/openai-compatible";
+var PLEXUS_BASE_URL_OPTION = "plexusBaseURL";
 var ENV_BASE_URL = "PLEXUS_BASE_URL";
 var ENV_API_KEY = "PLEXUS_API_KEY";
 var MODELS_FETCH_TIMEOUT_MS = 1e4;
@@ -13,6 +14,36 @@ var PLACEHOLDER_MODEL_ID = "plexus-unconfigured";
 
 // ../plexus-models/src/convert.ts
 var REASONING_PARAMS = new Set(["reasoning", "include_reasoning", "reasoning_effort"]);
+var API_DIALECT_MAP = {
+  chat_completions: "openai-completions",
+  "openai-completions": "openai-completions",
+  messages: "anthropic-messages",
+  "anthropic-messages": "anthropic-messages",
+  gemini: "google-generative-ai",
+  "google-generative-ai": "google-generative-ai",
+  responses: "openai-responses",
+  "openai-responses": "openai-responses"
+};
+function mapPreferredApi(raw) {
+  if (raw === undefined)
+    return "openai-completions";
+  const candidates = Array.isArray(raw) ? raw : [raw];
+  for (const candidate of candidates) {
+    const mapped = API_DIALECT_MAP[candidate];
+    if (mapped !== undefined)
+      return mapped;
+  }
+  return "openai-completions";
+}
+function adjustBaseUrl(baseUrl, preferredApi) {
+  const stripped = baseUrl.replace(/\/+$/, "");
+  switch (preferredApi) {
+    case "google-generative-ai":
+      return stripped.endsWith("/v1") ? `${stripped.slice(0, -3)}/v1beta` : stripped;
+    default:
+      return stripped;
+  }
+}
 async function fetchPlexusModels(apiKey, modelsUrl) {
   const res = await fetch(modelsUrl, {
     headers: {
@@ -138,9 +169,10 @@ function createV2Client(serverUrl, input) {
 function resolveConfig(provider) {
   const envBaseURL = process.env[ENV_BASE_URL];
   const envApiKey = process.env[ENV_API_KEY];
-  const optBaseURL = typeof provider?.options?.baseURL === "string" ? trimURL(provider.options.baseURL) : undefined;
+  const optBaseURL = typeof provider?.options?.[PLEXUS_BASE_URL_OPTION] === "string" ? trimURL(provider.options[PLEXUS_BASE_URL_OPTION]) : undefined;
+  const legacyBaseURL = typeof provider?.options?.baseURL === "string" ? trimURL(provider.options.baseURL) : undefined;
   const optApiKey = typeof provider?.options?.apiKey === "string" ? provider.options.apiKey.trim() : undefined;
-  const baseURL = (envBaseURL ? trimURL(envBaseURL) : undefined) || optBaseURL || undefined;
+  const baseURL = (envBaseURL ? trimURL(envBaseURL) : undefined) || optBaseURL || legacyBaseURL || undefined;
   const apiKey = (envApiKey ? envApiKey.trim() : undefined) || optApiKey || undefined;
   return { baseURL: baseURL || undefined, apiKey: apiKey || undefined };
 }
@@ -150,7 +182,7 @@ async function persistToGlobalConfig(serverUrl, client, baseURL, apiKey) {
     config: {
       provider: {
         [PLEXUS_PROVIDER_ID]: {
-          options: { baseURL, apiKey }
+          options: { [PLEXUS_BASE_URL_OPTION]: baseURL, apiKey }
         }
       }
     }
@@ -172,6 +204,22 @@ function createLogger(client) {
 // src/mapper.ts
 var REASONING_PARAMS2 = new Set(["reasoning", "include_reasoning", "reasoning_effort"]);
 var DEFAULT_CONTEXT = 8192;
+function resolveModelProvider(model, baseURL) {
+  const preferredApi = mapPreferredApi(model.preferred_api);
+  const api = adjustBaseUrl(baseURL, preferredApi);
+  switch (preferredApi) {
+    case "anthropic-messages":
+      return { npm: "@ai-sdk/anthropic", api };
+    case "google-generative-ai":
+      return { npm: "@ai-sdk/google", api };
+    case "openai-responses":
+      return { npm: "@ai-sdk/openai", api };
+    case "openai-completions":
+      return { api };
+    default:
+      return { api };
+  }
+}
 function parsePrice(value) {
   if (!value)
     return 0;
@@ -213,7 +261,7 @@ function buildOutputModalities(model) {
     return null;
   return ["text"];
 }
-function buildModels(models) {
+function buildModels(models, baseURL) {
   const result = {};
   for (const m of models) {
     if (!m.id)
@@ -231,9 +279,11 @@ function buildModels(models) {
     const cacheWritePrice = parsePrice(m.pricing?.input_cache_write);
     const hasCachePricing = cacheReadPrice > 0 || cacheWritePrice > 0;
     const hasNonTextInput = inputModalities.some((mod) => mod !== "text");
+    const provider = resolveModelProvider(m, baseURL);
     const entry = {
       id: m.id,
       name: m.name ?? m.id,
+      provider,
       limit: {
         context: contextLength,
         output: maxOutput
@@ -261,13 +311,54 @@ function buildModels(models) {
 
 // src/plugin.ts
 var lastRefresh = null;
-async function refreshModels(client, baseURL, apiKey) {
+function mergeModelMaps(base, overrides) {
+  if (!overrides)
+    return base;
+  const merged = { ...base };
+  for (const [id, override] of Object.entries(overrides)) {
+    const existing = merged[id];
+    if (!existing) {
+      merged[id] = override;
+      continue;
+    }
+    merged[id] = {
+      ...existing,
+      ...override,
+      provider: {
+        ...existing.provider ?? {},
+        ...override.provider ?? {}
+      },
+      ...existing.cost || override.cost ? {
+        cost: {
+          ...existing.cost ?? { input: 0, output: 0 },
+          ...override.cost ?? {}
+        }
+      } : {},
+      limit: {
+        ...existing.limit,
+        ...override.limit
+      },
+      modalities: {
+        input: override.modalities?.input ?? existing.modalities.input,
+        output: override.modalities?.output ?? existing.modalities.output
+      }
+    };
+  }
+  return merged;
+}
+async function refreshModels(client, baseURL, log, apiKey) {
   if (lastRefresh && Date.now() - lastRefresh.at < REFRESH_TTL_MS) {
+    log.info(`Using in-memory plexus model cache (${Object.keys(lastRefresh.models).length} models)`);
     return lastRefresh.models;
   }
   const url = modelsUrl(baseURL);
   const { models: apiModels, raw } = await fetchPlexusModels(apiKey ?? "", url);
-  const built = buildModels(apiModels);
+  const built = buildModels(apiModels, apiBase(baseURL));
+  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(() => {});
   return built;
@@ -282,14 +373,21 @@ var PlexusProviderPlugin = async (ctx) => {
       const existingOptions = typeof existing["options"] === "object" && existing["options"] !== null ? existing["options"] : {};
       const existingModels = typeof existing["models"] === "object" && existing["models"] !== null ? existing["models"] : null;
       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 cachedSync = readCachedModelsSync();
+      if (cachedSync) {
+        log.info(`Loaded sync plexus cache with ${Object.keys(cachedSync).length} models`);
+      }
       const merged = {
         ...existing,
         name: existing["name"] ?? PLEXUS_PROVIDER_NAME,
         npm: existing["npm"] ?? OPENAI_COMPATIBLE_NPM,
         options: {
           ...existingOptions,
-          ...baseURL ? { baseURL: apiBase(baseURL) } : {},
+          ...baseURL ? { [PLEXUS_BASE_URL_OPTION]: baseURL } : {},
           ...apiKey ? { apiKey } : {}
         },
         models: existingModels ?? cachedSync ?? {
@@ -301,21 +399,32 @@ var PlexusProviderPlugin = async (ctx) => {
           }
         }
       };
+      const mergedOptions = merged["options"];
+      delete mergedOptions["baseURL"];
       if (baseURL) {
         try {
-          const built = await refreshModels(client, baseURL, apiKey);
-          merged["models"] = { ...built, ...existingModels ?? {} };
+          const built = await refreshModels(client, baseURL, log, apiKey);
+          merged["models"] = mergeModelMaps(built, existingModels);
           log.info(`Loaded ${Object.keys(built).length} plexus models from ${baseURL}`);
         } catch (e) {
           log.warn(`Live model refresh failed, using cache: ${String(e)}`);
           const cached = await readCachedModels(client);
           if (cached) {
-            merged["models"] = { ...cached, ...existingModels ?? {} };
+            merged["models"] = mergeModelMaps(cached, existingModels);
           }
         }
       } else {
         log.info("Plexus baseURL not configured; skipping live refresh");
       }
+      try {
+        const mergedModels = merged["models"];
+        for (const id of ["gemini-3.5-flash", "claude-haiku-4-5", "small-fast"]) {
+          const m = mergedModels?.[id];
+          if (!m)
+            continue;
+          log.info(`Merged model ${id}: provider.npm=${m.provider?.npm ?? "(unset)"} provider.api=${m.provider?.api ?? "(unset)"}`);
+        }
+      } catch {}
       cfg.provider[PLEXUS_PROVIDER_ID] = merged;
     },
     auth: {
@@ -324,8 +433,8 @@ var PlexusProviderPlugin = async (ctx) => {
         const auth = await getAuth();
         const { baseURL, apiKey } = resolveConfig(providerInfo);
         const key = (auth?.type === "api" ? auth.key : undefined) ?? apiKey;
+        log.info(`Auth loader resolved plexus config: baseURL=${baseURL ?? "(missing)"} apiKey=${key ? "present" : "missing"}`);
         return {
-          ...baseURL ? { baseURL: apiBase(baseURL) } : {},
           ...key ? { apiKey: key } : {}
         };
       },
@@ -383,6 +492,7 @@ export {
   PLEXUS_PROVIDER_ID,
   PLEXUS_PLUGIN_ID,
   PLEXUS_LOG_SERVICE,
+  PLEXUS_BASE_URL_OPTION,
   PLACEHOLDER_MODEL_ID,
   OPENAI_COMPATIBLE_NPM,
   MODELS_FETCH_TIMEOUT_MS,

package/package.json

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