activeagent 1.1.0 → 1.3.0

data/lib/active_agent/dashboard/app/models/active_agent/dashboard/sandbox_session.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Manages sandbox execution sessions for agent runs.
-    #
-    # Sandbox sessions provide isolated execution environments for running
-    # agents with tools like browser automation, file system access, etc.
-    #
-    # Supports both local (Docker/Incus) and cloud (Cloud Run) sandbox providers.
-    #
-    # @example Creating a sandbox session
-    #   session = ActiveAgent::Dashboard::SandboxSession.create!(
-    #     sandbox_type: "playwright_mcp"
-    #   )
-    #   session.provision!
-    #
-    class SandboxSession < ApplicationRecord
-      # Owner associations - optional to support anonymous users
-      belongs_to :user, class_name: ActiveAgent::Dashboard.user_class, optional: true if ActiveAgent::Dashboard.user_class
-      belongs_to :account, class_name: ActiveAgent::Dashboard.account_class, optional: true if ActiveAgent::Dashboard.multi_tenant?
-      belongs_to :agent_template, class_name: "ActiveAgent::Dashboard::AgentTemplate", optional: true
-
-      has_many :sandbox_runs, class_name: "ActiveAgent::Dashboard::SandboxRun", dependent: :destroy
-      has_one :session_recording, class_name: "ActiveAgent::Dashboard::SessionRecording", dependent: :nullify
-
-      # Session statuses
-      enum :status, {
-        pending: 0,
-        provisioning: 1,
-        ready: 2,
-        running: 3,
-        completed: 4,
-        expired: 5,
-        failed: 6
-      }
-
-      # Sandbox types
-      SANDBOX_TYPES = %w[playwright_mcp terminal research].freeze
-
-      # Default limits (can be overridden by platform tier limits)
-      DEFAULT_LIMITS = {
-        max_runs: 10,
-        timeout_seconds: 300,
-        max_tokens: 50_000,
-        session_duration_minutes: 15
-      }.freeze
-
-      # Validations
-      validates :session_id, presence: true, uniqueness: true
-      validates :sandbox_type, inclusion: { in: SANDBOX_TYPES }
-
-      # Callbacks
-      before_validation :generate_session_id, on: :create
-      before_create :set_defaults
-
-      # Scopes
-      scope :active, -> { where(status: [ :pending, :provisioning, :ready, :running ]) }
-      scope :expired_sessions, -> { where("expires_at < ?", Time.current) }
-      scope :by_type, ->(type) { where(sandbox_type: type) }
-      scope :anonymous, -> { where(user_id: nil) }
-      scope :recent, -> { order(created_at: :desc) }
-
-      # Check if session is still valid
-      def active?
-        !expired? && !failed? && !completed? && expires_at > Time.current
-      end
-
-      # Check if can run more tasks
-      def can_run?
-        active? && runs_count < max_runs
-      end
-
-      # Record a new run (thread-safe for parallel execution)
-      def record_run!(task:, result:, duration_ms:, tokens:, screenshots: [], provider: nil)
-        run = {
-          id: SecureRandom.uuid,
-          task: task,
-          result: result,
-          duration_ms: duration_ms,
-          tokens: tokens,
-          screenshots: screenshots,
-          provider: provider,
-          status: "completed",
-          created_at: Time.current.iso8601
-        }
-
-        with_lock do
-          reload
-          self.runs = runs + [ run ]
-          self.runs_count = runs.size
-          self.total_tokens += tokens
-          self.total_duration_ms += duration_ms
-          self.last_activity_at = Time.current
-          save!
-        end
-
-        run
-      end
-
-      # Provision the sandbox
-      def provision!
-        return if provisioning? || ready?
-
-        update!(status: :provisioning)
-
-        # Use configured sandbox service
-        if Rails.env.development? || Rails.env.test?
-          ActiveAgent::Dashboard::SandboxProvisionJob.perform_now(id)
-        else
-          ActiveAgent::Dashboard::SandboxProvisionJob.perform_later(id)
-        end
-      end
-
-      # Mark as ready with sandbox URL
-      def mark_ready!(sandbox_url:, sandbox_job_id: nil)
-        update!(
-          status: :ready,
-          cloud_run_url: sandbox_url,
-          cloud_run_job_id: sandbox_job_id
-        )
-      end
-
-      # Expire the session
-      def expire!
-        update!(status: :expired)
-        ActiveAgent::Dashboard::SandboxCleanupJob.perform_later(id) if cloud_run_job_id.present?
-      end
-
-      # Summary for API responses
-      def summary
-        {
-          id: id,
-          session_id: session_id,
-          sandbox_type: sandbox_type,
-          status: status,
-          runs_count: runs_count,
-          max_runs: max_runs,
-          total_tokens: total_tokens,
-          expires_at: expires_at&.iso8601,
-          created_at: created_at.iso8601,
-          cloud_run_url: cloud_run_url
-        }
-      end
-
-      # Detailed info including runs
-      def details
-        summary.merge(
-          runs: runs,
-          total_duration_ms: total_duration_ms,
-          last_activity_at: last_activity_at&.iso8601
-        )
-      end
-
-      private
-
-      def generate_session_id
-        self.session_id ||= SecureRandom.uuid
-      end
-
-      def set_defaults
-        limits = ActiveAgent::Dashboard.sandbox_limits || DEFAULT_LIMITS
-        self.expires_at ||= limits[:session_duration_minutes].minutes.from_now
-        self.max_runs ||= limits[:max_runs]
-        self.timeout_seconds ||= limits[:timeout_seconds]
-      end
-    end
-  end
-end

