solid_loop 0.0.4 → 0.0.5

data/app/controllers/solid_loop/mcp_sessions_controller.rb

@@ -5,6 +5,18 @@ module SolidLoop
     def index
       @pagination = paginate(SolidLoop::Admin::McpSessionsQuery.new(params).call)
       @mcp_sessions = @pagination[:records]
+
+      # A session is only ever reused while its loop can still run, so "is this
+      # session still usable" is really "is its loop still alive" — plus whether
+      # tool discovery ever produced anything. Both are gathered in one grouped
+      # query each instead of touching `session.loop` / `session.mcp_tools` per
+      # row (an N+1 over two tables on every page view).
+      session_ids = @mcp_sessions.map(&:id)
+      @loop_statuses = SolidLoop::Loop
+        .where(id: @mcp_sessions.map(&:loop_id).compact.uniq)
+        .pluck(:id, :status)
+        .to_h
+      @tool_counts = SolidLoop::McpTool.where(mcp_session_id: session_ids).group(:mcp_session_id).count
     end
 
     def show

data/app/controllers/solid_loop/messages_controller.rb

@@ -1,8 +1,18 @@
 module SolidLoop
   class MessagesController < ApplicationController
+    # Same reasoning as EventsController::LIST_COLUMNS: the list renders a role,
+    # a model name and token counts, while `content` / `reasoning_content` /
+    # `tool_calls_raw` are the biggest columns on the table (a single reasoning
+    # blob routinely runs to thousands of characters). Narrowed after pagination
+    # so the count query is unaffected.
+    LIST_COLUMNS = %i[
+      id loop_id role metadata cost created_at
+      tokens_total tokens_prompt tokens_completion tokens_prompt_cached
+    ].freeze
+
     def index
       @pagination = paginate(SolidLoop::Admin::MessagesQuery.new(params).call)
-      @messages = @pagination[:records]
+      @messages = @pagination[:records].select(*LIST_COLUMNS)
     end
 
     def show

data/app/controllers/solid_loop/tool_calls_controller.rb

@@ -3,10 +3,42 @@ module SolidLoop
     def index
       @pagination = paginate(SolidLoop::Admin::ToolCallsQuery.new(params).call)
       @tool_calls = @pagination[:records]
+      @loop_ids_by_message = loop_ids_by_message(@tool_calls)
+      @function_names = function_filter_options
     end
 
     def show
       @tool_call = SolidLoop::ToolCall.find(params[:id])
     end
+
+    private
+
+    # The loop a tool call belongs to lives one hop away (tool_call -> message ->
+    # loop_id). Reading it as `tool_call.message.loop_id` in the view is an N+1
+    # over a table that grows by several rows per turn, and `includes(:message)`
+    # would drag every message's content / reasoning_content / tool_calls_raw
+    # (routinely tens of KB each) into memory to read a single bigint. One narrow
+    # pluck keyed by message_id instead: a single extra query, two columns.
+    def loop_ids_by_message(tool_calls)
+      message_ids = tool_calls.map(&:message_id).compact.uniq
+      return {} if message_ids.empty?
+
+      SolidLoop::Message.where(id: message_ids).pluck(:id, :loop_id).to_h
+    end
+
+    # The callable functions are a small, known set — the tools discovered from
+    # the MCP servers — so the filter is a select, not a free-text box the user
+    # has to spell from memory. `solid_loop_mcp_tools` is bounded by
+    # (sessions x tools) and is the cheap side of this lookup; DISTINCTing the
+    # ever-growing tool_calls table would not be.
+    def function_filter_options
+      names = SolidLoop::McpTool.distinct.order(:name).pluck(:name)
+
+      # Keep a hand-entered / bookmarked filter selectable even when its tool is
+      # no longer advertised by any session, so the URL is never silently
+      # rewritten to "All".
+      current = params[:function_name].presence
+      current ? (names + [ current ]).uniq : names
+    end
   end
 end

data/app/helpers/solid_loop/application_helper.rb

@@ -93,7 +93,10 @@ module SolidLoop
       label = resolved[:label].presence || "#{loop.subject_type} ##{loop.subject_id}"
       url = sl_safe_subject_url(resolved[:url])
 
-      url ? link_to(label, url) : label
+      # Without an explicit class the anchor takes the browser's default link
+      # blue, which is nearly unreadable on the dark admin background — and the
+      # muted colour set on the wrapping element does not cascade into an <a>.
+      url ? link_to(label, url, class: "sl-subject-link") : label
     end
 
     private

