tracebook 0.1.0

data/app/jobs/tracebook/persist_interaction_job.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "json"
+require "stringio"
+require "securerandom"
+require "time"
+
+module Tracebook
+  # Background job for persisting LLM interactions.
+  #
+  # Handles the complete persistence pipeline:
+  # 1. Deserialize payload
+  # 2. Apply PII redaction
+  # 3. Calculate cost based on pricing rules
+  # 4. Store interaction in database (with encryption)
+  # 5. Handle large payloads via ActiveStorage
+  # 6. Enqueue rollup job for analytics
+  #
+  # This job is enqueued by {Tracebook.record!} when `config.persist_async` is true.
+  #
+  # @example Enqueuing directly
+  #   PersistInteractionJob.perform_later(
+  #     provider: "openai",
+  #     model: "gpt-4o",
+  #     request_payload: { messages: messages },
+  #     response_payload: response,
+  #     input_tokens: 100,
+  #     output_tokens: 50
+  #   )
+  #
+  # @example Synchronous execution (testing)
+  #   interaction = PersistInteractionJob.perform_now(payload)
+  #
+  # @see Tracebook.record!
+  # @see RedactionPipeline
+  # @see Pricing::Calculator
+  class PersistInteractionJob < ApplicationJob
+    # Default inline payload size threshold (64KB)
+    INLINE_THRESHOLD_BYTES = 64 * 1024
+
+    # Processes and persists an LLM interaction.
+    #
+    # @param payload [Hash] Normalized interaction attributes
+    # @return [Interaction] The persisted interaction record
+    #
+    # @raise [ActiveRecord::RecordInvalid] if interaction fails validation
+    def perform(payload)
+      normalized = from_payload(payload)
+      redacted = redaction_pipeline.call(normalized)
+      cost = Pricing::Calculator.call(
+        provider: redacted.provider,
+        model: redacted.model,
+        input_tokens: redacted.input_tokens,
+        output_tokens: redacted.output_tokens,
+        occurred_at: occurred_at(redacted)
+      )
+
+      interaction = persist_interaction(redacted, cost)
+      enqueue_rollup(interaction)
+      interaction
+    end
+
+    private
+
+    def from_payload(payload)
+      attributes = payload.to_h.deep_symbolize_keys
+      NormalizedInteraction.new(**attributes)
+    end
+
+    def persist_interaction(normalized, cost)
+      attributes = {
+        provider: normalized.provider,
+        model: normalized.model,
+        project: normalized.project,
+        request_text: normalized.request_text,
+        response_text: normalized.response_text,
+        input_tokens: normalized.input_tokens,
+        output_tokens: normalized.output_tokens,
+        total_tokens: total_tokens(normalized),
+        latency_ms: normalized.latency_ms,
+        status: normalized.status,
+        error_class: normalized.error_class,
+        error_message: normalized.error_message,
+        tags: normalized.tags,
+        metadata: normalized.metadata,
+        parent_id: normalized.parent_id,
+        session_id: normalized.session_id,
+        cost_input_cents: cost.input_cents,
+        cost_output_cents: cost.output_cents,
+        cost_total_cents: cost.total_cents,
+        currency: cost.currency || Tracebook.config.default_currency
+      }
+
+      ActiveRecord::Base.transaction do
+        Interaction.create!(attributes).tap do |interaction|
+          interaction.user = normalized.user if normalized.user
+          persist_payloads(interaction, normalized)
+          interaction.save! if interaction.changed?
+        end
+      end
+    end
+
+    def total_tokens(normalized)
+      [ normalized.input_tokens.to_i, normalized.output_tokens.to_i ].compact.sum
+    end
+
+    def persist_payloads(interaction, normalized)
+      store_payload(:request, interaction, normalized.request_payload)
+      store_payload(:response, interaction, normalized.response_payload)
+    end
+
+    def store_payload(type, interaction, payload)
+      return if payload.nil?
+
+      serialized = JSON.generate(payload)
+      if serialized.bytesize > inline_threshold
+        blob = create_blob(serialized, "#{type}-payload")
+        interaction.public_send("#{type}_payload_store=", "active_storage")
+        interaction.public_send("#{type}_payload_blob_id=", blob.id)
+        interaction.public_send("#{type}_payload=", nil)
+      else
+        interaction.public_send("#{type}_payload_store=", "inline")
+        interaction.public_send("#{type}_payload=", payload)
+      end
+    end
+
+    def inline_threshold
+      Tracebook.config.inline_payload_bytes
+    end
+
+    def create_blob(contents, label)
+      ActiveStorage::Blob.create_and_upload!(
+        io: StringIO.new(contents),
+        filename: "tracebook-#{label}-#{SecureRandom.uuid}.json",
+        content_type: "application/json"
+      )
+    end
+
+    def enqueue_rollup(interaction)
+      DailyRollupsJob.perform_later(
+        date: interaction.created_at.to_date,
+        provider: interaction.provider,
+        model: interaction.model,
+        project: interaction.project
+      )
+    end
+
+    def redaction_pipeline
+      @redaction_pipeline ||= RedactionPipeline.new(config: Tracebook.config)
+    end
+
+    def occurred_at(normalized)
+      normalized.metadata && normalized.metadata["timestamp"] ? Time.parse(normalized.metadata["timestamp"].to_s) : Time.current
+    rescue ArgumentError
+      Time.current
+    end
+  end
+end
+
+TraceBook = Tracebook unless defined?(TraceBook)

