`model_mismatch` naming both, rather than silently answered by the grant's.

- Every successful proxy response attributes the effective model — the

  `x-openagents-model` header and each SSE chunk's `model` field — so a

  client renders what answered rather than what it assumed. Because a

  mismatch is refused, requested and effective agree on every `200`.

  client renders what answered rather than what it assumed. A named model is

  never substituted: because a mismatch is refused, a caller that named one

  gets that one or an error.

- Amended 2026-08-25 (#199): where **nothing named a model** — neither the

  mint nor the call — the server selects, preferring a configured lane that is

  not `degraded` in catalog order and falling back to the catalog default when

  every configured lane is degraded. This is not substitution: there was no

  request to substitute for, and a caller that said "whatever you serve" is

  better served by a lane that answers than by a fixed one that does not. It

  is bounded to exactly that case — a model named in the body, or a grant

  minted for a model other than the default, is routed as it always was — and

  the effective model is attributed on the response as always, so the answer

  still says what produced it.

The chat lane keeps the same law through `OpenAgents.Chat.Backends`: an

unsupported `model` on `POST /api/v1/chat/turns` is a typed `422`, and

  @spec default_id() :: String.t()

  def default_id, do: default().id

  @doc """

  The model the server selects for a caller that names none, by policy.

  A lane that is configured and not degraded is preferred, in catalog order.

  If no such lane exists because every configured lane is degraded, or

  because no lane is configured, the catalog default is returned. The proxy

  still uses `Models.available?/1` to refuse the call when the default is

  unavailable, so a degraded default is used but an unavailable one is not.

  """

  @spec select() :: t()

  def select do

    models = all()

    case Enum.find(models, &healthy?/1) do

      nil -> default()

      model -> model

    end

  end

  @doc "The id of the model `select/0` returns."

  @spec select_id() :: String.t()

  def select_id, do: select().id

  @doc """

  The model with this id, or `:error`.

  def fetch(_id), do: :error

  @doc """

  Whether this model's adapter reports its credential configured.

  An adapter that does not export `configured?/0` is taken as configured: the

  test adapters need no credential, and an adapter that cannot say is refused

  at call time by its own `missing_api_key` rather than guessed at here.

  """

  @doc """

  What a client should believe about a lane, as one word.

    end

  end

  @doc """

  Whether this model's adapter reports its credential configured.

  An adapter that does not export `configured?/0` is taken as configured: the

  test adapters need no credential, and an adapter that cannot say is refused

  at call time by its own `missing_api_key` rather than guessed at here.

  """

  @spec available?(t()) :: boolean()

  def available?(%{adapter: adapter}) do

    if Code.ensure_loaded?(adapter) and function_exported?(adapter, :configured?, 0) do

    end

  end

  defp healthy?(%{id: id} = model) do

    available?(model) and not match?({:degraded, _}, Health.status(id))

  end

  @doc """

  The public projection of the catalog, for `GET /api/v1/models`.

    # proxy never re-reads or re-parses it.

    with {:ok, token} <- bearer(conn),

         {:ok, grant} <- resolve(token),

         {:ok, model} <- route(grant),

         {:ok, model} <- route(grant, conn.body_params),

         :ok <- serving(model),

         :ok <- requested_model(model, conn.body_params),

         {:ok, request} <- build_request(model, conn.body_params) do

  # with. A grant minted before the model was routable — or one whose model has

  # since been withdrawn — is refused here rather than sent to a provider that

  # does not serve it.

  defp route(grant) do

    case Models.fetch(grant.model_id) do

      {:ok, model} -> {:ok, model}

      :error -> {:error, :model_unavailable}

  defp route(grant, body) do

    if no_model_in_body?(body) and grant.model_id == Models.default_id() do

      {:ok, Models.select()}

    else

      case Models.fetch(grant.model_id) do

        {:ok, model} -> {:ok, model}

        :error -> {:error, :model_unavailable}

      end

    end

  end

  defp no_model_in_body?(body) do

    case Map.get(body, "model") do

      absent when absent in [nil, ""] -> true

      _ -> false

    end

  end

        # What the catalog publishes about this lane follows from what it

        # actually did, not only from whether a credential is configured.

        OpenAgents.Inference.Health.record_failure(model.id, status)

        Logger.warning(

          "inference_proxy_failed code=#{class}" <>

            if(status == nil, do: "", else: " upstream_status=#{status}")

defmodule OpenAgents.Inference.ModelsSelectTest do

  use ExUnit.Case, async: false

  alias OpenAgents.Inference.Health

  alias OpenAgents.Inference.Models

  setup do

    if is_nil(Process.whereis(OpenAgents.Inference.Health)) do

      start_supervised!({OpenAgents.Inference.Health, []})

    end

    Health.reset()

    on_exit(&Health.reset/0)

    :ok

  end

  test "select returns the catalog default when every lane is healthy" do

    assert Models.select().id == Models.default_id()

  end

  test "select prefers the first configured and non-degraded lane when the default is degraded" do

    default = Models.default_id()

    for _ <- 1..Health.degraded_after() do

      Health.record_failure(default)

    end

    selected = Models.select()

    refute selected.id == default

    assert selected.id == "ox-alpha"

  end

  test "select returns the default when all configured lanes are degraded, not the first one" do

    # Make the default unavailable so the first configured lane would be a

    # non-default entry under the old fallback.

    previous = Application.get_env(:openagents, :vercel_gateway_provider)

    Application.put_env(

      :openagents,

      :vercel_gateway_provider,

      OpenAgents.Providers.UnconfiguredTestProvider

    )

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

    for id <- Models.ids(), id != Models.default_id(), _ <- 1..Health.degraded_after() do

      Health.record_failure(id)

    end

    assert Models.select().id == Models.default_id()

  end

  test "select returns the catalog default when no lane is configured" do

    lanes = [:provider, :openrouter_provider, :vercel_gateway_provider]

    previous = Map.new(lanes, &{&1, Application.get_env(:openagents, &1)})

    for lane <- lanes do

      Application.put_env(:openagents, lane, OpenAgents.Providers.UnconfiguredTestProvider)

    end

    on_exit(fn ->

      for {lane, value} <- previous, do: Application.put_env(:openagents, lane, value)

    end)

    assert Models.select().id == Models.default_id()

  end

  describe "the boundary of server selection" do

    test "a lane named in the body is never substituted, even when degraded" do

      # PROVIDER-002: a caller that named a model gets that model or an error.

      # Selection exists only for the case where nothing named one.

      for _ <- 1..Health.degraded_after(), do: Health.record_failure("gemini-3.7-flash", 503)

      assert {:ok, model} = Models.fetch("gemini-3.7-flash")

      assert model.id == "gemini-3.7-flash"

      assert Models.availability(model) == "degraded"

    end

  end

end

  alias OpenAgents.Inference

  alias OpenAgents.Inference.Grant

  alias OpenAgents.Inference.Health

  alias OpenAgents.Inference.Models

  alias OpenAgents.Machines

  alias OpenAgents.Providers.RecordingTestProvider

  alias OpenAgents.Repo

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

    end

  end

  describe "server-side model selection" do

    setup do

      Health.reset()

      on_exit(&Health.reset/0)

      :ok

    end

    test "all lanes healthy selects the catalog default and reports it", %{conn: conn} do

      %{token: token} = grant("policy-healthy")

      conn =

        post_chat(conn, token, %{

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

        })

      assert conn.status == 200

      expected = Models.default_id()

      assert get_resp_header(conn, "x-openagents-model") == [expected]

      for chunk <- sse_events(conn.resp_body), chunk != "[DONE]" do

        assert Jason.decode!(chunk)["model"] == expected

      end

    end

    test "default degraded selects a healthy alternative and reports it", %{conn: conn} do

      default = Models.default_id()

      for _ <- 1..Health.degraded_after() do

        Health.record_failure(default)

      end

      expected = Models.select_id()

      refute expected == default

      %{token: token} = grant("policy-degraded")

      conn =

        post_chat(conn, token, %{

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

        })

      assert conn.status == 200

      assert get_resp_header(conn, "x-openagents-model") == [expected]

      for chunk <- sse_events(conn.resp_body), chunk != "[DONE]" do

        assert Jason.decode!(chunk)["model"] == expected

      end

    end

    test "every lane degraded still selects the default and reports it", %{conn: conn} do

      for id <- Models.ids(), _ <- 1..Health.degraded_after() do

        Health.record_failure(id)

      end

      expected = Models.select_id()

      assert expected == Models.default_id()

      %{token: token} = grant("policy-all-degraded")

      conn =

        post_chat(conn, token, %{

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

        })

      assert conn.status == 200

      assert get_resp_header(conn, "x-openagents-model") == [expected]

      for chunk <- sse_events(conn.resp_body), chunk != "[DONE]" do

        assert Jason.decode!(chunk)["model"] == expected

      end

    end

  end

end