data/app/helpers/solid_loop/metrics_helper.rb

@@ -0,0 +1,232 @@
+module SolidLoop
+  # Presentation of the numbers the admin list pages are actually read FOR:
+  # how long something took, when it last did anything, and whether the wire
+  # call succeeded. Kept out of ApplicationHelper (money / failure classification
+  # / subject linking) because these are list-table formatters with their own
+  # thresholds, and the thresholds are the interesting part.
+  module MetricsHelper
+    # ---- Durations ---------------------------------------------------------
+    # One duration formatter for every list page, so 0.24s and 40s are visibly
+    # different at a glance and a 10-minute call never reads as "600.0".
+    #
+    #   0.004 -> "0.004s"    12.42  -> "12.4s"
+    #   0.24  -> "0.240s"    608.55 -> "10m 9s"
+    #   2.98  -> "2.98s"     5400   -> "1h 30m"
+    #
+    # `0` (and nil) render as "—": every duration column in the schema defaults
+    # to 0.0, so a zero is far more likely to mean "never recorded" than "took
+    # no time at all", and printing "0.00s" for it invents a measurement.
+    def sl_duration(seconds, blank: "—")
+      return blank if seconds.nil?
+
+      value = seconds.to_f
+      return blank if value <= 0
+
+      case value
+      when 0...1     then format("%.3fs", value)
+      when 1...10    then format("%.2fs", value)
+      when 10...60   then format("%.1fs", value)
+      when 60...3600 then "#{(value / 60).floor}m #{(value % 60).round}s"
+      else                "#{(value / 3600).floor}h #{((value % 3600) / 60).round}m"
+      end
+    end
+
+    # Slowness is relative to what the call IS. A local LLM completion routinely
+    # runs for a minute and that is normal; an MCP tool call that takes a minute
+    # is pathological. Colouring both against one absolute threshold would paint
+    # the whole Events page red and make the outliers — the 608s read timeout
+    # that had to be found by hand in psql — invisible again.
+    SL_DURATION_SCALES = {
+      llm: { warn: 60.0, slow: 300.0 },
+      tool: { warn: 5.0, slow: 30.0 }
+    }.freeze
+
+    def sl_duration_severity(seconds, scale: :tool)
+      value = seconds.to_f
+      thresholds = SL_DURATION_SCALES.fetch(scale, SL_DURATION_SCALES[:tool])
+
+      return :slow if value >= thresholds[:slow]
+      return :warn if value >= thresholds[:warn]
+
+      nil
+    end
+
+    # A formatted, severity-coloured duration cell.
+    def sl_duration_cell(seconds, scale: :tool, blank: "—")
+      text = sl_duration(seconds, blank: blank)
+      return tag.span(text, class: "sl-metric sl-metric--blank") if text == blank
+
+      severity = sl_duration_severity(seconds, scale: scale)
+      classes = [ "sl-metric" ]
+      classes << "sl-metric--#{severity}" if severity
+
+      tag.span(text, class: classes.join(" "), title: "#{format('%.3f', seconds.to_f)}s")
+    end
+
+    # ---- Event families ----------------------------------------------------
+    # Every event used to wear the same blue badge, so an LLM completion and an
+    # MCP handshake were indistinguishable while scanning. Group by protocol
+    # family instead: LLM traffic, MCP tool invocations, and the MCP lifecycle
+    # chatter (initialize / list_tools / list_prompts / list_resources) that is
+    # noise most of the time.
+    def sl_event_family(name)
+      case name.to_s
+      when /\Allm/       then :llm
+      when "mcp_tool_call" then :mcp
+      when /\Amcp/       then :mcp_meta
+      else :other
+      end
+    end
+
+    def sl_event_badge_class(name)
+      case sl_event_family(name)
+      when :llm      then "sl-badge--llm"
+      when :mcp      then "sl-badge--mcp"
+      when :mcp_meta then "sl-badge--mcp-meta"
+      else "sl-badge--processing"
+      end
+    end
+
+    # The duration scale an event should be judged on (see SL_DURATION_SCALES).
+    def sl_event_duration_scale(name)
+      sl_event_family(name) == :llm ? :llm : :tool
+    end
+
+    # ---- Event status ------------------------------------------------------
+    # There is no `status` column: an event's outcome is buried in
+    # `response_data`, whose shape depends on which middleware wrote it.
+    #
+    #   * a failing HTTP response  -> { http_status:, response_headers:, response_body: }
+    #   * a raised/transport error -> { error: "Faraday::TimeoutError: ..." }
+    #   * a JSON-RPC envelope      -> { jsonrpc:, result: } or { error: { code:, message: } }
+    #   * an MCP tool-level failure -> { result: { isError: true, ... } }
+    #   * a plain OK completion    -> the parsed provider body (no status at all)
+    #
+    # Returns { label:, kind:, title: } where `kind` is :ok, :warn, :error or
+    # :unknown. A 2xx envelope carrying an `isError` tool result is :warn, not
+    # :error — the transport worked, the tool did not.
+    def sl_event_status(event)
+      data = event.response_data.presence || {}
+      data = {} unless data.is_a?(Hash)
+
+      http_status = data["http_status"] || data[:http_status]
+      error = data["error"] || data[:error]
+
+      if http_status.present?
+        code = http_status.to_i
+        { label: code.to_s, kind: code.between?(200, 299) ? :ok : :error, title: error.presence || "HTTP #{code}" }
+      elsif error.present?
+        { label: "ERR", kind: :error, title: sl_event_error_text(error) }
+      elsif sl_event_tool_error?(data)
+        { label: "TOOL ERR", kind: :warn, title: "200 — the call succeeded but the tool reported isError" }
+      elsif data.any?
+        { label: "200", kind: :ok, title: nil }
+      else
+        { label: "—", kind: :unknown, title: "No response recorded" }
+      end
+    end
+
+    def sl_event_status_badge(event)
+      status = sl_event_status(event)
+      if status[:kind] == :unknown
+        # No response was ever written back onto the event — either it is still
+        # in flight, or the process died before finalizing it. Both are worth
+        # seeing, and neither is a status code.
+        return tag.span(status[:label], class: "sl-metric sl-metric--blank", title: status[:title])
+      end
+
+      tag.span(status[:label],
+               class: "sl-badge sl-badge--http-#{status[:kind]}",
+               title: status[:title])
+    end
+
+    # ---- Recency -----------------------------------------------------------
+    # Compact "how long ago", because on a list page the question is never the
+    # wall-clock timestamp, it is "is this thing still moving".
+    def sl_time_ago(time)
+      return "—" if time.blank?
+
+      seconds = (Time.current - time).to_f
+      return "just now" if seconds < 10
+
+      case seconds
+      when 10...60      then "#{seconds.round}s ago"
+      when 60...3600    then "#{(seconds / 60).floor}m ago"
+      when 3600...86400 then "#{(seconds / 3600).floor}h ago"
+      else "#{(seconds / 86400).floor}d ago"
+      end
+    end
+
+    # An idle ACTIVE loop is the whole point of the Last Activity column: a
+    # `running` loop whose row has not been written for minutes is not working,
+    # it is hung. Terminal loops are supposed to be idle, so they are never
+    # flagged.
+    SL_IDLE_WARN_SECONDS = 5 * 60
+    SL_IDLE_STALLED_SECONDS = 15 * 60
+
+    def sl_idle_severity(loop, at: nil)
+      return nil unless SolidLoop::Loop::ACTIVE_STATUSES.include?(loop.status)
+
+      timestamp = at || loop.updated_at
+      return nil if timestamp.blank?
+
+      idle = (Time.current - timestamp).to_f
+      return :slow if idle >= SL_IDLE_STALLED_SECONDS
+      return :warn if idle >= SL_IDLE_WARN_SECONDS
+
+      nil
+    end
+
+    # ---- Tokens ------------------------------------------------------------
+    def sl_tokens(count, blank: "—")
+      value = count.to_i
+      return blank if value.zero?
+
+      number_with_delimiter(value)
+    end
+
+    # ---- Identifiers -------------------------------------------------------
+    # A 48-character MCP session id used to eat half the table. Show enough of
+    # it to recognise and to match against a server log, keep the whole thing
+    # one click away.
+    def sl_truncated_id(value, head: 20, tail: 6)
+      value = value.to_s
+      return "—" if value.empty?
+      return value if value.length <= head + tail + 1
+
+      "#{value[0, head]}…#{value[-tail, tail]}"
+    end
+
+    # Truncated id + a copy button. `navigator.clipboard` needs a secure
+    # context; the fallback keeps the full value selectable via the title
+    # attribute and a text selection on click.
+    def sl_copyable_id(value)
+      value = value.to_s
+      return tag.span("—", class: "sl-metric sl-metric--blank") if value.empty?
+
+      tag.span(class: "sl-copyable") do
+        concat tag.code(sl_truncated_id(value), class: "sl-copyable__text", title: value)
+        concat tag.button("Copy",
+                          type: "button",
+                          class: "sl-btn sl-btn--small sl-copyable__btn",
+                          data: { clipboard: value },
+                          onclick: "navigator.clipboard && navigator.clipboard.writeText(this.dataset.clipboard);" \
+                                   "var b=this;b.textContent='Copied';setTimeout(function(){b.textContent='Copy'},1200);")
+      end
+    end
+
+    private
+
+    def sl_event_error_text(error)
+      text = error.is_a?(Hash) ? (error["message"] || error[:message] || error.to_json) : error.to_s
+      text.length > 300 ? "#{text[0, 299]}…" : text
+    end
+
+    def sl_event_tool_error?(data)
+      result = data["result"] || data[:result]
+      return false unless result.is_a?(Hash)
+
+      result["isError"] == true || result[:isError] == true
+    end
+  end
+end

