@heyramzi/utils 0.0.0-stage → 1.13.0

package/src/ai/image-agnes.test.ts

@@ -0,0 +1,130 @@
+import { afterEach, describe, expect, it, vi } from "vite-plus/test";
+import { generateImage } from "#src/ai/image.js";
+
+function mockFetch(replies: { ok?: boolean; status?: number; json?: unknown; bytes?: string }[]) {
+  const calls: { url: string; init?: RequestInit }[] = [];
+  let index = 0;
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (url: string | URL, init?: RequestInit) => {
+      calls.push({ url: String(url), init });
+      const reply = replies[Math.min(index++, replies.length - 1)];
+      return {
+        ok: reply.ok ?? true,
+        status: reply.status ?? 200,
+        headers: new Headers({ "content-type": "image/webp" }),
+        json: async () => reply.json ?? {},
+        arrayBuffer: async () => new TextEncoder().encode(reply.bytes ?? "").buffer,
+      } as unknown as Response;
+    }),
+  );
+  return calls;
+}
+
+const OPTS = { prompt: "a poster", apiKey: "agnes_test" };
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  vi.unstubAllEnvs();
+});
+
+describe("generateImage on the agnes lane", () => {
+  it("posts to the Agnes images endpoint and returns decoded bytes at no cost", async () => {
+    const calls = mockFetch([{ json: { data: [{ b64_json: btoa("PNGDATA") }] } }]);
+
+    const image = await generateImage({ ...OPTS, provider: "agnes" });
+
+    expect(calls[0].url).toBe("https://apihub.agnes-ai.com/v1/images/generations");
+    expect(new TextDecoder().decode(image.bytes)).toBe("PNGDATA");
+    expect(image.priceUsd).toBe(0);
+    expect(image.config.provider).toBe("agnes");
+  });
+
+  // The tier is the output resolution, because that is how Agnes prices a frame.
+  it.each([
+    ["small", "1K"],
+    ["medium", "2K"],
+    ["large", "4K"],
+  ] as const)("maps the %s tier to size %s", async (tier, size) => {
+    const calls = mockFetch([{ json: { data: [{ b64_json: btoa("x") }] } }]);
+
+    await generateImage({ ...OPTS, provider: "agnes", tier });
+
+    expect(JSON.parse(String(calls[0].init?.body))).toMatchObject({ size, ratio: "1:1" });
+  });
+
+  // The regression guard for a 5-minute hang. Asking Agnes for base64 makes it hold the connection without sending headers, and undici kills the request at exactly 300s with UND_ERR_HEADERS_TIMEOUT.
+
+  // The same prompt answers in 35s in url mode. Measured 31 Aug 2026.
+  it("never asks for base64, which is what made the request time out", async () => {
+    const calls = mockFetch([
+      { json: { data: [{ url: "https://cdn.agnes/f.png" }] } },
+      { bytes: "PNG" },
+    ]);
+
+    await generateImage({ ...OPTS, provider: "agnes" });
+
+    const body = JSON.parse(String(calls[0].init?.body));
+    expect(body.return_base64).toBeUndefined();
+    expect(body.extra_body).toBeUndefined();
+  });
+
+  // Measured 9 Sep 2026: the lane carries text-to-image only, and reports a reference as `403 team not allowed to access model`, which reads as a dead lane rather than a
+
+  // missing capability. It used to send the reference as a data URI and let the API answer that; refusing before the call is what makes the error true,
+
+  // and no request is worth spending to be told this.
+  it("refuses a reference before spending a call, and says why", async () => {
+    const calls = mockFetch([{ json: { data: [{ b64_json: btoa("x") }] } }]);
+
+    await expect(
+      generateImage({
+        ...OPTS,
+        provider: "agnes",
+        references: [{ bytes: new TextEncoder().encode("REF"), mediaType: "image/jpeg" }],
+      }),
+    ).rejects.toThrow("draws from a prompt only");
+
+    expect(calls).toHaveLength(0);
+  });
+
+  it("carries the aspect ratio through as `ratio`", async () => {
+    const calls = mockFetch([{ json: { data: [{ b64_json: btoa("x") }] } }]);
+
+    await generateImage({ ...OPTS, provider: "agnes", aspectRatio: "16:9" });
+
+    expect(JSON.parse(String(calls[0].init?.body)).ratio).toBe("16:9");
+  });
+
+  // An account that ignores `return_base64` answers with a url instead. Fetching
+  // it here keeps every caller on one return shape: bytes.
+  it("fetches the url when the account answers with one instead of base64", async () => {
+    const calls = mockFetch([
+      { json: { data: [{ url: "https://cdn.agnes/frame.webp" }] } },
+      { bytes: "WEBPDATA" },
+    ]);
+
+    const image = await generateImage({ ...OPTS, provider: "agnes" });
+
+    expect(calls[1].url).toBe("https://cdn.agnes/frame.webp");
+    expect(new TextDecoder().decode(image.bytes)).toBe("WEBPDATA");
+    expect(image.mediaType).toBe("image/webp");
+  });
+
+  it("carries the provider's own message when it refuses", async () => {
+    mockFetch([{ ok: false, status: 400, json: { error: { message: "ratio not supported" } } }]);
+
+    await expect(generateImage({ ...OPTS, provider: "agnes" })).rejects.toThrow(
+      "ratio not supported",
+    );
+  });
+
+  it("names the env var when no key is anywhere", async () => {
+    vi.stubEnv("AGNES_API_KEY", "");
+    mockFetch([{ json: {} }]);
+
+    await expect(generateImage({ prompt: "p", provider: "agnes" })).rejects.toThrow(
+      "AGNES_API_KEY",
+    );
+  });
+});

