openai_model: "gpt-5.6-luna",

  openai_api_key: nil,

  openrouter_api_key: nil,

  openrouter_model: "stealth/ox-alpha",

  # The OpenRouter spelling of GLM 5.3 Flash. `stealth/ox-alpha` was this same

  # model under its pre-launch name, and OpenRouter now answers that slug with

  # a 404 that says so. Note the hyphen: OpenRouter writes the creator

  # `z-ai`, the Vercel gateway writes it `zai`, and the two are not

  # interchangeable.

  openrouter_model: "z-ai/glm-5.3-flash",

  # The typed model catalog (`OpenAgents.Inference.Models`, PROVIDER-002):

  # every model this deployment serves, in the order a client should offer

  # them; the first entry is the default. `id` is the public name a caller

  # (including omitting it) for a working figure. `OpenAgents.Inference.Pricing`

  # reads that word, and only `:declared` is billable (METER-001).

  #

  # Every rate below is a placeholder written to make the system run. None of

  # them was read off a provider's price page, so all of them say `:placeholder`

  # and nothing may bill from a cost they produced. Replacing them is an owner

  # action: enter the provider's real rates and set `source: :declared` in the

  # same edit.

  # Every rate below is a placeholder: no operator has declared any of them, so

  # all of them say `:placeholder` and nothing may bill from a cost they

  # produced. Replacing them is an owner action: enter the provider's rates and

  # set `source: :declared` in the same edit.

  #

  # A model with no `pricing` key records no estimated cost at all — not a

  # zero. `gpt-5.6-luna` is that model and it is the lane the coder runs on, so

  # the account's metered spend is a floor rather than a total until it has

  # rates. Every read surface says `unpriced` rather than `$0.00`.

  # The GLM 5.3 Flash figures are the ones to be careful with. Its posted rates

  # on 2026-08-26 were $0.075 in, $0.25 out, and $0.015 cached in per million

  # tokens — a limited-time half-price offer that ends 2026-09-09 16:00 UTC,

  # after which list price is $0.15, $0.50, and $0.03. The entry carries list

  # price, because a figure that silently doubles in two weeks is worse than

  # one that is honestly high, and because neither figure is declared either

  # way. The Gemini figures were written to make the system run and were not

  # read off any price page.

  #

  # 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.

  # A model with no `pricing` key records no estimated cost at all — not a zero

  # — and its usage records stamp `pricing_id: "unpriced"`. No entry below is in

  # that state now that `gpt-5.6-luna` has been withdrawn, but the state is

  # still reached: a call the gateway's fallback chain rescues is answered by a

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

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

  #

  # 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.

  # This list is exactly two 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

  # `model_unavailable`). Withdrawing an entry is therefore a real withdrawal

  # rather than a hidden one.

  #

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

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

  # GLM 5.3 Flash leads, so it is what a caller that names none gets: a million

  # tokens of context, and cheap enough per token to hold an ordinary

  # conversation on a model that reasons before it answers. Its thinking is

  # charged against `max_output` before a word of the answer is — a 256-token

  # allowance was spent 243 tokens deep in reasoning and the answer was cut off

  # mid-word on `finish_reason: "length"` — so the allowance below is the

  # ceiling the gateway publishes for the lane rather than a modest figure.

  #

  # `ox-alpha`, which used to be listed here on the OpenRouter lane, was this

  # same model under its pre-launch name. OpenRouter now answers

  # `stealth/ox-alpha` with a 404 saying so, which is why it is gone rather

  # than demoted: there was never a second model to keep. The old public id

  # deliberately does not resolve to the new entry — silently answering a

  # withdrawn name with a survivor is what PROVIDER-002 forbids.

  #

  # Gemini 3.7 Flash is second: fast, a million tokens of context, and steady

  # 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.

  #

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

  # chain, tried inside a single call when the requested model fails, and it is

  # not a menu: nobody selects a model from it. Luna sitting last in it is the

  # backstop of a backstop. Withdrawing Luna from this catalog means no caller

  # can choose it; it does not mean the gateway may never fall back to it.

  #

  # A call the chain rescues is still attributed honestly. The adapter reads the

  # serving model back off the response, so a call answered by a model this

  # catalog does not admit records no price at all — `pricing_id: "unpriced"` —

  # rather than being charged at the rates of the model that was asked for

  # (METER-001, PROVIDER-002).

  model_catalog: [

    %{

      id: "glm-5.3-flash",

      # Through the Vercel gateway, which resolves the slug to z.ai and calls

      # it with the BYOK z.ai credentials this account holds there. The

      # `providerOptions.gateway.order` pin below names Vertex, which does not

      # serve this model; the gateway reports `"planningReasoning":"BYOK

      # credentials available for: zai"` and routes to z.ai anyway, so the pin

      # costs this lane nothing.

      provider: :vercel_gateway,

      provider_model: "zai/glm-5.3-flash",

      # A million, per z.ai's listing and the gateway's. OpenRouter publishes

      # 1,048,576 for the same model; a million is the smaller of the two and

      # the number the serving lane states.

      context_window: 1_000_000,

      # The gateway's published ceiling for this lane. It has to be large: the

      # model reasons against this allowance, so a small one is spent thinking

      # and the caller is handed a truncated answer on a 200.

      max_output: 131_000,

      # Placeholder: list price ($0.15 in, $0.50 out, $0.03 cached in, per

      # million tokens), not the half-price offer running until 2026-09-09

      # 16:00 UTC. Rates an operator has not declared, so nothing may bill from

      # them until `source` says `:declared`.

      pricing: %{

        id: "placeholder.glm-5.3-flash.v1",

        source: :placeholder,

        input_per_million_tokens: 150_000,

        output_per_million_tokens: 500_000,

        cached_input_per_million_tokens: 30_000

      }

    },

    %{

      id: "gemini-3.7-flash",

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

        output_per_million_tokens: 10_000_000,

        cached_input_per_million_tokens: 100_000

      }

    },

    %{

      id: "ox-alpha",

      provider: :openrouter,

      provider_model: {:config, :openrouter_model},

      # 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,

      # Placeholder: the operator must set real provider rates and flip `source`

      # to `:declared` before anything bills from this. This entry does not

      # declare a cached-input rate.

      pricing: %{

        id: "placeholder.ox-alpha.v1",

        source: :placeholder,

        input_per_million_tokens: 500_000,

        output_per_million_tokens: 2_000_000

      }

    },

    %{

      id: {:config, :openai_model},

      provider: :openai,

      provider_model: {:config, :openai_model},

      context_window: 272_000,

      max_output: 4_096

      # This entry deliberately omits `pricing`, so a grant pinned to it records

      # no estimated cost rather than a made-up zero. Its usage records stamp

      # `pricing_id: "unpriced"`, `Threads.spend/1` refuses to total a session

      # that touched it, and the thread page shows the word instead of a

      # figure. Giving this lane real rates is the single highest-value edit in

      # this file: it is where the coder's spend actually goes.

    }

  ],

  gemini_api_key: nil,

  # 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"],

  # The gateway's ordered fallback chain, tried within one call when the

  # requested model fails. `zai/glm-5.3-flash` leads it because it is the only

  # entry this deployment also admits in `:model_catalog`: a rescued call that

  # lands on an admitted model is priced and attributed normally, and every

  # other entry here records no price at all. `openai/gpt-5.6-luna` stays last

  # at owner direction — it is the backstop of a backstop, reachable only

  # automatically and selectable by nobody.

  vercel_gateway_fallback_models: [

    "zai/glm-5.3-flash",

    "zai/glm-5.3",

    "zai/glm-5.2",

    "openai/gpt-5.6-luna"

  # column; only account creation reads this.

  account_credit_microusd: 20_000_000,

  visitor_credit_microusd: 2_000_000,

  inference_input_price_microusd_per_ktoken: 1_250,

  inference_output_price_microusd_per_ktoken: 10_000,

  forge_enabled: false,

  forge_boot_converge_enabled: false,

  forge_deploy_lane_enabled: false,

| GitHub | `GITHUB_TOKEN_ENCRYPTION_KEY_ID` | Bounded active-key identifier prefixed with `development-`, `test-`, `staging-`, or `production-` to match the runtime |

| GitHub | `GITHUB_TOKEN_DECRYPTION_KEYS_JSON` | Optional map of at most 16 same-environment prior keys used only during rewrap; omit the active ID |

| Providers | `OPENAI_API_KEY` | Environment-specific provider secret; required by the current text provider |

| Providers | `OPENROUTER_API_KEY` | Environment-specific server-only credential for the `/chat` OpenRouter adapter; the `/chat` console requests `stealth/ox-alpha` only, so a turn fails rather than answering as another model; empty disables the adapter |

| Providers | `OPENROUTER_API_KEY` | Environment-specific server-only credential for the `/chat` OpenRouter adapter; the `/chat` console requests `z-ai/glm-5.3-flash` only, so a turn fails rather than answering as another model; empty disables the adapter |

| Providers | `OPENAGENTS_INFERENCE_PROXY_URL` | HTTPS URL without credentials when computers are enabled; empty disables |

| Computers | `OPENAGENTS_MACHINE_TOKEN_TTL_SECONDS` | `300` through `2592000`; Gate 5 uses the 30-day maximum |

| Recording | `VOICE_RECORDING_ENCRYPTION_KEY` | Base64-encoded 32-byte key when recording is enabled; empty disables recording storage |

  # OPENROUTER_API_KEY environment variable natively, so the setup script

  # never touches the credential.

  #

  # This is the one lane that still buys inference from OpenRouter rather than

  # through the Vercel gateway, and it is a deliberate temporary exception:

  # OpenCode speaks to OpenRouter itself, so it needs OpenRouter's own spelling

  # of the model (`z-ai/glm-5.3-flash`, hyphenated, where the gateway writes

  # `zai/glm-5.3-flash`). OpenRouter charges slightly more for the same model.

  # Moving this lane onto the gateway is the intended destination and a

  # separate change.

  #

  # The order matters. The whole script runs under `set -euo pipefail`, so the

  # configuration is written first: an install that fails on a bad network day

  # then costs the binary and nothing else, and a later manual install finds

  # the model already pointed at Ox Alpha.

  # the model already pointed at GLM 5.3 Flash.

  defp setup_script do

    model = Application.get_env(:openagents, :openrouter_model, "stealth/ox-alpha")

    model = Application.get_env(:openagents, :openrouter_model, "z-ai/glm-5.3-flash")

    configuration =

      Jason.encode!(%{

  # output list is not a Gemini turn and vice versa, so a conversation that

  # switches backends replays only the turns the chosen backend produced rather

  # than handing one provider another's transcript shape. A row written before

  # backends were named is an Ox Alpha turn, which is what its `NULL` means.

  # backends were named is an Ox Alpha turn — GLM 5.3 Flash under its

  # pre-launch name — which is what its `NULL` means.

  defp provider_history(conversation_id, excluded_run_id, backend) do

    default_id = Backends.default_id()

  defp usage_view(_counts, _completion), do: nil

  # Ox Alpha reports a reasoning count of zero for turns it plainly reasoned

  # through, so that zero measures nothing the turn did and the turn reports no

  # reasoning count rather than a count of none. The call is made here, against

  # the same stored reasoning the transcript renders, so a row written before

  # this rule reads the same way as one written after it and no stored count is

  # ever rewritten.

  # GLM 5.3 Flash reports a reasoning count of zero for turns it plainly

  # reasoned through, so that zero measures nothing the turn did and the turn

  # reports no reasoning count rather than a count of none. The call is made

  # here, against the same stored reasoning the transcript renders, so a row

  # written before this rule reads the same way as one written after it and no

  # stored count is ever rewritten.

  defp reasoning_view(0, completion), do: if(reasoned?(completion), do: nil, else: 0)

  defp reasoning_view(count, _completion), do: count

  @backends [

    %{

      id: "ox-alpha",

      label: "Ox Alpha",

      id: "glm-5.3-flash",

      label: "GLM 5.3 Flash",

      adapter: OpenRouter,

      model: nil,

      description: "Ox Alpha through OpenRouter. The default when a turn names no backend.",

      description: "GLM 5.3 Flash through OpenRouter. The default when a turn names no backend.",

      free: false

    },

    %{

    }

  ]

  @default_id "ox-alpha"

  # `ox-alpha` was this same model under its pre-launch name, and OpenRouter

  # now answers that slug with a 404 saying so, so this is a rename rather than

  # a substitution.

  @default_id "glm-5.3-flash"

  @type t :: %{

          id: String.t(),

  Server-side OpenRouter Responses adapter for the `/chat` console.

  The adapter keeps the OpenRouter credential and HTTP transport on the server.

  It requests Ox Alpha and uses chat completions only when a provider does not

  support Responses. It returns normalized failures without provider

  It requests GLM 5.3 Flash and uses chat completions only when a provider does

  not support Responses. It returns normalized failures without provider

  credentials or response bodies, and it separates the failures an operator can

  retry — a rate limit, an unavailable provider, an interrupted stream, and a

  malformed stream — from the ones a retry cannot fix.

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

  @responses_endpoint "https://openrouter.ai/api/v1/responses"

  @default_model "stealth/ox-alpha"

  @model_label "Ox Alpha"

  # `stealth/ox-alpha` was GLM 5.3 Flash under its pre-launch name; OpenRouter

  # answers that slug with a 404 now. Note the hyphen: OpenRouter writes the

  # creator `z-ai` and the Vercel gateway writes it `zai`.

  @default_model "z-ai/glm-5.3-flash"

  @model_label "GLM 5.3 Flash"

  @maximum_tool_rounds 6

  @tool_instructions """

  Ground every repository claim in repository tool output. Never claim that a file or directory exists unless a tool result confirms it. Use list_repository_directory before guessing a path, and use the returned paths exactly. Do not retry the same failed repository, path, and ref combination. If a read fails, list its parent directory once or tell the user that the requested content is unavailable.

  client selects from what is actually served instead of guessing.

  Two names appear per model and they are not the same name. The `id` is what

  a client asks for and what the grant publishes — `ox-alpha`. The

  `provider_model` is what the provider is called with — `stealth/ox-alpha`.

  a client asks for and what the grant publishes — `glm-5.3-flash`. The

  `provider_model` is what the provider is called with — `zai/glm-5.3-flash`.

  Keeping them apart is what lets the routed vendor string change without

  invalidating grants that already name the model. A catalog entry may write

  either name as `{:config, key}` to follow a runtime-configurable value.

  @doc """

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

  A thread opened before this list existed carries the vendor string

  (`stealth/ox-alpha`) in its `model` column, so a vendor spelling resolves to

  the model it routes rather than leaving those threads unable to mint.

  A thread opened before this list existed carries a vendor string rather than

  a public id in its `model` column, so a vendor spelling (`zai/glm-5.3-flash`)

  resolves to the model it routes rather than leaving those threads unable to

  mint. A vendor string this catalog no longer routes does not resolve: a

  withdrawn model is withdrawn, not quietly replaced with a survivor.

  """

  @spec fetch(String.t() | nil) :: {:ok, t()} | :error

  def fetch(id) when is_binary(id) do

  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. `gpt-5.6-luna` is the lane the coder

  actually runs on and this deployment has never been told its rates, 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.

  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.

  Every admitted model carries rates now, and none of them is declared, so the

  live case for a selectable model is `provisional`. `unpriced` is not dead

  code: a call the gateway's fallback chain answers with a model the catalog

  does not admit reaches it, and so would any entry added without rates.

  So a cost is never a bare integer here. Every metered usage record carries a

  `pricing_id` naming the rate table it was priced against, and the id resolves

  @moduledoc """

  OpenRouter chat-completions adapter for the inference proxy.

  This is the second provider the proxy can reach, and it exists so a grant can

  pin Ox Alpha: `OpenAgents.Inference.Models` names which model each provider

  No catalog entry names this lane today — both admitted models are served

  through the Vercel gateway — but the gateway adapter speaks this wire format

  and delegates its request building and stream decoding here, so this module

  is on the path of every proxied call. It also remains a lane a catalog entry

  may name: `OpenAgents.Inference.Models` names which model each provider

  serves, and the proxy dispatches on the grant's model rather than on one

  compiled-in module.

  # Every chat-completions chunk names the model that produced it, and that

  # name is not always the one the request asked for: the Vercel AI Gateway is

  # configured with a fallback list, so a call for `google/gemini-3.7-flash`

  # can come back served by `openai/gpt-5.6-luna`. Reading the field back is

  # can come back served by `zai/glm-5.3`. Reading the field back is

  # the only way the host learns which lane to price and attribute the call

  # against, so it is carried out as an event rather than dropped.

  #

  models Vercel tries if the primary model fails.

  That list is why this lane reports `substitutable?/0` as true: a call for

  `google/gemini-3.7-flash` can be answered by `openai/gpt-5.6-luna` and still

  return 200, so the model that was asked for is not evidence of the model that

  `google/gemini-3.7-flash` can be answered by `zai/glm-5.3` and still return

  200, so the model that was asked for is not evidence of the model that

  answered. The response's `model` field is, and the chat-completions decoder

  reads it back as `{:model_served, name}` so the call is priced and attributed

  against the lane that served it rather than the lane that was requested

  True exactly while a fallback list is configured. `providerOptions.gateway.models`

  is an instruction to Vercel to try another model when the primary fails, so a

  request for `google/gemini-3.7-flash` can be answered by `openai/gpt-5.6-luna`

  and return 200. The host reads the serving model back off the response; this

  request for `google/gemini-3.7-flash` can be answered by `zai/glm-5.3` and

  return 200. The host reads the serving model back off the response; this

  says what its silence means, because a lane that cannot be substituted for

  needs no disclosure to be attributed correctly.

  """

  `OpenAgents.Inference.Models.default_id/0`, `high` reasoning, and the

  `read_only` permission profile; a caller may narrow or widen only within the

  admitted vocabulary. The thread's model is the model its grant pins, so a

  caller that opens a thread on `ox-alpha` gets authority for `ox-alpha`.

  caller that opens a thread on `glm-5.3-flash` gets authority for

  `glm-5.3-flash`.

  Admission is where the ceiling lives. Elapsed authority is reaped first, so a

  slot held by an abandoned thread is released before the count is taken, and

  What answered is read back off the response rather than assumed from the

  request. One lane can substitute: the Vercel AI Gateway is configured with a

  fallback model list, so a call for `google/gemini-3.7-flash` can be served by

  `openai/gpt-5.6-luna` and still return 200. The serving model therefore

  `zai/glm-5.3` and still return 200. The serving model therefore

  decides three things — the name attributed on the response, the lane whose

  health is recorded, and the rate table the usage record is priced against

  (METER-001). A substitutable lane whose response discloses no model is

  caller states which model it wants is the thread it opens, and the response

  publishes the model the grant carries. Admitting it at the door is what lets

  a coding session run its own turns on one model and its delegated children on

  another: it opens a second thread on `ox-alpha` and gets authority for

  `ox-alpha`, with its own budget, rather than borrowing the first thread's.

  another: it opens a second thread on `gemini-3.7-flash` and gets authority

  for `gemini-3.7-flash`, with its own budget, rather than borrowing the first

  thread's.

  The exception is the `local` lane, and it is an exception to the grant, not

  to the record. `"lane": "local"` opens a transcript-only thread: the model is

defmodule OpenAgentsWeb.ChatConsoleLive do

  @moduledoc """

  The Ox Alpha console, reachable at `/chat` by operators only.

  The GLM 5.3 Flash console, reachable at `/chat` by operators only.

  The console drives one Ox Alpha conversation per operator account. It sends

  every request to OpenRouter from the server, so the provider credential never

  reaches the browser, and it prefers the Responses API, using chat completions

  only when a provider cannot serve Responses.

  The console drives one GLM 5.3 Flash conversation per operator account. It

  sends every request to OpenRouter from the server, so the provider credential

  never reaches the browser, and it prefers the Responses API, using chat

  completions only when a provider cannot serve Responses.

  It shares the AI Elements components with Sarah's transcript at `/sarah` and

  shares none of her state: no persona, no voice, no work queue, and no

  alias OpenAgentsWeb.LiveRefresh

  @suggestions [

    "Summarize what the Ox Alpha stress fleet measures today.",

    "Summarize what the stress fleet measures today.",

    "Draft a checklist for a cloud-computer stress run.",

    "Explain the difference between a push and a deploy here.",

    "Write a short status update for the current fleet work."

    20260825230000,

    20260826010000,

    20260826103000,

    20260826145554

    20260826145554,

    20260826160000

  ],

  "required_tables": [

    "users",

defmodule OpenAgents.Repo.Migrations.RenameOxAlphaChatBackend do

  use Ecto.Migration

  # Rename the recorded `ox-alpha` chat backend to `glm-5.3-flash`.

  #

  # `stealth/ox-alpha` was GLM 5.3 Flash under its pre-launch name; OpenRouter

  # answers that slug with a 404 saying so. The backend was renamed rather than

  # replaced, so the rows it wrote describe the same model under an old name.

  #

  # Leaving them would lose them. `OpenAgents.Chat.AccountTurns` replays a

  # conversation's history only into the backend that wrote it, matching on

  # this column, so a row still reading `ox-alpha` would never replay again —

  # the transcript would silently shorten rather than fail.

  def up do

    execute("UPDATE account_chat_runs SET backend = 'glm-5.3-flash' WHERE backend = 'ox-alpha'")

  end

  def down do

    execute("UPDATE account_chat_runs SET backend = 'ox-alpha' WHERE backend = 'glm-5.3-flash'")

  end

end

data: {"type":"response.output_item.done","response_id":"resp_repo_edit","output_index":1,"item":{"type":"function_call","id":"fc_repo_edit","call_id":"call_repo_edit","name":"edit","arguments":"{\"path\":\"notes.txt\",\"old_string\":\"beta\",\"new_string\":\"gamma\"}","status":"completed"}}

data: {"type":"response.completed","response":{"id":"resp_repo_edit","object":"response","status":"completed","model":"stealth/ox-alpha","output":[{"type":"reasoning","id":"rs_repo_edit","status":"completed","summary":[{"type":"summary_text","text":"Apply the exact replacement to the new draft."}],"encrypted_content":"encrypted-repo-edit"},{"type":"function_call","id":"fc_repo_edit","call_id":"call_repo_edit","name":"edit","arguments":"{\"path\":\"notes.txt\",\"old_string\":\"beta\",\"new_string\":\"gamma\"}","status":"completed"}]}}

data: {"type":"response.completed","response":{"id":"resp_repo_edit","object":"response","status":"completed","model":"z-ai/glm-5.3-flash","output":[{"type":"reasoning","id":"rs_repo_edit","status":"completed","summary":[{"type":"summary_text","text":"Apply the exact replacement to the new draft."}],"encrypted_content":"encrypted-repo-edit"},{"type":"function_call","id":"fc_repo_edit","call_id":"call_repo_edit","name":"edit","arguments":"{\"path\":\"notes.txt\",\"old_string\":\"beta\",\"new_string\":\"gamma\"}","status":"completed"}]}}

data: [DONE]

data: {"type":"response.output_item.done","response_id":"resp_repo_read","output_index":2,"item":{"type":"function_call","id":"fc_repo_read","call_id":"call_repo_read","name":"read","arguments":"{\"path\":\"notes.txt\",\"from\":\"workspace\"}","status":"completed"}}

data: {"type":"response.completed","response":{"id":"resp_repo_read","object":"response","status":"completed","model":"stealth/ox-alpha","output":[{"type":"reasoning","id":"rs_repo_read","status":"completed","summary":[{"type":"summary_text","text":"Read the current file before changing it."}],"encrypted_content":"encrypted-repo-read"},{"type":"message","id":"msg_repo_read_preamble","role":"assistant","status":"completed","content":[{"type":"output_text","text":"I will inspect the current workspace file before changing it.","annotations":[]}]},{"type":"function_call","id":"fc_repo_read","call_id":"call_repo_read","name":"read","arguments":"{\"path\":\"notes.txt\",\"from\":\"workspace\"}","status":"completed"}]}}

data: {"type":"response.completed","response":{"id":"resp_repo_read","object":"response","status":"completed","model":"z-ai/glm-5.3-flash","output":[{"type":"reasoning","id":"rs_repo_read","status":"completed","summary":[{"type":"summary_text","text":"Read the current file before changing it."}],"encrypted_content":"encrypted-repo-read"},{"type":"message","id":"msg_repo_read_preamble","role":"assistant","status":"completed","content":[{"type":"output_text","text":"I will inspect the current workspace file before changing it.","annotations":[]}]},{"type":"function_call","id":"fc_repo_read","call_id":"call_repo_read","name":"read","arguments":"{\"path\":\"notes.txt\",\"from\":\"workspace\"}","status":"completed"}]}}

data: [DONE]

data: {"type":"response.output_item.done","response_id":"resp_repo_reread","output_index":1,"item":{"type":"function_call","id":"fc_repo_reread","call_id":"call_repo_reread","name":"read","arguments":"{\"path\":\"notes.txt\",\"from\":\"workspace\"}","status":"completed"}}

data: {"type":"response.completed","response":{"id":"resp_repo_reread","object":"response","status":"completed","model":"stealth/ox-alpha","output":[{"type":"reasoning","id":"rs_repo_reread","status":"completed","summary":[{"type":"summary_text","text":"Read the file again to verify the edit."}],"encrypted_content":"encrypted-repo-reread"},{"type":"function_call","id":"fc_repo_reread","call_id":"call_repo_reread","name":"read","arguments":"{\"path\":\"notes.txt\",\"from\":\"workspace\"}","status":"completed"}]}}

data: {"type":"response.completed","response":{"id":"resp_repo_reread","object":"response","status":"completed","model":"z-ai/glm-5.3-flash","output":[{"type":"reasoning","id":"rs_repo_reread","status":"completed","summary":[{"type":"summary_text","text":"Read the file again to verify the edit."}],"encrypted_content":"encrypted-repo-reread"},{"type":"function_call","id":"fc_repo_reread","call_id":"call_repo_reread","name":"read","arguments":"{\"path\":\"notes.txt\",\"from\":\"workspace\"}","status":"completed"}]}}

data: [DONE]

data: {"type":"response.output_item.done","response_id":"resp_repo_write","output_index":1,"item":{"type":"function_call","id":"fc_repo_write","call_id":"call_repo_write","name":"write","arguments":"{\"path\":\"notes.txt\",\"content\":\"alpha beta\"}","status":"completed"}}

data: {"type":"response.completed","response":{"id":"resp_repo_write","object":"response","status":"completed","model":"stealth/ox-alpha","output":[{"type":"reasoning","id":"rs_repo_write","status":"completed","summary":[{"type":"summary_text","text":"Replace the file with the requested draft."}],"encrypted_content":"encrypted-repo-write"},{"type":"function_call","id":"fc_repo_write","call_id":"call_repo_write","name":"write","arguments":"{\"path\":\"notes.txt\",\"content\":\"alpha beta\"}","status":"completed"}]}}

data: {"type":"response.completed","response":{"id":"resp_repo_write","object":"response","status":"completed","model":"z-ai/glm-5.3-flash","output":[{"type":"reasoning","id":"rs_repo_write","status":"completed","summary":[{"type":"summary_text","text":"Replace the file with the requested draft."}],"encrypted_content":"encrypted-repo-write"},{"type":"function_call","id":"fc_repo_write","call_id":"call_repo_write","name":"write","arguments":"{\"path\":\"notes.txt\",\"content\":\"alpha beta\"}","status":"completed"}]}}

data: [DONE]

data: {"type":"response.created","response":{"id":"resp_demo","object":"response","status":"in_progress","model":"stealth/ox-alpha","output":[]}}

data: {"type":"response.created","response":{"id":"resp_demo","object":"response","status":"in_progress","model":"z-ai/glm-5.3-flash","output":[]}}

data: {"type":"response.in_progress","response":{"id":"resp_demo","object":"response","status":"in_progress","model":"stealth/ox-alpha","output":[]}}

data: {"type":"response.in_progress","response":{"id":"resp_demo","object":"response","status":"in_progress","model":"z-ai/glm-5.3-flash","output":[]}}

data: {"type":"response.output_item.added","response_id":"resp_demo","output_index":0,"item":{"type":"reasoning","id":"rs_demo","status":"in_progress","summary":[]}}

data: {"type":"response.output_item.done","response_id":"resp_demo","output_index":2,"item":{"type":"function_call","id":"fc_demo","call_id":"call_demo","name":"read_repository_file","arguments":"{\"repository\":\"OpenAgentsInc/openagents.com\",\"path\":\"README.md\",\"ref\":\"\"}","status":"completed"}}

data: {"type":"response.completed","response":{"id":"resp_demo","object":"response","status":"completed","model":"stealth/ox-alpha","output":[{"type":"reasoning","id":"rs_demo","status":"completed","summary":[{"type":"summary_text","text":"The user asked to read a repository file."}],"encrypted_content":"encrypted-demo-reasoning"},{"type":"message","id":"msg_tool_preamble","role":"assistant","status":"completed","content":[{"type":"output_text","text":"I will inspect the connected repository.","annotations":[]}]},{"type":"function_call","id":"fc_demo","call_id":"call_demo","name":"read_repository_file","arguments":"{\"repository\":\"OpenAgentsInc/openagents.com\",\"path\":\"README.md\",\"ref\":\"\"}","status":"completed"}],"usage":{"input_tokens":18,"output_tokens":11,"total_tokens":29,"output_tokens_details":{"reasoning_tokens":7}}}}

data: {"type":"response.completed","response":{"id":"resp_demo","object":"response","status":"completed","model":"z-ai/glm-5.3-flash","output":[{"type":"reasoning","id":"rs_demo","status":"completed","summary":[{"type":"summary_text","text":"The user asked to read a repository file."}],"encrypted_content":"encrypted-demo-reasoning"},{"type":"message","id":"msg_tool_preamble","role":"assistant","status":"completed","content":[{"type":"output_text","text":"I will inspect the connected repository.","annotations":[]}]},{"type":"function_call","id":"fc_demo","call_id":"call_demo","name":"read_repository_file","arguments":"{\"repository\":\"OpenAgentsInc/openagents.com\",\"path\":\"README.md\",\"ref\":\"\"}","status":"completed"}],"usage":{"input_tokens":18,"output_tokens":11,"total_tokens":29,"output_tokens_details":{"reasoning_tokens":7}}}}

data: [DONE]

        {:ok, raw, conn} = Plug.Conn.read_body(conn)

        payload = Jason.decode!(raw)

        assert payload["noEnv"] == true

        assert payload["setupScript"] =~ "openrouter/stealth/ox-alpha"

        assert payload["setupScript"] =~ "openrouter/z-ai/glm-5.3-flash"

        Req.Test.json(conn, box_body(%{"state" => "provisioning", "setupStatus" => "pending"}))

      end)

      end

    end

    assert {:ok, %{"id" => first_id, "model" => "ox-alpha"}} =

    assert {:ok, %{"id" => first_id, "model" => "glm-5.3-flash"}} =

             AccountTurns.submit(user, "First.", subscriber: self(), streamer: recorder.("ox"))

    assert_receive {:request, "ox", _first_request}

    assert_receive {:request, "gemini", gemini_request}

    assert_receive {:account_chat_completed, ^second_id, {:ok, _completion}}

    # Gemini sees its own first turn and nothing from the Ox Alpha lane.

    # Gemini sees its own first turn and nothing from the GLM 5.3 Flash lane.

    assert gemini_request["messages"] == [%{"role" => "user", "content" => "Second."}]

    assert gemini_request["model"] == "gemini-3.7-flash"

  end

  test "no preference resolves to the default, an unknown name does not" do

    assert {:ok, %{id: "ox-alpha"}} = Backends.fetch(nil)

    assert {:ok, %{id: "ox-alpha"}} = Backends.fetch("")

    assert {:ok, %{id: "glm-5.3-flash"}} = Backends.fetch(nil)

    assert {:ok, %{id: "glm-5.3-flash"}} = Backends.fetch("")

    # A caller that asked for one model and was quietly served another has no

    # way to tell, so an unknown name refuses rather than falling back.

            "id" => "resp_test",

            "object" => "response",

            "status" => "completed",

            "model" => "stealth/ox-alpha"

            "model" => "z-ai/glm-5.3-flash"

          }

        })

  setup {Req.Test, :verify_on_exit!}

  test "sends an OpenRouter-compatible Ox Alpha request with a free fallback" do

  test "sends an OpenRouter-compatible GLM 5.3 Flash request with a free fallback" do

    Req.Test.expect(__MODULE__, fn conn ->

      assert conn.request_path == "/api/v1/chat/completions"

      assert ["Bearer test-openrouter-key"] = Plug.Conn.get_req_header(conn, "authorization")

      assert String.starts_with?(referer, "http")

      assert %{

               "model" => "stealth/ox-alpha",

               "model" => "z-ai/glm-5.3-flash",

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

             } = conn.body_params

    assert {:ok, completion} =

             OpenRouter.complete(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

                 "models" => ["openrouter/free"],

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

               },

    assert {:error, :rate_limited} =

             OpenRouter.complete(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

                 "models" => ["openrouter/free"],

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

               },

        sse(%{

          "id" => "gen-metadata",

          "object" => "chat.completion.chunk",

          "model" => "stealth/ox-alpha",

          "model" => "z-ai/glm-5.3-flash",

          "provider" => "Stealth",

          "choices" => [%{"index" => 0, "delta" => %{"content" => "Measured"}}]

        }) <>

          sse(%{

            "id" => "gen-metadata",

            "object" => "chat.completion.chunk",

            "model" => "stealth/ox-alpha",

            "model" => "z-ai/glm-5.3-flash",

            "choices" => [],

            "usage" => %{

              "prompt_tokens" => 12,

      body =

        sse(%{

          "object" => "chat.completion.chunk",

          "model" => "stealth/ox-alpha",

          "model" => "z-ai/glm-5.3-flash",

          "choices" => [%{"index" => 0, "delta" => %{"content" => "Quiet"}}]

        }) <> "data: [DONE]\n\n"

               Plug.Conn.get_req_header(conn, "x-openrouter-categories")

      assert %{

               "model" => "stealth/ox-alpha",

               "model" => "z-ai/glm-5.3-flash",

               "reasoning" => %{

                 "effort" => "max",

                 "exclude" => false,

            "response" => %{

              "id" => "resp_test",

              "object" => "response",

              "model" => "stealth/ox-alpha",

              "model" => "z-ai/glm-5.3-flash",

              "output" => [

                %{

                  "type" => "reasoning",

    assert {:ok,

            %{

              "object" => "response",

              "model" => "stealth/ox-alpha",

              "model" => "z-ai/glm-5.3-flash",

              "assistant_message_id" => "msg_test",

              "assistant_content" => "Hello world",

              "reasoning_summary" => "Checked the prior context.",

            }} =

             OpenRouter.stream(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

                 "models" => ["openrouter/free"],

                 "reasoning" => "max",

                 "messages" => [

          "type" => "response.completed",

          "response" => %{

            "object" => "response",

            "model" => "stealth/ox-alpha",

            "model" => "z-ai/glm-5.3-flash",

            "output" => [

              %{

                "type" => "message",

    assert {:ok, %{"assistant_content" => "Continued"}} =

             OpenRouter.stream(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

                 "messages" => [

                   %{"role" => "user", "content" => "Think"},

                   %{

        sse(%{

          "id" => "gen-stream",

          "object" => "chat.completion.chunk",

          "model" => "stealth/ox-alpha",

          "model" => "z-ai/glm-5.3-flash",

          "choices" => [%{"index" => 0, "delta" => %{"content" => "Fallback"}}]

        }) <> "data: [DONE]\n\n"

    parent = self()

    assert {:ok, %{"object" => "chat.completion", "model" => "stealth/ox-alpha"}} =

    assert {:ok, %{"object" => "chat.completion", "model" => "z-ai/glm-5.3-flash"}} =

             OpenRouter.stream(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

                 "messages" => [

                   %{"role" => "user", "content" => "Hello"},

                   %{

             "The selected model does not support this tool definition."}} =

             OpenRouter.stream(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

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

               },

               fn _event -> :ok end,

    assert {:ok,

            %{

              "object" => "response",

              "model" => "stealth/ox-alpha",

              "model" => "z-ai/glm-5.3-flash",

              "assistant_message_id" => "msg_streamed",

              "assistant_content" => "Streaming works."

            }} =

             OpenRouter.stream(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

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

               },

               fn _event -> :ok end,

            }} =

             OpenRouter.stream(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

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

               },

               &send(parent, {:openrouter_event, &1}),

            "type" => "response.completed",

            "response" => %{

              "object" => "response",

              "model" => "stealth/ox-alpha",

              "model" => "z-ai/glm-5.3-flash",

              "output" => [

                %{

                  "type" => "message",

    assert {:ok, %{"assistant_content" => "OpenAgents is an agent platform."}} =

             OpenRouter.stream(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

                 "messages" => [%{"role" => "user", "content" => "Summarize the README."}]

               },

               &send(parent, {:openrouter_event, &1}),

            "type" => "response.completed",

            "response" => %{

              "object" => "response",

              "model" => "stealth/ox-alpha",

              "model" => "z-ai/glm-5.3-flash",

              "output" => [

                %{

                  "type" => "message",

    assert {:ok, %{"usage" => usage} = completion} =

             OpenRouter.stream(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

                 "messages" => [%{"role" => "user", "content" => "Summarize the README."}]

               },

               &send(parent, {:openrouter_event, &1}),

              "id" => "resp_repo_final",

              "object" => "response",

              "status" => "completed",

              "model" => "stealth/ox-alpha",

              "model" => "z-ai/glm-5.3-flash",

              "output" => [

                %{

                  "type" => "message",

    assert {:ok, %{"assistant_content" => "The file now contains alpha gamma."}} =

             OpenRouter.stream(

               %{

                 "model" => "stealth/ox-alpha",

                 "model" => "z-ai/glm-5.3-flash",

                 "messages" => [

                   %{

                     "role" => "user",

  defp stream_hello do

    OpenRouter.stream(

      %{"model" => "stealth/ox-alpha", "messages" => [%{"role" => "user", "content" => "Hello"}]},

      %{

        "model" => "z-ai/glm-5.3-flash",

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

      },

      fn _event -> :ok end,

      api_key: "test-openrouter-key",

      request_options: [plug: {Req.Test, __MODULE__}]

        "suite" => "terminal-bench@2.0",

        "agent" => "openagents-coder",

        "agent_version" => "0.3.5",

        "model" => "ox-alpha",

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

        "lane" => "proxy",

        "tasks_total" => 20,

        "tasks_passed" => 13,

      %{

        "suite" => "terminal-bench@2.0",

        "agent" => "openagents-coder",

        "model" => "ox-alpha",

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

        "lane" => "proxy",

        "tasks_total" => 5

      },

  alias OpenAgents.DataRights

  alias OpenAgents.Inference

  alias OpenAgents.Inference.Credit

  alias OpenAgents.Inference.Models

  alias OpenAgents.Repo

  alias OpenAgents.Threads

  alias OpenAgents.UnpricedLane

  defp account(key) do

    key |> github_user() |> Conversations.ensure_owner_visitor()

  # Cost is priced from tokens by `OpenAgents.Inference`, never taken from a

  # caller, so spend is stated here in the output tokens that price to it.

  defp output_tokens_costing(microusd) do

    div(

      microusd * 1_000,

      Application.fetch_env!(:openagents, :inference_output_price_microusd_per_ktoken)

    )

    div(microusd * 1_000_000, Models.default().pricing.output_per_million_tokens)

  end

  # `gpt-5.6-luna` was the shipped unpriced lane until it was withdrawn. What it

  # demonstrated is unchanged, so the lane is admitted for one test at a time.

  defp admit_unpriced_lane do

    previous = UnpricedLane.admit!()

    on_exit(fn -> UnpricedLane.restore(previous) end)

    UnpricedLane.id()

  end

  # A grant names exactly one fence, so spend is recorded through a real

  describe "spend the deployment has no price for" do

    test "an unpriced call draws nothing down, and the balance says so" do

      owner = account("credit-unpriced")

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

      unpriced = admit_unpriced_lane()

      {:ok, thread} =

        Threads.open(%Visitor{id: owner.id}, "Run the unpriced lane", model: unpriced)

      {:ok, thread} = Threads.open(%Visitor{id: owner.id}, "Run the unpriced lane", model: luna)

      {:ok, _fenced, grant, _token} = Threads.mint_grant(thread)

      {:ok, _metered} = Inference.record_usage(grant, %{"output_tokens" => 500_000})

    test "a grant that never bought anything is not counted as unpriced spend" do

      owner = account("credit-idle")

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

      unpriced = admit_unpriced_lane()

      {:ok, thread} = Threads.open(%Visitor{id: owner.id}, "Mint and stop", model: luna)

      {:ok, thread} = Threads.open(%Visitor{id: owner.id}, "Mint and stop", model: unpriced)

      {:ok, _fenced, _grant, _token} = Threads.mint_grant(thread)

      assert Credit.unpriced_calls(owner.id) == 0

    end

    test "a failure with no upstream status reports none rather than inventing one" do

      for _ <- 1..Health.degraded_after(), do: Health.record_failure("ox-alpha", nil)

      assert Health.status("ox-alpha") == {:degraded, nil}

      for _ <- 1..Health.degraded_after(), do: Health.record_failure("glm-5.3-flash", nil)

      assert Health.status("glm-5.3-flash") == {:degraded, nil}

    end

    test "lanes are tracked apart" do

    selected = Models.select()

    refute selected.id == default

    assert selected.id == "ox-alpha"

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

    assert selected.id == Enum.at(Models.ids(), 1)

  end

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

defmodule OpenAgents.Inference.ModelsTest do

  use ExUnit.Case, async: true

  alias OpenAgents.Chat.OpenRouter

  alias OpenAgents.Inference.Models

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

    default = Models.default()

    # 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)

    # GLM 5.3 Flash leads: a caller that names no model is holding a

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

    # reached on the gateway's own slug, not on the id a caller asks for.

    assert default.id == "glm-5.3-flash"

    assert default.provider == :vercel_gateway

    assert default.provider_model == "zai/glm-5.3-flash"

    assert default.adapter == Application.fetch_env!(:openagents, :vercel_gateway_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