opencode-zen-freex 0.2.5 → 0.2.7

package/MAINTAINING.md

@@ -39,6 +39,9 @@ measured against. Each axis carries `samples` and `how`; the short of it:
 | `deepseek-v4.1-flash-free` | output | 384000 | what this route declares for the same upstream model |
 | `mimo-v2.6-flash-free` | context | 1048576 | the route's own refusal, in its own words |
 | `mimo-v2.6-flash-free` | output | 131072 | the vendor's own catalogue entry |
+| `big-pickle` | output | 131072 | the ceiling the route names when it is asked for too much |
+| `nemotron-3.5-lightning-free` | context | 1000000 | the route's own refusal, in its own words |
+| `longcat-2.5-preview-free` | output | 262144 | the ceiling the route names when it is asked for too much |
 
 A prompt sized just over the window is refused with
 
@@ -62,6 +65,16 @@ figure is a rough one (characters, not tokens) and must not be read as a count.
 A second upstream words the same fact as "This endpoint's maximum context length
 is …" and breaks the request into text input, tool input and output.
 
+The ceiling, which is cheaper than the window: ask for `max_tokens: 1000000` on a
+short prompt and stop reading as soon as the answer starts. An upstream that
+validates the ceiling refuses and names it — `max_tokens is too large: 1000000.
+This model supports at most 131072 completion tokens`, or LongCat's
+`/max_tokens: 1000000 is not less or equal to 262144` — and one that does not
+just begins to answer, so the cost of asking every model is a few tokens each.
+Both wordings are in `limits.mjs` (`namedOutputCap`) and both are read from
+production refusals as well, which is how a ceiling that moves gets noticed
+without anyone running anything.
+
 The output: a paid twin's `limit` in `https://models.opencode.ai/api.json` is
 the stronger source, and re-reading it is the whole job. With no twin — `mimo`
 has none — the figure rests on the vendor's own entry, which is weaker evidence
@@ -103,10 +116,24 @@ asked for, unclamped, so this route states no completion ceiling of its own, and
 China token plan). Nothing above 32000 has been watched on this route, and
 `samples` says that rather than implying a witness.
 