package/src/ai/image.ts

@@ -0,0 +1,435 @@
+import { generateText, type LanguageModel } from "ai";
+import {
+  gatewayId,
+  IMAGE_OUTPUT_TOKEN_PRICE_USD,
+  resolveImageModelConfig,
+  type ImageModelConfig,
+  type ModelTier,
+  type Provider,
+} from "#src/ai/models.js";
+
+/**
+ * One image call for every caller, on the same three tiers as text.
+ */
+
+/*
+ * WHY it lives here and not in each app: an image call is not a `generateText` call with a prompt, it is a `generateText` call with a provider-specific `responseModalities` block,
+ */
+
+/*
+ * an aspect ratio nested one level deeper, a file part per reference, and a retry, because the model answers with prose instead of a picture often enough to lose a
+ */
+
+/*
+ * run.
+ */
+
+/*
+ * Four repos each wrote that by hand, each with its own key order in front of it, and that is how image traffic ended up bypassing the Cloudflare AI Gateway
+ */
+
+/*
+ * entirely: the bypass was never a decision, it was the fourth copy drifting.
+ */
+
+export type ImageReference = {
+  /** Raw bytes of an image the model should look at rather than imagine. */
+  bytes: Uint8Array;
+  mediaType: string;
+};
+
+export type GenerateImageOptions = {
+  prompt: string;
+  /** small samples, medium ships, large carries a face or a real logo. */
+  tier?: ModelTier;
+  provider?: Provider;
+  aspectRatio?: string;
+  references?: ImageReference[];
+  /** How many times to re-ask when the model answers with text. Default 3. */
+  attempts?: number;
+  /** OpenAI and Agnes: the key, when the environment does not carry it. */
+  apiKey?: string;
+  /**
+   * OpenAI: the pixel size asked for, which defaults from `aspectRatio`, because OpenAI takes a size from a fixed list rather than a ratio and the list has no 16:9 entry.
+   */
+
+  /*
+   * Agnes: the output resolution, which is how Agnes prices a frame, defaulting from the tier as 1K, 2K, 4K.
+   */
+  size?: string;
+  /**
+   * The gateway the Google lane draws through, e.g. `createGateway({ apiKey: env.AI_GATEWAY_API_KEY })`.
+   * Left out, the AI SDK's default provider takes the string id, which reads AI_GATEWAY_API_KEY itself.
+   */
+  gateway?: (modelId: string) => LanguageModel;
+};
+
+export type GeneratedImage = {
+  bytes: Uint8Array;
+  /** Carried out rather than assumed: the model answers JPEG as often as PNG. */
+  mediaType: string;
+  config: ImageModelConfig;
+  /** What this frame cost, recorded at the moment it was drawn. */
+  priceUsd: number;
+  attempts: number;
+};
+
+/**
+ * The Gemini image request. Without `responseModalities` the model answers in prose and the
+ * call fails as "returned no image", so a dropped options block reads as a dead lane.
+ */
+function providerOptions(config: ImageModelConfig, aspectRatio?: string) {
+  if (config.provider !== "google") {
+    throw new Error(`Provider "${config.provider}" has no image request shape in @heyramzi/utils.`);
+  }
+  return {
+    google: {
+      responseModalities: ["IMAGE"],
+      ...(aspectRatio ? { imageConfig: { aspectRatio } } : {}),
+    },
+  };
+}
+
+/** Base64 to bytes without Buffer, so the package stays runtime-agnostic. */
+function decodeBase64(value: string): Uint8Array {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+
+// ------------------------------------------------------------------- openai
+
+/**
+ * OpenAI's image family, which is not a chat model and so cannot go through the AI SDK path above.
+ */
+
+/*
+ * WHY a raw fetch rather than another adapter: `/v1/images/generations` and `/v1/images/edits` are their own endpoints with their own multipart shape, and the AI SDK's image surface does not carry the
+ */
+
+/*
+ * two arguments that make this model worth calling here: several reference images at once, and the fidelity flag that decides whether a supplied logo survives the render.
+ */
+
+/*
+ * This lane was deleted on 1 Sep 2026 and restored the same day, so the one thing worth writing down is what the round trip settled:
+ */
+
+/*
+ * the default provider is a separate question from whether the transport exists. Nothing reaches here unless a caller names `provider: "openai"`.
+ */
+
+/*
+ * The tier means quality, not a different checkpoint, because OpenAI bills the tokens a frame returns.
+ */
+const OPENAI_QUALITY: Record<ModelTier, string> = {
+  small: "low",
+  medium: "medium",
+  large: "high",
+};
+
+/**
+ * The size a ratio asks for.
+ */
+
+/*
+ * OpenAI takes a size from a list and the list has no 16:9 entry, so a widescreen frame is drawn at the widest landscape bracket and cropped by the caller.
+ */
+
+/*
+ * Left unmapped, a ratio falls through to `auto` rather than to a wrong shape.
+ */
+const OPENAI_SIZE_BY_RATIO: Record<string, string> = {
+  "16:9": "1536x1024",
+  "3:2": "1536x1024",
+  "1:1": "1024x1024",
+  "2:3": "1024x1536",
+  "9:16": "1024x1536",
+};
+
+type OpenAiImageResponse = {
+  data?: { b64_json?: string }[];
+  usage?: { output_tokens?: number };
+  error?: { message?: string; param?: string | null };
+};
+
+function openAiCost(config: ImageModelConfig, outputTokens: number | undefined): number {
+  const perToken = IMAGE_OUTPUT_TOKEN_PRICE_USD[config.modelId];
+  if (!perToken || !outputTokens) return config.pricePerImage;
+  return outputTokens * perToken;
+}
+
+/**
+ * The key, from the caller or from the environment.
+ */
+
+/*
+ * WHY the environment is reached through `globalThis`: this package ships without node types on purpose, so it runs in a worker as readily as in a script,
+ */
+
+/*
+ * and a bare `process.env` would not compile.
+ */
+function openAiKey(explicit?: string): string {
+  const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process
+    ?.env;
+  const apiKey = explicit ?? env?.OPENAI_API_KEY;
+  if (!apiKey) throw new Error("OPENAI_API_KEY is not set, so no OpenAI image can be drawn.");
+  return apiKey;
+}
+
+async function postOpenAi(
+  path: string,
+  body: BodyInit,
+  headers: Record<string, string>,
+  apiKey: string,
+) {
+  const response = await fetch(`https://api.openai.com/v1/${path}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${apiKey}`, ...headers },
+    body,
+  });
+  const json = (await response.json().catch(() => ({}))) as OpenAiImageResponse;
+  return { ok: response.ok, status: response.status, json };
+}
+
+/**
+ * One frame from OpenAI, with the references attached when there are any.
+ */
+
+/*
+ * `input_fidelity` is what keeps a supplied card, mark or screenshot reproduced rather than reinterpreted, and it is the reason references go to `/edits` instead of being described in the prompt.
+ */
+
+/*
+ * It is dropped and the call retried when the API says it does not know the parameter, so a model that has not shipped it yet degrades to a normal
+ */
+
+/*
+ * edit rather than failing the run.
+ */
+async function generateOpenAiImage(
+  config: ImageModelConfig,
+  options: GenerateImageOptions,
+  tier: ModelTier,
+): Promise<GeneratedImage> {
+  const size = options.size ?? OPENAI_SIZE_BY_RATIO[options.aspectRatio ?? ""] ?? "auto";
+  const quality = OPENAI_QUALITY[tier];
+  const references = options.references ?? [];
+  const apiKey = openAiKey(options.apiKey);
+
+  async function call(withFidelity: boolean) {
+    if (references.length === 0) {
+      return postOpenAi(
+        "images/generations",
+        JSON.stringify({ model: config.sdkId, prompt: options.prompt, size, quality, n: 1 }),
+        { "Content-Type": "application/json" },
+        apiKey,
+      );
+    }
+    const form = new FormData();
+    form.set("model", config.sdkId);
+    form.set("prompt", options.prompt);
+    form.set("size", size);
+    form.set("quality", quality);
+    form.set("n", "1");
+    if (withFidelity) form.set("input_fidelity", "high");
+    for (const [index, reference] of references.entries()) {
+      const extension = reference.mediaType.split("/")[1] ?? "png";
+      form.append(
+        "image[]",
+        new Blob([reference.bytes as unknown as ArrayBuffer], { type: reference.mediaType }),
+        `reference-${index + 1}.${extension}`,
+      );
+    }
+    return postOpenAi("images/edits", form, {}, apiKey);
+  }
+
+  let result = await call(references.length > 0);
+  const unknownParam = !result.ok && (result.json.error?.message ?? "").includes("input_fidelity");
+  if (unknownParam) result = await call(false);
+
+  if (!result.ok) {
+    throw new Error(
+      `${config.modelId} refused the request (${result.status}): ${result.json.error?.message ?? "no message"}`,
+    );
+  }
+
+  const base64 = result.json.data?.[0]?.b64_json;
+  if (!base64) throw new Error(`${config.modelId} returned no image data.`);
+
+  return {
+    bytes: decodeBase64(base64),
+    // The Images API answers PNG unless asked otherwise, and it is asked for
+    // nothing else here because a thumbnail is composited afterwards.
+    mediaType: "image/png",
+    config,
+    priceUsd: openAiCost(config, result.json.usage?.output_tokens),
+    attempts: 1,
+  };
+}
+
+/**
+ * Agnes Image 2.5 Flash: the free lane.
+ */
+
+/*
+ * WHY it is a branch rather than a router adapter, like OpenAI's above: Agnes answers on `/v1/images/generations`, the OpenAI Images shape, not the chat-with-image-parts shape the Gemini lane uses,
+ */
+
+/*
+ * so there is no language model for an adapter to hand back. And it is reached directly, because Cloudflare AI Gateway answers `Invalid provider` for every spelling of agnes.
+ */
+
+/*
+ * The tier is the output resolution, which is how Agnes prices an image. Every tier is $0 today; see the catalog entry for what happens when that ends.
+ */
+const AGNES_SIZE: Record<ModelTier, string> = {
+  small: "1K",
+  medium: "2K",
+  large: "4K",
+};
+
+const AGNES_BASE_URL = "https://apihub.agnes-ai.com/v1";
+
+function agnesKey(explicit?: string): string {
+  // This package ships without node types on purpose, so a bare `process.env`
+  // would not compile; `globalThis` is the route that does.
+  const env = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process
+    ?.env;
+  const key = explicit ?? env?.AGNES_API_KEY;
+  if (!key) {
+    throw new Error("The agnes image lane needs an API key: pass `apiKey`, or set AGNES_API_KEY.");
+  }
+  return key;
+}
+
+async function generateAgnesImage(
+  config: ImageModelConfig,
+  options: GenerateImageOptions,
+  tier: ModelTier,
+): Promise<GeneratedImage> {
+  const references = options.references ?? [];
+  // WHY a reference is refused HERE rather than on the wire, measured 9 Sep 2026.
+
+  // Agnes carries text-to-image only, and it reports that as `403 team not allowed to access model: agnes-image-2.5-flash` the moment the body carries an `image` array.
+
+  // The status names the model, so the lane reads as down, or as the wrong id, and a caller spends a run finding out it is neither.
+
+  // This says the one true thing instead.
+  if (references.length > 0) {
+    throw new Error(
+      `${config.modelId} draws from a prompt only: it refuses a reference image with a 403 that blames the model. Draw through a gateway for anything conditioned on a frame.`,
+    );
+  }
+  // WHY base64 is NOT requested, measured 31 Aug 2026. Asking for it
+
+  // (`return_base64: true` / `extra_body.response_format: "b64_json"`) makes Agnes hold the connection open without sending headers: the same prompt that answers in 35s in url mode died at exactly 300,003ms with undici's
+
+  // `UND_ERR_HEADERS_TIMEOUT`, `HTTP/2: "headers timeout after 300000"`. curl survives it because it has no such default.
+
+  // So the frame is always fetched from the url, which costs one extra round trip and always finishes.
+  const body: Record<string, unknown> = {
+    model: config.sdkId,
+    prompt: options.prompt,
+    size: options.size ?? AGNES_SIZE[tier],
+    ratio: options.aspectRatio ?? "1:1",
+  };
+  const response = await fetch(`${AGNES_BASE_URL}/images/generations`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${agnesKey(options.apiKey)}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  const json = (await response.json().catch(() => ({}))) as {
+    data?: { b64_json?: string; url?: string }[];
+    error?: { message?: string };
+    message?: string;
+  };
+  if (!response.ok) {
+    throw new Error(
+      `${config.modelId} refused the request (${response.status}): ${json.error?.message ?? json.message ?? "no message"}`,
+    );
+  }
+
+  const first = json.data?.[0];
+  // Kept for an account that answers base64 anyway; the request no longer asks.
+  if (first?.b64_json) {
+    return {
+      bytes: decodeBase64(first.b64_json),
+      mediaType: "image/png",
+      config,
+      priceUsd: config.pricePerImage,
+      attempts: 1,
+    };
+  }
+  // The normal path. Fetching it here rather than handing a URL out keeps every
+  // caller on one return shape: bytes.
+  if (first?.url) {
+    const image = await fetch(first.url);
+    if (!image.ok) {
+      throw new Error(`${config.modelId} returned a url that did not fetch (${image.status}).`);
+    }
+    return {
+      bytes: new Uint8Array(await image.arrayBuffer()),
+      mediaType: image.headers.get("content-type") ?? "image/png",
+      config,
+      priceUsd: config.pricePerImage,
+      attempts: 1,
+    };
+  }
+
+  throw new Error(`${config.modelId} returned no image data.`);
+}
+
+export async function generateImage(options: GenerateImageOptions): Promise<GeneratedImage> {
+  const tier = options.tier ?? "medium";
+  const config = resolveImageModelConfig(tier, options.provider);
+  // OpenAI's and Agnes's image models aren't language models, so they take their own REST lanes.
+  if (config.provider === "openai") return generateOpenAiImage(config, options, tier);
+  if (config.provider === "agnes") return generateAgnesImage(config, options, tier);
+  const id = gatewayId(config);
+  const model = options.gateway ? options.gateway(id) : id;
+  const attempts = options.attempts ?? 3;
+
+  let lastText = "";
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const result = await generateText({
+      model,
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: options.prompt },
+            ...(options.references ?? []).map((reference) => ({
+              type: "file" as const,
+              data: reference.bytes,
+              mediaType: reference.mediaType,
+            })),
+          ],
+        },
+      ],
+      providerOptions: providerOptions(config, options.aspectRatio),
+    });
+
+    const file = result.files.find((entry) => entry.mediaType.startsWith("image/"));
+    if (file) {
+      return {
+        bytes: file.uint8Array,
+        mediaType: file.mediaType,
+        config,
+        priceUsd: config.pricePerImage,
+        attempts: attempt,
+      };
+    }
+    lastText = (result.text ?? "").slice(0, 160);
+  }
+
+  throw new Error(
+    `${config.modelId} returned no image after ${attempts} attempts${lastText ? `: ${lastText}` : ""}`,
+  );
+}

