Vercel's AI Gateway rather than a vendor directly. It speaks the same chat

completions the OpenRouter adapter does, so it reuses that adapter's request

building and stream decoding and differs only in endpoint, credential, and the

provider it pins. The pin is the point: Gemini is served there by both `google`

and `vertex`, and only `vertex` spends this account's Google credits, so

`vercel_gateway_providers` names the provider set and an unpinned fallback

cannot quietly spend money instead.

provider it tries first. Gemini is served there by both `google` and `vertex`,

and `vertex` is where this account's Google credits are spent, so

`vercel_gateway_providers` names the provider order and `vercel_gateway_fallback_models`

names the model fallback list Vercel tries if the primary model fails.

Evidence: `OpenAgents.Providers.ProviderEvent`, `OpenAgents.Providers.OpenAI`,

`OpenAgents.Providers.OpenAI.StreamDecoderTest`,

  ],

  gemini_api_key: nil,

  vercel_gateway_api_key: nil,

  # Pin the gateway to Vertex for every model it serves here. The same Gemini

  # slug is also served by `google` — the Generative Language endpoint, which

  # is not where this account's credits are — and a silent fallback there would

  # spend money beside a balance already paid for.

  # Try Vertex first for every model it serves here. The same Gemini slug is

  # also served by `google` — the Generative Language endpoint, which is not

  # where this account's credits are — but the fallback models are not on

  # Vertex, so Vercel may try other providers for them.

  vercel_gateway_providers: ["vertex"],

  vercel_gateway_fallback_models: [

    "zai/glm-5.3",

    "zai/glm-5.2",

    "openai/gpt-5.6-luna"

  ],

  gemini_model: "gemini-3.7-flash",

  box_api_key: nil,

  box_api: [

config :openagents, :provider, OpenAgents.Providers.Test

config :openagents, :openrouter_provider, OpenAgents.Providers.Test

config :openagents, :vercel_gateway_provider, OpenAgents.Providers.Test

config :openagents, :vercel_gateway_fallback_models, []

config :openagents, :voice_call_provider, OpenAgents.Voice.TestCallProvider

config :openagents, :voice_sideband_provider, OpenAgents.Voice.TestSidebandProvider

  `"cost":"0"`: the call ran on Google's hardware against the credits, and the

  gateway charged nothing to put it there.

  `providerOptions.gateway.only` pins the provider, because the same slug is

  `providerOptions.gateway.order` tries Vertex first, because the same slug is

  also served by `google` — the Generative Language endpoint, which is not

  where the credits are. Without the pin a fallback would quietly spend money.

  where the credits are. `providerOptions.gateway.models` lists the fallback

  models Vercel tries if the primary model fails.

  The wire format is OpenRouter's, so the request building and the stream

  decoding are OpenRouter's too. What differs is the endpoint, the credential,

  @doc false

  def payload_extra do

    case Application.get_env(:openagents, :vercel_gateway_providers) do

      [_first | _rest] = providers -> %{providerOptions: %{gateway: %{only: providers}}}

      _unset -> %{}

    providers = Application.get_env(:openagents, :vercel_gateway_providers, [])

    fallbacks = Application.get_env(:openagents, :vercel_gateway_fallback_models, [])

    gateway =

      %{}

      |> maybe_put(:order, providers)

      |> maybe_put(:models, fallbacks)

    if map_size(gateway) > 0 do

      %{providerOptions: %{gateway: gateway}}

    else

      %{}

    end

  end

  defp maybe_put(map, _key, nil), do: map

  defp maybe_put(map, _key, []), do: map

  defp maybe_put(map, key, [_ | _] = values), do: Map.put(map, key, values)

end

  alias OpenAgents.Providers.VercelGateway

  describe "pinning the provider" do

    test "sends the gateway the provider set this deployment intends" do

  describe "provider routing" do

    test "sends the gateway the provider order this deployment intends" do

      # The same Gemini slug is served by `google` — the Generative Language

      # endpoint — and by `vertex`, which is where this account's credits are.

      # Without the pin, a fallback spends money beside a balance already paid

      # for, and nothing in the response would say so.

      assert VercelGateway.payload_extra() == %{providerOptions: %{gateway: %{only: ["vertex"]}}}

      # `order` tries Vertex first and lets Vercel move to other providers

      # for the configured fallback models.

      assert VercelGateway.payload_extra() == %{providerOptions: %{gateway: %{order: ["vertex"]}}}

    end

    test "sends no pin at all when none is configured, rather than an empty one" do

    test "sends no provider or model options when none are configured" do

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

      Application.put_env(:openagents, :vercel_gateway_providers, [])

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

      # An empty `only` would be a pin to nothing, which the gateway is entitled

      # An empty `order` would be a pin to nothing, which the gateway is entitled

      # to read as "no provider may serve this".

      assert VercelGateway.payload_extra() == %{}

    end

    test "sends the fallback model list when configured" do

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

      Application.put_env(:openagents, :vercel_gateway_fallback_models, [

        "zai/glm-5.3",

        "openai/gpt-5.6-luna"

      ])

      on_exit(fn ->

        Application.put_env(:openagents, :vercel_gateway_fallback_models, previous)

      end)

      assert VercelGateway.payload_extra() == %{

               providerOptions: %{

                 gateway: %{

                   order: ["vertex"],

                   models: ["zai/glm-5.3", "openai/gpt-5.6-luna"]

                 }

               }

             }

    end

  end

  describe "the credential" do