opencode-zen-freex 0.2.5 → 0.2.6

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
@@ -279,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

@@ -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/package.json

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