Also worth pointing out that that only works correctly because you are using Ash.get and so only have a single record.

If you did a_list_of_records |> Ash.load(:llm_response) your [single_thing] = ... match would fail.

Indeed, I changed my code (after refactoring some attribute names) to

  calculations do
    calculate :llm_response, :string do
      calculation fn runs, _context ->
        runs
        |> Ash.load!(chain: [:messages])
        |> Enum.map(fn run ->
          last_message = run.chain.messages |> List.last()
          last_message.content
        end)
      end
    end
  end

and now the above Ash.get as well as

LLMRun |> Ash.Query.for_read(:read) |> Ash.read!(load: :llm_response)

work as expected.

You can optimize this further:

  calculations do
    calculate :llm_response, :string do
      calculation fn runs, _context ->
        message_query =
          Message
          |> Ash.Query.sort(created_at: :desc)
          |> Ash.Query.limit(1)

        runs
        |> Ash.load!(chain: [messages: message_query])
        |> Enum.map(fn run ->
          last_message = run.chain.messages |> List.last()
          last_message.content
        end)
      end
    end
  end

Furthermore, if you break it out into a module-based calculation, you can take advantage of the more optimized dependency loading for calculations.

defmodule MyApp.MyDomain.MyResource.Calculations.LastRun do
  use Ash.Resource.Calculation

  def load(_, _, _) do
    message_query =
      Message
      |> Ash.Query.sort(created_at: :desc)
      |> Ash.Query.limit(1)

    [chain: [messages: message_query]]
  end

  def calculate(_, _, _) do
    Enum.map(runs, fn run ->
      last_message = run.chain.messages |> List.last()
      last_message.content
    end)
  end
end

Then you can do calculate :llm_response, :string, MyApp.MyDomain.MyResource.Calculations.LastRun