package/src/ai/models.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vite-plus/test";
+import {
+  getModelConfig,
+  imagePriceUsd,
+  MODEL_CATALOG,
+  MODEL_IDS,
+  model,
+  resolveModelConfig,
+} from "#src/ai/models.js";
+
+describe("MODEL_IDS", () => {
+  it("has entries for all provider-tier combinations", () => {
+    const providers = ["xai", "google", "anthropic"] as const;
+    const tiers = ["small", "medium", "large"] as const;
+    for (const p of providers) {
+      for (const t of tiers) {
+        expect(MODEL_IDS[p][t]).toBeTypeOf("string");
+      }
+    }
+  });
+});
+
+describe("MODEL_CATALOG", () => {
+  it("has a config entry for every model ID", () => {
+    const providers = ["xai", "google", "anthropic"] as const;
+    const tiers = ["small", "medium", "large"] as const;
+    for (const p of providers) {
+      for (const t of tiers) {
+        const id = MODEL_IDS[p][t];
+        const config = MODEL_CATALOG[id];
+        expect(config).toBeDefined();
+        expect(config.provider).toBe(p);
+        expect(config.pricing.input).toBeGreaterThan(0);
+        expect(config.pricing.output).toBeGreaterThan(0);
+      }
+    }
+  });
+});
+
+describe("MODEL_CATALOG ids apps name", () => {
+  it("prices every id the Studio apps hardcoded, under the right provider", () => {
+    const expected = {
+      "claude-haiku-5-5": "anthropic",
+      "claude-sonnet-5-5": "anthropic",
+      "claude-opus-5-5": "anthropic",
+      "claude-fable-5-1": "anthropic",
+      "gpt-5.6-luna": "openai",
+      "gpt-6-luna": "openai",
+      "gpt-6.1-sol": "openai",
+      "gemini-3.6-flash": "google",
+    } as const;
+    for (const [id, provider] of Object.entries(expected)) {
+      const config = getModelConfig(id);
+      expect(config.provider).toBe(provider);
+      expect(config.sdkId).toBe(id);
+      expect(config.pricing.input).toBeGreaterThan(0);
+      expect(config.pricing.output).toBeGreaterThan(config.pricing.input);
+    }
+  });
+
+  it("addresses Fable on the gateway with a dot, like the other Claude ids", () => {
+    expect(getModelConfig("claude-fable-5-1").gatewayId).toBe("anthropic/claude-fable-5.1");
+  });
+});
+
+describe("model", () => {
+  it("answers a provider-tier pair with the id the gateway knows it by", () => {
+    expect(model("medium", "anthropic")).toBe("anthropic/claude-sonnet-5.5");
+    expect(model("small", "xai")).toBe("spacexai/grok-4.7");
+    expect(model("large", "google")).toBe("google/gemini-3.8-flash");
+  });
+});
+
+describe("getModelConfig", () => {
+  it("returns full config for a short model ID", () => {
+    const config = getModelConfig("claude-sonnet-5-5");
+    expect(config.provider).toBe("anthropic");
+    expect(config.tier).toBe("medium");
+    expect(config.sdkId).toBe("claude-sonnet-5-5");
+    expect(config.pricing.input).toBe(2.0);
+  });
+});
+
+describe("resolveModelConfig", () => {
+  it("answers a bare tier with the default provider", () => {
+    expect(resolveModelConfig("medium").modelId).toBe("grok-4.7");
+  });
+});
+
+describe("imagePriceUsd", () => {
+  it("prices a frame filed under its sdk id as well as its model id", () => {
+    expect(imagePriceUsd("gemini-nano-banana-2.1")).toBe(0.067);
+    // The 2.0 ids left the catalog with the upgrade; frames drawn on them
+    // keep the price stored at draw time and no longer price off it.
+    expect(imagePriceUsd("gemini-3.1-flash-image")).toBeNull();
+    expect(imagePriceUsd("some-model-nobody-priced")).toBeNull();
+  });
+});