The Model Didn't Ship on Its Rumored Date — Read Your Context Limit From the API, Not the Headlines

Ask the model for its own limit

Gemini's model metadata already carries the input token limit. One models.get call retrieves it. There's no reason for a constant.

import { GoogleGenAI } from "@google/genai";
 
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
 
// Fetch once at startup, hold it in-process
async function loadBudget(model) {
  const info = await ai.models.get({ model });
  return {
    model: info.name,                       // the resolved concrete model
    inputLimit: info.inputTokenLimit,       // the published limit
    outputLimit: info.outputTokenLimit,
  };
}
 
const budget = await loadBudget("gemini-flash-latest");
console.log(budget);
// => { model: 'models/gemini-3.5-flash', inputLimit: ..., outputLimit: ... }

Pass an alias like gemini-flash-latest and info.name comes back with the resolved concrete model. You learn what the alias points at from a return value rather than a guess. Log it, and later you can trace exactly when the target swapped underneath you.

Note that this layer budgets length and cost — not capability. Whether thinking levels or structured output are supported is a separate probe, which I kept in a startup capability detection layer. Cram both into one layer and a failure in one takes the other down with it. Keeping the axes side by side, but separate, has been easier to live with.

Measure input with countTokens, then leave headroom

With the limit in hand, check whether the input fits before you send it. countTokens is an unbilled estimate meant exactly for this.

async function fits(model, contents, budget, headroom = 0.9) {
  const { totalTokens } = await ai.models.countTokens({ model, contents });
  const ceiling = Math.floor(budget.inputLimit * headroom);
  return { totalTokens, ceiling, ok: totalTokens <= ceiling };
}

headroom sits at 0.9 because the countTokens estimate and the tokens you're actually billed for don't always line up. System instructions, tool declarations, and attachment metadata can ride along afterward. Aim for the ceiling exactly and you'll occasionally exceed it. In production, "occasionally" means "eventually, always."

I re-measured this on my own wallpaper app's bulk description generation. The job I'd assumed needed an enormous context turned out to fit in a few thousand tokens. I'd been waiting on the number two million without knowing my own. That, it turns out, was the preparation worth doing first.

Don't crash when you overflow

If the check fails, degrade rather than throw. Try splitting, then summarizing, then demoting — and only fail once none of those apply.

async function generateWithinBudget(contents, budget, opts = {}) {
  const model = budget.model;
  const check = await fits(model, contents, budget);
  if (check.ok) {
    return ai.models.generateContent({ model, contents });
  }
 
  // 1) Splittable input: chunk it and process the pieces
  if (opts.splittable) {
    const chunks = splitByRatio(contents, check.totalTokens / check.ceiling);
    const parts = [];
    for (const c of chunks) parts.push(await generateWithinBudget(c, budget, opts));
    return mergeParts(parts);
  }
 
  // 2) Reference material: compress it first
  if (opts.summarizable) {
    const digest = await summarize(contents, budget);
    return generateWithinBudget(digest, budget, { ...opts, summarizable: false });
  }
 
  // 3) Neither applies: record it and fail explicitly
  throw new BudgetExceeded({
    model,
    needed: check.totalTokens,
    ceiling: check.ceiling,
  });
}

That third branch is the one I care about. Silently truncating and answering from a shortened input degrades quality while hiding the cause. If you truncate, say so in the record. If you can't answer, return that you can't. Working solo, you are the one who'll be debugging this in three months — the silence costs you personally.

The broader idea of confining a dependency to a single layer lives in isolating Gemini dependencies against deprecation. This budget layer sits comfortably inside that one.

Fail unreleased model IDs in CI

The surest way to stop pre-seeding is to verify in CI that every model ID in your config is actually callable. Twenty lines does it.

// scripts/check-models.mjs — run this in CI
import { GoogleGenAI } from "@google/genai";
 
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
const declared = ["gemini-flash-latest", process.env.GEMINI_MODEL].filter(Boolean);
 
const available = new Set();
for await (const m of await ai.models.list()) available.add(m.name.replace("models/", ""));
 
let failed = false;
for (const id of declared) {
  const ok = available.has(id);
  console.log(`${ok ? "OK  " : "MISS"} ${id}`);
  if (!ok) failed = true;
}
process.exit(failed ? 1 : 0);

models.list returns aliases alongside concrete models, so alias-based config passes fine. Read a headline, get excited, commit an early config — and CI goes red instead. All this does is move the red from a user's first request to a pull request page. That's a small thing, most days. On a day like today, it's the whole difference.

What to measure on the day it actually lands

Whenever gemini-3.5-pro does arrive, the day's work should be short if the layer above is already in place.

Step 5's promotion gate is written up in golden sets and rollback when an alias gets promoted. A brand-new model changes nothing about that procedure.

Look at the ordering and you'll notice that steps 1 and 2 don't require the release at all. You can run them against gemini-3.5-flash today. What there was to do while waiting turned out to live not in the thing being waited on, but in how you wait.

Wrapping up

The reported date arrived and nothing shipped. Nothing on my side broke either — because the limit comes from the model rather than a constant, and because CI checks that the model IDs exist. Put the rumor in config, and today would have been an outage.

For a next step: call models.get once and log inputTokenLimit. That number is the only ceiling you're entitled to rely on today. If it disagrees with the constant in your code, you've found the thing to fix.

I won't claim I've gotten good at waiting. Every slipped date pulls my attention. But if you keep adding things that don't move to your side of the line, the next delay arrives a little more quietly.