data/app/jobs/solid_loop/janitor_job.rb

@@ -0,0 +1,24 @@
+module SolidLoop
+  # A plain entry point for `SolidLoop.prune!`, installed by the host with
+  # whatever scheduler it already runs — the gem does NOT own a scheduler, for
+  # the same reason ReaperJob does not.
+  #
+  # Unlike the reaper this is NOT a per-minute concern: retention is measured in
+  # days, so daily is the natural cadence.
+  #
+  #   # good_job:
+  #   config.good_job.cron = {
+  #     solid_loop_reaper:  { cron: "* * * * *", class: "SolidLoop::ReaperJob" },
+  #     solid_loop_janitor: { cron: "17 4 * * *", class: "SolidLoop::JanitorJob" }
+  #   }
+  #
+  # A no-op unless at least one retention window is configured. Idempotent and
+  # safe to run concurrently.
+  class JanitorJob < ApplicationJob
+    queue_as :solid_loop_maintenance
+
+    def perform
+      SolidLoop.prune!
+    end
+  end
+end

data/app/jobs/solid_loop/llm_completion_job.rb

@@ -27,7 +27,7 @@ module SolidLoop
         loop_for_lease.transition_status(
           from: :queued,
           to: :failed,
-          error_message: "#{e.class}: #{e.message}",
+          error_message: SolidLoop::Redaction.redact_credentials("#{e.class}: #{e.message}"),
           execution_token: nil,
           lease_expires_at: nil
         )