data/lib/active_agent/dashboard/app/models/active_agent/dashboard/session_recording.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Records browser sessions for playback and analysis.
-    #
-    # Session recordings capture the sequence of actions taken during
-    # an agent run or sandbox session, including screenshots, DOM snapshots,
-    # and timing information.
-    #
-    # @example Starting a recording
-    #   recording = ActiveAgent::Dashboard::SessionRecording.start!(
-    #     agent_run: run,
-    #     name: "checkout_flow"
-    #   )
-    #
-    # @example Recording an action
-    #   recording.record_action!(
-    #     action_type: "click",
-    #     selector: "button.submit",
-    #     screenshot: screenshot_data
-    #   )
-    #
-    class SessionRecording < ApplicationRecord
-      belongs_to :agent_run, class_name: "ActiveAgent::Dashboard::AgentRun", optional: true
-      belongs_to :sandbox_session, class_name: "ActiveAgent::Dashboard::SandboxSession", optional: true
-
-      has_many :recording_actions, class_name: "ActiveAgent::Dashboard::RecordingAction", dependent: :destroy
-      has_many :recording_snapshots, class_name: "ActiveAgent::Dashboard::RecordingSnapshot", dependent: :destroy
-
-      enum :status, { recording: 0, completed: 1, failed: 2 }
-
-      validates :status, presence: true
-      validate :must_have_parent, unless: -> { demo_recording? || user_session? }
-
-      scope :recent, -> { order(created_at: :desc) }
-      scope :for_agent, ->(agent_id) { joins(:agent_run).where(agent_runs: { agent_id: agent_id }) }
-      scope :demo, -> { where(name: "lander_demo") }
-      scope :user_sessions, -> { where("name LIKE ?", "user_takeover_%") }
-
-      # Check if this is a demo recording (doesn't require parent)
-      def demo_recording?
-        name&.start_with?("lander_") || name == "demo"
-      end
-
-      # Check if this is a user takeover session (doesn't require parent)
-      def user_session?
-        name&.start_with?("user_takeover_")
-      end
-
-      # Start a new recording session
-      def self.start!(agent_run: nil, sandbox_session: nil, name: nil)
-        create!(
-          agent_run: agent_run,
-          sandbox_session: sandbox_session,
-          name: name || generate_name(agent_run, sandbox_session),
-          status: :recording,
-          metadata: { started_at: Time.current.iso8601 }
-        )
-      end
-
-      # Start a user takeover session (for lander demo analytics)
-      def self.start_user_session!(visitor_id: nil, parent_demo_id: nil, page_url: nil)
-        create!(
-          name: "user_takeover_#{Time.current.strftime('%Y%m%d_%H%M%S')}_#{SecureRandom.hex(4)}",
-          status: :recording,
-          metadata: {
-            started_at: Time.current.iso8601,
-            session_type: "user_takeover",
-            visitor_id: visitor_id,
-            parent_demo_id: parent_demo_id,
-            page_url: page_url,
-            user_agent: nil
-          }
-        )
-      end
-
-      # Record a browser action
-      def record_action!(action_type:, selector: nil, value: nil, screenshot: nil, dom_snapshot: nil, metadata: {})
-        raise "Recording already completed" unless recording?
-
-        action = recording_actions.create!(
-          action_type: action_type,
-          sequence: next_sequence,
-          timestamp_ms: elapsed_ms,
-          selector: selector,
-          value: value,
-          metadata: metadata
-        )
-
-        if screenshot.present?
-          snapshot = store_snapshot(screenshot, :screenshot, action)
-          action.update!(screenshot_key: snapshot.storage_key)
-        end
-
-        if dom_snapshot.present?
-          snapshot = store_snapshot(dom_snapshot, :dom, action)
-          action.update!(dom_snapshot_key: snapshot.storage_key)
-        end
-
-        increment!(:action_count)
-        action
-      end
-
-      # Complete the recording
-      def complete!
-        return unless recording?
-
-        update!(
-          status: :completed,
-          duration_ms: elapsed_ms,
-          metadata: metadata.merge(completed_at: Time.current.iso8601)
-        )
-      end
-
-      # Mark recording as failed
-      def fail!(error_message = nil)
-        return unless recording?
-
-        update!(
-          status: :failed,
-          duration_ms: elapsed_ms,
-          metadata: metadata.merge(
-            failed_at: Time.current.iso8601,
-            error: error_message
-          )
-        )
-      end
-
-      # Get timeline data for playback
-      def timeline
-        recording_actions.order(:sequence).map do |action|
-          {
-            id: action.id,
-            type: action.action_type,
-            sequence: action.sequence,
-            timestamp_ms: action.timestamp_ms,
-            selector: action.selector,
-            value: action.value,
-            screenshot_key: action.screenshot_key,
-            metadata: action.metadata
-          }
-        end
-      end
-
-      private
-
-      def must_have_parent
-        return if agent_run.present? || sandbox_session.present?
-
-        errors.add(:base, "must belong to an agent_run or sandbox_session")
-      end
-
-      def self.generate_name(agent_run, sandbox_session)
-        prefix = if agent_run&.agent
-          agent_run.agent.name.parameterize
-        elsif sandbox_session&.agent_template
-          sandbox_session.agent_template.name.parameterize
-        else
-          "session"
-        end
-
-        "#{prefix}_#{Time.current.strftime('%Y%m%d_%H%M%S')}"
-      end
-
-      def next_sequence
-        (recording_actions.maximum(:sequence) || 0) + 1
-      end
-
-      def elapsed_ms
-        ((Time.current - created_at) * 1000).to_i
-      end
-
-      def store_snapshot(data, snapshot_type, action = nil)
-        storage_key = generate_storage_key(snapshot_type, action&.sequence)
-
-        recording_snapshots.create!(
-          recording_action: action,
-          storage_key: storage_key,
-          snapshot_type: snapshot_type,
-          file_size_bytes: data.bytesize
-        )
-      end
-
-      def generate_storage_key(snapshot_type, sequence = nil)
-        parts = [ "recordings", id, snapshot_type.to_s ]
-        parts << sequence.to_s if sequence
-        parts << SecureRandom.hex(8)
-        parts.join("/")
-      end
-    end
-  end
-end

