actionagent 0.0.0 → 1.2.0

data/app/models/action_agent/provider_key.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # Per-account LLM provider credential (Settings -> Provider API Keys).
+  # Generation runs (AgentExecutionService and the evaluation LLM judge)
+  # prefer these over the platform's ENV-configured keys, so users can run
+  # agents with their own OpenAI/Anthropic/OpenRouter accounts — or point
+  # ollama at their own host (e.g. a tunnel to a locally running instance).
+  #
+  # The credential is encrypted at rest with Active Record Encryption. API
+  # keys are never rendered back to the client — only a masked hint; ollama
+  # hosts are not secret and are shown in full (see #display_hint).
+  class ProviderKey < ApplicationRecord
+    # Providers that authenticate with an API key.
+    KEY_PROVIDERS = %w[openai anthropic openrouter].freeze
+    # Providers addressed by host URL instead of a key.
+    HOST_PROVIDERS = %w[ollama].freeze
+    PROVIDERS = (KEY_PROVIDERS + HOST_PROVIDERS).freeze
+
+    include Ownable
+    owned_by :account, :user
+
+    encrypts :credential if ActionAgent.encrypt_credentials
+
+    validates :provider, presence: true, inclusion: { in: PROVIDERS }
+    # One credential per provider per owner; which column that means
+    # depends on the configured mode, so it is checked at validation time.
+    validate :provider_unique_within_owner
+    validates :credential, presence: true, length: { maximum: 500 }
+    validates :credential, format: { with: %r{\Ahttps?://\S+\z}, message: "must be an http(s):// URL" },
+      if: :host_based?
+
+    def host_based?
+      HOST_PROVIDERS.include?(provider)
+    end
+
+    # Options merged into generate_with for runs owned by this key's owner,
+    # overriding the host app's config/active_agent.yml credentials.
+    def generation_options
+      host_based? ? { host: credential } : { access_token: credential }
+    end
+
+    # "sk-a…Q2z9" for keys; hosts are shown in full.
+    def display_hint
+      return credential if host_based?
+
+      "#{credential.first(4)}…#{credential.last(4)}"
+    end
+
+    private
+
+    def provider_unique_within_owner
+      return if provider.blank?
+
+      siblings = self.class.for_owner(owner)
+      siblings = siblings.where.not(id: id) if persisted?
+      errors.add(:provider, "has already been taken") if siblings.exists?(provider: provider)
+    end
+  end
+end

data/app/models/action_agent/recording_action.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  class RecordingAction < ApplicationRecord
+    belongs_to :session_recording
+    has_one :snapshot, class_name: "RecordingSnapshot", dependent: :nullify
+
+    ACTION_TYPES = %w[
+      navigate
+      click
+      type
+      scroll
+      snapshot
+      select
+      hover
+      drag
+      file_upload
+      dialog
+      evaluate
+      wait
+      form_fill
+      key_press
+      focus
+      submit
+      handoff
+      user_action
+      completion
+    ].freeze
+
+    validates :action_type, presence: true, inclusion: { in: ACTION_TYPES }
+    validates :sequence, presence: true, uniqueness: { scope: :session_recording_id }
+    validates :timestamp_ms, presence: true
+
+    scope :ordered, -> { order(:sequence) }
+    scope :with_screenshots, -> { where.not(screenshot_key: nil) }
+
+    # Get the screenshot URL (signed URL from storage)
+    def screenshot_url(expires_in: 15.minutes)
+      return nil unless screenshot_key.present?
+
+      SessionRecordingService.signed_url_for(screenshot_key, expires_in: expires_in)
+    end
+
+    # Get the DOM snapshot content
+    def dom_snapshot_content
+      return nil unless dom_snapshot_key.present?
+
+      SessionRecordingService.fetch_snapshot(dom_snapshot_key)
+    end
+
+    # Format for API response
+    def as_json_for_api
+      {
+        id: id,
+        action_type: action_type,
+        sequence: sequence,
+        timestamp_ms: timestamp_ms,
+        selector: selector,
+        value: redacted_value,
+        screenshot_url: screenshot_url,
+        has_dom_snapshot: dom_snapshot_key.present?,
+        metadata: safe_metadata,
+        created_at: created_at.iso8601
+      }
+    end
+
+    # Get browser state at this action (for handoff)
+    def browser_state
+      {
+        url: extract_url,
+        form_values: metadata["form_values"],
+        scroll_position: metadata["scroll_position"],
+        active_element: selector,
+        action_type: action_type
+      }
+    end
+
+    private
+
+    def redacted_value
+      return value unless should_redact?
+
+      "[REDACTED]"
+    end
+
+    def should_redact?
+      return false unless value.present?
+
+      sensitive_patterns = [
+        /password/i,
+        /credit.?card/i,
+        /cvv/i,
+        /ssn/i,
+        /social.?security/i,
+        /\b\d{16}\b/, # Credit card numbers
+        /\b\d{3}-\d{2}-\d{4}\b/ # SSN format
+      ]
+
+      selector_is_sensitive = sensitive_patterns.any? { |p| selector&.match?(p) }
+      value_is_sensitive = sensitive_patterns.any? { |p| value.match?(p) }
+
+      selector_is_sensitive || value_is_sensitive
+    end
+
+    def safe_metadata
+      # Remove any sensitive data from metadata
+      metadata.except("password", "credit_card", "cvv", "ssn")
+    end
+
+    def extract_url
+      case action_type
+      when "navigate"
+        value
+      else
+        metadata["url"] || metadata["page_url"]
+      end
+    end
+  end
+end

data/app/models/action_agent/recording_snapshot.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  class RecordingSnapshot < ApplicationRecord
+    belongs_to :session_recording
+    belongs_to :recording_action, optional: true
+
+    # Guarded: a host app created with --skip-active-storage (or --minimal)
+    # has no has_one_attached, and the gem depends on railties rather than
+    # rails, so it may not even have the gem to require. Without this the
+    # engine dies during eager load at boot.
+    has_one_attached :file if defined?(ActiveStorage)
+
+    # Whether file attachment is available in this host app.
+    def self.attachments_available?
+      defined?(ActiveStorage) && method_defined?(:file)
+    end
+
+    SNAPSHOT_TYPES = %w[screenshot dom full_page].freeze
+
+    validates :storage_key, presence: true, uniqueness: true
+    validates :snapshot_type, presence: true, inclusion: { in: SNAPSHOT_TYPES }
+
+    scope :screenshots, -> { where(snapshot_type: "screenshot") }
+    scope :dom_snapshots, -> { where(snapshot_type: "dom") }
+    scope :ordered, -> { order(:created_at) }
+
+    # Get a signed URL for the file
+    def signed_url(expires_in: 15.minutes)
+      return nil unless self.class.attachments_available?
+      return nil unless file.attached?
+
+      file.url(expires_in: expires_in)
+    rescue StandardError
+      # Fallback if storage not configured
+      nil
+    end
+
+    # Store file data. Without Active Storage the row still records the
+    # snapshot's metadata; only the blob is skipped.
+    def store!(data, filename: nil, content_type: nil)
+      content_type ||= infer_content_type
+      filename ||= generate_filename
+
+      if self.class.attachments_available?
+        file.attach(
+          io: StringIO.new(data),
+          filename: filename,
+          content_type: content_type
+        )
+      end
+
+      update!(file_size_bytes: data.bytesize)
+    end
+
+    # For API response
+    def as_json_for_api
+      {
+        id: id,
+        storage_key: storage_key,
+        snapshot_type: snapshot_type,
+        width: width,
+        height: height,
+        file_size_bytes: file_size_bytes,
+        url: signed_url,
+        created_at: created_at.iso8601
+      }
+    end
+
+    private
+
+    def infer_content_type
+      case snapshot_type
+      when "screenshot", "full_page"
+        "image/png"
+      when "dom"
+        "text/html"
+      else
+        "application/octet-stream"
+      end
+    end
+
+    def generate_filename
+      ext = snapshot_type == "dom" ? "html" : "png"
+      "#{storage_key.tr('/', '_')}.#{ext}"
+    end
+  end
+end

data/app/models/action_agent/sandbox_instance_tier.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # SandboxInstanceTier
+  #
+  # Defines available instance sizes for sandbox sessions.
+  # Similar to Google Colab or Hugging Face Spaces hardware tiers.
+  #
+  # Usage:
+  #   tier = SandboxInstanceTier.find(:gpu_t4)
+  #   tier.cpu_cores      # => 4
+  #   tier.memory_gb      # => 16
+  #   tier.gpu            # => "nvidia-t4"
+  #   tier.hourly_cost    # => 0.35
+  #
+  class SandboxInstanceTier
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attribute :id, :string
+    attribute :name, :string
+    attribute :description, :string
+    attribute :cpu_cores, :integer
+    attribute :memory_gb, :integer
+    attribute :disk_gb, :integer
+    attribute :gpu, :string
+    attribute :gpu_memory_gb, :integer
+    attribute :hourly_cost, :decimal
+    attribute :monthly_cost, :decimal
+    attribute :available, :boolean, default: true
+    attribute :category, :string  # free, pro, enterprise
+
+    # Instance tier definitions
+    # Pricing modeled after Colab/HuggingFace/Lambda Labs
+    TIERS = {
+      # --- Free Tier ---
+      free: {
+        id: "free",
+        name: "Free",
+        description: "Basic CPU instance for testing",
+        cpu_cores: 2,
+        memory_gb: 4,
+        disk_gb: 10,
+        gpu: nil,
+        gpu_memory_gb: nil,
+        hourly_cost: 0.00,
+        monthly_cost: 0.00,
+        category: "free"
+      },
+
+      # --- CPU Tiers ---
+      cpu_small: {
+        id: "cpu_small",
+        name: "CPU Small",
+        description: "2 vCPUs, 8GB RAM",
+        cpu_cores: 2,
+        memory_gb: 8,
+        disk_gb: 20,
+        gpu: nil,
+        gpu_memory_gb: nil,
+        hourly_cost: 0.05,
+        monthly_cost: 36.00,
+        category: "pro"
+      },
+
+      cpu_medium: {
+        id: "cpu_medium",
+        name: "CPU Medium",
+        description: "4 vCPUs, 16GB RAM",
+        cpu_cores: 4,
+        memory_gb: 16,
+        disk_gb: 50,
+        gpu: nil,
+        gpu_memory_gb: nil,
+        hourly_cost: 0.10,
+        monthly_cost: 72.00,
+        category: "pro"
+      },
+
+      cpu_large: {
+        id: "cpu_large",
+        name: "CPU Large",
+        description: "8 vCPUs, 32GB RAM",
+        cpu_cores: 8,
+        memory_gb: 32,
+        disk_gb: 100,
+        gpu: nil,
+        gpu_memory_gb: nil,
+        hourly_cost: 0.20,
+        monthly_cost: 144.00,
+        category: "pro"
+      },
+
+      cpu_xlarge: {
+        id: "cpu_xlarge",
+        name: "CPU XLarge",
+        description: "16 vCPUs, 64GB RAM",
+        cpu_cores: 16,
+        memory_gb: 64,
+        disk_gb: 200,
+        gpu: nil,
+        gpu_memory_gb: nil,
+        hourly_cost: 0.40,
+        monthly_cost: 288.00,
+        category: "enterprise"
+      },
+
+      # --- GPU Tiers ---
+      gpu_t4: {
+        id: "gpu_t4",
+        name: "GPU T4",
+        description: "NVIDIA T4 (16GB VRAM), 4 vCPUs, 16GB RAM",
+        cpu_cores: 4,
+        memory_gb: 16,
+        disk_gb: 50,
+        gpu: "nvidia-tesla-t4",
+        gpu_memory_gb: 16,
+        hourly_cost: 0.35,
+        monthly_cost: 252.00,
+        category: "pro"
+      },
+
+      gpu_l4: {
+        id: "gpu_l4",
+        name: "GPU L4",
+        description: "NVIDIA L4 (24GB VRAM), 8 vCPUs, 32GB RAM",
+        cpu_cores: 8,
+        memory_gb: 32,
+        disk_gb: 100,
+        gpu: "nvidia-l4",
+        gpu_memory_gb: 24,
+        hourly_cost: 0.70,
+        monthly_cost: 504.00,
+        category: "pro"
+      },
+
+      gpu_a10g: {
+        id: "gpu_a10g",
+        name: "GPU A10G",
+        description: "NVIDIA A10G (24GB VRAM), 8 vCPUs, 32GB RAM",
+        cpu_cores: 8,
+        memory_gb: 32,
+        disk_gb: 100,
+        gpu: "nvidia-a10g",
+        gpu_memory_gb: 24,
+        hourly_cost: 1.00,
+        monthly_cost: 720.00,
+        category: "enterprise"
+      },
+
+      gpu_a100_40: {
+        id: "gpu_a100_40",
+        name: "GPU A100 40GB",
+        description: "NVIDIA A100 (40GB VRAM), 12 vCPUs, 85GB RAM",
+        cpu_cores: 12,
+        memory_gb: 85,
+        disk_gb: 200,
+        gpu: "nvidia-a100-40gb",
+        gpu_memory_gb: 40,
+        hourly_cost: 2.50,
+        monthly_cost: 1800.00,
+        category: "enterprise"
+      },
+
+      gpu_a100_80: {
+        id: "gpu_a100_80",
+        name: "GPU A100 80GB",
+        description: "NVIDIA A100 (80GB VRAM), 12 vCPUs, 170GB RAM",
+        cpu_cores: 12,
+        memory_gb: 170,
+        disk_gb: 200,
+        gpu: "nvidia-a100-80gb",
+        gpu_memory_gb: 80,
+        hourly_cost: 4.00,
+        monthly_cost: 2880.00,
+        category: "enterprise"
+      },
+
+      # --- High Memory Tiers ---
+      highmem_medium: {
+        id: "highmem_medium",
+        name: "High Memory Medium",
+        description: "4 vCPUs, 64GB RAM",
+        cpu_cores: 4,
+        memory_gb: 64,
+        disk_gb: 100,
+        gpu: nil,
+        gpu_memory_gb: nil,
+        hourly_cost: 0.25,
+        monthly_cost: 180.00,
+        category: "pro"
+      },
+
+      highmem_large: {
+        id: "highmem_large",
+        name: "High Memory Large",
+        description: "8 vCPUs, 128GB RAM",
+        cpu_cores: 8,
+        memory_gb: 128,
+        disk_gb: 200,
+        gpu: nil,
+        gpu_memory_gb: nil,
+        hourly_cost: 0.50,
+        monthly_cost: 360.00,
+        category: "enterprise"
+      }
+    }.freeze
+
+    class << self
+      def all
+        TIERS.values.map { |attrs| new(attrs) }
+      end
+
+      def find(id)
+        id = id.to_sym
+        raise ArgumentError, "Unknown tier: #{id}" unless TIERS.key?(id)
+
+        new(TIERS[id])
+      end
+
+      def available
+        all.select(&:available)
+      end
+
+      def by_category(category)
+        all.select { |t| t.category == category.to_s }
+      end
+
+      def cpu_tiers
+        all.select { |t| t.gpu.nil? }
+      end
+
+      def gpu_tiers
+        all.select { |t| t.gpu.present? }
+      end
+
+      def free_tier
+        find(:free)
+      end
+
+      def default_tier
+        find(:cpu_small)
+      end
+    end
+
+    def free?
+      hourly_cost.zero?
+    end
+
+    def has_gpu?
+      gpu.present?
+    end
+
+    def display_price
+      if free?
+        "Free"
+      else
+        "$#{format('%.2f', hourly_cost)}/hr"
+      end
+    end
+
+    def display_specs
+      specs = [ "#{cpu_cores} vCPU", "#{memory_gb}GB RAM", "#{disk_gb}GB disk" ]
+      specs << "#{gpu_memory_gb}GB #{gpu_display_name}" if has_gpu?
+      specs.join(" | ")
+    end
+
+    def gpu_display_name
+      return nil unless gpu
+
+      case gpu
+      when "nvidia-tesla-t4" then "T4"
+      when "nvidia-l4" then "L4"
+      when "nvidia-a10g" then "A10G"
+      when "nvidia-a100-40gb" then "A100 40GB"
+      when "nvidia-a100-80gb" then "A100 80GB"
+      else gpu.gsub("nvidia-", "").upcase
+      end
+    end
+
+    # Convert to Incus resource limits
+    def to_incus_limits
+      limits = {
+        "limits.cpu" => cpu_cores.to_s,
+        "limits.memory" => "#{memory_gb}GB",
+        "limits.processes" => (cpu_cores * 250).to_s
+      }
+
+      # GPU passthrough requires host configuration
+      if has_gpu?
+        limits["nvidia.runtime"] = "true"
+        limits["nvidia.require.cuda"] = "true"
+      end
+
+      limits
+    end
+
+    # Convert to Kubernetes resource spec
+    def to_kubernetes_resources
+      resources = {
+        requests: {
+          cpu: "#{cpu_cores * 500}m",
+          memory: "#{memory_gb / 2}Gi"
+        },
+        limits: {
+          cpu: cpu_cores.to_s,
+          memory: "#{memory_gb}Gi"
+        }
+      }
+
+      if has_gpu?
+        resources[:limits]["nvidia.com/gpu"] = "1"
+      end
+
+      resources
+    end
+
+    # GCP machine type mapping
+    def gcp_machine_type
+      if has_gpu?
+        # GPU instances use n1 or a2 series
+        case gpu
+        when "nvidia-a100-40gb", "nvidia-a100-80gb"
+          "a2-highgpu-1g"
+        else
+          "n1-standard-#{cpu_cores}"
+        end
+      elsif memory_gb > cpu_cores * 8
+        # High memory ratio
+        "n2-highmem-#{cpu_cores}"
+      else
+        "n2-standard-#{cpu_cores}"
+      end
+    end
+
+    # GCP accelerator config
+    def gcp_accelerator_config
+      return nil unless has_gpu?
+
+      {
+        accelerator_type: gpu,
+        accelerator_count: 1
+      }
+    end
+
+    def as_json(*)
+      {
+        id: id,
+        name: name,
+        description: description,
+        specs: {
+          cpu_cores: cpu_cores,
+          memory_gb: memory_gb,
+          disk_gb: disk_gb,
+          gpu: gpu,
+          gpu_memory_gb: gpu_memory_gb
+        },
+        pricing: {
+          hourly_cost: hourly_cost.to_f,
+          monthly_cost: monthly_cost.to_f,
+          display: display_price
+        },
+        category: category,
+        available: available
+      }
+    end
+  end
+end

data/app/models/action_agent/sandbox_run.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # SandboxRun tracks individual agent task executions within a sandbox container.
+  # This model uses SQLite in sandbox mode for isolated, ephemeral storage.
+  class SandboxRun < ApplicationRecord
+    enum :status, {
+      pending: 0,
+      running: 1,
+      completed: 2,
+      failed: 3,
+      cancelled: 4
+    }
+
+    validates :task, presence: true
+    validates :status, presence: true
+
+    scope :recent, -> { order(created_at: :desc) }
+    scope :completed_runs, -> { where(status: [ :completed, :failed ]) }
+
+    # Summary for API responses
+    def summary
+      {
+        id: id,
+        task: task.truncate(100),
+        status: status,
+        duration_ms: duration_ms,
+        tokens_used: tokens_used,
+        created_at: created_at&.iso8601,
+        completed_at: completed_at&.iso8601
+      }
+    end
+
+    # Detailed info including full result
+    def details
+      summary.merge(
+        task: task,
+        result: result,
+        error: error,
+        screenshots: screenshots || [],
+        started_at: started_at&.iso8601
+      )
+    end
+  end
+end