@mcowger/opencode-plexus 0.8.3 → 1.0.0

package/README.md

@@ -88,10 +88,10 @@ Then reference the built artifact in `opencode.json`:
 
 ### pi
 
-Run inside pi:
+Run inside pi using the native login flow:
 
 ```
-/plexus login
+/login plexus
 ```
 
 You will be prompted for:
@@ -106,6 +106,8 @@ To force a model refresh:
 /plexus refresh
 ```
 
+Use `/login plexus` for setup and `/logout plexus` to remove stored credentials.
+
 ### OpenCode
 
 Run inside OpenCode:
@@ -114,14 +116,19 @@ Run inside OpenCode:
 /connect
 ```
 
-Select **Plexus** and enter your base URL and API key. Models are loaded immediately and cached for fast startup on subsequent sessions.
+Select **Plexus** and enter your base URL and API key. Models are discovered through OpenCode's provider hook and cached for fast startup on subsequent sessions.
 
-For OpenCode, enter the Plexus API base URL including the trailing `/v1`, for example:
+You may enter either the Plexus root URL or the `/v1` API base URL:
 
 ```text
+https://plexus.example.com
 https://plexus.example.com/v1
 ```
 
+The plugins normalize either form to the Plexus root URL for storage and derive `/v1` paths when calling the API.
+
+OpenCode stores the API key in its native auth store and stores the Plexus base URL as auth metadata on that connection. Existing `provider.plexus.options.plexusBaseURL` config is still honored as a fallback.
+
 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
@@ -132,10 +139,12 @@ The OpenCode plugin respects each model's `preferred_api` value and routes model
 You can also pre-configure via environment variables:
 
 ```sh
-export PLEXUS_BASE_URL=https://plexus.example.com/v1
+export PLEXUS_API_URL=https://plexus.example.com
 export PLEXUS_API_KEY=your-api-key
 ```
 
+`PLEXUS_BASE_URL` is also accepted for compatibility; `PLEXUS_API_URL` wins when both are set.
+
 ---
 
 ## Configuration files
@@ -150,7 +159,7 @@ export PLEXUS_API_KEY=your-api-key
   plexus.log                   # extension activity log
 ```
 
-The API key is stored in pi's own credential store (`auth.json`) — never in a separate file.
+The API key is stored through pi's own auth storage. `PLEXUS_API_URL` or `PLEXUS_BASE_URL` can be used as an environment override.
 
 ### OpenCode
 
@@ -160,7 +169,9 @@ The API key is stored in pi's own credential store (`auth.json`) — never in a
   models-raw.json              # raw API response (diagnostics)
 ```
 
-The API key is stored in OpenCode's own credential store — never in a separate file.
+The API key is stored through OpenCode's auth flow, and the Plexus base URL is stored as auth metadata. `PLEXUS_API_URL`, `PLEXUS_BASE_URL`, and `PLEXUS_API_KEY` can be used as environment overrides.
+
+Both adapters also accept pi-style environment interpolation in configured strings, such as `${PLEXUS_API_URL}` or `$PLEXUS_API_KEY`. This is useful when checking non-secret config into an agent config file while keeping the actual values in the environment.
 
 ---
 
@@ -183,7 +194,7 @@ packages/
     package.json        # declares pi.extensions entry point
   plexus-opencode/      # OpenCode plugin adapter
     src/
-      plugin.ts         # Plugin export: config hook, auth handler
+      plugin.ts         # Plugin export: config hook, provider hook, auth handler
       mapper.ts         # PlexusApiModel → OpenCode ConfigModel
       cache.ts          # model cache I/O
       config-store.ts   # resolveConfig, persistToGlobalConfig
@@ -196,6 +207,30 @@ packages/
 
 `plexus-models` has zero imports from any agent framework. Each host adapter imports it via a relative path.
 