data/app/mailers/tracebook/application_mailer.rb

@@ -0,0 +1,6 @@
+module Tracebook
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/tracebook/application_record.rb

@@ -0,0 +1,5 @@
+module Tracebook
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/tracebook/interaction.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Tracebook
+  # ActiveRecord model for LLM interactions.
+  #
+  # Stores all data related to an LLM API call including request/response payloads
+  # (encrypted), usage metrics, cost, review state, and relationships.
+  #
+  # ## Encrypted Fields
+  # - `request_payload` - Full request sent to provider
+  # - `response_payload` - Full response from provider
+  # - `review_comment` - Reviewer's comments
+  #
+  # ## Enums
+  # - `status`: `:success`, `:error`, `:canceled`
+  # - `review_state`: `:pending`, `:approved`, `:flagged`, `:rejected`
+  #
+  # ## Associations
+  # - `parent` - Parent interaction for hierarchical chains
+  # - `user` - Polymorphic association to user who triggered the call
+  # - `request_payload_blob` - ActiveStorage blob for large requests
+  # - `response_payload_blob` - ActiveStorage blob for large responses
+  #
+  # @example Finding interactions
+  #   Interaction.by_provider("openai")
+  #     .by_model("gpt-4o")
+  #     .by_review_state(:pending)
+  #     .between_dates(30.days.ago, Date.current)
+  #
+  # @example Filtering with parameters
+  #   Interaction.filtered(
+  #     provider: "anthropic",
+  #     model: "claude-3-5-sonnet",
+  #     review_state: "flagged",
+  #     from: "2025-01-01",
+  #     to: "2025-01-31"
+  #   )
+  class Interaction < ApplicationRecord
+    self.table_name = "tracebook_interactions"
+
+    # @!attribute [rw] parent
+    #   @return [Tracebook::Interaction, nil] Parent interaction for hierarchical chains
+    belongs_to :parent, class_name: "Tracebook::Interaction", optional: true
+
+    # @!attribute [rw] user
+    #   @return [ActiveRecord::Base, nil] Polymorphic user who triggered this interaction
+    belongs_to :user, polymorphic: true, optional: true
+
+    # @!attribute [rw] request_payload_blob
+    #   @return [ActiveStorage::Blob, nil] Blob for large request payloads
+    belongs_to :request_payload_blob, class_name: "ActiveStorage::Blob", optional: true
+
+    # @!attribute [rw] response_payload_blob
+    #   @return [ActiveStorage::Blob, nil] Blob for large response payloads
+    belongs_to :response_payload_blob, class_name: "ActiveStorage::Blob", optional: true
+
+    # @!attribute [rw] status
+    #   @return [Symbol] Request status (:success, :error, :canceled)
+    enum :status, { success: 0, error: 1, canceled: 2 }, prefix: true
+
+    # @!attribute [rw] review_state
+    #   @return [Symbol] Review state (:pending, :approved, :flagged, :rejected)
+    enum :review_state, { pending: 0, approved: 1, flagged: 2, rejected: 3 }, prefix: true
+
+    attribute :tags, :json, default: []
+    attribute :metadata, :json, default: {}
+    attribute :request_payload, :json, default: {}
+    attribute :response_payload, :json, default: {}
+
+    validates :provider, presence: true
+    validates :model, presence: true
+
+    scope :by_provider, ->(provider) { where(provider: provider) if provider.present? }
+    scope :by_model, ->(model) { where(model: model) if model.present? }
+    scope :by_project, ->(project) { where(project: project) if project.present? }
+    scope :by_status, ->(status) { where(status: status) if status.present? }
+    scope :by_review_state, ->(state) { where(review_state: state) if state.present? }
+    scope :between_dates, ->(from, to) {
+      scope = all
+      scope = scope.where("created_at >= ?", Date.parse(from.to_s).beginning_of_day) if from.present?
+      scope = scope.where("created_at <= ?", Date.parse(to.to_s).end_of_day) if to.present?
+      scope
+    }
+    scope :tagged_with, ->(tag) {
+      where("tags LIKE ?", "%#{sanitize_sql_like(tag)}%") if tag.present?
+    }
+
+    def self.filtered(params)
+      by_provider(params[:provider])
+        .by_model(params[:model])
+        .by_project(params[:project])
+        .by_status(params[:status])
+        .by_review_state(params[:review_state])
+        .tagged_with(params[:tag])
+        .between_dates(params[:from], params[:to])
+    end
+  end
+end
+
+TraceBook = Tracebook unless defined?(TraceBook)

