grants that already name the model. The adapter for each model is read from

configuration, so no caller holds a compile-time dependency on one.

A third lane, `OpenAgents.Providers.VercelGateway`, reaches models through

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.

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

`OpenAgents.Providers.OpenAI.StreamDecoderTest`,

`OpenAgents.Providers.OpenRouter`,

`OpenAgents.Providers.OpenRouter.StreamDecoderTest`,

`OpenAgents.Providers.VercelGateway`,

`OpenAgents.Providers.VercelGatewayTest`,

`OpenAgents.Inference.ModelsTest`, `OpenAgents.Providers.Test`,

`OpenAgents.TurnProviderEventsTest`, and `OpenAgents.DependencyBoundaryTest`.

  voice_compaction_input_token_threshold: 16_000,

  provider: OpenAgents.Providers.OpenAI,

  openrouter_provider: OpenAgents.Providers.OpenRouter,

  vercel_gateway_provider: OpenAgents.Providers.VercelGateway,

  openai_model: "gpt-5.6-luna",

  openai_api_key: nil,

  openrouter_api_key: nil,

  # `provider` names a lane whose adapter module and credential are configured

  # separately, so no secret lives here; a lane whose credential is absent is

  # listed as unavailable, never silently substituted. `max_output` is the

  # per-call output cap the proxy's adapters actually send (4,096 tokens);

  # per-call output cap the proxy's adapters send for that model, and

  # `context_window` is the ceiling this deployment publishes for the lane.

  #

  # Gemini 3.7 Flash leads, so it is what a caller that names none gets: fast,

  # a million tokens of context, and steady enough to hold a conversation.

  #

  # Ox Alpha is what delegated children run on. It is built for sustained

  # agentic coding, which is what a child is given, and where it stalls the

  # cost is one child rather than the conversation — a session opened on it

  # answered "sup" with nothing at all, and a child's first request returned an

  # empty 200 after three minutes.

  #

  # Luna is the backup, and is what answers where the OpenRouter credential is

  # not configured and neither of the two above can be served.

  model_catalog: [

    %{

      id: {:config, :openai_model},

      provider: :openai,

      provider_model: {:config, :openai_model},

      context_window: 272_000,

      max_output: 4_096

      id: "gemini-3.7-flash",

      # Through the Vercel gateway, pinned to Vertex, so the call lands on

      # Google's hardware and spends this account's Google credits. OpenRouter

      # serves the same model and that lane worked, but its credits are not

      # these credits.

      provider: :vercel_gateway,

      provider_model: "google/gemini-3.7-flash",

      context_window: 1_048_576,

      max_output: 65_536

    },

    %{

      id: "ox-alpha",

      provider: :openrouter,

      provider_model: {:config, :openrouter_model},

      context_window: 256_000,

      # A million, per the model's own listing. The 256,000 here was a guess

      # made before there was a page to read.

      context_window: 1_000_000,

      # Ox Alpha is a reasoning model, and its thinking is charged against this

      # allowance before a single word of the answer is. At 4,096 a child agent

      # with a real task spent the whole budget reasoning and returned an empty

      # 200 after three minutes, which read as the proxy having failed.

      max_output: 64_000

    },

    %{

      id: {:config, :openai_model},

      provider: :openai,

      provider_model: {:config, :openai_model},

      context_window: 272_000,

      max_output: 4_096

    }

  ],

  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.

  vercel_gateway_providers: ["vertex"],

  gemini_model: "gemini-3.7-flash",

  box_api_key: nil,

  box_api: [

  config :openagents, :openai_api_key, optional_text.("OPENAI_API_KEY")

  config :openagents, :openrouter_api_key, optional_text.("OPENROUTER_API_KEY")

  config :openagents, :gemini_api_key, optional_text.("GEMINI_API_KEY")

  config :openagents, :vercel_gateway_api_key, optional_text.("AI_GATEWAY_API_KEY")

  config :openagents, :box_api_key, optional_text.("BOX_API_KEY")

end

# Test fakes for providers and voice sideband so the suite never reaches the network.

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

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

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

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

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

  # and the test environment swaps adapters without touching it.

  @provider_lanes %{

    openai: :provider,

    openrouter: :openrouter_provider

    openrouter: :openrouter_provider,

    vercel_gateway: :vercel_gateway_provider

  }

  @type t :: %{

      input: input_items(request),

      tools: Enum.map(request.tool_definitions, &tool_definition/1),

      parallel_tool_calls: false,

      max_output_tokens: 4_096,

      max_output_tokens: request.max_output,

      stream: true

    }

    |> maybe_put(:previous_response_id, request.previous_response_id)

  @endpoint "https://openrouter.ai/api/v1/chat/completions"

  @doc false

  def endpoint, do: @endpoint

  @impl true

  def id, do: "openrouter.chat_completions"

    end

  end

  @doc false

  def post(api_key, request, options), do: request(api_key, request, options)

  defp request(api_key, %Request{} = request, options) do

    request_options = Keyword.get(options, :request_options, [])

    base_options = [

      auth: {:bearer, api_key},

      headers: [{"accept", "text/event-stream"}],

      json: request_payload(request),

      json: Map.merge(request_payload(request), Keyword.get(options, :payload_extra, %{})),

      into: :self,

      receive_timeout: 120_000,

      retry: false

    ]

    case Req.post(@endpoint, Keyword.merge(base_options, request_options)) do

    endpoint = Keyword.get(options, :endpoint, @endpoint)

    case Req.post(endpoint, Keyword.merge(base_options, request_options)) do

      {:ok, response} ->

        {:ok, response}

      messages: messages(request),

      stream: true,

      stream_options: %{include_usage: true},

      max_tokens: 4_096

      max_tokens: request.max_output

    }

    |> maybe_put_tools(request.tool_definitions)

  end

    }

  end

  @doc false

  def consume(response, on_event), do: consume_response(response, on_event)

  defp consume_response(%Req.Response{status: status, body: body}, on_event)

       when status in 200..299 do

    body

  @moduledoc "Provider-neutral input frozen for one Sarah inference."

  @enforce_keys [:model_id, :instructions, :input]

  defstruct @enforce_keys ++ [tool_definitions: [], tool_outputs: [], previous_response_id: nil]

  defstruct @enforce_keys ++

              [

                tool_definitions: [],

                tool_outputs: [],

                previous_response_id: nil,

                # How many tokens the answer may take, from the model's catalog

                # entry. Carried here rather than compiled into each adapter,

                # because it is a fact about the model and the adapters had the

                # same literal in both — which meant a reasoning model, whose

                # thinking is charged against this same allowance, could spend

                # all of it before writing a word and return an empty answer.

                max_output: 4_096

              ]

  @typedoc """

  A prior tool call an assistant turn carried, so a continuation request can

defmodule OpenAgents.Providers.VercelGateway do

  @moduledoc """

  Vercel AI Gateway adapter: one endpoint in front of many providers.

  This is how Gemini reaches Google's own hardware, and the reason it exists is

  money. The credits this account holds are Google's, so a Gemini call has to

  land on Vertex to spend them. Two routes reach Vertex:

  1. Directly, with a Google identity. That was written and it worked, and it

     cost an OAuth token minter, a service-account JWT signer, a project-scoped

     `locations/global` path, and a workaround for Gemini 3 refusing any

     transcript whose `functionCall` parts do not carry back the

     `thoughtSignature` it produced — a 400, not a warning, with nowhere in an

     OpenAI-shaped transcript to put a 360-character signature.

  2. Through this gateway, which is OpenAI chat completions — the shape the

     OpenRouter adapter already speaks — and which does that translation

     itself.

  The gateway's own reply settles it. With BYOK Vertex credentials configured

  it answers `"credentialType":"byok"`, `"resolvedProvider":"vertex"`, and

  `"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

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

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

  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,

  and the pin.

  """

  @behaviour OpenAgents.Providers.Provider

  alias OpenAgents.Providers.{OpenRouter, Request}

  @endpoint "https://ai-gateway.vercel.sh/v1/chat/completions"

  @impl true

  def id, do: "vercel_gateway.chat_completions"

  @impl true

  def capabilities, do: [:text, :tool_calls, :usage]

  @impl true

  def configured? do

    match?({:ok, _key}, OpenAgents.RuntimeConfig.fetch_secret(:vercel_gateway_api_key))

  end

  @impl true

  def stream(%Request{} = request, on_event) when is_function(on_event, 1) do

    stream(request, on_event, [])

  end

  @doc false

  def stream(%Request{} = request, on_event, options)

      when is_function(on_event, 1) and is_list(options) do

    with {:ok, api_key} <- fetch_api_key(options),

         {:ok, response} <- OpenRouter.post(api_key, request, gateway_options(options)) do

      OpenRouter.consume(response, on_event)

    end

  end

  defp fetch_api_key(options) do

    case Keyword.fetch(options, :api_key) do

      {:ok, key} when is_binary(key) and byte_size(key) > 0 ->

        {:ok, key}

      _not_supplied ->

        case OpenAgents.RuntimeConfig.fetch_secret(:vercel_gateway_api_key) do

          {:ok, key} -> {:ok, key}

          {:error, :not_configured} -> {:error, :missing_api_key}

        end

    end

  end

  defp gateway_options(options) do

    options

    |> Keyword.put(:endpoint, @endpoint)

    |> Keyword.put(:payload_extra, payload_extra())

  end

  @doc false

  def payload_extra do

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

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

      _unset -> %{}

    end

  end

end

  @spec fetch_secret(:openai_api_key | :openrouter_api_key) ::

          {:ok, String.t()} | {:error, :not_configured}

  def fetch_secret(secret)

      when secret in [:openai_api_key, :openrouter_api_key, :gemini_api_key] do

      when secret in [

             :openai_api_key,

             :openrouter_api_key,

             :gemini_api_key,

             :vercel_gateway_api_key

           ] do

    case Application.fetch_env(:openagents, secret) do

      {:ok, value} when is_binary(value) and byte_size(value) > 0 -> {:ok, value}

      _missing -> {:error, :not_configured}

      instructions: join_text(system),

      input: Enum.flat_map(turns, &input_message/1),

      tool_definitions: tool_definitions(body["tools"]),

      tool_outputs: tool_outputs(turns)

      tool_outputs: tool_outputs(turns),

      max_output: model.max_output

    }

    if request.input == [] do

  alias OpenAgents.Chat.OpenRouter

  alias OpenAgents.Inference.Models

  test "the default model is the configured one, served by the configured adapter" do

  test "the default is the catalog's first entry, served by that lane's adapter" do

    default = Models.default()

    assert default.id == Application.fetch_env!(:openagents, :openai_model)

    assert default.provider_model == default.id

    assert default.adapter == Application.fetch_env!(:openagents, :provider)

    # Gemini 3.7 Flash leads: a caller that names no model is holding a

    # conversation, and that is what this deployment answers one with.

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

    assert default.provider_model == "google/gemini-3.7-flash"

    assert default.adapter == Application.fetch_env!(:openagents, :openrouter_provider)

    assert Models.default_id() == default.id

    assert Models.default_id() == hd(Models.ids())

  end

  test "the OpenAI lane is still served, as the backup it now is" do

    configured = Application.fetch_env!(:openagents, :openai_model)

    assert {:ok, luna} = Models.fetch(configured)

    assert luna.provider_model == luna.id

    assert luna.adapter == Application.fetch_env!(:openagents, :provider)

  end

  test "ox-alpha publishes a public id and routes the vendor string" do

    assert Models.available_ids() == Models.ids()

  end

  describe "the answer allowance a model publishes" do

    test "Ox Alpha's is large enough for a model that reasons before it answers" do

      # Its thinking is charged against the same allowance as its answer. At

      # 4,096 a child agent with a real task spent the whole budget reasoning

      # and returned nothing, after three minutes, on a 200.

      {:ok, ox} = Models.fetch("ox-alpha")

      assert ox.max_output >= 32_000

      assert ox.context_window >= 1_000_000

    end

    test "the published catalog carries it, so a client is not guessing" do

      entry = Enum.find(Models.catalog(), &(&1["id"] == "ox-alpha"))

      assert entry["max_output"] == 64_000

    end

    test "Gemini is routed through the gateway, on the slug the gateway knows" do

      # Not `gemini-3.7-flash`, which is what a caller asks for. The gateway

      # resolves `creator/model` slugs, and it is pinned to Vertex so the call

      # spends this account's Google credits.

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

      assert gemini.provider == :vercel_gateway

      assert gemini.provider_model == "google/gemini-3.7-flash"

    end

  end

end

      {:ok, grant, token} = Inference.mint(input)

      assert grant.status == "active"

      assert grant.model_id == Application.fetch_env!(:openagents, :openai_model)

      assert grant.model_id == OpenAgents.Inference.Models.default_id()

      assert String.starts_with?(token, "sig_")

      assert grant.max_calls > 0

      # Only the digest is stored; the token is not recoverable from the row.

    Enum.map_join(frames, "", &("data: " <> Jason.encode!(&1) <> "\n\n")) <> "data: [DONE]\n\n"

  end

  describe "how many tokens the answer may take" do

    test "comes from the model's catalog entry, not a literal in this module" do

      # Ox Alpha is a reasoning model: its thinking is charged against this

      # allowance before a word of the answer is. Hardcoded at 4,096, a child

      # agent with a real task spent the whole budget reasoning and returned an

      # empty 200 after three minutes, which read as the proxy having failed.

      request = %Request{

        model_id: "stealth/ox-alpha",

        instructions: "Be brief.",

        input: [%{role: "user", content: "hello"}],

        max_output: 64_000

      }

      assert OpenRouter.request_payload(request)[:max_tokens] == 64_000

    end

    test "defaults to a figure a caller that names none still works on" do

      request = %Request{

        model_id: "stealth/ox-alpha",

        instructions: "Be brief.",

        input: [%{role: "user", content: "hello"}]

      }

      assert OpenRouter.request_payload(request)[:max_tokens] == 4_096

    end

  end

end

  @adapters %{

    OpenAgents.Providers.OpenAI => :outbound_http,

    OpenAgents.Providers.OpenRouter => :outbound_http,

    OpenAgents.Providers.VercelGateway => :outbound_http,

    OpenAgents.Providers.RecordingTestProvider => :in_process,

    OpenAgents.Providers.Test => :in_process,

    OpenAgents.Providers.UnconfiguredTestProvider => :in_process,

    OpenAgents.Conversations => :pins_a_composed_request,

    OpenAgents.Providers.OpenAI => :adapter,

    OpenAgents.Providers.OpenRouter => :adapter,

    OpenAgents.Providers.VercelGateway => :adapter,

    OpenAgents.Providers.RecordingTestProvider => :adapter,

    OpenAgents.Providers.Test => :adapter,

    OpenAgents.Providers.Request => :the_struct_itself

defmodule OpenAgents.Providers.VercelGatewayTest do

  use ExUnit.Case, async: true

  alias OpenAgents.Providers.VercelGateway

  describe "pinning the provider" do

    test "sends the gateway the provider set 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"]}}}

    end

    test "sends no pin at all when none is configured, rather than an empty one" 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

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

      assert VercelGateway.payload_extra() == %{}

    end

  end

  describe "the credential" do

    test "is its own, not OpenRouter's" do

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

      Application.put_env(:openagents, :vercel_gateway_api_key, nil)

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

      refute VercelGateway.configured?()

      Application.put_env(:openagents, :vercel_gateway_api_key, "vck_test")

      assert VercelGateway.configured?()

    end

  end

  test "speaks chat completions, and says so" do

    assert VercelGateway.id() == "vercel_gateway.chat_completions"

    assert :tool_calls in VercelGateway.capabilities()

  end

end

    assert error["served"] == OpenAgents.Inference.Models.ids()

    # The grant's model_id stays Sarah's configured model, never the body's.

    assert grant.model_id == Application.fetch_env!(:openagents, :openai_model)

    assert grant.model_id == OpenAgents.Inference.Models.default_id()

  end

  test "a body naming a served model other than the grant's is refused, never substituted",

  describe "routing the grant's model" do

    setup do

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

      Application.put_env(:openagents, :openrouter_provider, RecordingTestProvider)

      # Both routed lanes, because these tests are about which model string

      # reaches a provider and the models are spread across them: Ox Alpha on

      # OpenRouter, Gemini on the gateway.

      lanes = [:openrouter_provider, :vercel_gateway_provider]

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

      for lane <- lanes, do: Application.put_env(:openagents, lane, RecordingTestProvider)

      Application.put_env(:openagents, :test_recording_provider_observer, self())

      on_exit(fn ->

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

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

        Application.delete_env(:openagents, :test_recording_provider_observer)

      end)

    end

      assert output.output == %{"content" => "hello"}

    end

    test "a default grant stays on the default lane", %{conn: conn} do

    test "a default grant is called with the default model's own vendor string", %{conn: conn} do

      # This once asserted the default lane was *not* the recorded one, which

      # only held while the default sat on the other adapter. What it was

      # checking is that a grant naming no model is routed as its own catalog

      # entry says — the vendor string, not the public id — and that survives

      # the default moving between lanes.

      %{token: token} = grant("default-lane")

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

      assert conn.status == 200

      refute_received {:recorded_request, _id, _request}

      assert_received {:recorded_request, "test.recording_provider", request}

      {:ok, default} = OpenAgents.Inference.Models.fetch(OpenAgents.Inference.Models.default_id())

      assert request.model_id == default.provider_model

      refute request.model_id == default.id

    end

    test "a grant naming a model the proxy cannot route is refused", %{conn: conn} do

      # A grant's model column is immutable and the mint refuses an unroutable

      # name, so the only way here is the routed set changing underneath a live

      # grant — a model withdrawn after it was issued.

      configured = Application.fetch_env!(:openagents, :openai_model)

      Application.put_env(:openagents, :openai_model, "#{configured}-withdrawn")

      on_exit(fn -> Application.put_env(:openagents, :openai_model, configured) end)

      # grant — a model withdrawn after it was issued. Withdrawn by taking it

      # out of the catalog, rather than by renaming one lane's configured

      # model, so the test says what it means whichever model leads.

      granted = OpenAgents.Inference.Models.default_id()

      catalog = Application.fetch_env!(:openagents, :model_catalog)

      Application.put_env(

        :openagents,

        :model_catalog,

        Enum.reject(catalog, fn entry ->

          case entry.id do

            {:config, key} -> Application.fetch_env!(:openagents, key) == granted

            id -> id == granted

          end

        end)

      )

      on_exit(fn -> Application.put_env(:openagents, :model_catalog, catalog) end)

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

  end

  test "a lane without a configured credential is listed unavailable, not omitted", %{conn: conn} do

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

    # The OpenAI lane, because the default now sits on the OpenRouter one and

    # this test is about a lane going dark *without* taking the default with

    # it: "served here, not currently configured" has to be distinguishable

    # from "not served here" while the deployment still answers.

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

    Application.put_env(

      :openagents,

      :openrouter_provider,

      OpenAgents.Providers.UnconfiguredTestProvider

    )

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

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

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

    body =

      conn

    # availability changes.

    assert Enum.map(body["models"], & &1["id"]) == Models.ids()

    ox_alpha = Enum.find(body["models"], &(&1["id"] == "ox-alpha"))

    assert ox_alpha["availability"] == "unavailable"

    luna =

      Enum.find(body["models"], &(&1["id"] == Application.fetch_env!(:openagents, :openai_model)))

    assert luna["availability"] == "unavailable"

    default_entry = Enum.find(body["models"], &(&1["id"] == body["default"]))

    assert default_entry["availability"] == "available"

      assert body["code"] == "model_unavailable"

      assert Map.has_key?(body["errors"], "model")

      # The refusal names what is currently available.

      assert body["message"] =~ OpenAgents.Inference.Models.default_id()

      # The refusal names what is currently available. Unconfiguring this lane

      # takes every model on it, which is more than one now, so the check is

      # that each surviving model is named rather than that the default is —

      # the default may be on the lane that just went dark.

      available =

        Enum.filter(OpenAgents.Inference.Models.all(), &OpenAgents.Inference.Models.available?/1)

      assert available != []

      for model <- available, do: assert(body["message"] =~ model.id)

    end

    test "a model the proxy cannot route is refused, naming the field", %{conn: conn} do