# model this catalog does not admit and therefore has no rates. Every read

  # surface says `unpriced` rather than `$0.00`.

  #

  # This list is exactly two models, and a caller may spend nothing else. A

  # This list is exactly three models, and a caller may spend nothing else. A

  # model absent from it cannot be minted a grant (`OpenAgents.Inference.mint/1`

  # refuses the name) and cannot be called on a grant minted before it was

  # withdrawn (`OpenAgentsWeb.InferenceProxyController` refuses

  # enough to hold a conversation. It led this list until GLM 5.3 Flash was

  # added.

  #

  # Both entries are on `:vercel_gateway`, and that is a single point of failure

  # this file no longer papers over. `gpt-5.6-luna` used to be the third entry

  # and the backup that answered when neither of the others could be served.

  # It is withdrawn from this list and nothing replaced it, so if the gateway

  # itself is unreachable this deployment serves no model at all: both lanes

  # report `unavailable` and neither is substituted for the other.

  # The first two entries are on `:vercel_gateway`. `openrouter/free` is the

  # independent Coder Free lane, and it remains available when the gateway is

  # unavailable. OpenRouter limits that router to free models, so its declared

  # per-token rates are zero even though the selected provider model can vary.

  #

  # `vercel_gateway_fallback_models` below is a different list and it still ends

  # with `openai/gpt-5.6-luna`, deliberately. That is the gateway's own ordered

        output_per_million_tokens: 10_000_000,

        cached_input_per_million_tokens: 100_000

      }

    },

    %{

      # The Coder Free lane resolves this exact fallback after checking for a

      # deployment-specific preferred free model. OpenRouter selects a current

      # free model behind this router id, so callers cannot be promised one

      # vendor context window. Its route only selects zero-price models.

      id: "openrouter/free",

      provider: :openrouter,

      provider_model: "openrouter/free",

      context_window: 32_768,

      max_output: 8_192,

      pricing: %{

        id: "declared.openrouter-free.v1",

        source: :declared,

        input_per_million_tokens: 0,

        output_per_million_tokens: 0,

        cached_input_per_million_tokens: 0

      }

    }

  ],

  gemini_api_key: nil,

  }

  @type pricing :: %{

          required(:input_per_million_tokens) => pos_integer(),

          required(:output_per_million_tokens) => pos_integer(),

          optional(:cached_input_per_million_tokens) => pos_integer()

          required(:input_per_million_tokens) => non_neg_integer(),

          required(:output_per_million_tokens) => non_neg_integer(),

          optional(:cached_input_per_million_tokens) => non_neg_integer()

        }

  @type t :: %{

  @moduledoc """

  What a metered call cost, and on whose authority.

  Metering that prices some lanes at zero is worse than no metering: it reports

  a number, and the number is wrong. This deployment ran for a long time with

  Metering that prices an unknown lane at zero is worse than no metering: it

  reports a number, and the number is wrong. This deployment ran for a long time with

  `gpt-5.6-luna` admitted and its rates never entered, so a surface that read a

  missing cost as zero would have shown `$0.00` beside a session that spent

  real money — and shown it in the same typeface as a figure that was measured.

  `unpriced` is not an error state and it is not a free lane. It is the

  deployment saying it does not know what a call cost, which is a different

  fact from the call having cost nothing, and the distinction survives all the

  way to the read surfaces. Turning it into a number is an owner action —

  entering real rates in `config :openagents, :model_catalog` — not something

  this module may guess at.

  fact from the call having cost nothing. A declared zero rate is a measured

  free lane; an absent rate remains unknown. The distinction survives all the

  way to the read surfaces.

  The `pricing_id` convention is `OpenAgents.Voice.Usage`'s, so

  `OpenAgents.DataRights.AtifExport` reads inference usage and voice usage with

  `Unpriced`, never `$0.00` — the deployment not knowing what a call cost is a

  different fact from the call having cost nothing. And a rate this deployment

  wrote to make itself run is labelled `provisional`, so nobody reads a working

  figure as a price. Today that is every rate in the catalog, and the page says

  so at the top rather than leaving a reader to infer it column by column.

  figure as a price. The Coder Free lane declares zero rates because its router

  only selects free models; the other listed rates remain provisional.

  Availability is `Models.availability/1`, the same word the endpoint

  publishes, refreshed on a slow tick: a page about what a lane costs that

    assert ids == Enum.uniq(ids)

    assert Models.default_id() in ids

    assert ids == ["glm-5.3-flash", "gemini-3.7-flash"]

    assert ids == ["glm-5.3-flash", "gemini-3.7-flash", "openrouter/free"]

    assert Enum.map(Models.all(), & &1.id) == ids

    assert Models.fetch("attacker/gpt-9-ultra") == :error

    assert Models.fetch(nil) == :error

      assert glm["pricing"]["basis"] == "provisional"

    end

    test "every published lane carries a pricing block, because every one is priced" do

    test "the free router declares its zero price" do

      free_router = Enum.find(Models.catalog(), &(&1["id"] == "openrouter/free"))

      assert free_router["pricing"]["id"] == "declared.openrouter-free.v1"

      assert free_router["pricing"]["input_per_million_tokens"] == 0

      assert free_router["pricing"]["output_per_million_tokens"] == 0

      assert free_router["pricing_basis"] == "declared"

    end

    test "each catalog lane carries a pricing block" do

      for entry <- Models.catalog() do

        assert Map.has_key?(entry, "pricing")

        assert entry["pricing_basis"] == "provisional"

      end

    end

  end

  describe "the catalog this deployment actually ships" do

    test "no lane claims declared rates, because none has been given any" do

      # The moment an operator enters real rates and sets `source: :declared`,

      # this test fails and whoever did it has to say so here. That is the

      # point: turning a lane billable is a decision, not a config typo.

    test "only the free router claims declared zero rates" do

      bases = Enum.map(OpenAgents.Inference.Models.catalog(), & &1["pricing_basis"])

      assert "declared" not in bases

      free_router =

        Enum.find(OpenAgents.Inference.Models.catalog(), &(&1["id"] == "openrouter/free"))

      assert Enum.count(bases, &(&1 == "declared")) == 1

      assert "provisional" in bases

      assert free_router["pricing"]["input_per_million_tokens"] == 0

      assert free_router["pricing"]["output_per_million_tokens"] == 0

    end

    test "every shipped lane carries rates, so none of them reads as unpriced" do

      # This was not true while `gpt-5.6-luna` was admitted, and it is the one

      # thing that changed when it was withdrawn. `unpriced` did not stop being

      # reachable — a gateway fallback that answers with a model this catalog

      # does not admit still produces it, which is what

      # `OpenAgentsWeb.InferenceProxyFallbackTest` proves — but no model a

      # caller may select is in that state.

    test "every shipped lane carries rates, so none reads as unpriced" do

      bases = Enum.map(OpenAgents.Inference.Models.catalog(), & &1["pricing_basis"])

      assert "unpriced" not in bases

    on_exit(fn -> Application.put_env(:openagents, :vercel_gateway_provider, previous) end)

    conn = post_chat(conn, token, %{"messages" => [%{"role" => "user", "content" => "hi"}]})

    conn =

      post_chat(conn, token, %{

        "model" => "glm-5.3-flash",

        "messages" => [%{"role" => "user", "content" => "hi"}]

      })

    assert conn.status == 503

    assert Jason.decode!(conn.resp_body)["error"]["code"] == "model_unavailable"

  (#200, METER-001).

  The endpoint answered the CLI; nothing rendered the catalog for a human. What

  matters here is not that the page exists but that it carries the same absence

  the endpoint does: an unpriced lane shows the word rather than `$0.00`, and a

  deployment with no declared rates says so at the top instead of presenting a

  column of working figures as a price list.

  matters here is not that the page exists but that it carries the same pricing

  truth as the endpoint does: an unpriced lane shows the word rather than

  `$0.00`, while the declared Coder Free router shows its zero rate.

  """

  use OpenAgentsWeb.ConnCase, async: false

             "placeholder.gemini-3.7-flash.v1"

  end

  test "the page says nothing is billable while no lane declares its rates", %{conn: conn} do

    {:ok, view, _html} = live(reader(conn, "model-catalog-not-billable"), ~p"/models")

  test "the declared free router is billable at zero", %{conn: conn} do

    {:ok, view, _html} = live(reader(conn, "model-catalog-free"), ~p"/models")

    assert has_element?(view, "#model-catalog-not-billable")

    refute has_element?(view, "#model-catalog-not-billable")

    assert view |> element(~s([id="model-basis-openrouter/free"])) |> render() =~ "declared"

    assert view |> element(~s([id="model-input-rate-openrouter/free"])) |> render() =~ "$0.00"

    assert view |> element(~s([id="model-output-rate-openrouter/free"])) |> render() =~ "$0.00"

  end

  test "the billable notice is derived from the catalog, not written into the page",