data/app/models/tracebook/pricing_rule.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Tracebook
+  # Pricing rule for calculating LLM interaction costs.
+  #
+  # Defines cost per 1000 tokens for a provider/model pattern. Supports
+  # glob patterns for matching multiple models and date-based effective periods.
+  #
+  # ## Fields
+  # - `provider` - Provider name (e.g., "openai", "anthropic")
+  # - `model_glob` - Glob pattern for matching models (e.g., "gpt-4o*", "claude-3-5-*")
+  # - `input_per_1k` - Cost per 1000 input tokens
+  # - `output_per_1k` - Cost per 1000 output tokens
+  # - `currency` - Currency code (e.g., "USD")
+  # - `effective_from` - Date this pricing takes effect
+  # - `effective_to` - Optional end date for this pricing
+  #
+  # @example Creating pricing rules
+  #   PricingRule.create!(
+  #     provider: "openai",
+  #     model_glob: "gpt-4o",
+  #     input_per_1k: 2.50,
+  #     output_per_1k: 10.00,
+  #     currency: "USD",
+  #     effective_from: Date.new(2024, 8, 6)
+  #   )
+  #
+  # @example Glob patterns
+  #   # Exact match
+  #   model_glob: "gpt-4o"
+  #
+  #   # All GPT-4o variants
+  #   model_glob: "gpt-4o*"
+  #
+  #   # All Claude 3.5 models
+  #   model_glob: "claude-3-5-*"
+  #
+  #   # Fallback for any model
+  #   model_glob: "*"
+  #
+  # @example Finding applicable rule
+  #   rule = PricingRule
+  #     .where(provider: "openai")
+  #     .where("? >= effective_from", Date.current)
+  #     .where("effective_to IS NULL OR ? < effective_to", Date.current)
+  #     .find { |r| r.matches_model?("gpt-4o-mini") }
+  class PricingRule < ApplicationRecord
+    self.table_name = "tracebook_pricing_rules"
+
+    validates :provider, presence: true
+    validates :model_glob, presence: true
+    validates :effective_from, presence: true
+
+    # Returns true if this rule is active on the given date.
+    #
+    # @param date [Date] The date to check
+    # @return [Boolean] true if rule is effective on this date
+    #
+    # @example
+    #   rule.active_on?(Date.current) # => true
+    #   rule.active_on?(Date.new(2020, 1, 1)) # => false
+    def active_on?(date)
+      date >= effective_from && (effective_to.nil? || date < effective_to)
+    end
+
+    # Returns true if this rule's glob pattern matches the given model.
+    #
+    # Uses case-insensitive file glob matching.
+    #
+    # @param model [String] Model identifier to match
+    # @return [Boolean] true if pattern matches
+    #
+    # @example
+    #   rule = PricingRule.new(model_glob: "gpt-4o*")
+    #   rule.matches_model?("gpt-4o") # => true
+    #   rule.matches_model?("gpt-4o-mini") # => true
+    #   rule.matches_model?("claude-3-5-sonnet") # => false
+    def matches_model?(model)
+      File.fnmatch?(model_glob, model, File::FNM_CASEFOLD)
+    end
+  end
+end
+
+TraceBook = Tracebook unless defined?(TraceBook)

