defp finish_run(run_id, {:ok, completion}) do

    # Token counts are read before redaction, which blanks every field whose

    # name contains `token`, and are stored beside the redacted completion.

    usage = usage_counts(completion["usage"])

    usage = usage_counts(completion)

    completion = OpenAgents.Tools.Redaction.redact(completion)

    terminal_update(run_id, "response_completed", completion, %{

  # Provider-reported counts only. OpenRouter names them differently across its

  # two APIs, and a field the provider left out stays `nil` instead of a guess.

  defp usage_counts(usage) when is_map(usage) do

  defp usage_counts(%{"usage" => usage} = completion) when is_map(usage) do

    counts = %{

      "input" => token_count(usage["input_tokens"] || usage["prompt_tokens"]),

      "output" => token_count(usage["output_tokens"] || usage["completion_tokens"]),

      "total" => token_count(usage["total_tokens"]),

      "reasoning" =>

        token_count(

          detail(usage, "output_tokens_details", "reasoning_tokens") ||

            detail(usage, "completion_tokens_details", "reasoning_tokens")

        ),

      "reasoning" => reasoning_count(usage, completion),

      "cached" =>

        token_count(

          detail(usage, "input_tokens_details", "cached_tokens") ||

    if Enum.all?(Map.values(counts), &is_nil/1), do: nil, else: counts

  end

  defp usage_counts(_usage), do: nil

  defp usage_counts(_completion), do: nil

  # Some models report a reasoning count of zero for a turn that carries

  # reasoning output. That zero measures nothing, so the turn reports no

  # reasoning count rather than a count of none.

  defp reasoning_count(usage, completion) do

    count =

      token_count(

        detail(usage, "output_tokens_details", "reasoning_tokens") ||

          detail(usage, "completion_tokens_details", "reasoning_tokens")

      )

    if count == 0 and reasoned?(completion), do: nil, else: count

  end

  defp reasoned?(%{"reasoning_summary" => summary}) when is_binary(summary) and summary != "",

    do: true

  defp reasoned?(%{"reasoning_items" => [_item | _rest]}), do: true

  defp reasoned?(%{"output" => output}) when is_list(output),

    do: Enum.any?(output, &match?(%{"type" => "reasoning"}, &1))

  defp reasoned?(_completion), do: false

  defp usage_view(counts) when is_map(counts),

    do: %{

  defp chat_request(request), do: request

  defp continue_responses_tool_calls(

         {:ok, %{"tool_calls" => tool_calls, "output" => provider_output}},

         {:ok, %{"tool_calls" => tool_calls, "output" => provider_output} = completion},

         api_key,

         payload,

         on_event,

         payload <- Map.update!(payload, "input", &(&1 ++ provider_output ++ tool_outputs)),

         {:ok, response} <- responses_stream_request(api_key, payload, options),

         result <- consume_responses_stream(response, on_event, payload["model"]) do

      continue_responses_tool_calls(

        result,

      result

      |> carry_usage(Map.get(completion, "usage"))

      |> continue_responses_tool_calls(

        api_key,

        payload,

        on_event,

       ),

       do: result

  # A turn spends one provider request per tool round, and each response reports

  # only what that round consumed. Carrying the earlier counts forward keeps the

  # whole turn in the usage the completion reports.

  defp carry_usage({:ok, completion}, earlier) when is_map(earlier),

    do: {:ok, Map.put(completion, "usage", add_usage(Map.get(completion, "usage"), earlier))}

  defp carry_usage(result, _earlier), do: result

  # A count no round reported stays absent instead of becoming a zero.

  defp add_usage(usage, earlier) when is_map(usage) and is_map(earlier),

    do:

      Map.merge(usage, earlier, fn _key, value, earlier_value ->

        add_count(value, earlier_value)

      end)

  defp add_usage(nil, earlier), do: earlier

  defp add_usage(usage, _earlier), do: usage

  defp add_count(value, earlier) when is_number(value) and is_number(earlier),

    do: value + earlier

  defp add_count(value, earlier) when is_map(value) and is_map(earlier),

    do: add_usage(value, earlier)

  defp add_count(value, _earlier), do: value

  defp execute_tool_calls(tool_calls, on_event, tool_runtime) do

    result =

      Enum.reduce_while(tool_calls, [], fn %{

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}}}

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: [DONE]

           } = Jason.decode!(tool_output)

  end

  test "sums the usage every tool round reported" do

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

      body =

        Path.expand("../../fixtures/openrouter/responses_tool_call.sse", __DIR__)

        |> File.read!()

      conn

      |> Plug.Conn.put_resp_content_type("text/event-stream")

      |> Plug.Conn.send_resp(200, body)

    end)

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

      body =

        sse(%{

          "type" => "response.content_part.delta",

          "delta" => "OpenAgents is an agent platform."

        }) <>

          sse(%{

            "type" => "response.completed",

            "response" => %{

              "object" => "response",

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

              "output" => [

                %{

                  "type" => "message",

                  "id" => "msg_after_tool",

                  "role" => "assistant",

                  "status" => "completed",

                  "content" => [

                    %{

                      "type" => "output_text",

                      "text" => "OpenAgents is an agent platform.",

                      "annotations" => []

                    }

                  ]

                }

              ],

              "usage" => %{

                "input_tokens" => 30,

                "output_tokens" => 5,

                "total_tokens" => 35,

                "output_tokens_details" => %{"reasoning_tokens" => 0}

              }

            }

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

      conn

      |> Plug.Conn.put_resp_content_type("text/event-stream")

      |> Plug.Conn.send_resp(200, body)

    end)

    parent = self()

    assert {:ok, tool_registry_snapshot} = Registry.build([RepositoryFileToolStub])

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

             OpenRouter.stream(

               %{

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

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

               },

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

               api_key: "test-openrouter-key",

               tool_registry_snapshot: tool_registry_snapshot,

               tool_execution_context: tool_execution_context(),

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

             )

    assert usage == %{

             "input_tokens" => 48,

             "output_tokens" => 16,

             "total_tokens" => 64,

             "output_tokens_details" => %{"reasoning_tokens" => 7}

           }

  end

  test "replays provider output around ordered read, write, edit, and reread calls" do

    repository_state = start_supervised!({Agent, fn -> "initial" end})

    refute has_element?(view, "#chat-console-evidence-#{run_id}")

  end

  test "a turn that reasoned without a reasoning count omits the category", %{conn: conn} do

    key = "console-unmetered-reasoning-operator"

    user = github_user(key)

    conn = log_in_admin_user(conn, key)

    streamer = fn _request, callback, _options ->

      callback.({:reasoning_delta, "Weighing the fleet."})

      callback.({:text_delta, "The fleet is idle."})

      {:ok,

       %{

         "object" => "response",

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

         "assistant_content" => "The fleet is idle.",

         "reasoning_summary" => "Weighing the fleet.",

         "usage" => %{

           "input_tokens" => 24,

           "output_tokens" => 8,

           "total_tokens" => 32,

           "output_tokens_details" => %{"reasoning_tokens" => 0}

         }

       }}

    end

    assert {:ok, %{"id" => run_id}} =

             AccountTurns.submit(user, "Report the fleet.",

               subscriber: self(),

               streamer: streamer

             )

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

    {:ok, view, _html} = live(conn, ~p"/chat")

    assert has_element?(view, "#chat-console-usage-#{run_id}", "Input 24")

    refute has_element?(view, "#chat-console-usage-#{run_id}", "Reasoning")

    assert has_element?(view, "#chat-console-token-input", "24")

    refute has_element?(view, "#chat-console-token-reasoning")

  end

  test "a completed turn shows a context meter where a window is configured", %{conn: conn} do

    key = "console-context-operator"

    user = github_user(key)