opencode-zen-freex 0.2.6 → 0.2.7

package/MAINTAINING.md

@@ -195,6 +195,26 @@ the cooldown answers like a refusal.
 
 ## Things that are easy to break
 
+**Marking a list as fallen back when Zen's own list was read.** `discover()`
+returns every id Zen's `/models` lists; the catalogue and the console docs only
+add what each model *is* — name, protocol, limits. When either of those two
+cannot be read, the list is not a fallback: it is Zen's, current, and complete to
+the last id. Saying so costs a user something real, because the host reacts to
+that marker by keeping the last list it read in full, and a machine that cannot
+reach `raw.githubusercontent.com` or `models.opencode.ai` — mainland China, for
+one — then never sees a model Zen made free since. The marker belongs to the one
+case that describes it: the listing itself could not be read, so what is returned
+really is the last list there was (`yetone/magpie#2385`).
+
+**Waiting for the catalogue before offering a model Zen already lists.** An id
+ending in `-free` that neither the catalogue nor the docs describe is offered
+anyway, asked through the provider's own protocol (openai-compatible, and so
+chat) — the way OpenCode asks a model with no package of its own. Zen lists a
+model the hour it turns free and the catalogue catches up later; a host should
+see it in between. An id that does not call itself free still needs the
+catalogue's word, and one the snapshot or the docs name keeps that say:
+`jev-1.13-free` is SystemOne and stays out.
+
 **Adding a header.** The set sent has one owner: `outboundHeaders` in
 `provider.mjs`, which the plugin builds its request with and which the gate asks
 Zen with, so neither can drift from the other on its own. `index.test.mjs` pins

package/README.md

@@ -47,7 +47,9 @@ magpie plugin login opencode-zen-free
 
 免费模型的目录上限有时被 Zen 少报，而少报的那一边没有谁会报错：`deepseek-v4.1-flash-free` 在目录里是 20 万上下文 / 3.2 万输出，而同一上游模型的付费 id 是 100 万 / 38.4 万。上下文窗口太小只会让宿主安静地早点压缩，输出上限太小会把回复截断成看起来像模型自己停下的样子，所以插件对这类模型按实测与路由自述对齐（依据与复测方法见 `MAINTAINING.md` 的 “Limits Zen under-reports”），并在运行中采用上游自报的窗口。
 
-已下线的模型和 SystemOne 模型会被排除。这份列表在宿主每次列举模型时重新获取（magpie 在启动时做一次，之后每小时一次）：Zen 不再免费开放的模型会退出列表，新转为免费的模型会加入列表。如果读不到 Zen 的列表，就沿用上一次的结果；第一次还没读到之前，用的是打包在插件里的那份，所以这个 provider 不会空着。请求一个当前并不免费的模型，会得到一个 404 并列出当时免费的模型；若某个模型是在上次列举之后才转免费的，请求会在重新获取列表后照常服务（最多每分钟一次）。可用性和限流由 Zen 决定，插件这边拿不到剩余额度。
+已下线的模型和 SystemOne 模型会被排除。这份列表在宿主每次列举模型时重新获取（magpie 在启动时做一次，之后每小时一次）：Zen 不再免费开放的模型会退出列表，新转为免费的模型会加入列表——**不等** OpenCode 的目录或文档写到它：只要 Zen 的列表里有、id 里带 `-free`，就按 provider 自己的协议（OpenAI 兼容 / chat）提供，目录晚一步也不影响。
+
+目录或文档读不到时**不算 fallback**：Zen 的列表已经读到了，它就是当前该提供的东西；报成 fallback 会让宿主保守地沿用上一次完整读到的列表，于是读不到 `raw.githubusercontent.com` 或 `models.opencode.ai` 的机器永远看不到之后新转免费的模型。只有**列表本身**读不到才沿用上一次结果；第一次还没读到之前，用的是打包在插件里的那份，所以这个 provider 不会空着。请求一个当前并不免费的模型，会得到一个 404 并列出当时免费的模型；若某个模型是在上次列举之后才转免费的，请求会在重新获取列表后照常服务（最多每分钟一次）。可用性和限流由 Zen 决定，插件这边拿不到剩余额度。
 
 ## 免费层不再应答时
 

package/limits-audit.mjs

@@ -16,11 +16,12 @@
 // prompt of about a million tokens — minutes and megabytes — and belongs to the
 // one id a signal has already pointed at; the numbers live in limits.mjs and are
 // put there by a measurement, never by a script. What this does ask is cheap:
-// one request of `max_tokens: 1000000` per offered id, stopped as soon as it
-// starts writing. An upstream that validates the ceiling refuses and names its
-// own; one that does not just begins to answer and is cut off after the first
-// chunk. Either way the cost is a handful of tokens, and a 410 or a 400 for a
-// model that is gone is visible in the same request.
+// one request of `max_tokens: 1000000` per offered id that speaks the chat
+// shape, stopped as soon as it starts writing. An upstream that validates the
+// ceiling refuses and names its own; one that does not just begins to answer and
+// is cut off after the first chunk. Either way the cost is a handful of tokens,
+// and a 410 or a 400 for a model that is gone is visible in the same request.
+// An id the snapshot places on another protocol is listed and not asked.
 //
 // The offered set is the listing's, not the catalogue's: Zen's /v1/models
 // carries 10 of the 40 free ids the catalogue still describes, and a plugin
@@ -36,6 +37,7 @@
 
 import { PROFILES } from "./core-tools.mjs";
 import { LIMITS, limitOverrides, namedContextWindow, namedOutputCap } from "./limits.mjs";
+import { SDK, bootstrapProtocols } from "./models.mjs";
 import { CATALOG, DEFAULT_BASE } from "./provider.mjs";
 import { chatRequest } from "./tools-smoke.mjs";
 
@@ -46,11 +48,18 @@ const READ_BUDGET = 4096;
 const ASKED_CEILING = 1_000_000;
 
 // The ids the plugin would offer: the listing's, kept where the catalogue calls