+**Looking for the next one, instead of waiting to notice it.** `bun run
+limits:audit` asks the route which free models it still offers — the listing's
+ten, not the forty the catalogue still describes — and asks each one the cheap
+question above. It groups them by the `x-opencode-upstream-model-id` the route
+answers with, because two ids naming one upstream model are one capability, so a
+declaration that differs inside a group is the question worth asking. It prints
+those, the ceilings it was told, the windows a refusal named, and the ids that
+are gone (410) or unavailable (400); it writes nothing and measures no window.
+Its first run named
+`big-pickle`'s ceiling and two ids declared below what the route says
+(`nemotron-3.5-lightning-free` at a quarter of its window, `longcat-2.5-preview-free`
+at half its ceiling), which is the whole argument for having it.
+
 ## The loop
 
 ```sh
 bun test              # the unit tests; these never touch the network
+bun run limits:audit  # what the route offers, what limits it states, what to measure
 bun run check:gate    # asks Zen which generations are still accepted
 bun run capture -- --dry   # takes a fresh capture and reports the difference
 bun run capture            # writes it
@@ -168,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
@@ -279,4 +326,26 @@ you do not have permission to access it.
 
 which reads exactly like the package not existing. It is the same status npm
 gives a genuine permission failure, so a 404 from a publish says nothing at
-all until the token has been checked.
+all until the token has been checked.
+
+**A publish that no longer offers the browser at all.** A token can be dead
+while npm says nothing about it until a write is attempted. Measured: `npm
+whoami` answers
+
+```
+npm error 401 Unauthorized - GET https://registry.npmjs.org/-/whoami
+```
+
+and the publish answers that same 404 without ever printing an auth address,
+because with no usable credential the request goes out unauthenticated and npm
+reports the result as not-found. `npm login --auth-type=web` is the fix — the
+browser exchange again, which replaces the stored token — and the publish after
+it asks for the second factor in the browser once more. **Two authorizations in
+a row is the normal shape of this**, not a sign that something is wrong. So on a
+404 from a publish, ask `npm whoami` before anything else: 401 is a session that
+has to be renewed, and everything else is the permission problem above.
+
+npm says on login that "tokens that bypass 2FA are being restricted for account
+changes and direct publishing", so the granular route below is on its way out as
+a way to publish; the browser is the road, and the token is the exception it is
+already written to be.

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

@@ -0,0 +1,262 @@
+// Asks the route which free models it still offers, groups them by the upstream
+// model serving them, and says which look under-declared.
+//
+//   bun run limits:audit
+//
+// Why this exists. Zen's catalogue is where this plugin declares limits from,
+// and two of the ids it publishes were declared far below what the model does:
+// `deepseek-v4.1-flash-free` at 200000/32000 against 1048576/384000, and
+// `mimo-v2.6-flash-free` at 200000/32000 against 1048576/131072. Both were found
+// by hand, one id at a time. What makes them findable without reading every id
+// by eye is that the route answers `x-opencode-upstream-model-id` on every
+// request: two ids naming one upstream model are one capability, so a
+// declaration that differs inside such a group is the question worth asking.
+//
+// What this does not do: measure a window, or write anything. A window costs a
+// 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 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
+// only ever offers what the listing has. Auditing the other 30 reports a page
+// of `Model is unavailable` about models nobody can pick.
+//
+// What is reported, per offered id: the upstream model and the ids sharing it,
+// the ceiling a refusal named, the window a refusal named, and the status. The
+// candidates at the end are the reason to run it.
+//
+// Exit code is 0 when at least one offered id answered, 1 when none did: being
+// unable to ask is not a finding about limits.
+
+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";
+
+const BASE = process.env.ZEN_BASE_URL ?? DEFAULT_BASE;
+const CATALOG_URL = process.env.ZEN_CATALOG_URL ?? CATALOG;
+const GENERATION = process.env.ZEN_GENERATION ?? "1.x";
+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 — 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 /-free$/.test(id);
+    return /free/i.test(id) || (model.cost?.input === 0 && model.cost?.output === 0);
+  });
+}
+
+// Offered ids by the upstream model serving them, which is the route's own
+// answer and not a guess from the id's shape.
+export function groupByUpstream(rows) {
+  const groups = new Map();
+  for (const row of rows) {
+    if (!row.upstream) continue;
+    groups.set(row.upstream, [...(groups.get(row.upstream) ?? []), row]);
+  }
+  return groups;
+}
+
+// What is worth a measurement, in the order it should be read. `covered` are the
+// ids limits.mjs already carries evidence for, which are said once and not
+// raised again. Exported for the tests.
+export function findings(rows, covered = new Set()) {
+  const out = [];
+  for (const row of rows) {
+    const declared = row.declared ?? {};
+    // An id limits.mjs already carries evidence for is not asked for again: its
+    // numbers are in the table and repeating them here would bury what is new.
+    // Its status is still printed in the table above, so a model that dies is
+    // not hidden by this — only its numbers stop being a question.
+    if (covered.has(row.id)) continue;
+    if (row.ceiling !== undefined && row.ceiling !== declared.output)
+      out.push(
+        `${row.id}: the route names a ceiling of ${row.ceiling} completion tokens, the catalogue declares ${declared.output ?? "none"}`,
+      );
+    if (row.window !== undefined && row.window !== declared.context)
+      out.push(
+        `${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) {
+      // 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)) {
+    const largest = (axis) => Math.max(...list.map((row) => row.declared?.[axis] ?? 0));
+    if (list.length < 2) continue;
+    if (new Set(list.map((row) => `${row.declared?.context}/${row.declared?.output}`)).size < 2) continue;
+    for (const row of list) {
+      if (covered.has(row.id)) continue;
+      if ((row.declared?.context ?? 0) >= largest("context") && (row.declared?.output ?? 0) >= largest("output"))
+        continue;
+      const siblings = list
+        .filter((other) => other.id !== row.id)
+        .map((other) => `${other.id} (${other.declared?.context}/${other.declared?.output})`)
+        .join(", ");
+      out.push(
+        `${row.id}: declared ${row.declared?.context}/${row.declared?.output}, and ${upstream} is also served as ${siblings}`,
+      );
+    }
+  }
+  return out;
+}
+
+function says(text) {
+  const match = text.match(/"(?:message|param)"\s*:\s*"([^"]{0,160})"/);
+  if (match) return match[1];
+  // Some upstreams refuse in words that are not under a `message` key at all,
+  // and a refusal nobody can read is not a finding.
+  const flat = text.replace(/\s+/g, " ").trim();
+  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}`);
+  return response.json();
+}
+
+// One cheap question per id. The ceiling asked for is past anything this route
+// serves, so an upstream that validates it says what it allows, and the stream
+// is dropped as soon as it starts rather than paying for an answer nobody reads.
+async function ask(id, names) {
+  const { headers, body } = chatRequest({
+    model: id,
+    generation: GENERATION,
+    profile: PROFILES[GENERATION],
+    names,
+    maxTokens: ASKED_CEILING,
+  });
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 45000);
+  try {
+    const response = await fetch(`${BASE}/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    let text = "";
+    if (response.ok) {
+      const reader = response.body?.getReader();
+      if (reader) {
+        const decoder = new TextDecoder();
+        while (text.length < READ_BUDGET) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          text += decoder.decode(value, { stream: true });
+        }
+      }
+    } else {
+      text = (await response.text()).slice(0, READ_BUDGET);
+    }
+    const upstream = response.headers.get("x-opencode-upstream-model-id") ?? undefined;
+    const endpoint = response.headers.get("x-opencode-endpoint-id") ?? undefined;
+    return {
+      status: response.status,
+      upstream,
+      endpoint,
+      window: namedContextWindow(text),
+      ceiling: namedOutputCap(text),
+      says: response.ok ? "" : says(text),
+    };
+  } catch (error) {
+    return { status: 0, says: error.message, upstream: undefined, endpoint: undefined };
+  } finally {
+    clearTimeout(timer);
+    controller.abort();
+  }
+}
+
+// Only a run asks the route. The tests import the helpers above and must not
+// reach the network.
+if (import.meta.main) {
+  const names = [...PROFILES[GENERATION].required];
+  const [listing, catalog] = await Promise.all([getJSON(`${BASE}/models`), getJSON(CATALOG_URL)]);
+  const models = catalog?.opencode?.models ?? {};
+  const ids = offeredIds(
+    (Array.isArray(listing?.data) ? listing.data : []).map((entry) => entry?.id).filter(Boolean),
+    models,
+  );
+  const free = Object.keys(models).filter(
+    (id) => /free/i.test(id) || (models[id].cost?.input === 0 && models[id].cost?.output === 0),
+  );
+  console.log(`limits audit — ${BASE}`);
+  console.log(`${ids.length} free ids are offered; the catalogue still describes ${free.length}\n`);
+
+  const rows = [];
+  // 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 });
+    // What the plugin declares is the catalogue's limit with limits.mjs over it,
+    // 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 pair = (limit) => `${limit.context ?? "—"}/${limit.output ?? "—"}`;
+    const mark = answer.status === 200 ? "  " : "! ";
+    console.log(
+      `${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}` : ""}`,
+    );
+  }
+
+  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}`);
+  if (!candidates.length) console.log("  none — every offered id is either measured or declared at what the route states");
+
+  if (!answered.length) {
+    console.log(
+      "\nNothing answered, so this says nothing about limits. Check the network or ZEN_BASE_URL and ask again.",
+    );
+    process.exitCode = 1;
+  }
+}

