activeagent 1.0.1 → 1.0.2

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

@@ -0,0 +1,169 @@
+# 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

@@ -0,0 +1,193 @@
+# 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

@@ -0,0 +1,198 @@
+# 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 || {}
+
+      # Calculate totals from all spans
+      total_duration = root_span["duration_ms"]
+      total_input = 0
+      total_output = 0
+      total_thinking = 0
+
+      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
+
+    # 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

@@ -0,0 +1,105 @@
+<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 %>
+        <% trace.spans.each_with_index do |span, index| %>
+          <%
+            start_pct = ((span["start_time_relative_ms"] || 0) / total_duration * 100).clamp(0, 100)
+            width_pct = ((span["duration_ms"] || 0) / total_duration * 100).clamp(0.5, 100 - start_pct)
+            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>