data/app/models/tracebook/redaction_rule.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Tracebook
+  # Rule for redacting PII from interaction payloads.
+  #
+  # Defines a regex pattern to detect and replace sensitive data before
+  # persistence. Runs on request, response, or both payloads.
+  #
+  # ## Fields
+  # - `name` - Human-readable name for this rule
+  # - `pattern` - Regular expression pattern to match
+  # - `replacement` - Replacement string (e.g., "[REDACTED]", "[EMAIL]")
+  # - `applies_to` - Where to apply: `:request`, `:response`, `:both`, `:metadata`
+  # - `enabled` - Whether this rule is active
+  #
+  # ## Built-in Rules
+  # TraceBook includes default redactors for:
+  # - Email addresses
+  # - Phone numbers (US format)
+  # - Credit card PANs
+  #
+  # @example Creating a custom redaction rule
+  #   RedactionRule.create!(
+  #     name: "API Keys",
+  #     pattern: 'api_key["\s]*[:=]["\s]*\K[\w-]+',
+  #     replacement: "[API_KEY]",
+  #     applies_to: :both,
+  #     enabled: true
+  #   )
+  #
+  # @example Email redaction
+  #   RedactionRule.create!(
+  #     name: "Email Addresses",
+  #     pattern: '\b[\w\.-]+@[\w\.-]+\.\w{2,}\b',
+  #     replacement: "[EMAIL]",
+  #     applies_to: :both,
+  #     enabled: true
+  #   )
+  #
+  # @example SSN redaction
+  #   RedactionRule.create!(
+  #     name: "Social Security Numbers",
+  #     pattern: '\b\d{3}-\d{2}-\d{4}\b',
+  #     replacement: "[SSN]",
+  #     applies_to: :both,
+  #     enabled: true
+  #   )
+  #
+  # @see Redactors::Email
+  # @see Redactors::Phone
+  # @see Redactors::CardPAN
+  class RedactionRule < ApplicationRecord
+    self.table_name = "tracebook_redaction_rules"
+
+    # @!attribute [rw] applies_to
+    #   @return [Symbol] Where to apply redaction (:request, :response, :both, :metadata)
+    enum :applies_to, { request: 0, response: 1, both: 2, metadata: 3 }
+
+    validates :name, presence: true
+    validates :pattern, presence: true
+    validates :replacement, presence: true
+
+    # Returns the compiled regex pattern.
+    #
+    # Caches the compiled pattern for performance. If pattern is invalid,
+    # falls back to escaped literal match.
+    #
+    # @return [Regexp] Compiled regular expression with MULTILINE flag
+    #
+    # @example
+    #   rule = RedactionRule.new(pattern: '\b\d{3}-\d{2}-\d{4}\b')
+    #   rule.compiled_pattern.match("123-45-6789") # => MatchData
+    def compiled_pattern
+      @compiled_pattern ||= Regexp.new(pattern, Regexp::MULTILINE)
+    rescue RegexpError
+      Regexp.new(Regexp.escape(pattern.to_s))
+    end
+  end
+end
+
+TraceBook = Tracebook unless defined?(TraceBook)