package/limits.mjs

@@ -66,6 +66,36 @@ export const LIMITS = {
       how: "Xiaomi's own entry for mimo-v2.6-flash, api.xiaomimimo.com and its China token plan, declares 1048576/131072, as do DeepInfra and nan; this route declares 32000 for the free id and states no completion ceiling of its own",
     },
   },
+  "big-pickle": {
+    output: {
+      value: 131072,
+      source: "route",
+      declaredAt: 32000,
+      measured: "2026-10-15",
+      samples: "the endpoint refused the request asking for 200000 and named its own ceiling; nothing watched above 32000",
+      how: "\"max_tokens is too large: 200000. This model supports at most 131072 completion tokens, whereas you provided 200000.\" — an upstream that validates the requested ceiling and states its own. No context entry: this id is the same upstream model as mimo-v2.6-flash-free (x-opencode-upstream-model-id answers mimo-v2.6-flash) on a different endpoint, and two endpoints of one model are not one window — the attempt to measure this one answered 200 with an empty body, which is not an answer, so that axis stays with the catalogue.",
+    },
+  },
+  "nemotron-3.5-lightning-free": {
+    context: {
+      value: 1000000,
+      source: "route",
+      declaredAt: 262144,
+      measured: "2026-10-15",
+      samples: "a refusal that named the window, which is what `bun run limits:audit` asks for; nothing near the wall has been served yet",
+      how: "\"This endpoint's maximum context length is 1000000 tokens. However, you requested about …\" — read from the refusal the audit provoked by asking for more completion tokens than the window leaves, on the same upstream that words it as the mimo entry above. The catalogue declares 262144 for this id.",
+    },
+  },
+  "longcat-2.5-preview-free": {
+    output: {
+      value: 262144,
+      source: "route",
+      declaredAt: 131072,
+      measured: "2026-10-15",
+      samples: "the ceiling named by a refusal, from the same audit run; nothing above 131072 watched on this route",
+      how: "\"Upstream request failed: [invalid_parameter] 参数校验失败: /max_tokens: 1000000 is not less or equal to 262144\" — the second wording namedOutputCap reads, where the ceiling is the number max_tokens has to stay under. Its context needs nothing: the catalogue's 1000000 is what that same refusal calls the endpoint's window.",
+    },
+  },
 };
 
 // "This model's maximum context length is 1048576 tokens. However, you
