opencode-zen-freex 0.2.4 → 0.2.6

package/MAINTAINING.md

@@ -21,7 +21,8 @@ ids the catalogue is wrong in the one direction nothing complains about: too
 small. `deepseek-v4.1-flash-free` is declared 200000/32000 while
 `deepseek-v4.1-flash` — the paid id serving the same upstream model, which
 `x-opencode-upstream-model-id` confirms — is declared 1000000/384000 in that
-same catalogue.
+same catalogue, and `mimo-v2.6-flash-free` is declared 200000/32000 against a
+model whose own vendor publishes 1048576/131072.
 
 Both numbers are acted on. The window decides when a conversation is compacted
 and how much of it is ever sent; the output cap is sent as `max_tokens` on every
@@ -32,10 +33,15 @@ quietly never used, which is why this stayed invisible for so long.
 `limits.mjs` holds what was measured, per axis, with the catalogue value it was
 measured against. Each axis carries `samples` and `how`; the short of it:
 
-| axis | value | from |
-| --- | --- | --- |
-| context | 1048576 | the route's own refusal, in its own words |
-| output | 384000 | what this route declares for the same upstream model |
+| id | axis | value | from |
+| --- | --- | --- | --- |
+| `deepseek-v4.1-flash-free` | context | 1048576 | the route's own refusal, in its own words |
+| `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
 
@@ -53,10 +59,30 @@ published what that model does; a single reply of 306,880 completion tokens
 number out of the refusal, three times, interleaved, per the rule below. The
 filler measured 4.887 characters per token with about 1700 tokens of fixed
 request overhead, and a request that is *served* says nothing about where the
-wall is. The output: re-read the paid id's `limit` in
-`https://models.opencode.ai/api.json`. A value Zen accepts is not evidence —
-`max_tokens: 2000000` under a short prompt answers 200 and writes nothing like
-it — and neither is a generation nobody watched finish.
+wall is — it is what the calibration is checked against, since
+`usage.prompt_tokens` is the real count while the refusal's "requested about"
+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
+and has to say so in `samples`: what is declared is what a vendor publishes, not
+something watched. A value Zen accepts is not evidence — `max_tokens: 2000000`
+under a short prompt answers 200 and writes nothing like it, and `mimo`'s refusal
+came back with the 200000 it was asked for rather than with a ceiling — and
+neither is a generation nobody watched finish.
 
 **What voids it.** Each axis records the catalogue value it was measured
 against, and an axis whose declaration moved is dropped rather than kept: a
@@ -71,15 +97,43 @@ start and hourly after, so a route that changes the window it enforces is
 followed without anyone editing this file. Nothing is persisted: a restart falls
 back to what is measured here.
 
-**A lead, not evidence.** `mimo-v2.6-flash-free` is declared 200000/32000 here
-too, and another plugin on this route has reported Zen answering that id with
-`maximum context length is 1048576 tokens`. That is somebody else's measurement
-of a different id, so it is not in `limits.mjs`: measure it before adding it.
+**The same shape on a second upstream.** `mimo-v2.6-flash-free` is declared
+200000/32000 here too, and its window is a route figure like the one above — an
+850,249 token prompt was served first, its needle echoed back, and then a prompt
+just over the wall was refused with
+
+```
+This endpoint's maximum context length is 1048576 tokens. However, you requested
+about 1496523 tokens (1295079 of text input, 1444 of tool input, 200000 in the
+output).
+```
+
+which is the route naming its own window, on an upstream that words it
+differently from the DeepSeek ids. Its output is the first figure in this file
+resting on a vendor page: that same refusal came back with the 200000 it was
+asked for, unclamped, so this route states no completion ceiling of its own, and
+131072 is Xiaomi's entry for `mimo-v2.6-flash` (`api.xiaomimimo.com`, and its
+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
@@ -252,4 +306,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/limits-audit.mjs

@@ -0,0 +1,238 @@
+// 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, 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.
+//
+// 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 { 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. Exported for the tests.
+export function offeredIds(listing, catalog) {
+  return listing.filter((id) => {
+    const model = catalog?.[id];
+    if (!model) return false;
+    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;
+    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}` : ""}`,
+      );
+    }
+  }
+  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) : "";
+}
+
+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 = [];
+  for (const id of ids) {
+    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 mark = answer.status === 200 ? "  " : "! ";
+    console.log(
+      `${mark}${id.padEnd(34)} ${`${effective.context}/${effective.output}`.padStart(17)}` +
+        `${moved ? `  (catalogue ${declared.context}/${declared.output})` : ""}  ${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)));
+  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

@@ -48,34 +48,118 @@ export const LIMITS = {
       how: "deepseek-v4.1-flash, the paid id serving the same upstream model, is declared 384000 in this same catalogue; DeepSeek's own page says 384K, which is 393216 read as binary K",
     },
   },
+  "mimo-v2.6-flash-free": {
+    context: {
+      value: 1048576,
+      source: "route",
+      declaredAt: 200000,
+      measured: "2026-10-15",
+      samples: "an 850,249 token prompt served, its needle echoed back; a prompt just over the window refused 400",
+      how: "a different upstream from the DeepSeek ids, and it says so in its own words: \"This endpoint's maximum context length is 1048576 tokens. However, you requested about 1496523 tokens (1295079 of text input, 1444 of tool input, 200000 in the output).\"",
+    },
+    output: {
+      value: 131072,
+      source: "vendor",
+      declaredAt: 32000,
+      measured: "2026-10-15",
+      samples: "nothing above 32000 watched on this route; that same refusal came back with the requested 200000 unclamped",
+      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
 // requested 1422278 tokens (1038278 in the messages, 384000 in the
 // completion)." — the route's own words, and the only sentence seen on this
-// route that states a window. A generic 400 says nothing attributable and is
-// left alone; §7 of the measured notes has a context overflow and an invalid
-// parameter answering with byte-identical 400s on another Zen model.
+// route that states a window. A second upstream phrases the same fact as "This
+// endpoint's maximum context length is ...", with the request broken into text
+// input, tool input and output; both are the route naming its own window, and
+// its "requested about" figure is a rough one (chars, not tokens) rather than
+// the count a served request reports in `usage.prompt_tokens`. A generic 400
+// says nothing attributable and is left alone; §7 of the measured notes has a
+// context overflow and an invalid parameter answering with byte-identical 400s
+// 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;
@@ -83,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;
   }
@@ -97,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-zen-freex",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "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" };

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,
     },
   };
 }