@dan-ai-studio/dshopencodego 0.1.43 → 0.1.44

package/lib/index.js

@@ -42702,31 +42702,32 @@ function parseGoDocument(markdown) {
   }
   return { quotas, protocols };
 }
-async function fetchGoDocument(signal) {
-  const failures = [];
-  for (const url of GO_DOC_URLS) {
-    try {
-      const timeout = AbortSignal.timeout(METADATA_FETCH_TIMEOUT_MS);
-      const response = await fetch(url, {
-        redirect: "error",
-        headers: { ...attributionHeaders2(), accept: "text/plain", "cache-control": "no-cache" },
-        signal: signal === void 0 ? timeout : AbortSignal.any([signal, timeout])
+async function readSource(url, signal) {
+  const timeout = AbortSignal.timeout(METADATA_FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, {
+      redirect: "error",
+      headers: { ...attributionHeaders2(), accept: "text/plain", "cache-control": "no-cache" },
+      signal: signal === void 0 ? timeout : AbortSignal.any([signal, timeout])
+    });
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => {
       });
-      if (!response.ok) {
-        await response.body?.cancel().catch(() => {
-        });
-        failures.push(`${url} answered HTTP ${response.status}`);
-        continue;
-      }
-      const document = parseGoDocument(await readBoundedText(response, GO_DOC_MAX_BYTES));
-      if (document.quotas.size === 0) {
-        failures.push(`${url} carried no allowance table`);
-        continue;
-      }
-      return document;
-    } catch (error) {
-      failures.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
+      return { failure: `${url} answered HTTP ${response.status}` };
     }
+    const document = parseGoDocument(await readBoundedText(response, GO_DOC_MAX_BYTES));
+    if (document.quotas.size === 0) return { failure: `${url} carried no allowance table` };
+    return { document };
+  } catch (error) {
+    return { failure: `${url}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+async function fetchGoDocument(signal) {
+  const attempts = await Promise.all(GO_DOC_URLS.map((url) => readSource(url, signal)));
+  const failures = [];
+  for (const attempt of attempts) {
+    if ("document" in attempt) return attempt.document;
+    failures.push(attempt.failure);
   }
   throw new LlmError3(
     `could not read the Go documentation (${failures.join("; ")})`,
@@ -42996,12 +42997,19 @@ var OpencodeGoCatalog = class {
   constructor(options) {
     this.options = options;
   }
-  /** The cached snapshot, refreshed when it is older than the configured TTL. */
-  snapshot(force = false) {
+  /**
+   * The cached snapshot, refreshed when it is older than the configured TTL.
+   * @param force - revalidate every source, ignoring the cache.
+   * @param signal - caller cancellation, forwarded to the documentation read,
+   *   the slowest source and the only one a caller can cancel; a build already
+   *   in flight keeps the signal of the caller that started it, because one
+   *   shared snapshot cannot carry two different cancellations.
+   */
+  snapshot(force = false, signal) {
     if (!force && this.served !== void 0 && Date.now() - this.served.fetchedAtMs < this.options.refreshMs) {
       return Promise.resolve(this.served);
     }
-    this.pending ??= this.build().then((snapshot2) => {
+    this.pending ??= this.build(signal).then((snapshot2) => {
       this.served = snapshot2;
       return snapshot2;
     }).finally(() => {
@@ -43015,14 +43023,15 @@ var OpencodeGoCatalog = class {
    * A model this build has never seen forces one revalidation even inside the
    * TTL, because "unknown" and "newly added" look identical from here.
    * @param id - the requested model id.
+   * @param signal - caller cancellation, forwarded to a forced revalidation.
    * @returns the snapshot holding the model.
    * @throws {LlmError} `MODEL_METADATA_UNAVAILABLE` when the gateway advertises
    *   the id but this build cannot configure it, naming the reason.
    */
-  async forModel(id) {
+  async forModel(id, signal) {
     let snapshot2 = await this.snapshot();
     if (!snapshot2.facts.has(id) && !snapshot2.unavailable.has(id)) {
-      snapshot2 = await this.snapshot(true);
+      snapshot2 = await this.snapshot(true, signal);
     }
     const reason = snapshot2.unavailable.get(id);
     if (reason !== void 0) {
@@ -43033,14 +43042,17 @@ var OpencodeGoCatalog = class {
     }
     return snapshot2;
   }
-  /** Revalidate every source, reusing the metadata document when it is unchanged. */
-  async build() {
+  /**
+   * Revalidate every source, reusing the metadata document when it is unchanged.
+   * @param signal - caller cancellation, forwarded to the documentation read.
+   */
+  async build(signal) {
     const builtin = builtinModels(this.options.baseURL);
     const readDocument = this.options.readDocument ?? fetchGoDocument;
     const [listing, metadata, documentation] = await Promise.allSettled([
       fetchModelIds(this.options.baseURL),
       this.refreshMetadata(builtin),
-      readDocument()
+      readDocument(signal)
     ]);
     if (metadata.status === "rejected") {
       this.options.observers?.onFallback?.({
@@ -43206,8 +43218,8 @@ function inferFamily(id) {
   const lower = id.toLowerCase();
   return ["grok", "gpt", "muse"].some((family) => lower.startsWith(family)) ? "openai-responses" : "openai-completions";
 }
-async function discoverCatalogModels(catalog) {
-  const snapshot2 = await catalog.snapshot(true);
+async function discoverCatalogModels(catalog, signal) {
+  const snapshot2 = await catalog.snapshot(true, signal);
   if (!snapshot2.live) {
     const detail = snapshot2.listingFailure instanceof LlmError4 ? snapshot2.listingFailure.message : "the live model listing is unreachable";
     throw new LlmError4(`dshopencodego: ${detail}; refresh the model list to retry`, "DISCOVERY_FAILED", {
@@ -44129,6 +44141,7 @@ function readConfig(config) {
     return field?.get === void 0 ? [] : [[key, field.get()]];
   }));
 }
+var PLAIN_HTTP_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
 function assertBaseURL(raw) {
   let url;
   try {
@@ -44139,6 +44152,11 @@ function assertBaseURL(raw) {
   if (url.protocol !== "https:" && url.protocol !== "http:") {
     throw new Error(`dshopencodego: baseURL "${raw}" must be http or https`);
   }
+  if (url.protocol === "http:" && !PLAIN_HTTP_HOSTS.has(url.hostname)) {
+    throw new Error(
+      `dshopencodego: baseURL "${raw}" must use https outside localhost \u2014 a plain-http endpoint would send the API key in clear text`
+    );
+  }
   if (url.search.length > 0 || url.hash.length > 0) {
     throw new Error(`dshopencodego: baseURL "${raw}" must not carry a query or fragment`);
   }
@@ -44153,6 +44171,10 @@ import { requestImageDimensions } from "@deepseek-ai/dsh-attachment";
 
 // src/conversion/replay.ts
 import { LlmError as LlmError5 } from "@deepseek-ai/dsh-llm";
+var REPLAYABLE_STOP_REASONS = ["stop", "length", "toolUse", "error", "aborted"];
+function replayableStopReason(stopReason) {
+  return REPLAYABLE_STOP_REASONS.includes(stopReason) ? stopReason : "error";
+}
 function parseArguments(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -44184,7 +44206,7 @@ function toPiReplayState(message, requestedModel = message.model) {
     ...responseModel === void 0 ? {} : { responseModel },
     ...message.responseId === void 0 ? {} : { responseId: message.responseId },
     ...message.providerThinkingLevel === void 0 ? {} : { providerThinkingLevel: message.providerThinkingLevel },
-    stopReason: message.stopReason
+    stopReason: replayableStopReason(message.stopReason)
   };
   return {
     response,
@@ -44226,7 +44248,7 @@ function readReplayState(value) {
   for (const key of ["api", "provider", "model"]) {
     if (typeof response[key] !== "string" || response[key].length === 0) return invalidReplay(`${key} must be a non-empty string`);
   }
-  if (!["stop", "length", "toolUse", "error", "aborted"].includes(String(response["stopReason"]))) {
+  if (!REPLAYABLE_STOP_REASONS.includes(String(response["stopReason"]))) {
     return invalidReplay("unknown stopReason");
   }
   for (const key of ["responseModel", "responseId", "providerThinkingLevel"]) {
@@ -44804,6 +44826,10 @@ function isModelEnabled(model, visibility) {
   if (typeof explicit === "boolean") return explicit;
   return typeof model.recommended === "boolean" ? model.recommended : model.deprecated !== true;
 }
+function unadvertisedVisibilityIds(visibility, advertised) {
+  const known = new Set(advertised);
+  return Object.keys(visibility).filter((id) => !known.has(id)).sort();
+}
 function validReleaseDate2(value) {
   return typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
 }
@@ -44834,6 +44860,85 @@ function providerHeaders(sessionId) {
   };
 }
 
+// src/usage/meter.ts
+function usableRates(cost) {
+  if (cost === void 0) return void 0;
+  if (!(cost.input > 0) && !(cost.output > 0)) return void 0;
+  return {
+    input: cost.input,
+    output: cost.output,
+    ...cost.cacheRead > 0 ? { cacheRead: cost.cacheRead } : {},
+    ...cost.cacheWrite > 0 ? { cacheWrite: cost.cacheWrite } : {}
+  };
+}
+var EMPTY3 = {
+  calls: 0,
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0,
+  cacheWriteTokens: 0,
+  totalTokens: 0
+};
+function spendOf(usage, rates2) {
+  const fallback = rates2.input > 0 ? rates2.input : rates2.output;
+  const cacheRead = usage.cacheReadTokens ?? 0;
+  const cacheWrite = usage.cacheWriteTokens ?? 0;
+  return (usage.inputTokens * rates2.input + usage.outputTokens * rates2.output + cacheRead * (rates2.cacheRead ?? fallback) + cacheWrite * (rates2.cacheWrite ?? fallback)) / 1e6;
+}
+function add(totals, usage) {
+  const inputTokens = totals.inputTokens + usage.inputTokens;
+  const outputTokens = totals.outputTokens + usage.outputTokens;
+  const cacheReadTokens = totals.cacheReadTokens + (usage.cacheReadTokens ?? 0);
+  const cacheWriteTokens = totals.cacheWriteTokens + (usage.cacheWriteTokens ?? 0);
+  const totalTokens = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+  const reasoningTokens = (totals.reasoningTokens ?? 0) + (usage.reasoningTokens ?? 0);
+  const rates2 = usage.rates;
+  const billedTokens = usage.inputTokens + usage.outputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+  const unpricedTokens = (totals.unpricedTokens ?? 0) + (rates2 === void 0 ? billedTokens : 0);
+  const estimatedUSD = rates2 === void 0 ? totals.estimatedUSD : (totals.estimatedUSD ?? 0) + spendOf(usage, rates2);
+  return {
+    calls: totals.calls + 1,
+    inputTokens,
+    outputTokens,
+    cacheReadTokens,
+    cacheWriteTokens,
+    // The four counts are disjoint (uncached input, cached input, output), so
+    // their sum is the billed total. The provider's own `totalTokens` is not
+    // used: it is optional, and mixing the two would double-count a cache read.
+    totalTokens,
+    ...reasoningTokens > 0 ? { reasoningTokens } : {},
+    ...estimatedUSD === void 0 ? {} : { estimatedUSD },
+    // Only meaningful next to an estimate: a reading with no priced call at all
+    // says so by omitting `estimatedUSD`, and naming every token as "unpriced"
+    // there would just restate the total.
+    ...estimatedUSD === void 0 || unpricedTokens === 0 ? {} : { unpricedTokens }
+  };
+}
+var UsageMeter = class {
+  sinceMs = Date.now();
+  totals = EMPTY3;
+  byModel = /* @__PURE__ */ new Map();
+  /**
+   * Record one completed call.
+   * @param model - the model id the call was made with.
+   * @param usage - the provider's own usage for that call, with the rates that
+   *   were published for the model at the time it ran.
+   */
+  record(model, usage) {
+    this.totals = add(this.totals, usage);
+    this.byModel.set(model, add(this.byModel.get(model) ?? EMPTY3, usage));
+  }
+  /** The current reading, busiest model first. */
+  snapshot(now = Date.now()) {
+    return {
+      sinceMs: this.sinceMs,
+      atMs: now,
+      totals: this.totals,
+      models: [...this.byModel.entries()].map(([model, totals]) => ({ model, ...totals })).sort((left, right) => right.totalTokens - left.totalTokens || left.model.localeCompare(right.model))
+    };
+  }
+};
+
 // src/adapter.ts
 var DISABLES_THINKING_WHEN_UNSET = /* @__PURE__ */ new Set(["deepseek", "zai", "qwen", "qwen-chat-template"]);
 function withModelLimit(model, limits) {
@@ -44853,6 +44958,13 @@ function stopSequencesFor(model, stop) {
     "UNSUPPORTED_OPTION"
   );
 }
+async function* observingTerminalUsage(events, observe) {
+  for await (const event of events) {
+    if (event.type === "done") observe(event.message.usage);
+    else if (event.type === "error") observe(event.error.usage);
+    yield event;
+  }
+}
 var OpencodeGoAdapter = class extends LlmAdapter {
   cache;
   options;
@@ -44888,6 +45000,28 @@ var OpencodeGoAdapter = class extends LlmAdapter {
   providerInfo(provider) {
     return { id: provider, name: DISPLAY_NAME };
   }
+  /**
+   * This route declares no request-image pricing, and that is a decision
+   * rather than an omission.
+   *
+   * `priceImages` must answer with the visual tokens the wire actually carries
+   * for every image occurrence, and nothing available to this plugin can
+   * answer that. The route fronts several model families behind three
+   * protocols whose vision accounting differs and is not published by the
+   * gateway; the catalog carries text rates only (`ModelCost` is input,
+   * output, cache read and cache write) and states no vision rule; and the one
+   * implementation shipped upstream anchors on a single provider's own
+   * published accounting (`dsh-llm-deepseek`). An invented number would not
+   * fail loudly: the token meter sums these values into its surface estimate
+   * and the retention policy spends real budget against them, so a wrong
+   * answer is worse than the contract's own default — declaring none, which
+   * leaves every consumer on its neutral estimate. Revisit this once the
+   * gateway's per-family visual accounting is known and checked against the
+   * usage it reports.
+   */
+  imageRequestPricing(_provider, _model) {
+    return void 0;
+  }
   async listModels(_provider) {
     const config = this.options.config();
     const snapshot2 = await this.catalogOf(config).snapshot();
@@ -44977,6 +45111,7 @@ var OpencodeGoAdapter = class extends LlmAdapter {
       const facts = snapshot2.facts.get(options.model);
       if (facts === void 0) throw new LlmError8(`opencode-go has no model "${options.model}"`, "UNKNOWN_MODEL");
       const model = withModelLimit(toPiModel(facts, config.baseURL), config.modelLimits);
+      const rates2 = usableRates(facts.cost);
       const stop = stopSequencesFor(model, options.stop);
       const ceiling = config.modelLimits[model.id]?.maxTokens;
       const maxTokens = options.maxTokens === void 0 || ceiling === null || ceiling === void 0 ? options.maxTokens : Math.min(options.maxTokens, ceiling);
@@ -44988,6 +45123,7 @@ var OpencodeGoAdapter = class extends LlmAdapter {
       const consumer = new AbortController();
       const upstream = options.signal === void 0 ? consumer.signal : AbortSignal.any([options.signal, consumer.signal]);
       const watchdog = __using(_stack, idleWatchdog(upstream, config.streamIdleTimeoutMs, "LLM_STREAM_IDLE_TIMEOUT"));
+      let timedOut = false;
       try {
         const containsImage = options.messages.some((message) => contentHasImage2(message.content));
         if (containsImage && !model.input.includes("image")) {
@@ -45008,7 +45144,8 @@ var OpencodeGoAdapter = class extends LlmAdapter {
           };
         }
         const context = imageRequest === void 0 ? await toPiContext(options, void 0, this.options.onReplayDegrade) : await toPiContext({ ...options, signal: watchdog.signal }, imageRequest, this.options.onReplayDegrade);
-        const events = snapshot2.provider.streamSimple(model, normalizeContext(context), {
+        let reportedReasoning;
+        const events = observingTerminalUsage(snapshot2.provider.streamSimple(model, normalizeContext(context), {
           apiKey,
           ...reasoning === void 0 || reasoning === "off" ? {} : { reasoning },
           ...options.temperature === void 0 ? {} : { temperature: options.temperature },
@@ -45025,6 +45162,8 @@ var OpencodeGoAdapter = class extends LlmAdapter {
           // The agent recovery layer owns visible attempts; one adapter call is
           // one SDK attempt.
           maxRetries: 0
+        }), (usage) => {
+          reportedReasoning = usage.reasoning;
         });
         const iterator = toStreamChunks(events, model.contextWindow, options.signal, model.id)[Symbol.asyncIterator]();
         let exhausted = false;
@@ -45039,21 +45178,32 @@ var OpencodeGoAdapter = class extends LlmAdapter {
               return;
             }
             if (result.value.type === "usage") {
-              this.options.onUsage?.({ model: options.model, usage: result.value.usage });
+              this.options.onUsage?.({
+                model: options.model,
+                usage: {
+                  ...result.value.usage,
+                  // pi-ai reports this as part of `output`, and `mapUsage` drops
+                  // it; the meter records it without adding it to a total.
+                  ...reportedReasoning === void 0 || reportedReasoning <= 0 ? {} : { reasoningTokens: reportedReasoning },
+                  ...rates2 === void 0 ? {} : { rates: rates2 }
+                }
+              });
             }
             yield result.value;
           }
         } finally {
           if (!exhausted) {
+            timedOut = timeoutOf(watchdog.signal, "LLM_STREAM_IDLE_TIMEOUT") !== void 0;
             consumer.abort("opencode-go stream consumer stopped");
             try {
-              await iterator.return(void 0);
+              void Promise.resolve(iterator.return(void 0)).catch(() => {
+              });
             } catch (_abortedSdkTeardown) {
             }
           }
         }
       } catch (error) {
-        if (timeoutOf(watchdog.signal, "LLM_STREAM_IDLE_TIMEOUT") !== void 0) {
+        if (timedOut || timeoutOf(watchdog.signal, "LLM_STREAM_IDLE_TIMEOUT") !== void 0) {
           throw new LlmError8("opencode-go stream idle timeout", "TIMEOUT", { cause: error });
         }
         if (options.signal?.aborted) {
@@ -45266,13 +45416,20 @@ function parseTotals(value) {
     if (typeof entry !== "number" || !Number.isFinite(entry) || entry < 0) throw new Error(`invalid meter field "${key}"`);
     return entry;
   };
+  const optionalCount = (key) => row[key] === void 0 ? void 0 : count(key);
+  const reasoningTokens = optionalCount("reasoningTokens");
+  const estimatedUSD = optionalCount("estimatedUSD");
+  const unpricedTokens = optionalCount("unpricedTokens");
   return {
     calls: count("calls"),
     inputTokens: count("inputTokens"),
     outputTokens: count("outputTokens"),
     cacheReadTokens: count("cacheReadTokens"),
     cacheWriteTokens: count("cacheWriteTokens"),
-    totalTokens: count("totalTokens")
+    totalTokens: count("totalTokens"),
+    ...reasoningTokens === void 0 ? {} : { reasoningTokens },
+    ...estimatedUSD === void 0 ? {} : { estimatedUSD },
+    ...unpricedTokens === void 0 ? {} : { unpricedTokens }
   };
 }
 function parseGoMeter(value) {
@@ -45397,6 +45554,8 @@ function catalogReading(snapshot2, visibility, listingFailure, now) {
 // src/catalog/service.ts
 var OpencodeGoCatalogService = class extends TypertRemoteService {
   options;
+  /** The last reported set of unadvertised switches, as a comparable fact. */
+  reportedUnadvertised;
   constructor(ctx, options) {
     super(ctx, "opencodeGoCatalog");
     this.options = options;
@@ -45411,15 +45570,49 @@ var OpencodeGoCatalogService = class extends TypertRemoteService {
   }
   async project(force) {
     const catalog = this.options.catalog();
-    const snapshot2 = await catalog.snapshot(force);
-    const failure = snapshot2.listingFailure;
-    return catalogReading(
-      snapshot2,
-      this.options.visibility(),
-      failure === void 0 ? void 0 : failure instanceof LlmError9 || failure instanceof Error ? failure.message : String(failure)
-    );
+    try {
+      const snapshot2 = await catalog.snapshot(force);
+      const failure = snapshot2.listingFailure;
+      const visibility = this.options.visibility();
+      const reading = catalogReading(
+        snapshot2,
+        visibility,
+        failure === void 0 ? void 0 : failure instanceof LlmError9 || failure instanceof Error ? failure.message : String(failure)
+      );
+      this.reportUnadvertised(snapshot2, visibility);
+      return reading;
+    } catch (error) {
+      throw catalogFailure(error);
+    }
+  }
+  /**
+   * Report switches for ids the gateway never advertised.
+   *
+   * `modelVisibility` is per-id configuration, and an entry naming a model the
+   * gateway does not serve has no effect anywhere — the picker cannot show a
+   * model that is not in the listing, so without this the switch is silent.
+   * (The reverse case, advertised but unbuildable, is `onUnconfigured`.)
+   *
+   * Only a live listing is evidence of absence: a retained snapshot after an
+   * outage would accuse models that merely could not be re-read. The set is
+   * compared as a fact, so re-reading the page does not repeat the warning.
+   * @param snapshot - the snapshot the reading was projected from.
+   * @param visibility - the switches in force for this read.
+   */
+  reportUnadvertised(snapshot2, visibility) {
+    const missing = snapshot2.live && visibility !== void 0 ? unadvertisedVisibilityIds(visibility, [...snapshot2.facts.keys(), ...snapshot2.unavailable.keys()]) : [];
+    const facts = JSON.stringify(missing);
+    if (facts === this.reportedUnadvertised) return;
+    this.reportedUnadvertised = facts;
+    if (missing.length > 0) this.options.onUnadvertised?.(missing);
   }
 };
+function catalogFailure(error) {
+  return new RemoteError("dshopencodego/catalog-unavailable", error instanceof Error ? error.message : "The OpenCode Go catalog is unavailable", {
+    retryable: true,
+    retainPrevious: true
+  }, { cause: error });
+}
 
 // src/update/check.ts
 var PACKAGE_NAME = "@dan-ai-studio/dshopencodego";
@@ -45435,6 +45628,14 @@ function parseVersion(value) {
     prerelease: prerelease === void 0 ? void 0 : prerelease.split(".")
   };
 }
+function comparePrereleaseIdentifier(left, right) {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : void 0;
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : void 0;
+  if (leftNumber !== void 0 && rightNumber !== void 0) return leftNumber - rightNumber;
+  if (leftNumber !== void 0) return -1;
+  if (rightNumber !== void 0) return 1;
+  return left < right ? -1 : left > right ? 1 : 0;
+}
 function compareVersions(left, right) {
   const ours = parseVersion(left);
   const theirs = parseVersion(right);
@@ -45452,7 +45653,8 @@ function compareVersions(left, right) {
     const theirsPart = theirs.prerelease[index];
     if (oursPart === void 0) return -1;
     if (theirsPart === void 0) return 1;
-    if (oursPart !== theirsPart) return oursPart < theirsPart ? -1 : 1;
+    const difference = comparePrereleaseIdentifier(oursPart, theirsPart);
+    if (difference !== 0) return difference;
   }
   return 0;
 }
@@ -45505,7 +45707,7 @@ function createUpdateChecker(deps) {
 }
 
 // src/update/version.ts
-var PLUGIN_VERSION = true ? "0.1.43" : "0.0.0-dev";
+var PLUGIN_VERSION = true ? "0.1.44" : "0.0.0-dev";
 
 // src/update/service.ts
 import { TypertRemoteService as TypertRemoteService2 } from "@deepseek-ai/dsh-typert-protocol";
@@ -45533,56 +45735,6 @@ var OpencodeGoUpdateService = class extends TypertRemoteService2 {
   }
 };
 
-// src/usage/meter.ts
-var EMPTY3 = {
-  calls: 0,
-  inputTokens: 0,
-  outputTokens: 0,
-  cacheReadTokens: 0,
-  cacheWriteTokens: 0,
-  totalTokens: 0
-};
-function add(totals, usage) {
-  const inputTokens = totals.inputTokens + usage.inputTokens;
-  const outputTokens = totals.outputTokens + usage.outputTokens;
-  const cacheReadTokens = totals.cacheReadTokens + (usage.cacheReadTokens ?? 0);
-  const cacheWriteTokens = totals.cacheWriteTokens + (usage.cacheWriteTokens ?? 0);
-  return {
-    calls: totals.calls + 1,
-    inputTokens,
-    outputTokens,
-    cacheReadTokens,
-    cacheWriteTokens,
-    // The four counts are disjoint (uncached input, cached input, output), so
-    // their sum is the billed total. The provider's own `totalTokens` is not
-    // used: it is optional, and mixing the two would double-count a cache read.
-    totalTokens: inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens
-  };
-}
-var UsageMeter = class {
-  sinceMs = Date.now();
-  totals = EMPTY3;
-  byModel = /* @__PURE__ */ new Map();
-  /**
-   * Record one completed call.
-   * @param model - the model id the call was made with.
-   * @param usage - the provider's own usage for that call.
-   */
-  record(model, usage) {
-    this.totals = add(this.totals, usage);
-    this.byModel.set(model, add(this.byModel.get(model) ?? EMPTY3, usage));
-  }
-  /** The current reading, busiest model first. */
-  snapshot(now = Date.now()) {
-    return {
-      sinceMs: this.sinceMs,
-      atMs: now,
-      totals: this.totals,
-      models: [...this.byModel.entries()].map(([model, totals]) => ({ model, ...totals })).sort((left, right) => right.totalTokens - left.totalTokens || left.model.localeCompare(right.model))
-    };
-  }
-};
-
 // src/usage/windows.ts
 import { attributionHeaders as attributionHeaders6, LlmError as LlmError10 } from "@deepseek-ai/dsh-llm";
 var USAGE_MAX_BYTES = 1024 * 1024;
@@ -45697,6 +45849,37 @@ function apply(ctx, raw) {
   const constant = live === void 0 ? PlainConfig(raw ?? {}) : void 0;
   const current = () => live === void 0 ? constant : readConfig(live);
   assertBaseURL(current().baseURL);
+  const settingsNs = ctx.fiber?.entry?.options.id ?? name;
+  let directory;
+  let directoryError;
+  let directoryRetired = false;
+  const directoryEntry = (error) => ({
+    provider: PROVIDER_ID,
+    displayName: DISPLAY_NAME,
+    settingsNs,
+    // This plugin's profile is the entry's whole `config:` mapping — the
+    // bundled `cordis.patch.yml` inserts `id: dshopencodego` with the route's
+    // fields directly under `config`, and `src/config.ts` owns exactly those
+    // fields — so there is no path from the section root to a nested profile.
+    settingsPath: [],
+    defaultBaseURL: DEFAULT_BASE_URL,
+    ...error === void 0 ? {} : { error }
+  });
+  const publishDirectory = (error) => {
+    if (directoryRetired || directory !== void 0 && error === directoryError) return;
+    directoryError = error;
+    const entry = directoryEntry(error);
+    try {
+      if (directory === void 0) directory = ctx.llm.registerConfigurableProviders([entry]);
+      else directory.replace([entry]);
+    } catch (failure) {
+      directoryRetired = true;
+      ctx.logger.error(
+        `dshopencodego: could not publish the "${PROVIDER_ID}" configurable-provider entry; the Models page will not offer this route's model discovery (${String(failure)})`
+      );
+    }
+  };
+  publishDirectory(void 0);
   const resolveApiKey = async () => {
     const ref = current().apiKeyEnv;
     const credentials = ctx.get("credentials");
@@ -45740,7 +45923,10 @@ function apply(ctx, raw) {
   });
   ctx.plugin(OpencodeGoCatalogService, {
     catalog: () => adapter.catalogOf(current()),
-    visibility: () => current().modelVisibility
+    visibility: () => current().modelVisibility,
+    onUnadvertised: (ids) => {
+      ctx.logger.warn(`dshopencodego: modelVisibility configures models the gateway does not advertise: ${ids.join(", ")}; those switches have no effect until the gateway publishes them`);
+    }
   });
   ctx.plugin(OpencodeGoUpdateService, { currentVersion: PLUGIN_VERSION });
   let registration;
@@ -45762,38 +45948,50 @@ function apply(ctx, raw) {
         ctx.logger.info("dshopencodego: disabled by configuration; the route and its models are withdrawn");
       }
     }
+    publishDirectory(enabled && !credentialConfigured ? `the route is withheld until ${current().apiKeyEnv} is stored through the credentials service` : void 0);
   };
   const syncRoute = () => {
-    const visibility = JSON.stringify(current().modelVisibility);
-    if (visibility !== visibilityFacts) {
-      visibilityFacts = visibility;
-      registration?.replace([PROVIDER_ID]);
-    }
-    const credentials = ctx.get("credentials");
-    const ref = current().apiKeyEnv;
-    if (credentials === void 0) {
-      applyRoute(launchEnvironmentOf(ctx).get(ref)?.value !== void 0);
-      return;
+    try {
+      const visibility = JSON.stringify(current().modelVisibility);
+      if (visibility !== visibilityFacts) {
+        visibilityFacts = visibility;
+        registration?.replace([PROVIDER_ID]);
+      }
+      const credentials = ctx.get("credentials");
+      const ref = current().apiKeyEnv;
+      if (credentials === void 0) {
+        applyRoute(launchEnvironmentOf(ctx).get(ref)?.value !== void 0);
+        return;
+      }
+      void credentials.describe(credentialRef(ref)).then((info) => {
+        if (ref === current().apiKeyEnv) applyRoute(info.configured);
+      }).catch((error) => {
+        ctx.logger.error(`dshopencodego: credential describe failed; keeping the previous route state (${String(error)})`);
+      });
+    } catch (error) {
+      ctx.logger.error(
+        `dshopencodego: could not re-evaluate the route after a configuration change; keeping the previous route state (${String(error)})`
+      );
     }
-    void credentials.describe(credentialRef(ref)).then((info) => {
-      if (ref === current().apiKeyEnv) applyRoute(info.configured);
-    }).catch((error) => {
-      ctx.logger.error(`dshopencodego: credential describe failed; keeping the previous route state (${String(error)})`);
-    });
   };
   syncRoute();
-  const undiscover = ctx.llm.registerModelDiscovery(name, async (request) => {
-    if (request.provider !== PROVIDER_ID && !(request.baseURL ?? "").includes("opencode.ai")) {
-      throw new LlmError12(
-        "dshopencodego discovers only OpenCode Go/Console endpoints; enter this provider's models by hand",
-        "DISCOVERY_UNSUPPORTED"
-      );
+  const undiscover = ctx.llm.registerModelDiscovery(
+    settingsNs,
+    async (request, signal) => {
+      if (request.provider !== PROVIDER_ID && !(request.baseURL ?? "").includes("opencode.ai")) {
+        throw new LlmError12(
+          "dshopencodego discovers only OpenCode Go/Console endpoints; enter this provider's models by hand",
+          "DISCOVERY_UNSUPPORTED"
+        );
+      }
+      return discoverCatalogModels(adapter.catalogOf(current()), signal);
     }
-    return discoverCatalogModels(adapter.catalogOf(current()));
-  });
+  );
   ctx.effect(() => () => {
     registration?.();
     undiscover();
+    directory?.();
+    directoryRetired = true;
   });
   ctx.on("internal/config", function(_raw, next) {
     const value = next();