@@ -119,7 +119,7 @@ module SolidLoop
       # loop row is not a stale-worker no-op).
       return false unless loop_record
 
-      error_msg = "#{error.class}: #{error.message}"
+      error_msg = SolidLoop::Redaction.redact_credentials("#{error.class}: #{error.message}")
       Rails.logger.error "LlmCompletionJob reconciling uncaught error: #{error_msg}\n#{error.backtrace&.take(10)&.join("\n")}"
 
       loop_record.transition_status(

data/app/models/solid_loop/base.rb

@@ -85,17 +85,65 @@ module SolidLoop
       :open_ai
     end
 
+    # How previous turns' reasoning is sent back to the model. `nil` (the
+    # default) defers to the dialect, which picks the shape its provider
+    # actually has a slot for — `"reasoning_content"` on `open_ai`, `:xml`
+    # elsewhere. Return an explicit array to override, including `[]` to send no
+    # reasoning back at all.
+    #
+    # This matters more than it looks. `:xml` welds every past thought into the
+    # assistant message body, where it is billed as prompt tokens on every
+    # subsequent turn and compounds: measured agent loops were spending 40% of
+    # their context window on repacked reasoning that the chat template then
+    # discarded. See docs/decisions/reasoning_persistence.md.
     def reasoning_strategies
-      # Default to the most robust method for returning thoughts: XML wrapping
-      [ :xml ]
+      nil
     end
 
     def mcp_principal
       subject
     end
 
+    # How hard the model should think, when the provider exposes that as a
+    # discrete level. `nil` (the default) sends nothing and leaves the provider's
+    # own default in place. Each dialect renders it into its native shape:
+    #
+    #   open_ai    reasoning_effort: "low"
+    #   anthropic  output_config: { effort: "low" }
+    #   gemini     generationConfig.thinkingConfig.thinkingLevel: "LOW"
+    #
+    # The accepted levels differ by provider (OpenAI-compatible endpoints take
+    # minimal/low/medium/high; Anthropic adds xhigh and max; Gemini takes
+    # LOW/MEDIUM/HIGH), so the value is passed through rather than validated
+    # here — the provider is the authority on its own vocabulary.
+    def reasoning_effort
+      nil
+    end
+
+    # Cap on generated tokens, sent as `max_tokens` when set. `nil` (the default)
+    # sends NOTHING — the provider applies its own default, which is what most
+    # OpenAI-compatible endpoints want; a gem-chosen number would silently
+    # truncate responses that were previously uncapped. Override to opt in.
     def max_tokens
-      16 * 1024 # Default
+      nil
+    end
+
+    # Extra provider payload keys, deep-merged OVER the built payload right
+    # before the dialect renders it. The built payload is otherwise closed
+    # (model, messages, stream, tools), so this is the seam for anything the
+    # gem does not model itself: `reasoning_effort`, `temperature`, `top_p`,
+    # `max_tokens`, provider-specific extensions.
+    #
+    #   def llm_params
+    #     { reasoning_effort: "low", temperature: 0.2 }
+    #   end
+    #
+    # Merged last, so a host can also override a key the gem set (e.g. force
+    # `stream: false` for one agent). Keys reach the wire as written for the
+    # OpenAI dialect; the Anthropic and Gemini dialects re-render the payload,
+    # so only keys those dialects read survive there.
+    def llm_params
+      {}
     end
 
     def max_steps
@@ -110,6 +158,9 @@ module SolidLoop
       10.0
     end
 
+    # Budget of ACTUAL WORK — LLM generation plus tool execution — not wall clock
+    # since the loop was created. Time spent paused, failed, or queued does not
+    # count against it (see `Loop#work_duration`).
     def max_duration
       2.hours
     end
@@ -143,13 +194,45 @@ module SolidLoop
       end
     end
 
-    def resume!
+    # `from:` narrows which statuses may be resumed, defaulting to all of
+    # SolidLoop::Loop::RESUMABLE_STATUSES. A caller that means "restart what
+    # stalled" should pass `from: %i[paused failed]`: the default also re-enters
+    # a `completed` loop, which is right for continuing a conversation and wrong
+    # for anything that has already reported a final result — a benchmark run,
+    # a settled ticket — where the resumed turn silently appends to it.
+    #
+    # Returns false when the loop is not in an accepted status, exactly as
+    # before; passing a status that can NEVER be resumed (`running`, `queued`) is
+    # a caller error and raises, because it would otherwise no-op forever.
+    def resume!(from: SolidLoop::Loop::RESUMABLE_STATUSES)
+      accepted = Array(from).map(&:to_s)
+      unknown  = accepted - SolidLoop::Loop::RESUMABLE_STATUSES
+      if unknown.any?
+        raise ArgumentError,
+          "resume! cannot accept #{unknown.join(', ')}; " \
+          "resumable statuses are #{SolidLoop::Loop::RESUMABLE_STATUSES.join(', ')}"
+      end
+
       # State advancement and dispatch commit atomically inside the lock's
       # transaction (same-database transactional job backend): a crash leaves
       # neither a running loop without jobs nor jobs for a rolled-back resume.
       loop_record.with_lock do
-        raise StandardError, "Unfreeze in admin UI before resuming this loop" if loop_record.admin_frozen?
-        return false unless loop_record.init? || loop_record.paused? || loop_record.failed? || loop_record.completed?
+        raise SolidLoop::FrozenLoopError, "Unfreeze in admin UI before resuming this loop" if loop_record.admin_frozen?
+        return false unless accepted.include?(loop_record.status)
+
+        # Mirror of `pause!`'s cleanup. Any assistant shell still `processing`
+        # here belongs to a DEAD generation by construction — none of the
+        # resumable statuses has a live turn — and nothing else will ever finish
+        # it: the graceful-error path in Middlewares::ErrorHandling only
+        # finalizes the shell its own attempt created, and its token-fenced CAS
+        # no-ops entirely once a resume has rotated the generation, which leaves
+        # that shell orphaned. It stays hidden (born-hidden protocol) so a
+        # partial never re-enters a retried turn as history; marking it failed
+        # keeps `processing` meaning "a turn is actually in flight" instead of
+        # accumulating phantoms in the admin UI.
+        loop_record.messages.where(role: "assistant", status: "processing").find_each do |shell|
+          shell.update!(status: "failed", is_hidden: true)
+        end
 
         pending_tool_calls = loop_record.unresolved_tool_calls.to_a
         if pending_tool_calls.any?

data/app/models/solid_loop/loop.rb

@@ -22,8 +22,30 @@ module SolidLoop
     }, default: :init
 
     ACTIVE_STATUSES = %w[init queued running].freeze