+## Plexus model metadata
+
+The `/v1/models` endpoint returns an OpenRouter-style list. These fields drive host behavior:
+
+| Field | Effect |
+|---|---|
+| `preferred_api` | String or array. First recognized value selects the host API dialect. |
+| `supported_parameters` | `reasoning`, `include_reasoning`, or `reasoning_effort` enables reasoning support. |
+| `architecture.input_modalities` | Enables text/image/audio/video/pdf support where the host supports it. |
+| `architecture.output_modalities` | Non-text-only output models are filtered from OpenCode chat providers. |
+| `pricing` | Converted into host per-million-token cost metadata. Plexus returns per-token prices. |
+| `pricing.tiers` | Alternate rates above `input_tokens_above`; mapped to native pi and OpenCode context pricing tiers. |
+| `top_provider` | Supplies context and output token limits when present. |
+| `pi_provider` / `pi_model` | Lets the pi adapter reuse built-in pi compat, headers, and thinking-level metadata. |
+| `pi_options` | pi compat overrides. These win over heuristic and built-in metadata. |
+
+Models with a falsy `id` are skipped. Missing metadata falls back to safe defaults.
+
+## Adapter behavior
+
+- **pi** refreshes on session start and through `/plexus refresh`. It accepts either root URLs or URLs ending in `/v1` and normalizes them before calling Plexus.
+- **OpenCode** seeds the provider from cache or a placeholder model during config loading, then performs live discovery through the `provider.models` hook. If Plexus is slow or unavailable, OpenCode uses the cache and lets the refresh continue in the background.
+- Both adapters convert Plexus's per-token base and tier rates to the per-million-token units expected by their host.
+
 ## Development
 
 After cloning, install dependencies to set up the pre-commit hook:

package/dist/index.js

@@ -7,6 +7,7 @@ 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_URL = "PLEXUS_API_URL";
 var ENV_API_KEY = "PLEXUS_API_KEY";
 var MODELS_FETCH_TIMEOUT_MS = 1e4;
 var REFRESH_TTL_MS = 60000;
@@ -52,11 +53,11 @@ async function fetchPlexusModels(apiKey, modelsUrl, timeoutMs = DEFAULT_MODELS_F
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
+    const headers = { Accept: "application/json" };
+    if (apiKey)
+      headers.Authorization = `Bearer ${apiKey}`;
     const res = await fetch(modelsUrl, {
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        Accept: "application/json"
-      },
+      headers,
       signal: controller.signal
     });
     if (!res.ok) {
@@ -74,35 +75,21 @@ async function fetchPlexusModels(apiKey, modelsUrl, timeoutMs = DEFAULT_MODELS_F
   }
 }
 // src/cache.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { join } from "path";
 var PLUGIN_SUBDIR = join("plugins", "plexus");
 var CACHE_FILE = "models-cache.json";
 var RAW_FILE = "models-raw.json";
-var resolvedDir = null;
 function fallbackDir() {
   return join(homedir(), ".local", "share", "opencode", PLUGIN_SUBDIR);
 }