data/lib/active_agent/dashboard/app/models/active_agent/telemetry_trace.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  # Stores telemetry traces from ActiveAgent clients.
-  #
-  # Each trace represents a complete generation lifecycle, including prompt
-  # preparation, LLM calls, tool invocations, and error handling.
-  #
-  # This model supports two modes:
-  # - Local mode: No account association (single-tenant, self-hosted)
-  # - Multi-tenant mode: With account association (for activeagents.ai platform)
-  #
-  # @example Creating a trace from ingested data (local mode)
-  #   ActiveAgent::TelemetryTrace.create_from_payload(trace_payload, sdk_info)
-  #
-  # @example Creating a trace with account (multi-tenant mode)
-  #   ActiveAgent::TelemetryTrace.create_from_payload(trace_payload, sdk_info, account: account)
-  #
-  class TelemetryTrace < ::ActiveRecord::Base
-    self.table_name = "active_agent_telemetry_traces"
-
-    # Optional account association for multi-tenant mode
-    # The host app can add: belongs_to :account if needed
-    if ActiveAgent::Dashboard.multi_tenant?
-      belongs_to :account, class_name: ActiveAgent::Dashboard.account_class
-    end
-
-    # Status values for traces
-    STATUS_OK = "OK"
-    STATUS_ERROR = "ERROR"
-    STATUS_UNSET = "UNSET"
-
-    validates :trace_id, presence: true
-
-    # Scopes
-    scope :recent, -> { order(timestamp: :desc) }
-    scope :with_errors, -> { where(status: STATUS_ERROR) }
-    scope :for_service, ->(name) { where(service_name: name) }
-    scope :for_environment, ->(env) { where(environment: env) }
-    scope :for_agent, ->(agent_class) { where(agent_class: agent_class) }
-    scope :for_date_range, ->(start_date, end_date) { where(timestamp: start_date..end_date) }
-    scope :for_account, ->(account) { where(account: account) if ActiveAgent::Dashboard.multi_tenant? }
-
-    # Creates a TelemetryTrace from an ingested trace payload.
-    #
-    # Extracts relevant data from the trace payload and stores it in a
-    # normalized format for querying and analysis.
-    #
-    # @param trace [Hash] The trace payload from ActiveAgent::Telemetry
-    # @param sdk_info [Hash] SDK metadata
-    # @param account [Object, nil] Optional account for multi-tenant mode
-    # @return [TelemetryTrace] The created trace
-    def self.create_from_payload(trace, sdk_info = {}, account: nil)
-      spans = trace["spans"] || []
-      root_span = spans.find { |s| s["parent_span_id"].nil? } || spans.first || {}
-
-      total_duration = root_span["duration_ms"]
-
-      # Instrumentation mirrors LLM token usage onto the root span for
-      # display, so summing every span double-counts. When child spans
-      # carry token data, they are the source of truth; the root span only
-      # counts for single-span traces.
-      counted_spans = spans.reject { |s| s["parent_span_id"].nil? }
-      counted_spans = spans if counted_spans.none? { |s| span_token_sum(s).positive? }
-
-      total_input = 0
-      total_output = 0
-      total_thinking = 0
-
-      counted_spans.each do |span|
-        tokens = span["tokens"] || {}
-        total_input += (tokens["input"] || 0)
-        total_output += (tokens["output"] || 0)
-        total_thinking += (tokens["thinking"] || 0)
-      end
-
-      # Extract agent info from root span attributes
-      attributes = root_span["attributes"] || {}
-      agent_class = attributes["agent.class"]
-      agent_action = attributes["agent.action"]
-
-      # Find any error message
-      error_span = spans.find { |s| s["status"] == STATUS_ERROR }
-      error_message = error_span&.dig("attributes", "error.message")
-
-      attrs = {
-        trace_id: trace["trace_id"],
-        service_name: trace["service_name"],
-        environment: trace["environment"],
-        timestamp: Time.parse(trace["timestamp"]),
-        spans: spans,
-        resource_attributes: trace["resource_attributes"],
-        sdk_info: sdk_info,
-        total_duration_ms: total_duration,
-        total_input_tokens: total_input,
-        total_output_tokens: total_output,
-        total_thinking_tokens: total_thinking,
-        status: root_span["status"] || STATUS_UNSET,
-        agent_class: agent_class,
-        agent_action: agent_action,
-        error_message: error_message
-      }
-
-      # Add account if in multi-tenant mode
-      attrs[:account] = account if ActiveAgent::Dashboard.multi_tenant? && account
-
-      create!(attrs)
-    end
-
-    # Sums a span's token counts (used to decide which spans carry the
-    # authoritative token data during ingestion).
-    #
-    # @api private
-    def self.span_token_sum(span)
-      tokens = span["tokens"] || {}
-      tokens.fetch("input", 0).to_i + tokens.fetch("output", 0).to_i + tokens.fetch("thinking", 0).to_i
-    end
-
-    # Returns the root span of this trace.
-    #
-    # @return [Hash, nil] The root span or nil
-    def root_span
-      spans&.find { |s| s["parent_span_id"].nil? }
-    end
-
-    # Returns all LLM spans in this trace.
-    #
-    # @return [Array<Hash>] LLM spans
-    def llm_spans
-      spans&.select { |s| s["type"] == "llm" } || []
-    end
-
-    # Returns all tool call spans in this trace.
-    #
-    # @return [Array<Hash>] Tool spans
-    def tool_spans
-      spans&.select { |s| s["type"] == "tool" } || []
-    end
-
-    # Returns total token count.
-    #
-    # @return [Integer] Total tokens used
-    def total_tokens
-      (total_input_tokens || 0) + (total_output_tokens || 0) + (total_thinking_tokens || 0)
-    end
-
-    # Returns whether this trace had an error.
-    #
-    # @return [Boolean]
-    def error?
-      status == STATUS_ERROR
-    end
-
-    # Returns display name for the trace.
-    #
-    # @return [String] Display name (e.g., "WeatherAgent.forecast")
-    def display_name
-      if agent_class && agent_action
-        "#{agent_class}.#{agent_action}"
-      elsif agent_class
-        agent_class
-      else
-        trace_id&.first(8)
-      end
-    end
-
-    # Returns formatted duration.
-    #
-    # @return [String] Duration in ms or s
-    def formatted_duration
-      return "—" unless total_duration_ms
-
-      if total_duration_ms >= 1000
-        "#{(total_duration_ms / 1000.0).round(2)}s"
-      else
-        "#{total_duration_ms.round(0)}ms"
-      end
-    end
-
-    # Returns formatted token count.
-    #
-    # @return [String] Token count with K suffix for large numbers
-    def formatted_tokens
-      count = total_tokens
-      return "0" if count.zero?
-
-      if count >= 1000
-        "#{(count / 1000.0).round(1)}K"
-      else
-        count.to_s
-      end
-    end
-
-    # Returns the provider used (from LLM spans).
-    #
-    # @return [String, nil] Provider name
-    def provider
-      llm_span = llm_spans.first
-      return nil unless llm_span
-
-      llm_span.dig("attributes", "llm.provider")
-    end
-
-    # Returns the model used (from LLM spans).
-    #
-    # @return [String, nil] Model name
-    def model
-      llm_span = llm_spans.first
-      return nil unless llm_span
-
-      llm_span.dig("attributes", "llm.model")
-    end
-  end
-end