+
+    # Seconds this loop has actually WORKED: LLM generation plus tool execution.
+    # Derived rather than stored so it can never drift from the counters that
+    # feed it (`duration_generation` is incremented on both the success and the
+    # failure path; `duration_tools` on each tool invocation).
+    #
+    # This is what `max_duration` budgets against. Wall clock since `created_at`
+    # would also count time the loop spent paused, failed, or simply waiting in a
+    # queue — so a loop resumed after an outage could exhaust its whole budget
+    # having done none of the work, and a loop paused overnight would be dead on
+    # arrival. Work that a hard kill lost is not counted either, which is the
+    # right direction to err: you do not spend budget on work you did not get.
+    def work_duration
+      duration_generation.to_f + duration_tools.to_f
+    end
     STOPPABLE_STATUSES = (ACTIVE_STATUSES + [ "paused" ]).freeze
 
+    # Statuses `Base#resume!` will re-enter. `completed` is included on purpose:
+    # continuing a finished conversation is a legitimate operation for a chat.
+    # It is also the one that surprises callers who mean "restart what stalled" —
+    # a resumed `completed` loop appends to a run that had already reported its
+    # result — so `resume!` takes a `from:` to narrow this set.
+    RESUMABLE_STATUSES = %w[init paused failed completed].freeze
+
     def admin_frozen?
       frozen_at.present?
     end