data/app/models/tracebook/rollup_daily.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Tracebook
+  # Daily aggregated metrics for LLM interactions.
+  #
+  # Stores summarized statistics by date/provider/model/project for analytics
+  # and cost reporting. Updated nightly by {DailyRollupsJob}.
+  #
+  # ## Fields
+  # - `date` - Date of rollup (part of composite PK)
+  # - `provider` - Provider name (part of composite PK)
+  # - `model` - Model identifier (part of composite PK)
+  # - `project` - Project name (part of composite PK, nullable)
+  # - `interactions_count` - Total number of interactions
+  # - `success_count` - Number of successful interactions
+  # - `error_count` - Number of failed interactions
+  # - `input_tokens_sum` - Sum of input tokens
+  # - `output_tokens_sum` - Sum of output tokens
+  # - `cost_cents_sum` - Total cost in cents
+  #
+  # ## Primary Key
+  # Composite PK: `(date, provider, model, project)`
+  #
+  # @example Querying daily metrics
+  #   RollupDaily
+  #     .where(provider: "openai", date: Date.current)
+  #     .sum(:cost_cents_sum) / 100.0 # Total cost in dollars
+  #
+  # @example Finding top models by cost
+  #   RollupDaily
+  #     .where(date: 30.days.ago..Date.current)
+  #     .group(:provider, :model)
+  #     .sum(:cost_cents_sum)
+  #     .sort_by { |_, cents| -cents }
+  #     .first(10)
+  #
+  # @example Error rate for a model
+  #   rollup = RollupDaily.find_by(date: Date.current, provider: "openai", model: "gpt-4o")
+  #   error_rate = rollup.error_count.to_f / rollup.interactions_count
+  #
+  # @see DailyRollupsJob
+  class RollupDaily < ApplicationRecord
+    self.table_name = "tracebook_rollups_dailies"
+
+    # @!attribute [rw] interactions_count
+    #   @return [Integer] Total number of interactions (default: 0)
+    attribute :interactions_count, :integer, default: 0
+
+    # @!attribute [rw] success_count
+    #   @return [Integer] Number of successful interactions (default: 0)
+    attribute :success_count, :integer, default: 0
+
+    # @!attribute [rw] error_count
+    #   @return [Integer] Number of failed interactions (default: 0)
+    attribute :error_count, :integer, default: 0
+
+    # @!attribute [rw] input_tokens_sum
+    #   @return [Integer] Sum of input tokens across all interactions (default: 0)
+    attribute :input_tokens_sum, :integer, default: 0
+
+    # @!attribute [rw] output_tokens_sum
+    #   @return [Integer] Sum of output tokens across all interactions (default: 0)
+    attribute :output_tokens_sum, :integer, default: 0
+
+    # @!attribute [rw] cost_cents_sum
+    #   @return [Integer] Total cost in cents (default: 0)
+    attribute :cost_cents_sum, :integer, default: 0
+
+    validates :date, presence: true
+  end
+end
+
+TraceBook = Tracebook unless defined?(TraceBook)

data/app/views/layouts/tracebook/application.html.erb

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Tracebook</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+
+  <%= stylesheet_link_tag "tracebook/application", media: "all", "data-turbo-track": "reload" %>
+  <%= javascript_include_tag "tracebook/application", defer: true, "data-turbo-track": "reload" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/tracebook/interactions/index.html.erb

@@ -0,0 +1,105 @@
+<div class="tb-container">
+  <header class="tb-header">
+    <h1>TraceBook Interactions</h1>
+    <div class="tb-kpis">
+      <div class="tb-kpi">
+        <span>Total</span>
+        <strong><%= @kpis[:total] %></strong>
+      </div>
+      <div class="tb-kpi">
+        <span>Success</span>
+        <strong><%= @kpis[:success] %></strong>
+      </div>
+      <div class="tb-kpi">
+        <span>Total Tokens</span>
+        <strong><%= @kpis[:input_tokens] + @kpis[:output_tokens] %></strong>
+      </div>
+      <div class="tb-kpi">
+        <span>Cost (¢)</span>
+        <strong><%= @kpis[:cost_cents] %></strong>
+      </div>
+    </div>
+  </header>
+
+  <section class="tb-filters">
+    <%= form_with url: interactions_path, method: :get, scope: :filters, data: { turbo_frame: "interactions_table" }, class: "tb-filter-form" do |form| %>
+      <div class="tb-filter-grid">
+        <div>
+          <%= form.label :provider %>
+          <%= form.select :provider, options_for_select(@providers, @filters[:provider]), include_blank: "All" %>
+        </div>
+        <div>
+          <%= form.label :model %>
+          <%= form.select :model, options_for_select(@models, @filters[:model]), include_blank: "All" %>
+        </div>
+        <div>
+          <%= form.label :project %>
+          <%= form.select :project, options_for_select(@projects, @filters[:project]), include_blank: "All" %>
+        </div>
+        <div>
+          <%= form.label :status %>
+          <%= form.select :status, options_for_select(TraceBook::Interaction.statuses.keys, @filters[:status]), include_blank: "All" %>
+        </div>
+        <div>
+          <%= form.label :review_state %>
+          <%= form.select :review_state, options_for_select(TraceBook::Interaction.review_states.keys, @filters[:review_state]), include_blank: "All" %>
+        </div>
+        <div>
+          <%= form.label :tag %>
+          <%= form.text_field :tag, value: @filters[:tag] %>
+        </div>
+        <div>
+          <%= form.label :from, "From (date)" %>
+          <%= form.date_field :from, value: @filters[:from] %>
+        </div>
+        <div>
+          <%= form.label :to, "To (date)" %>
+          <%= form.date_field :to, value: @filters[:to] %>
+        </div>
+      </div>
+      <div class="tb-filter-actions">
+        <%= form.submit "Apply" %>
+        <%= link_to "Reset", interactions_path, class: "tb-link" %>
+      </div>
+    <% end %>
+  </section>
+
+  <section class="tb-table-wrapper">
+    <%= form_with url: bulk_review_interactions_path, method: :post, data: { controller: "keyboard" }, html: { tabindex: 0 } do %>
+      <%= hidden_field_tag :review_state, "approved", data: { keyboard_target: "reviewState" } %>
+      <div class="tb-table-actions">
+        <button type="submit">Bulk Approve</button>
+        <button type="submit" formaction="<%= exports_path(format: :csv, filters: @filters.to_h) %>" formmethod="post">Export CSV</button>
+      </div>
+
+      <turbo-frame id="interactions_table">
+        <table class="tb-table" data-keyboard-target="table">
+          <thead>
+            <tr>
+              <th><input type="checkbox" data-keyboard-target="toggleAll"></th>
+              <th>Timestamp</th>
+              <th>Provider</th>
+              <th>Model</th>
+              <th>Status</th>
+              <th>Tokens</th>
+              <th>Cost (¢)</th>
+            </tr>
+          </thead>
+          <tbody>
+            <% @interactions.each do |interaction| %>
+              <tr data-controller="row" data-keyboard-target="row">
+                <td><%= check_box_tag "interaction_ids[]", interaction.id, false, data: { keyboard_target: "checkbox" } %></td>
+                <td><%= link_to interaction.created_at.strftime("%Y-%m-%d %H:%M"), interaction_path(interaction) %></td>
+                <td><%= interaction.provider %></td>
+                <td><%= interaction.model %></td>
+                <td><%= interaction.status %></td>
+                <td><%= interaction.total_tokens %></td>
+                <td><%= interaction.cost_total_cents %></td>
+              </tr>
+            <% end %>
+          </tbody>
+        </table>
+      </turbo-frame>
+    <% end %>
+  </section>
+</div>