-// them free. Exported for the tests.
-export function offeredIds(listing, catalog) {
+// them free — or, for an id neither the catalogue nor the docs describe, where
+// the id names itself free and nothing else names its protocol, which is what
+// models.mjs offers on its own say-so. An id the snapshot already calls
+// something this plugin has no SDK for is not offered by anyone: `jev-1.13-free`
+// is SystemOne, and stays out here for the same reason buildModels leaves it out.
+// Exported for the tests.
+export function offeredIds(listing, catalog, snapshot = bootstrapProtocols) {
   return listing.filter((id) => {
+    const protocol = snapshot?.[id];
+    if (protocol !== undefined && !Object.hasOwn(SDK, protocol)) return false;
     const model = catalog?.[id];
-    if (!model) return false;
+    if (!model) return /-free$/.test(id);
     return /free/i.test(id) || (model.cost?.input === 0 && model.cost?.output === 0);
   });
 }
@@ -87,15 +96,13 @@ export function findings(rows, covered = new Set()) {
         `${row.id}: a refusal named a window of ${row.window}, the catalogue declares ${declared.context ?? "none"}`,
       );
     const named = row.ceiling !== undefined || row.window !== undefined;
+    // A model that does not speak the shape this audit asks with is not a limits
+    // finding and must not sit in this list for ever: it is said once, beside the
+    // ids that were not asked at all.
+    if (protocolScoped(row)) continue;
     if (row.status !== 200 && !named) {
-      // A 400 this audit provoked by asking for too much is the audit working,
-      // not a finding, and neither is a refusal a number was just read out of.
-      // What is left is worth reading: a 410, a 400 that named nothing, and a
-      // model that does not speak the shape asked with.
-      const protocol = /protocol|format/i.test(row.says ?? "");
-      out.push(
-        `${row.id}: HTTP ${row.status}${protocol ? " (does not speak the chat shape this audit asks with)" : ""}${row.says ? ` — ${row.says}` : ""}`,
-      );
+      // What is left is worth reading: a 410, and a 400 that named nothing.
+      out.push(`${row.id}: HTTP ${row.status}${row.says ? ` — ${row.says}` : ""}`);
     }
   }
   for (const [upstream, list] of groupByUpstream(rows)) {
@@ -127,6 +134,13 @@ function says(text) {
   return flat ? flat.slice(0, 160) : "";
 }
 
+// A refusal that names the protocol rather than a limit. This audit asks the
+// chat shape, so a model that speaks Responses or Messages answers by saying so;
+// that is the host's business, not a limit to measure.
+export function protocolScoped(row) {
+  return /protocol|format/i.test(row?.says ?? "");
+}
+
 async function getJSON(url) {
   const response = await fetch(url, { signal: AbortSignal.timeout(30000) });
   if (!response.ok) throw new Error(`${url} answered HTTP ${response.status}`);
@@ -202,7 +216,12 @@ if (import.meta.main) {
   console.log(`${ids.length} free ids are offered; the catalogue still describes ${free.length}\n`);
 
   const rows = [];
-  for (const id of ids) {
+  // This asks the chat shape only. An id the snapshot places on another protocol
+  // is left to the host that speaks it, and said once rather than reported as a
+  // finding it cannot be.
+  const asked = ids.filter((id) => (bootstrapProtocols[id] ?? "chat") === "chat");
+  const elsewhere = ids.filter((id) => !asked.includes(id));
+  for (const id of asked) {
     const answer = await ask(id, names);
     const declared = models[id]?.limit ?? {};
     rows.push({ id, declared, ...answer });
@@ -210,12 +229,12 @@ if (import.meta.main) {
     // so that is what is printed; the catalogue's own pair is shown beside it
     // when the two differ, since that is the under-report being answered.
     const effective = { ...declared, ...limitOverrides(id, declared) };
-    const moved =
-      effective.context !== declared.context || effective.output !== declared.output;
+    const moved = effective.context !== declared.context || effective.output !== declared.output;
+    const pair = (limit) => `${limit.context ?? "—"}/${limit.output ?? "—"}`;
     const mark = answer.status === 200 ? "  " : "! ";
     console.log(
-      `${mark}${id.padEnd(34)} ${`${effective.context}/${effective.output}`.padStart(17)}` +
-        `${moved ? `  (catalogue ${declared.context}/${declared.output})` : ""}  ${answer.status}` +
+      `${mark}${id.padEnd(34)} ${pair(effective).padStart(17)}` +
+        `${moved ? `  (catalogue ${pair(declared)})` : ""}  ${answer.status}` +
         `${answer.upstream ? `  ${answer.upstream}${answer.endpoint ? ` via ${answer.endpoint}` : ""}` : ""}` +
         `${answer.ceiling !== undefined ? `  ceiling=${answer.ceiling}` : ""}${answer.window !== undefined ? `  window=${answer.window}` : ""}` +
         `${answer.says ? `  — ${answer.says}` : ""}`,
@@ -224,6 +243,11 @@ if (import.meta.main) {
 
   const answered = rows.filter((row) => row.status === 200);
   const candidates = findings(rows, new Set(Object.keys(LIMITS)));
+  const skipped = [...elsewhere, ...rows.filter(protocolScoped).map((row) => row.id)];
+  if (skipped.length)
+    console.log(
+      `\nnot asked, this audit asks the chat shape only: ${skipped.map((id) => `${id}${bootstrapProtocols[id] ? ` (${bootstrapProtocols[id]})` : ""}`).join(", ")}`,
+    );
   console.log(`\nlimits.mjs already carries evidence for: ${Object.keys(LIMITS).join(", ")}`);
   console.log(`\n${candidates.length} candidate${candidates.length === 1 ? "" : "s"}:`);
   for (const line of candidates) console.log(`  ${line}`);

package/models.mjs

@@ -43,13 +43,31 @@ export function isFree(id, model = {}) {
   );
 }
 
+// Whether an id names itself free — Zen names them "-free" — which is all this
+// can know about one that neither the catalogue nor the docs describe yet: Zen
+// made it free after they were last written, or they could not be read. Such a
+// model is asked the way OpenCode asks a model with no package of its own,
+// through the provider's own (openai-compatible, and so chat), so a new free
+// model is offered the hour Zen lists it rather than the hour the catalogue
+// catches up. An id that does not call itself free still needs the catalogue's
+// word (a paid one, or a zero-cost one Zen never named).
+function listedFree(id) {
+  return /-free$/.test(id);
+}
+
 export function buildModels(ids, provider, protocols, baseURL) {
   const result = {};
   for (const id of ids) {
     if (typeof id !== "string" || !id || id === "__proto__") continue;
     const raw = provider.models?.[id];
     const model = raw ?? {};
-    const protocol = protocols[id] ?? (raw && sdkProtocol(model.provider?.npm ?? provider.npm));
+    const protocol =
+      protocols[id] ??
+      (raw
+        ? sdkProtocol(model.provider?.npm ?? provider.npm)
+        : listedFree(id)
+          ? (sdkProtocol(provider.npm) ?? "chat")
+          : undefined);
     if (!isFree(id, model) || !Object.hasOwn(SDK, protocol)) continue;
     const input = model.modalities?.input ?? ["text"];
     const output = model.modalities?.output ?? ["text"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-zen-freex",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "OpenCode Zen's free models, for hosts that are not OpenCode: the public credential, automatic discovery and native streaming protocols",
   "type": "module",
   "main": "./index.mjs",

package/provider.mjs

@@ -359,7 +359,13 @@ async function server(_input, options = {}) {
           discovered[id] = known[id];
         }
       }
-      discovered[Symbol.for("magpie.fellBack")] = true;
+      // Deliberately not said as fallen back. Zen's own list was read, and what
+      // it lists is what gets offered; said as a fallback, magpie keeps the last
+      // list it read in full instead, and a host that cannot reach the catalogue
+      // or the docs — GitHub's raw host, from mainland China — would never see a
+      // model Zen made free since (yetone/magpie#2385). A listing that could not
+      // be read is still said so, above, because then this really is the last
+      // list there was.
     }
     known = discovered;
     listed = true;