Status: Current

The public transparency surfaces — `/changelog`, `/api/changelog`, and the

The public transparency surfaces — `/api/changelog` and the

forge web UI (`/<owner>/<repo>`, `/<owner>/<repo>/commit/:sha`,

`/<owner>/<repo>/tree/:ref/*path`, `/<owner>/<repo>/blob/:ref/*path` —

addressed exactly like the GitHub URLs

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

      # The declared promotion makes this lane free until the exclusive UTC

      # cutoff, after which pricing automatically returns to the regular table

      # without another deployment.

      pricing: %{

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

        source: :placeholder,

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

        source: :declared,

        input_per_million_tokens: 150_000,

        output_per_million_tokens: 500_000,

        cached_input_per_million_tokens: 30_000

        cached_input_per_million_tokens: 30_000,

        promotion: %{

          id: "declared.glm-5.3-flash.free-through-2026-08-31.v1",

          source: :declared,

          ends_at: ~U[2026-09-01 00:00:00Z],

          input_per_million_tokens: 0,

          output_per_million_tokens: 0,

          cached_input_per_million_tokens: 0

        }

      }

    },

    %{

config :openagents, :runtime_environment, :test

# Pin pricing at the promotion's exclusive cutoff so the general credit suite

# continues to exercise paid-default behavior. Promotion boundary tests pass

# explicit instants to `OpenAgents.Inference.Pricing.effective_pricing/2`.

config :openagents, :pricing_now, ~U[2026-09-01 00:00:00Z]

# Test fixtures create the forum boards each test needs; the seed migration

# stays out of their way. See SeedGeneralForumBoard.

config :openagents, :seed_forum_boards, false

| `chat_stream_chunk` | streaming assistant deltas, throttled to one event per second per stream | `conversation_id`, `modality` |

| `chat_tool_called` | `Turns.TurnServer` tool request; `tool_call_started` in `Chat.AccountTurns` | `tool_name`, `turn_id`, `conversation_id`; never arguments |

| `chat_tokens_used` | once per turn at terminal state in `Turns.TurnServer` and `Chat.AccountTurns` | `input_tokens`, `output_tokens`, `model`, `provider`, `conversation_id`, `turn_id`, `outcome` |

| `inference_model_selected` | inference proxy after grant and catalog admission, before the provider call | requested, granted, selected, provider, and provider model IDs; availability; substitution policy; effective pricing table, basis, rates, and promotion cutoff; request shape counts; grant budget ceilings and fence types; never bearer material, prompts, instructions, tool arguments, or provider credentials |

| `inference_model_served` | successful inference proxy call | all selection properties plus effective served model, disclosure state, outcome, and whether the provider reported usage |

| `inference_model_failed` | failed inference proxy provider call | all selection properties plus outcome, sanitized reason code, upstream status, and whether the provider reported usage |

| `chat_turn_failed` | non-completed terminal turn in `ChatLive`; failed or cancelled run in `Chat.AccountTurns` | `reason`, `outcome`, `conversation_id`, `turn_id` |

| `chat_voice_started` / `chat_voice_ended` | voice session lifecycle broadcasts in `ChatLive` | `conversation_id`; end adds `outcome`, `duration_ms` |

| `memory_saved` | `ProfileMemory.remember_explicit` | `disposition`: `stored`, `already_active` |

    default_id = default_id()

    Enum.map(all(), fn model ->

      pricing = Pricing.effective_pricing(model)

      base = %{

        "id" => model.id,

        "provider" => Atom.to_string(model.provider),

        "context_window" => model.context_window,

        "max_output" => model.max_output,

        "availability" => availability(model),

        "pricing_basis" => Pricing.basis_of(model.pricing),

        "pricing_basis" => Pricing.basis_of(pricing),

        "default" => model.id == default_id

      }

      case model.pricing do

        nil ->

          base

        %{} = pricing ->

          Map.put(base, "pricing", public_pricing(pricing))

      end

      base

      |> maybe_put_pricing(pricing)

      |> maybe_put_promotion(model, pricing)

    end)

  end

  defp maybe_put_pricing(base, nil), do: base

  defp maybe_put_pricing(base, pricing), do: Map.put(base, "pricing", public_pricing(pricing))

  defp maybe_put_promotion(base, model, pricing) do

    case Pricing.promotion_ends_at(model) do

      %DateTime{} = ends_at ->

        Map.put(base, "pricing_promotion", %{

          "active" => Pricing.pricing_id(pricing) != Pricing.pricing_id(model.pricing),

          "ends_at" => DateTime.to_iso8601(ends_at)

        })

      nil ->

        base

    end

  end

  defp public_pricing(pricing) do

    base = %{

      "id" => Pricing.pricing_id(pricing),

  `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

  Every admitted model carries rates now. A time-bounded promotion can replace

  a model's regular table until its exclusive UTC cutoff. `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.

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

  to one of three bases:

    * `declared` — the operator entered the provider's published rates. This is

      the only basis anything may bill from (`billable?/1`).

    * `declared` — the operator entered the provider's published rates or a

      promotional zero rate. This is the only basis anything may bill from

      (`billable?/1`).

    * `provisional` — the deployment carries rates that were written to make

      the system run rather than read off a provider's price page, or rates

      whose table is unnamed. A cost is computed and labelled; no bill may

  @unpriced "unpriced"

  @unattributed "unattributed"

  @doc "The effective rate table for a model at the given UTC instant."

  @spec effective_pricing(map(), DateTime.t()) :: map() | nil

  def effective_pricing(model, now \\ pricing_now())

  def effective_pricing(%{pricing: nil}, _now), do: nil

  def effective_pricing(%{pricing: pricing}, %DateTime{} = now) do

    case Map.get(pricing, :promotion) do

      %{ends_at: %DateTime{} = ends_at} = promotion ->

        if DateTime.compare(now, ends_at) == :lt do

          Map.delete(promotion, :ends_at)

        else

          Map.delete(pricing, :promotion)

        end

      _absent ->

        Map.delete(pricing, :promotion)

    end

  end

  @doc "Whether a model's promotional rate table is active now."

  @spec promotion_active?(map(), DateTime.t()) :: boolean()

  def promotion_active?(model, now \\ pricing_now()) do

    match?(%{pricing: %{promotion: %{ends_at: %DateTime{}}}}, model) and

      pricing_id(effective_pricing(model, now)) != pricing_id(model.pricing)

  end

  @doc "The exclusive UTC cutoff for a model's promotion, when configured."

  @spec promotion_ends_at(map()) :: DateTime.t() | nil

  def promotion_ends_at(%{pricing: %{promotion: %{ends_at: %DateTime{} = ends_at}}}),

    do: ends_at

  def promotion_ends_at(_model), do: nil

  @doc "The `pricing_id` written for a lane with no declared rates."

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

  def unpriced, do: @unpriced

  @doc "The basis for a model, by catalog id or resolved model."

  @spec basis(map() | String.t() | nil) :: String.t()

  def basis(%{pricing: pricing}), do: basis_of(pricing)

  def basis(%{pricing: _pricing} = model), do: model |> effective_pricing() |> basis_of()

  def basis(model_id) do

    case Models.fetch(model_id) do

      {:ok, model} -> basis_of(model.pricing)

      {:ok, model} -> basis(model)

      :error -> @unpriced

    end

  end

  @spec pricing_id_for(String.t() | nil) :: String.t()

  def pricing_id_for(model_id) do

    case Models.fetch(model_id) do

      {:ok, model} -> pricing_id(model.pricing)

      {:ok, model} -> model |> effective_pricing() |> pricing_id()

      :error -> @unpriced

    end

  end

  def price(usage, model_id) when is_map(usage) do

    pricing =

      case Models.fetch(model_id) do

        {:ok, model} -> model.pricing

        {:ok, model} -> effective_pricing(model)

        :error -> nil

      end

  # DEREFERENCEABLE USAGE RECORD is the contract.

  defp declared_id?(id) do

    Enum.any?(Models.all(), fn model ->

      pricing_id(model.pricing) == id and basis_of(model.pricing) == "declared"

      Enum.any?(rate_tables(model.pricing), fn pricing ->

        pricing_id(pricing) == id and basis_of(pricing) == "declared"

      end)

    end)

  end

  defp rate_tables(nil), do: []

  defp rate_tables(pricing) do

    [Map.delete(pricing, :promotion)] ++

      case Map.get(pricing, :promotion) do

        %{} = promotion -> [Map.delete(promotion, :ends_at)]

        _absent -> []

      end

  end

  @doc """

  Whether a stored usage record may be billed from.

  defp integer(value) when is_integer(value), do: value

  defp integer(value) when is_float(value), do: trunc(value)

  defp integer(_value), do: 0

  defp pricing_now do

    Application.get_env(:openagents, :pricing_now, DateTime.utc_now())

  end

end

defmodule OpenAgentsWeb.ChangelogController do

  @moduledoc """

  `GET /api/changelog` — the machine-readable changelog

  (schema `openagents.changelog.v1`), the superset of the public `/changelog`

  page including receipt row ids so agents can cross-check every claim

  against the receipt chain. Same posture as `/api/status`: public,

  read-only, bounded, no identity state.

  (schema `openagents.changelog.v1`), including receipt row ids so clients can

  cross-check every claim against the receipt chain. Same posture as

  `/api/status`: public, read-only, bounded, no identity state.

  """

  use OpenAgentsWeb, :controller

  alias OpenAgents.Analytics

  alias OpenAgents.Inference

  alias OpenAgents.Inference.Models

  alias OpenAgents.Inference.{Models, Pricing}

  alias OpenAgents.Providers.{Request, ToolDefinition, ToolOutput}

  def create(conn, _params) do

  # it is not an event property.

  defp selection_properties(grant, model, request, body) do

    requested = Map.get(body, "model")

    pricing = Pricing.effective_pricing(model)

    promotion_ends_at = Pricing.promotion_ends_at(model)

    %{

      "selection_schema" => "inference_model_selection.v1",

      "selected_model" => model.id,

      "provider" => Atom.to_string(model.provider),

      "provider_model" => model.provider_model,

      "pricing_id" => Pricing.pricing_id(pricing),

      "pricing_basis" => Pricing.basis_of(pricing),

      "pricing_promotion_active" =>

        Pricing.pricing_id(pricing) != Pricing.pricing_id(model.pricing),

      "pricing_promotion_ends_at" =>

        if(promotion_ends_at, do: DateTime.to_iso8601(promotion_ends_at), else: nil),

      "input_price_per_million_tokens" => pricing && pricing.input_per_million_tokens,

      "output_price_per_million_tokens" => pricing && pricing.output_per_million_tokens,

      "cached_input_price_per_million_tokens" =>

        pricing && Map.get(pricing, :cached_input_per_million_tokens),

      "model_availability" => Models.availability(model),

      "model_available" => Models.available?(model),

      "adapter_substitutable" => substitutable?(model.adapter),

defmodule OpenAgentsWeb.LegacyChangelogController do

  use OpenAgentsWeb, :controller

  def index(conn, _params), do: redirect(conn, to: ~p"/docs/changelog")

end

    %{

      title: "Transparency",

      items: [

        %{slug: "changelog", title: "Changelog", icon: "text", route: "/changelog"},

        %{slug: "changelog", title: "Changelog", icon: "text", route: "/docs/changelog"},

        %{slug: "status", title: "Status", icon: "check-circle", route: "/status"},

        %{slug: "leaderboard", title: "Leaderboard", icon: "star", route: "/leaderboard"}

      ]

  Signed in, a marketing pitch is the wrong thing to show: the visitor has

  already been sold, and what they want is the state of the work. The same

  route renders a dashboard -- repositories, open issues, projects, what the

  forum is discussing, and what shipped recently -- the way a code host's home

  does.

  forum is discussing -- the way a code host's home does.

  The dashboard describes the viewer's work across every repository they can

  read, not one repository chosen for them, and it says so by reading through

  It is also current. Every panel names a publisher and re-reads when it hears

  one, so an issue opened in another tab moves the count and the feed without a

  refresh, and the same holds for a project, a repository, a forum post, and a

  changelog entry. The announcements carry ids and nothing else: each panel

  refresh, and the same holds for a project, a repository, and a forum post.

  The announcements carry ids and nothing else: each panel

  re-reads through the same authorized read that filled it at mount, so a

  viewer can never be handed a row -- or a row counted into a number -- the

  database would have refused them. Bursts collapse into one re-read of only

  use OpenAgentsWeb, :live_view

  alias OpenAgents.Accounts

  alias OpenAgents.Changelog

  alias OpenAgents.Forum

  alias OpenAgents.Issues

  alias OpenAgents.Projects

  alias OpenAgentsWeb.LiveRefresh

  alias OpenAgentsWeb.UI.Landing

  @repo "openagents.com"

  # The one line the landing page asks a reader to run. It is the command

  # `priv/docs/install-cli.md` documents and the script

  # `priv/static/install.sh` serves, so the page cannot advertise an installer

  @feed_limit 8

  @project_limit 6

  @post_limit 6

  @changelog_limit 5

  @impl true

  def mount(params, _session, socket) do

    :ok = Repositories.subscribe_all_projects()

    :ok = Repositories.subscribe_repository_changes()

    :ok = Forum.subscribe_posts()

    :ok = Changelog.subscribe()

  end

  @impl true

  def handle_info(:live_refresh, socket),

    do: {:noreply, LiveRefresh.run(socket, &refresh_panel/2)}

  def handle_info(message, socket) do

    if Changelog.ledger_event?(message),

      do: {:noreply, mark_stale(socket, :changelog)},

      else: {:noreply, socket}

  end

  def handle_info(_message, socket), do: {:noreply, socket}

  # One re-armed timer, shared with every other live surface through

  # `LiveRefresh`, so a burst of announcements costs one re-read rather than

  defp refresh_panel(socket, :issues), do: assign_issues(socket)

  defp refresh_panel(socket, :projects), do: assign_projects(socket)

  defp refresh_panel(socket, :posts), do: assign_posts(socket)

  defp refresh_panel(socket, :changelog), do: assign_changelog(socket, refresh: true)

  defp refresh_panel(socket, :repositories) do

    socket.assigns.changed_repositories

    |> assign_issues()

    |> assign_projects()

    |> assign_posts()

    |> assign_changelog()

    |> assign_repositories()

  end

    )

  end

  # Mount reads the shared cache, because every signed-in page load would

  # otherwise rebuild the projection and the cache exists to stop exactly that.

  # A live refresh bypasses it, because a rail told the ledger moved and then

  # handed the cached answer would render the state it was told had changed.

  defp assign_changelog(socket, opts \\ []) do

    assign(socket, :changelog, changelog_entries(opts))

  end

  defp assign_repositories(socket) do

    repositories = Repositories.list_visible_repositories(socket.assigns.current_user)

    |> stream(:repositories, repositories)

  end

  # The ledger is a bounded public projection and can legitimately refuse. An

  # empty rail is the honest answer; the home page should not crash over it.

  #

  # Its agent-layer rows carry no authored note, which is what left the rail

  # rendering a column of bare relative times. A row states what it is or it

  # does not render.

  defp changelog_entries(opts) do

    case Changelog.timeline(@repo, opts) do

      {:ok, rows} ->

        rows

        |> Enum.map(&%{entry_at: &1.entry_at, summary: changelog_summary(&1)})

        |> Enum.reject(&is_nil(&1.summary))

        |> Enum.take(@changelog_limit)

      {:error, _reason} ->

        []

    end

  end

  defp changelog_summary(%{summary: summary}) when is_binary(summary) do

    case String.trim(summary) do

      "" -> nil

      trimmed -> trimmed

    end

  end

  defp changelog_summary(%{short_sha: short_sha}) when is_binary(short_sha),

    do: "Receipted deploy of #{short_sha}"

  defp changelog_summary(_row), do: nil

  @impl true

  def render(%{current_user: user} = assigns) when not is_nil(user) do

    ~H"""

              No posts yet on the boards you can read.

            </p>

          </section>

          <section class="panel" aria-labelledby="dashboard-changelog">

            <header class="panel__header">

              <h2 id="dashboard-changelog" class="panel__title">Latest from the changelog</h2>

            </header>

            <ol :if={@changelog != []} class="changelog-rail">

              <li :for={entry <- @changelog}>

                <p class="changelog-rail__when">{relative_time(entry.entry_at)}</p>

                <p class="changelog-rail__summary">{entry.summary}</p>

              </li>

            </ol>

            <p :if={@changelog == []} class="panel__empty">Nothing recorded yet.</p>

            <.link navigate={~p"/changelog"} class="panel__more">

              View changelog <.icon name="arrow-right" />

            </.link>

          </section>

        </aside>

      </div>

    </Layouts.app>

            <.button navigate={~p"/docs"} variant={:ghost} size={:sm} class="hero__link">

              Read the docs <.icon name="chevron-right" />

            </.button>

            <.button navigate={~p"/changelog"} variant={:ghost} size={:sm} class="hero__link">

              Changelog <.icon name="chevron-right" />

            </.button>

            <.button

              navigate={~p"/OpenAgentsInc/openagents.com"}

              variant={:ghost}

            <.link navigate={~p"/models"}>Models</.link>

          </:column>

          <:column title="Transparency">

            <.link navigate={~p"/changelog"}>Changelog</.link>

            <.link navigate={~p"/status"}>Status</.link>

            <.link navigate={~p"/leaderboard"}>Leaderboard</.link>

          </:column>

    # canonical topic route. Unknown ids answer 404; the mirror is never read.

    get "/forum/topic/:id", LegacyForumController, :topic

    get "/forum/post/:id", LegacyForumController, :post

    get "/changelog", LegacyChangelogController, :index

    live_session :public,

      on_mount: [{OpenAgentsWeb.UserAuth, :mount_current_user}] do

      live "/", HomeLive, :index

      live "/status", NetworkStatusLive, :index

      live "/changelog", ChangelogLive, :index

      live "/leaderboard", LeaderboardLive, :index

      live "/coder", CoderLive, :index

# Changelog

[The changelog](/changelog) lists every change to the application, in two

layers.

## Two layers

The top layer is a plain-language summary of what changed and why it matters.

Expanding an entry reveals the receipt chain underneath: the commit, the build,

the deploy, and the elapsed time from push to live.

Most changelogs ask you to trust a summary. This one lets you check it, which

is the entire point of publishing it.

## Verifying an entry

Each entry links to its commit. From the commit you can read the diff, and the

receipts tell you when that exact revision went live.

## What is not published

Disclosure is per-repository. An entry may show that a change happened and what

class it belonged to while withholding the diff, if that repository serves at a

lower level.

## Coder 0.1

Released August 2026.

Coder 0.1 brings interactive coding, model access, tools, delegation, and

durable session history into the OpenAgents CLI.

### Work in your terminal

- Stream Markdown responses, reasoning, tool status, and diffs in an interactive

  terminal interface. The interface includes scrollback, prompt history,

  multiline paste, and dropped image references.

- Read, write, edit, and search files. Run shell commands with bounded tool

  output.

- Resume prior threads from their server-side transcripts.

### Choose how inference runs

- Switch between Coder Flash and Coder Free with `Shift+Tab`. Coder displays the

  active lane below the composer.

- Use local Ollama models or a development server lane when you want inference

  to run outside the hosted lanes.

- Inspect the effective model and account balance, and retry transient provider

  failures without losing the turn.

### Delegate work

- Delegate to installed ACP-compatible coding agents, including Claude Code,

  Codex, and Devin.

- Run child tasks in parallel and keep their transcripts with the parent task.

- Discover installed skills and capabilities, and run delegated tools behind

  the shell safety gate.

### Control long-running work

- Use `/goal` to set an objective, inspect its status and budget, pause or resume

  it, and clear it when the work is complete.

- Cancel the current turn without clearing queued work or exiting Coder. Coder

  also cleans up active tools and child processes and settles canceled turns

  once.

- Sign in and out from the terminal while storing credentials in your operating

  system's credential store.

The release is covered by an interactive PTY test harness and a Cargo workspace

completion gate. Installed binaries report their published release version.

Read the closed work for the [native terminal interface](https://openagents.com/OpenAgentsInc/openagents/issues/117),

[first-class tools](https://openagents.com/OpenAgentsInc/openagents/issues/127),

[model lanes](https://openagents.com/OpenAgentsInc/openagents/issues/131),

[CLI consolidation](https://openagents.com/OpenAgentsInc/openagents/issues/137),

[ACP delegation](https://openagents.com/OpenAgentsInc/openagents/issues/72), and

[turn cancellation](https://openagents.com/OpenAgentsInc/openagents/issues/142).

## Trailers

Commits carry trailers identifying the agent session that produced them, where

one did. This is what lets a change be traced from the [changelog](/changelog)

one did. This is what lets a change be traced from the

[machine-readable changelog](/api/changelog)

back to the conversation that caused it.

## Deploy history

Where a commit reached the fleet, its receipt chain is visible from the

changelog: pushed, built, deployed, and how long each step took.

machine-readable changelog: pushed, built, deployed, and how long each step

took.

[stacks](/docs/stacked-pull-requests) order several of them so each builds on

the one before it.

Three surfaces exist to show the system's own work rather than yours. The

[changelog](/changelog) lists every change with the receipt chain that took it

live. [Status](/status) reports fleet health. The

Three surfaces describe the system itself rather than your work. The

[changelog](/docs/changelog) presents product releases. [Status](/status)

reports fleet health. The

[leaderboard](/leaderboard) ranks contributors by tokens.

## What is not here yet

defmodule OpenAgents.Inference.ModelsTest do

  use ExUnit.Case, async: true

  alias OpenAgents.Inference.Models

  alias OpenAgents.Inference.{Models, Pricing}

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

    default = Models.default()

      assert pricing["cached_input_per_million_tokens"] == 100_000

    end

    test "the default's rates are provisional, so nothing may bill from them" do

    test "the default publishes its currently effective rate table" do

      glm = Enum.find(Models.catalog(), &(&1["id"] == "glm-5.3-flash"))

      effective = Pricing.effective_pricing(Models.default())

      assert glm["pricing"]["id"] == "placeholder.glm-5.3-flash.v1"

      assert glm["pricing"]["input_per_million_tokens"] == 150_000

      assert glm["pricing"]["output_per_million_tokens"] == 500_000

      assert glm["pricing"]["cached_input_per_million_tokens"] == 30_000

      assert glm["pricing"]["id"] == effective.id

      # Read off the gateway's own listing, which still is not an operator

      # declaring them (METER-001).

      assert glm["pricing_basis"] == "provisional"

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

      assert glm["pricing"]["input_per_million_tokens"] ==

               effective.input_per_million_tokens

      assert glm["pricing"]["output_per_million_tokens"] ==

               effective.output_per_million_tokens

      assert glm["pricing"]["cached_input_per_million_tokens"] ==

               effective.cached_input_per_million_tokens

      assert glm["pricing_basis"] == Pricing.basis_of(effective)

      assert glm["pricing"]["basis"] == Pricing.basis_of(effective)

      assert glm["pricing_promotion"]["ends_at"] == "2026-09-01T00:00:00Z"

      assert glm["pricing_promotion"]["active"] == Pricing.promotion_active?(Models.default())

    end

    test "the free router declares its zero price" do

    end

  end

  describe "the GLM free promotion" do

    test "uses zero declared rates before the cutoff and regular rates at the cutoff" do

      {:ok, glm} = OpenAgents.Inference.Models.fetch("glm-5.3-flash")

      promotional = Pricing.effective_pricing(glm, ~U[2026-08-31 23:59:59.999999Z])

      regular = Pricing.effective_pricing(glm, ~U[2026-09-01 00:00:00Z])

      assert promotional.id == "declared.glm-5.3-flash.free-through-2026-08-31.v1"

      assert promotional.source == :declared

      assert promotional.input_per_million_tokens == 0

      assert promotional.output_per_million_tokens == 0

      assert promotional.cached_input_per_million_tokens == 0

      assert Pricing.promotion_active?(glm, ~U[2026-08-31 23:59:59Z])

      assert regular.id == "declared.glm-5.3-flash.v1"

      assert regular.source == :declared

      assert regular.input_per_million_tokens == 150_000

      refute Pricing.promotion_active?(glm, ~U[2026-09-01 00:00:00Z])

      assert Pricing.promotion_ends_at(glm) == ~U[2026-09-01 00:00:00Z]

    end

    test "the declared promotion remains billable as a zero-cost historical record" do

      usage = %{

        "pricing_id" => "declared.glm-5.3-flash.free-through-2026-08-31.v1",

        "estimated_cost_microusd" => 0

      }

      assert Pricing.usage_basis(usage) == "declared"

      assert Pricing.billable?(usage)

    end

  end

  describe "pricing one usage record" do

    test "an unpriced model writes no cost key — not a zero" do

      priced =

  end

  describe "the catalog this deployment actually ships" do

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

    test "declared tables publish the configured rates" do

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

      free_router =

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

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

      glm = Enum.find(OpenAgents.Inference.Models.catalog(), &(&1["id"] == "glm-5.3-flash"))

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

      assert "provisional" in bases

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

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

      assert glm["pricing"]["input_per_million_tokens"] == 150_000

      assert glm["pricing"]["output_per_million_tokens"] == 500_000

    end

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

  alias OpenAgents.Inference

  alias OpenAgents.Inference.Grant

  alias OpenAgents.Inference.Models

  alias OpenAgents.Inference.{Models, Pricing}

  alias OpenAgents.Machines

  alias OpenAgents.Repo

  alias OpenAgents.UnpricedLane

      assert once.usage["input_tokens"] == 100

      assert once.usage["output_tokens"] == 40

      assert once.usage["total_tokens"] == 140

      assert once.usage["estimated_cost_microusd"] > 0

      assert once.usage["estimated_cost_microusd"] >= 0

      assert once.usage["pricing_id"] == Pricing.pricing_id_for(grant.model_id)

      assert once.usage["schema"] == "sarah.inference_grant_usage.v1"

      {:ok, twice} = Inference.record_usage(once, %{"input_tokens" => 10, "output_tokens" => 5})

          "cache_read_input_tokens" => cache_read

        })

      pricing = Models.default().pricing

      pricing = Pricing.effective_pricing(Models.default())

      expected =

        ((input - cache_read) * pricing.input_per_million_tokens +

  alias OpenAgents.Inference

  alias OpenAgents.Inference.Credit

  alias OpenAgents.Inference.Grant

  alias OpenAgents.Inference.Models

  alias OpenAgents.Inference.{Models, Pricing}

  alias OpenAgents.Repo

  alias OpenAgents.Threads

  alias OpenAgents.Threads.Event

      assert spent.call_count == 2

      {:ok, _child, child_grant, _token} =

        Threads.open_and_mint(user, "Child", parent_thread_id: parent.id)

        Threads.open_and_mint(user, "Child",

          parent_thread_id: parent.id,

          model: "gemini-3.7-flash"

        )

      assert child_grant.max_calls == 3

    end

      set_config(:thread_grant_max_calls, nil)

      set_config(:thread_grant_max_total_tokens, nil)

      user = owner("child-cost")

      {:ok, parent, grant, _token} = Threads.open_and_mint(user, "Parent")

      # Output tokens priced at the default lane's own output rate, so the

      {:ok, parent, grant, _token} =

        Threads.open_and_mint(user, "Parent", model: "gemini-3.7-flash")

      # Output tokens priced at the paid lane's own output rate, so the

      # arithmetic below follows the catalog rather than restating it.

      rate = Models.default().pricing.output_per_million_tokens

      output = 20_000

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

      rate = Pricing.effective_pricing(paid_model).output_per_million_tokens

      output = 5_000

      cost = div(output * rate, 1_000_000)

      {:ok, spent} = Inference.record_usage(grant, %{"output_tokens" => output})

      assert spent.usage["estimated_cost_microusd"] == cost

      {:ok, _child, child_grant, _token} =

        Threads.open_and_mint(user, "Child", parent_thread_id: parent.id)

        Threads.open_and_mint(user, "Child",

          parent_thread_id: parent.id,

          model: "gemini-3.7-flash"

        )

      assert child_grant.max_cost_microusd == 100_000 - cost

    end

      spend = Threads.spend(thread)

      rate = Models.default().pricing.input_per_million_tokens

      pricing = Pricing.effective_pricing(Models.default())

      rate = pricing.input_per_million_tokens

      assert spend.cost.microusd == rate

      assert spend.cost.priced_microusd == rate

      assert spend.cost.basis == "provisional"

      assert spend.cost.basis == Pricing.basis_of(pricing)

      assert spend.cost.unpriced_models == []

    end

      assert spend.cost.microusd == nil

      # Nothing measured is thrown away — the priced half is still reported,

      # just not as the answer to "what did this cost".

      assert spend.cost.priced_microusd == Models.default().pricing.input_per_million_tokens

      assert spend.cost.priced_microusd ==

               Pricing.effective_pricing(Models.default()).input_per_million_tokens

      assert spend.cost.basis == "unpriced"

      assert spend.cost.unpriced_models == [unpriced]

    end

      spend = Threads.spend(thread)

      assert spend.grants == 2

      assert spend.cost.microusd == Models.default().pricing.input_per_million_tokens

      assert spend.cost.microusd ==

               Pricing.effective_pricing(Models.default()).input_per_million_tokens

      assert spend.cost.unpriced_calls == 0

    end

  alias OpenAgents.Inference.Grant

  alias OpenAgents.Inference.Health

  alias OpenAgents.Inference.Models

  alias OpenAgents.Inference.Pricing

  alias OpenAgents.Machines

  alias OpenAgents.Providers.RecordingTestProvider

  alias OpenAgents.Repo

    metered = Repo.get(Grant, grant.id)

    assert metered.call_count == 1

    assert metered.usage["total_tokens"] == 12

    assert metered.usage["estimated_cost_microusd"] > 0

    assert metered.usage["estimated_cost_microusd"] >= 0

    assert metered.usage["pricing_id"] == Pricing.pricing_id_for(default.id)

    assert_receive {:analytics, "inference_model_selected", distinct_id, selected}

    assert distinct_id =~ "visitor_"

    assert selected["grant_model"] == Models.default_id()

    assert selected["selected_model"] == Models.default_id()

    assert selected["provider_model"] == default.provider_model

    assert selected["pricing_id"] == Pricing.pricing_id_for(default.id)

    assert selected["pricing_basis"] == Pricing.basis(default.id)

    assert selected["input_message_count"] == 1

    assert selected["tool_definition_count"] == 0

    assert selected["tool_output_count"] == 0

  alias OpenAgents.Inference

  alias OpenAgents.Inference.Credit

  alias OpenAgents.Inference.Grant

  alias OpenAgents.Inference.Models

  alias OpenAgents.Inference.{Models, Pricing}

  alias OpenAgents.Repo

  alias OpenAgents.Threads

  alias OpenAgents.UnpricedLane

      opened =

        authenticated

        |> post(~p"/api/v1/threads", %{"objective" => "Spend it all."})

        |> post(~p"/api/v1/threads", %{

          "objective" => "Spend it all.",

          "model" => "gemini-3.7-flash"

        })

        |> json_response(201)

      grant = Repo.get_by!(Grant, thread_id: opened["thread"]["id"])

      allowance = Credit.allowance(grant.owner_visitor_id)

      rate = Models.default().pricing.output_per_million_tokens

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

      rate = Pricing.effective_pricing(paid_model).output_per_million_tokens

      {:ok, _metered} =

        Inference.record_usage(grant, %{

      # A million input tokens costs exactly the default lane's per-million

      # rate, whatever the catalog's head happens to be.

      rate = Models.default().pricing.input_per_million_tokens

      pricing = Pricing.effective_pricing(Models.default())

      rate = pricing.input_per_million_tokens

      body = authenticated |> get(~p"/api/v1/threads/#{id}") |> json_response(200)

      assert body["thread"]["spend"]["cost"]["microusd"] == rate

      assert body["thread"]["spend"]["cost"]["basis"] == "provisional"

      assert body["thread"]["spend"]["cost"]["basis"] == Pricing.basis_of(pricing)

      assert body["thread"]["spend"]["cost"]["unpriced_models"] == []

      # Priced is not the same as billable: these are placeholder rates.

      assert body["grant"]["pricing"]["basis"] == "provisional"

      assert body["grant"]["pricing"]["billable"] == false

      assert body["grant"]["pricing"]["basis"] == Pricing.basis_of(pricing)

      assert body["grant"]["pricing"]["billable"] ==

               (Pricing.basis_of(pricing) == "declared")

      assert body["grant"]["spent"]["cost_microusd"] == rate

    end

  end

    refute html =~ "One continuing conversation"

    refute html =~ ~s(href="/chat")

    refute html =~ "Account menu"

    refute html =~ ~s(href="/changelog")

  end

  test "an authenticated account sees the dashboard, not the pitch", %{conn: conn} do

    html = html_response(get(conn, ~p"/"), 200)

    # Someone who has signed in has already been sold. The same route shows the

    # state of the work instead: open issues, projects, and what shipped.

    # state of the work instead: open issues and projects.

    refute html =~ "Your all-in-one coding agent."

    assert html =~ "Open issues"

    assert html =~ "Latest from the changelog"

    refute html =~ "Latest from the changelog"

    refute html =~ ~s(href="/changelog")

    assert html =~ ~s(class="dashboard")

  end

defmodule OpenAgentsWeb.ChangelogLiveTest do

  @moduledoc """

  The public changelog page and its API twin (#138, TRANSPARENCY-001):

  opens without a session, shows the human layer with the receipt detail

  expandable underneath, keeps the anonymous command bar free of account

  controls, stays content-free of node internals, and serves the same

  timeline as schema-versioned JSON at /api/changelog — 404 for a dark

  repo.

  The documentation changelog and the retained changelog API.

  """

  use OpenAgentsWeb.ConnCase, async: false

    %{entry: entry}

  end

  test "renders the entry's summary and category for a visitor with no session", %{conn: conn} do

    {:ok, _view, html} = live(conn, ~p"/changelog")

  test "GET /changelog redirects to the documentation changelog", %{conn: conn} do

    conn = get(conn, ~p"/changelog")

    assert html =~ "Changelog"

    assert html =~ "Moved the mic button test entry"

    assert html =~ ~s(id="changelog-filter-ui")

    assert redirected_to(conn, 302) == ~p"/docs/changelog"

  end

  test "the detail expansion carries the sha and a link to the commit page", %{conn: conn} do

    {:ok, _view, html} = live(conn, ~p"/changelog")

  test "the documentation changelog presents Coder 0.1", %{conn: conn} do

    {:ok, _view, html} = live(conn, ~p"/docs/changelog")

    assert html =~ "abcdef1"

    assert html =~ "/OpenAgentsInc/openagents.com/commit/abcdef1"

  end

  test "carries the shared command bar without account controls for a visitor", %{conn: conn} do

    {:ok, _view, html} = live(conn, ~p"/changelog")

    # The shell supplies the one command bar; the page no longer builds a second.

    refute html =~ ~s(class="command-bar")

    refute html =~ ~s(id="account-bar-trigger")

    refute html =~ ~s(id="return-to-conversation")

  end

  test "carries the shell sidebar when logged in", %{conn: conn} do