data/app/models/solid_loop/message.rb

@@ -17,16 +17,42 @@ module SolidLoop
       tool: "tool"
     }
 
-    def tps
-      return 0.0 unless tokens_completion.to_i > 0
+    # Shortest decode window (seconds) from which a throughput figure is believed.
+    # Below it the ratio is dominated by measurement noise: when the whole
+    # response arrives in a single chunk, `duration_generation` and `ttft` nearly
+    # coincide, the denominator collapses toward zero and the quotient explodes
+    # into the thousands. Measured against real traffic, one turn in ~200 lands
+    # there and reports ~9200 tok/s; every other turn sits under 80.
+    MIN_DECODE_WINDOW = 0.25
+
+    # Tokens per second over the DECODE window only — prefill (ttft) is excluded,
+    # so this is generation speed rather than end-to-end latency. Returns 0.0
+    # when the window is too short to measure, which callers render as "no data"
+    # rather than as a zero throughput.
+    def self.derive_tps(tokens_completion:, duration_generation:, ttft:)
+      tokens = tokens_completion.to_i
+      return 0.0 unless tokens.positive?
 
-      # Generation time starts from first token until the end
-      # total_duration is duration_generation
-      actual_gen_time = duration_generation.to_f - ttft.to_f
+      window = duration_generation.to_f - ttft.to_f
+      return 0.0 if window < MIN_DECODE_WINDOW
 
-      return 0.0 if actual_gen_time <= 0
+      (tokens / window).round(2)
+    end
 
-      (tokens_completion.to_f / actual_gen_time).round(2)
+    # Prefers the PERSISTED column so Ruby and SQL agree: aggregating `tps` in a
+    # query and reading `message.tps` must not disagree. Falls back to deriving
+    # it for rows written before the column was populated for every provider
+    # (only the llama.cpp parser reported a rate; the OpenAI/Anthropic/Gemini
+    # parsers stored 0.0, so historical rows on those providers hold nothing).
+    def tps
+      persisted = self[:tps].to_f
+      return persisted if persisted.positive?
+
+      self.class.derive_tps(
+        tokens_completion: tokens_completion,
+        duration_generation: duration_generation,
+        ttft: ttft
+      )
     end
 
     def cumulative_duration

data/app/models/solid_loop/tool_call.rb

@@ -1,6 +1,12 @@
 module SolidLoop
   class ToolCall < ApplicationRecord
-    belongs_to :message, inverse_of: :tool_calls
+    # `touch: true`: a tool_call's OUTCOME (result / is_success / executed_at)
+    # fills in via a nested write LONG after its parent assistant message was
+    # created. Touching the message on every tool_call write bumps the message's
+    # `updated_at`, so a host polling messages by `updated_at > cursor` re-syncs
+    # the enriched tool_call even once that message is no longer the newest —
+    # otherwise the outcome (e.g. a rejection) can stay stuck client-side.
+    belongs_to :message, inverse_of: :tool_calls, touch: true
     belongs_to :mcp_session, class_name: "SolidLoop::McpSession", optional: true, inverse_of: :tool_calls
 
     scope :ordered, -> { order(:id) }