@@ -81,24 +111,55 @@ export const LIMITS = {
 // on another Zen model.
 const NAMED_CONTEXT = /maximum context length is (\d+) tokens/i;
 
-// Windows named by a refusal while this process is running, by model id. Not
-// persisted: it is the same kind of fact as LIMITS, only newer, and a restart
-// falls back to what was measured last.
+// "max_tokens is too large: 200000. This model supports at most 131072 completion
+// tokens, whereas you provided 200000." — an upstream that validates the ceiling
+// it was asked for and names its own, which is the only sentence seen on this
+// route that states a completion ceiling at all. It is worth knowing that the
+// DeepSeek upstream does not validate: `max_tokens: 2000000` under a short prompt
+// answers 200 there, so silence from this one says nothing about a model, and a
+// request that is served is not evidence of a ceiling either way.
+const NAMED_OUTPUT = [
+  /supports at most (\d+) completion tokens/i,
+  // "/max_tokens: 1000000 is not less or equal to 262144" — LongCat's wording for
+  // the same fact, where the ceiling is the number it has to stay under.
+  /max_tokens:?\s*\d+\s+is not less or equal to\s+(\d+)/i,
+];
+
+// Names a refusal made while this process is running, by model id. Not
+// persisted: the same kind of fact as LIMITS, only newer, so a restart falls
+// back to what was measured last.
 const OBSERVED = new Map();
+const OBSERVED_OUTPUT = new Map();
 
 // The window a refusal names, or undefined when the body says nothing
 // attributable. Exported for the tests and for anyone reading a capture.
 export function namedContextWindow(text) {
-  const match = NAMED_CONTEXT.exec(typeof text === "string" ? text : "");
+  return namedNumber(NAMED_CONTEXT, text);
+}
+
+// The completion ceiling a refusal names, or undefined. Same rule as the window:
+// the body has to name the parameter and a number, or it says nothing.
+export function namedOutputCap(text) {
+  for (const pattern of NAMED_OUTPUT) {
+    const value = namedNumber(pattern, text);
+    if (value !== undefined) return value;
+  }
+  return undefined;
+}
+
+function namedNumber(pattern, text) {
+  const match = pattern.exec(typeof text === "string" ? text : "");
   if (!match) return undefined;
   const tokens = Number.parseInt(match[1], 10);
   return Number.isSafeInteger(tokens) && tokens > 0 ? tokens : undefined;
 }
 
-// Read a refusal for a window it names. Only non-2xx responses are read, and
-// only the first `limit` characters of one: this is an error path on the
-// request's way to a caller that is waiting, so it must never be able to fail a
-// request, change a response, or buffer a body that is not small.
+// Read a refusal for the names it makes about this model's limits. Only non-2xx
+// responses are read, and only the first `limit` characters of one: this is an
+// error path on the request's way to a caller that is waiting, so it must never
+// be able to fail a request, change a response, or buffer a body that is not
+// small. Returns undefined when the body names nothing attributable, otherwise
+// whichever axes it named.
 export async function observeRouteStatement(id, response, limit = 4096) {
   try {
     if (typeof id !== "string" || !id || response?.ok !== false) return undefined;
@@ -106,9 +167,12 @@ export async function observeRouteStatement(id, response, limit = 4096) {
       .clone()
       .text()
       .catch(() => "");
-    const tokens = namedContextWindow(text.slice(0, limit));
-    if (tokens !== undefined) OBSERVED.set(id, tokens);
-    return tokens;
+    const context = namedContextWindow(text.slice(0, limit));
+    const output = namedOutputCap(text.slice(0, limit));
+    if (context === undefined && output === undefined) return undefined;
+    if (context !== undefined) OBSERVED.set(id, context);
+    if (output !== undefined) OBSERVED_OUTPUT.set(id, output);
+    return { context, output };
   } catch {
     return undefined;
   }
@@ -120,22 +184,24 @@ const ROUTE_TIERS = new Set(["route", "route-twin"]);
 // a plain object to spread over the catalogue's own limit. Empty when there is
 // no evidence, when the evidence was measured against a different catalogue, or
 // when it would change nothing.
-export function limitOverrides(id, declared = {}, table = LIMITS, observed = OBSERVED) {
+export function limitOverrides(
+  id,
+  declared = {},
+  table = LIMITS,
+  observed = OBSERVED,
+  observedOutput = OBSERVED_OUTPUT,
+) {
   const overrides = {};
   const record = table?.[id];
-  const live = observed?.get(id);
   for (const axis of ["context", "output"]) {
     const declaredValue = declared?.[axis];
     const entry = record?.[axis];
+    const live = (axis === "context" ? observed : observedOutput)?.get(id);
     // A route statement made while this process was running is the same tier as
     // the table and newer than it, so it is taken as it stands. Everything else
     // has to have been measured against the catalogue in front of us now.
     const value =
-      axis === "context" && live !== undefined
-        ? live
-        : entry && entry.declaredAt === declaredValue
-          ? entry.value
-          : undefined;
+      live !== undefined ? live : entry && entry.declaredAt === declaredValue ? entry.value : undefined;
     if (value === undefined || !Number.isSafeInteger(value) || value <= 0) continue;
     if (value === declaredValue) continue;
     if (entry && !ROUTE_TIERS.has(entry.source) && Number.isSafeInteger(declaredValue) && value < declaredValue)

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.5",
+  "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",
@@ -10,6 +10,7 @@
     "core-tools.mjs",
     "fingerprint.json",
     "limits.mjs",
+    "limits-audit.mjs",
     "models.mjs",
     "stream.mjs",
     "tool-response.mjs",
@@ -27,6 +28,7 @@
   "scripts": {
     "test": "bun test",
     "check:gate": "bun tools-smoke.mjs",
+    "limits:audit": "bun limits-audit.mjs",
     "capture": "bun capture.mjs"
   },
   "magpie": { "icon": "https://opencode.ai/favicon-v3.ico", "maxConcurrency": 2 }

package/provider.mjs

@@ -15,8 +15,8 @@ import { guardToolResponse } from "./tool-response.mjs";
 
 // Zen moved behind opencode.ai/inference; everything under /zen/ answers 403
 // FreeTierError now, however the request is made.
-const DEFAULT_BASE = "https://opencode.ai/inference/v1";
-const CATALOG = "https://models.opencode.ai/api.json";
+export const DEFAULT_BASE = "https://opencode.ai/inference/v1";
+export const CATALOG = "https://models.opencode.ai/api.json";
 const DOCS =
   "https://raw.githubusercontent.com/anomalyco/opencode/dev/services/www/src/docs/content/console/models.mdx";
 const PATHS = { chat: "/chat/completions", responses: "/responses", anthropic: "/messages" };
@@ -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;

package/tools-smoke.mjs

@@ -72,8 +72,14 @@ function says(text) {
 }
 
 // The request a shape is asked with. It is its own function so index.test.mjs
-// can hold it against the request the plugin was observed to send, offline.
+// can hold it against the request the plugin was observed to send, offline, and
+// so limits-audit.mjs asks with the same shape this gate does instead of a copy
+// of it — a copy is what drifted before (it was missing `accept`).
 export function requestFor(generation, profile, names) {
+  return chatRequest({ model: MODEL, generation, profile, names, maxTokens: 40 });
+}
+
+export function chatRequest({ model, generation, profile, names, maxTokens = 40, messages }) {
   return {
     headers: outboundHeaders({
       session: sessionID(),
@@ -82,12 +88,12 @@ export function requestFor(generation, profile, names) {
       protocol: "chat",
     }),
     body: {
-      model: MODEL,
-      messages: [{ role: "user", content: "hi" }],
+      model,
+      messages: messages ?? [{ role: "user", content: "hi" }],
       tools: names.map((name) => ({ type: "function", function: profile.tools[name] })),
       stream: true,
       stream_options: { include_usage: true },
-      max_tokens: 40,
+      max_tokens: maxTokens,
     },
   };
 }