data/app/views/tracebook/interactions/show.html.erb

@@ -0,0 +1,44 @@
+<div class="tb-container">
+  <nav class="tb-breadcrumbs">
+    <%= link_to "← Back", interactions_path %>
+  </nav>
+
+  <header class="tb-header">
+    <h1>Interaction <%= @interaction.id %></h1>
+    <div class="tb-meta-grid">
+      <div><span>Provider</span><strong><%= @interaction.provider %></strong></div>
+      <div><span>Model</span><strong><%= @interaction.model %></strong></div>
+      <div><span>Status</span><strong><%= @interaction.status %></strong></div>
+      <div><span>Review</span><strong><%= @interaction.review_state %></strong></div>
+      <div><span>Tokens</span><strong><%= @interaction.total_tokens %></strong></div>
+      <div><span>Cost (¢)</span><strong><%= @interaction.cost_total_cents %></strong></div>
+    </div>
+  </header>
+
+  <% request_payload = payload_for(@interaction, :request) %>
+  <section class="tb-section" data-controller="json-viewer" data-json-viewer-collapsed-value="true">
+    <h2>Request</h2>
+    <pre data-json-viewer-target="content"><%= formatted_payload(request_payload, @interaction.request_text) %></pre>
+  </section>
+
+  <% response_payload = payload_for(@interaction, :response) %>
+  <section class="tb-section" data-controller="json-viewer">
+    <h2>Response</h2>
+    <pre data-json-viewer-target="content"><%= formatted_payload(response_payload, @interaction.response_text) %></pre>
+  </section>
+
+  <section class="tb-section">
+    <h2>Metadata</h2>
+    <pre><%= formatted_payload(@interaction.metadata, "{}") %></pre>
+  </section>
+
+  <section class="tb-section">
+    <%= form_with url: review_interaction_path(@interaction), method: :post, class: "tb-review-form" do %>
+      <div>
+        <%= label_tag :review_state, "Review State" %>
+        <%= select_tag :review_state, options_for_select(TraceBook::Interaction.review_states.keys, @interaction.review_state) %>
+      </div>
+      <%= submit_tag "Update Review" %>
+    <% end %>
+  </section>
+</div>