data/lib/active_agent/dashboard/app/views/active_agent/dashboard/traces/_trace_detail.html.erb

@@ -1,117 +0,0 @@
-<div class="space-y-4">
-  <!-- Trace Info -->
-  <div class="grid grid-cols-2 md:grid-cols-4 gap-4 text-sm">
-    <div>
-      <span class="text-gray-500 dark:text-gray-400">Trace ID</span>
-      <div class="font-mono text-gray-900 dark:text-white"><%= trace.trace_id %></div>
-    </div>
-    <div>
-      <span class="text-gray-500 dark:text-gray-400">Service</span>
-      <div class="text-gray-900 dark:text-white"><%= trace.service_name || "—" %></div>
-    </div>
-    <div>
-      <span class="text-gray-500 dark:text-gray-400">Provider</span>
-      <div class="text-gray-900 dark:text-white"><%= trace.provider || "—" %></div>
-    </div>
-    <div>
-      <span class="text-gray-500 dark:text-gray-400">Model</span>
-      <div class="text-gray-900 dark:text-white"><%= trace.model || "—" %></div>
-    </div>
-  </div>
-
-  <% if trace.error? && trace.error_message.present? %>
-    <div class="bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800 rounded p-3">
-      <div class="flex">
-        <svg class="h-5 w-5 text-red-400" viewBox="0 0 20 20" fill="currentColor">
-          <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clip-rule="evenodd" />
-        </svg>
-        <div class="ml-3">
-          <h3 class="text-sm font-medium text-red-800 dark:text-red-200">Error</h3>
-          <p class="mt-1 text-sm text-red-700 dark:text-red-300"><%= trace.error_message %></p>
-        </div>
-      </div>
-    </div>
-  <% end %>
-
-  <!-- Token Breakdown -->
-  <div class="flex gap-6 text-sm">
-    <div class="flex items-center gap-2">
-      <div class="w-3 h-3 rounded-full bg-blue-500"></div>
-      <span class="text-gray-500">Input:</span>
-      <span class="font-medium text-gray-900 dark:text-white"><%= number_with_delimiter(trace.total_input_tokens || 0) %></span>
-    </div>
-    <div class="flex items-center gap-2">
-      <div class="w-3 h-3 rounded-full bg-green-500"></div>
-      <span class="text-gray-500">Output:</span>
-      <span class="font-medium text-gray-900 dark:text-white"><%= number_with_delimiter(trace.total_output_tokens || 0) %></span>
-    </div>
-    <% if trace.total_thinking_tokens.to_i > 0 %>
-      <div class="flex items-center gap-2">
-        <div class="w-3 h-3 rounded-full bg-purple-500"></div>
-        <span class="text-gray-500">Thinking:</span>
-        <span class="font-medium text-purple-600 dark:text-purple-400"><%= number_with_delimiter(trace.total_thinking_tokens) %></span>
-      </div>
-    <% end %>
-  </div>
-
-  <!-- Spans Timeline -->
-  <% if trace.spans.present? %>
-    <div class="mt-4">
-      <h4 class="text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">Span Timeline</h4>
-      <div class="relative bg-gray-100 dark:bg-gray-800 rounded-lg p-4">
-        <% total_duration = (trace.total_duration_ms || 1).to_f %>
-        <% total_duration = 1.0 if total_duration.zero? %>
-        <%
-          # Offsets relative to the root span's start. Span payloads carry
-          # absolute ISO8601 start_time values, not relative offsets.
-          root = trace.root_span || trace.spans.first || {}
-          root_start = Time.parse(root["start_time"]) rescue nil
-        %>
-        <% trace.spans.each_with_index do |span, index| %>
-          <%
-            relative_ms = span["start_time_relative_ms"]
-            if relative_ms.nil? && root_start && span["start_time"].present?
-              span_start = Time.parse(span["start_time"]) rescue nil
-              relative_ms = ((span_start - root_start) * 1000).round(2) if span_start
-            end
-            start_pct = ((relative_ms || 0).to_f / total_duration * 100).clamp(0, 100)
-            width_pct = ((span["duration_ms"] || 0).to_f / total_duration * 100).clamp(0.5, [ 100 - start_pct, 0.5 ].max)
-            span_type = span["type"] || "unknown"
-            colors = {
-              "root" => "bg-gray-400",
-              "prompt" => "bg-blue-400",
-              "llm" => "bg-indigo-500",
-              "generate" => "bg-indigo-400",
-              "tool" => "bg-amber-500",
-              "thinking" => "bg-purple-500",
-              "response" => "bg-green-400"
-            }
-            bg_color = colors[span_type] || "bg-gray-400"
-          %>
-          <div class="flex items-center gap-2 mb-2">
-            <div class="w-24 text-xs text-gray-500 dark:text-gray-400 truncate" title="<%= span["name"] %>">
-              <%= span["name"]&.split(".")&.last || span_type %>
-            </div>
-            <div class="flex-1 h-6 bg-gray-200 dark:bg-gray-700 rounded relative overflow-hidden">
-              <div class="span-bar absolute h-full <%= bg_color %> rounded <%= span["status"] == "ERROR" ? 'opacity-50 bg-red-500' : '' %>"
-                   style="left: <%= start_pct %>%; width: <%= width_pct %>%;"
-                   title="<%= span["name"] %>: <%= span["duration_ms"]&.round(1) %>ms">
-              </div>
-            </div>
-            <div class="w-16 text-xs text-gray-500 dark:text-gray-400 text-right">
-              <%= span["duration_ms"] ? "#{span["duration_ms"].round(1)}ms" : "—" %>
-            </div>
-          </div>
-        <% end %>
-      </div>
-    </div>
-  <% end %>
-
-  <!-- Raw Data (collapsed) -->
-  <details class="mt-4">
-    <summary class="text-sm text-gray-500 dark:text-gray-400 cursor-pointer hover:text-gray-700">
-      View raw trace data
-    </summary>
-    <pre class="mt-2 p-3 bg-gray-100 dark:bg-gray-800 rounded text-xs overflow-x-auto"><%= JSON.pretty_generate(trace.as_json(except: [:id, :created_at, :updated_at])) %></pre>
-  </details>
-</div>