-async function getDir(client) {
-  if (resolvedDir)
-    return resolvedDir;
-  try {
-    const res = await client.path.get();
-    const data = res?.data;
-    const state = typeof data?.state === "string" && data.state ? data.state : undefined;
-    if (state) {
-      resolvedDir = join(state, PLUGIN_SUBDIR);
-      return resolvedDir;
-    }
-  } catch {}
-  resolvedDir = fallbackDir();
-  return resolvedDir;
+function getDir() {
+  return fallbackDir();
 }
-async function readCachedModels(client) {
+async function readCachedModels(_client) {
   try {
-    const dir = await getDir(client);
+    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)) {
@@ -113,9 +100,9 @@ async function readCachedModels(client) {
     return null;
   }
 }
-async function writeCache(client, models, raw) {
+async function writeCache(_client, models, raw) {
   try {
-    const dir = await getDir(client);
+    const dir = getDir();
     await mkdir(dir, { recursive: true });
     const cache = { models, timestamp: Date.now() };
     await writeFile(join(dir, CACHE_FILE), JSON.stringify(cache, null, 2) + `
@@ -124,27 +111,24 @@ async function writeCache(client, models, raw) {
       await writeFile(join(dir, RAW_FILE), JSON.stringify(raw, null, 2) + `
 `, "utf8");
     }
-    try {
-      const syncDir = fallbackDir();
-      mkdirSync(syncDir, { recursive: true });
-      writeFileSync(join(syncDir, CACHE_FILE), JSON.stringify(cache, null, 2) + `
-`, "utf8");
-    } catch {}
   } catch {}
 }
 
-// src/config-store.ts
-import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
-
 // src/url.ts
 function trimURL(s) {
   return s.trim().replace(/\/+$/, "");
 }
+function rootURL(s) {
+  const next = trimURL(s);
+  if (!next)
+    return "";
+  return next.endsWith("/v1") ? next.slice(0, -3) : next;
+}
 function apiBase(baseURL) {
-  const next = trimURL(baseURL);
+  const next = rootURL(baseURL);
   if (!next)
     return "";
-  return next.endsWith("/v1") ? next : `${next}/v1`;
+  return `${next}/v1`;
 }
 function modelsUrl(baseURL) {
   const base = apiBase(baseURL);
@@ -152,40 +136,76 @@ function modelsUrl(baseURL) {
 }
 
 // src/config-store.ts
-function getV1ClientConfig(input) {
-  return input._client?.getConfig?.() ?? {};
+var ENV_VAR_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var ENV_VAR_NAME_PREFIX_RE = /^[A-Za-z_][A-Za-z0-9_]*/;
+var AUTH_METADATA_BASE_URL = "plexusBaseURL";
+function resolveConfigTemplate(value) {
+  let result = "";
+  let index = 0;
+  while (index < value.length) {
+    const dollarIndex = value.indexOf("$", index);
+    if (dollarIndex < 0) {
+      result += value.slice(index);
+      break;
+    }
+    result += value.slice(index, dollarIndex);
+    const nextChar = value[dollarIndex + 1];
+    if (nextChar === "$" || nextChar === "!") {
+      result += nextChar;
+      index = dollarIndex + 2;
+      continue;
+    }
+    if (nextChar === "{") {
+      const endIndex = value.indexOf("}", dollarIndex + 2);
+      if (endIndex < 0) {
+        result += "$";
+        index = dollarIndex + 1;
+        continue;
+      }
+      const name = value.slice(dollarIndex + 2, endIndex);
+      if (!ENV_VAR_NAME_RE.test(name)) {
+        result += value.slice(dollarIndex, endIndex + 1);
+        index = endIndex + 1;
+        continue;
+      }
+      const envValue = process.env[name];
+      if (envValue === undefined)
+        return;
+      result += envValue;
+      index = endIndex + 1;
+      continue;
+    }
+    const match = value.slice(dollarIndex + 1).match(ENV_VAR_NAME_PREFIX_RE);
+    if (match) {
+      const envValue = process.env[match[0]];
+      if (envValue === undefined)
+        return;
+      result += envValue;
+      index = dollarIndex + 1 + match[0].length;
+      continue;
+    }
+    result += "$";
+    index = dollarIndex + 1;
+  }
+  return result;
 }
-function createV2Client(serverUrl, input) {
-  const v1Config = getV1ClientConfig(input);
-  return createOpencodeClient({
-    baseUrl: serverUrl.toString(),
-    fetch: v1Config.fetch,
-    headers: v1Config.headers,
-    throwOnError: true
-  });
+function resolveStringOption(value) {
+  if (typeof value !== "string")
+    return;
+  const resolved = resolveConfigTemplate(value)?.trim();
+  return resolved || undefined;
 }
-function resolveConfig(provider) {
-  const envBaseURL = process.env[ENV_BASE_URL];
+function resolveConfig(provider, authMetadata) {
+  const envBaseURL = process.env[ENV_API_URL] ?? process.env[ENV_BASE_URL];
   const envApiKey = process.env[ENV_API_KEY];
-  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 || legacyBaseURL || undefined;
+  const authBaseURL = resolveStringOption(authMetadata?.[AUTH_METADATA_BASE_URL]);
+  const optBaseURL = resolveStringOption(provider?.options?.[PLEXUS_BASE_URL_OPTION]);
+  const legacyBaseURL = resolveStringOption(provider?.options?.baseURL);
+  const optApiKey = resolveStringOption(provider?.options?.apiKey);
+  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 };
 }
-async function persistToGlobalConfig(serverUrl, client, baseURL, apiKey) {
-  const v2 = createV2Client(serverUrl, client);
-  await v2.global.config.update({
-    config: {
-      provider: {
-        [PLEXUS_PROVIDER_ID]: {
-          options: { [PLEXUS_BASE_URL_OPTION]: baseURL, apiKey }
-        }
-      }
-    }
-  });
-}
 
 // src/log.ts
 function createLogger(client) {
@@ -202,6 +222,7 @@ function createLogger(client) {
 // src/mapper.ts
 var REASONING_PARAMS2 = new Set(["reasoning", "include_reasoning", "reasoning_effort"]);
 var DEFAULT_CONTEXT = 8192;
+var PER_TOKEN_TO_PER_MILLION = 1e6;
 function resolveModelProvider(model, baseURL) {
   const preferredApi = mapPreferredApi(model.preferred_api);
   const api = adjustBaseUrl(baseURL, preferredApi);
@@ -222,7 +243,24 @@ function parsePrice(value) {
   if (!value)
     return 0;
   const n = parseFloat(value);
-  return Number.isNaN(n) ? 0 : n;
+  return Number.isFinite(n) && n >= 0 ? n * PER_TOKEN_TO_PER_MILLION : 0;
+}
+function buildPricingTiers(model) {
+  const pricing = model.pricing;
+  if (!pricing?.tiers)
+    return;
+  const tiers = pricing.tiers.flatMap((tier) => {
+    if (!Number.isFinite(tier.input_tokens_above) || tier.input_tokens_above < 0)
+      return [];
+    return [{
+      inputTokensAbove: tier.input_tokens_above,
+      input: parsePrice(tier.prompt ?? pricing.prompt),
+      output: parsePrice(tier.completion ?? pricing.completion),
+      cacheRead: parsePrice(tier.input_cache_read ?? pricing.input_cache_read),
+      cacheWrite: parsePrice(tier.input_cache_write ?? pricing.input_cache_write)
+    }];
+  });
+  return tiers.length > 0 ? tiers : undefined;
 }
 function mapModality(m) {
   switch (m) {
@@ -276,6 +314,7 @@ function buildModels(models, baseURL) {
     const cacheReadPrice = parsePrice(m.pricing?.input_cache_read);
     const cacheWritePrice = parsePrice(m.pricing?.input_cache_write);
     const hasCachePricing = cacheReadPrice > 0 || cacheWritePrice > 0;
+    const pricingTiers = buildPricingTiers(m);
     const hasNonTextInput = inputModalities.some((mod) => mod !== "text");
     const provider = resolveModelProvider(m, baseURL);
     const entry = {
@@ -300,7 +339,8 @@ function buildModels(models, baseURL) {
       ...params.includes("tools") ? { tool_call: true } : {},
       ...params.some((p) => REASONING_PARAMS2.has(p)) ? { reasoning: true } : {},
       ...params.includes("temperature") ? { temperature: true } : {},
-      ...hasNonTextInput ? { attachment: true } : {}
+      ...hasNonTextInput ? { attachment: true } : {},
+      ...pricingTiers ? { pricingTiers } : {}
     };
     result[m.id] = entry;
   }
@@ -310,6 +350,80 @@ function buildModels(models, baseURL) {
 // src/plugin.ts
 var lastRefresh = null;
 var inFlightRefresh = null;
+function toRuntimeCapabilities(model) {
+  const input = new Set(model.modalities.input);
+  const output = new Set(model.modalities.output);
+  return {
+    temperature: model.temperature ?? false,
+    reasoning: model.reasoning ?? false,
+    attachment: model.attachment ?? false,
+    toolcall: model.tool_call ?? false,
+    input: {
+      text: input.has("text"),
+      audio: input.has("audio"),
+      image: input.has("image"),
+      video: input.has("video"),
+      pdf: input.has("pdf")
+    },
+    output: {
+      text: output.has("text"),
+      audio: output.has("audio"),
+      image: output.has("image"),
+      video: output.has("video"),
+      pdf: output.has("pdf")
+    },
+    interleaved: false
+  };
+}
+function toRuntimeModels(models, provider) {
+  const result = {};
+  const providerNpm = typeof provider.options?.["npm"] === "string" ? provider.options["npm"] : OPENAI_COMPATIBLE_NPM;
+  const providerApi = typeof provider.options?.[PLEXUS_BASE_URL_OPTION] === "string" ? apiBase(provider.options[PLEXUS_BASE_URL_OPTION]) : "";
+  for (const [id, model] of Object.entries(models)) {
+    result[id] = {
+      id: model.id,
+      providerID: provider.id,
+      api: {
+        id: provider.id,
+        url: model.provider?.api ?? providerApi,
+        npm: model.provider?.npm ?? providerNpm
+      },
+      name: model.name,
+      capabilities: toRuntimeCapabilities(model),
+      cost: {
+        input: model.cost?.input ?? 0,
+        output: model.cost?.output ?? 0,
+        cache: {
+          read: model.cost?.cache_read ?? 0,
+          write: model.cost?.cache_write ?? 0
+        },
+        ...model.pricingTiers ? {
+          tiers: model.pricingTiers.map((tier) => ({
+            input: tier.input,
+            output: tier.output,
+            cache: { read: tier.cacheRead, write: tier.cacheWrite },
+            tier: { type: "context", size: tier.inputTokensAbove }
+          }))
+        } : {}
+      },
+      limit: model.limit,
+      status: "active",
+      options: {},
+      headers: {},
+      release_date: ""
+    };
+  }
+  return result;
+}
+function toConfigModels(models) {
+  return Object.fromEntries(Object.entries(models).map(([id, model]) => {
+    const { pricingTiers: _pricingTiers, ...configModel } = model;
+    return [id, configModel];
+  }));
+}
+function authMetadata(auth) {
+  return auth?.type === "api" ? auth.metadata : undefined;
+}
 function raceWithTimeout(promise, timeoutMs) {
   return new Promise((resolve) => {
     const timer = setTimeout(() => resolve({ status: "timed-out" }), timeoutMs);
@@ -322,41 +436,6 @@ function raceWithTimeout(promise, timeoutMs) {
     });
   });
 }
-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;
-}
 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)`);
@@ -409,7 +488,7 @@ var PlexusProviderPlugin = async (ctx) => {
           ...baseURL ? { [PLEXUS_BASE_URL_OPTION]: baseURL } : {},
           ...apiKey ? { apiKey } : {}
         },
-        models: existingModels ?? cachedAsync ?? {
+        models: existingModels ?? (cachedAsync ? toConfigModels(cachedAsync) : null) ?? {
           [PLACEHOLDER_MODEL_ID]: {
             id: PLACEHOLDER_MODEL_ID,
             name: "Plexus (run /connect to configure)",
@@ -421,25 +500,7 @@ var PlexusProviderPlugin = async (ctx) => {
       const mergedOptions = merged["options"];
       delete mergedOptions["baseURL"];
       if (baseURL) {
-        const refreshPromise = refreshModels(client, baseURL, log, apiKey);
-        const race = await raceWithTimeout(refreshPromise, CONFIG_HOOK_REFRESH_BUDGET_MS);
-        if (race.status === "resolved") {
-          merged["models"] = mergeModelMaps(race.value, existingModels);
-          log.info(`Loaded ${Object.keys(race.value).length} plexus models from ${baseURL}`);
-        } else if (race.status === "rejected") {
-          log.warn(`Live model refresh failed, using cache: ${String(race.error)}`);
-          if (cachedAsync) {
-            merged["models"] = mergeModelMaps(cachedAsync, existingModels);
-          }
-        } else {
-          log.info(`Live model refresh still pending after ${CONFIG_HOOK_REFRESH_BUDGET_MS}ms; using cache and continuing in background`);
-          if (cachedAsync) {
-            merged["models"] = mergeModelMaps(cachedAsync, existingModels);
-          }
-          refreshPromise.catch((e) => {
-            log.warn(`Background plexus model refresh failed: ${String(e)}`);
-          });
-        }
+        log.info("Plexus baseURL configured; live discovery delegated to provider.models hook");
       } else {
         log.info("Plexus baseURL not configured; skipping live refresh");
       }
@@ -454,11 +515,41 @@ var PlexusProviderPlugin = async (ctx) => {
       } catch {}
       cfg.provider[PLEXUS_PROVIDER_ID] = merged;
     },
+    provider: {
+      id: PLEXUS_PROVIDER_ID,
+      models: async (provider, hookCtx) => {
+        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 refreshPromise = refreshModels(client, baseURL, log, key);
+        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);
+        if (race.status === "rejected") {
+          log.warn(`Provider hook live refresh failed, using cache: ${String(race.error)}`);
+        } else {
+          log.info(`Provider hook refresh still pending after ${CONFIG_HOOK_REFRESH_BUDGET_MS}ms; using cache and continuing in background`);
+          refreshPromise.catch((e) => {
+            log.warn(`Background plexus model refresh failed: ${String(e)}`);
+          });
+        }
+        return cached ? toRuntimeModels(cached, provider) : {};
+      }
+    },
     auth: {
       provider: PLEXUS_PROVIDER_ID,
       async loader(getAuth, providerInfo) {
         const auth = await getAuth();
-        const { baseURL, apiKey } = resolveConfig(providerInfo);
+        const authMetadataValue = auth?.type === "api" ? auth.metadata : undefined;
+        const { baseURL, apiKey } = resolveConfig(providerInfo, authMetadataValue);
         const key = (auth?.type === "api" ? auth.key : undefined) ?? apiKey;
         log.info(`Auth loader resolved plexus config: baseURL=${baseURL ?? "(missing)"} apiKey=${key ? "present" : "missing"}`);
         return {
@@ -479,7 +570,7 @@ var PlexusProviderPlugin = async (ctx) => {
             }
           ],
           async authorize(inputs = {}) {
-            const baseURL = trimURL(inputs["baseURL"] ?? "");
+            const baseURL = rootURL(inputs["baseURL"] ?? "");
             const apiKey = (inputs["apiKey"] ?? "").trim();
             if (!baseURL || !apiKey)
               return { type: "failed" };
@@ -490,13 +581,13 @@ var PlexusProviderPlugin = async (ctx) => {
               log.error(`Plexus URL probe failed at ${baseURL}: ${String(e)}`);
               return { type: "failed" };
             }
-            try {
-              await persistToGlobalConfig(ctx.serverUrl, client, baseURL, apiKey);
-            } catch (e) {
-              log.error(`Failed to persist Plexus config: ${String(e)}`);
-            }
             lastRefresh = null;
-            return { type: "success", provider: PLEXUS_PROVIDER_ID, key: apiKey };
+            return {
+              type: "success",
+              provider: PLEXUS_PROVIDER_ID,
+              key: apiKey,
+              metadata: { [AUTH_METADATA_BASE_URL]: baseURL }
+            };
           }
         }
       ]
@@ -524,6 +615,7 @@ export {
   OPENAI_COMPATIBLE_NPM,
   MODELS_FETCH_TIMEOUT_MS,
   ENV_BASE_URL,
+  ENV_API_URL,
   ENV_API_KEY,
   CONFIG_HOOK_REFRESH_BUDGET_MS
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mcowger/opencode-plexus",
-	"version": "0.8.3",
+	"version": "1.0.0",
 	"description": "OpenCode plugin: Plexus provider with dynamic model discovery",
 	"type": "module",
 	"module": "./dist/index.js",
@@ -26,8 +26,8 @@
 		"build": "bun run build.ts"
 	},
 	"dependencies": {
-		"@opencode-ai/plugin": "^1.15.7",
-		"@opencode-ai/sdk": "^1.15.7"
+		"@opencode-ai/plugin": "^1.17.18",
+		"@opencode-ai/sdk": "^1.17.18"
 	},
 	"peerDependencies": {
 		"typescript": "^5"