activeagent 1.0.1 → 1.0.2

data/lib/active_agent/dashboard/app/jobs/active_agent/dashboard/sandbox_provision_job.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Dashboard
+    # Background job for provisioning sandbox environments.
+    #
+    # Creates isolated execution environments (Docker, Cloud Run, etc.)
+    # for running agents with tools.
+    #
+    class SandboxProvisionJob < ApplicationJob
+      queue_as :default
+
+      def perform(sandbox_session_id)
+        session = SandboxSession.find(sandbox_session_id)
+        return unless session.provisioning?
+
+        begin
+          result = provision_sandbox(session)
+
+          session.mark_ready!(
+            sandbox_url: result[:url],
+            sandbox_job_id: result[:job_id]
+          )
+        rescue => e
+          session.update!(
+            status: :failed,
+            error_message: e.message
+          )
+        end
+      end
+
+      private
+
+      def provision_sandbox(session)
+        case ActiveAgent::Dashboard.sandbox_service
+        when :cloud_run
+          provision_cloud_run(session)
+        when :kubernetes
+          provision_kubernetes(session)
+        else
+          provision_local(session)
+        end
+      end
+
+      def provision_local(session)
+        # Local mode: No actual provisioning needed
+        # The sandbox runs in the same process or via Docker
+        {
+          url: "http://localhost:#{3000 + session.id}",
+          job_id: "local-#{session.session_id}"
+        }
+      end
+
+      def provision_cloud_run(session)
+        # TODO: Implement Cloud Run provisioning
+        raise NotImplementedError, "Cloud Run provisioning not yet implemented in engine"
+      end
+
+      def provision_kubernetes(session)
+        # TODO: Implement Kubernetes provisioning
+        raise NotImplementedError, "Kubernetes provisioning not yet implemented in engine"
+      end
+    end
+  end
+end

data/lib/active_agent/dashboard/app/jobs/active_agent/process_telemetry_traces_job.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  # Processes telemetry traces received from ActiveAgent clients.
+  #
+  # This job handles the asynchronous processing of trace data to avoid
+  # blocking the ingestion endpoint. It:
+  # - Creates TelemetryTrace records for each trace
+  # - Updates aggregate statistics
+  # - Handles any errors gracefully
+  #
+  # @example Local mode
+  #   ActiveAgent::ProcessTelemetryTracesJob.perform_later(
+  #     traces: [...],
+  #     sdk_info: { name: "activeagent", version: "0.5.0" },
+  #     received_at: "2024-01-15T10:30:00Z"
+  #   )
+  #
+  # @example Multi-tenant mode
+  #   ActiveAgent::ProcessTelemetryTracesJob.perform_later(
+  #     account_id: 1,
+  #     traces: [...],
+  #     sdk_info: { name: "activeagent", version: "0.5.0" },
+  #     received_at: "2024-01-15T10:30:00Z"
+  #   )
+  #
+  class ProcessTelemetryTracesJob < ::ActiveJob::Base
+    queue_as :default
+
+    # Maximum traces to process in a single job to avoid memory issues
+    MAX_TRACES_PER_JOB = 100
+
+    def perform(account_id: nil, traces:, sdk_info:, received_at:)
+      account = resolve_account(account_id)
+
+      # In multi-tenant mode, require an account
+      if ActiveAgent::Dashboard.multi_tenant? && account.nil?
+        Rails.logger.warn("[ProcessTelemetryTracesJob] Skipping traces - no valid account")
+        return
+      end
+
+      traces = traces.take(MAX_TRACES_PER_JOB)
+
+      traces.each do |trace|
+        process_trace(trace, sdk_info, account)
+      rescue StandardError => e
+        Rails.logger.error(
+          "[ProcessTelemetryTracesJob] Failed to process trace #{trace['trace_id']}: " \
+          "#{e.class} - #{e.message}"
+        )
+      end
+    end
+
+    private
+
+    def resolve_account(account_id)
+      return nil unless ActiveAgent::Dashboard.multi_tenant?
+      return nil unless account_id
+
+      account_class = ActiveAgent::Dashboard.account_class.constantize
+      account_class.find_by(id: account_id)
+    end
+
+    def process_trace(trace, sdk_info, account)
+      model = ActiveAgent::Dashboard.trace_model
+
+      # Build uniqueness scope
+      scope = model.where(trace_id: trace["trace_id"])
+      scope = scope.where(account: account) if ActiveAgent::Dashboard.multi_tenant? && account
+
+      # Skip if trace already exists (idempotency)
+      return if scope.exists?
+
+      model.create_from_payload(trace, sdk_info, account: account)
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Dashboard
+    # Represents an AI agent configuration.
+    #
+    # Agents are the core entity in the dashboard, storing all configuration
+    # needed to execute AI interactions including provider settings, instructions,
+    # tools, and appearance.
+    #
+    # Supports both local (single-user) and multi-tenant (account-scoped) modes.
+    #
+    # @example Creating an agent
+    #   agent = ActiveAgent::Dashboard::Agent.create!(
+    #     name: "Code Assistant",
+    #     provider: "openai",
+    #     model: "gpt-4o"
+    #   )
+    #
+    # @example Executing an agent
+    #   run = agent.execute("Explain this code", code: "def foo; end")
+    #
+    class Agent < ApplicationRecord
+      # Associations - owner is optional to support both modes
+      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?
+
+      has_many :agent_versions, class_name: "ActiveAgent::Dashboard::AgentVersion", dependent: :destroy
+      has_many :agent_runs, class_name: "ActiveAgent::Dashboard::AgentRun", dependent: :destroy
+
+      # Validations
+      validates :name, presence: true, length: { minimum: 2, maximum: 100 }
+      validates :slug, presence: true, format: { with: /\A[a-z0-9\-_]+\z/ }
+      validates :provider, presence: true
+      validates :model, presence: true
+
+      # Ensure slug uniqueness within scope
+      if ActiveAgent::Dashboard.multi_tenant?
+        validates :slug, uniqueness: { scope: :account_id }
+      else
+        validates :slug, uniqueness: { scope: :user_id }
+      end
+
+      # Status enum
+      enum :status, { draft: 0, active: 1, archived: 2 }
+
+      # Callbacks
+      before_validation :generate_slug, on: :create
+      after_create :create_initial_version
+      after_update :create_version_on_config_change, if: :configuration_changed?
+
+      # Scopes
+      scope :active_agents, -> { where(status: :active) }
+      scope :by_provider, ->(provider) { where(provider: provider) }
+      scope :with_tool, ->(tool) { where("tools @> ?", [ tool ].to_json) }
+
+      # Available presets matching AgentAvatar component
+      PRESET_TYPES = %w[
+        terminal webDeveloper documentAnalysis writing translation
+        playwright research imageAnalysis computerUse productDesign
+      ].freeze
+
+      # Available instruction sets
+      INSTRUCTION_SETS = %w[
+        github ruby rails aws gcp python typescript docker kubernetes
+      ].freeze
+
+      # Available tools/MCPs
+      AVAILABLE_TOOLS = %w[
+        terminal playwright filesystem code database slack fetch search edit translate memory
+      ].freeze
+
+      # Available providers
+      PROVIDERS = %w[openai anthropic ollama openrouter].freeze
+
+      # Returns the configuration as a hash for versioning
+      def configuration_snapshot
+        {
+          name: name,
+          description: description,
+          provider: provider,
+          model: model,
+          instructions: instructions,
+          preset_type: preset_type,
+          appearance: appearance,
+          instruction_sets: instruction_sets,
+          tools: tools,
+          mcp_servers: mcp_servers,
+          model_config: model_config,
+          response_format: response_format
+        }
+      end
+
+      # Restore from a version
+      def restore_from_version!(version)
+        config = version.configuration_snapshot
+        update!(
+          instructions: config["instructions"],
+          preset_type: config["preset_type"],
+          appearance: config["appearance"],
+          instruction_sets: config["instruction_sets"],
+          tools: config["tools"],
+          mcp_servers: config["mcp_servers"],
+          model_config: config["model_config"],
+          response_format: config["response_format"]
+        )
+      end
+
+      # Get the latest version
+      def latest_version
+        agent_versions.order(version_number: :desc).first
+      end
+
+      # Get version count
+      def version_count
+        agent_versions.count
+      end
+
+      # Generate Ruby agent class code
+      def to_agent_class_code
+        <<~RUBY
+          class #{agent_class_name || name.camelize}Agent < ApplicationAgent
+            generate_with :#{provider}, model: "#{model}"#{model_config_code}
+
+            def perform
+              prompt#{instructions_code}
+            end
+          end
+        RUBY
+      end
+
+      # Execute a run with this agent
+      def execute(input_prompt, **params)
+        run = agent_runs.create!(
+          input_prompt: input_prompt,
+          input_params: params,
+          status: :pending,
+          trace_id: SecureRandom.uuid
+        )
+
+        # Queue the execution job
+        ActiveAgent::Dashboard::AgentExecutionJob.perform_later(run.id)
+
+        run
+      end
+
+      # Quick test execution (synchronous)
+      def test_execute(input_prompt, **params)
+        run = agent_runs.create!(
+          input_prompt: input_prompt,
+          input_params: params,
+          status: :running,
+          trace_id: SecureRandom.uuid,
+          started_at: Time.current
+        )
+
+        begin
+          result = build_and_execute_agent(input_prompt, **params)
+
+          run.update!(
+            output: result[:output],
+            output_metadata: result[:metadata],
+            status: :complete,
+            completed_at: Time.current,
+            duration_ms: ((Time.current - run.started_at) * 1000).to_i,
+            input_tokens: result.dig(:usage, :input_tokens),
+            output_tokens: result.dig(:usage, :output_tokens),
+            total_tokens: result.dig(:usage, :total_tokens)
+          )
+        rescue => e
+          run.update!(
+            status: :failed,
+            completed_at: Time.current,
+            error_message: e.message,
+            error_backtrace: e.backtrace&.first(10)&.join("\n")
+          )
+        end
+
+        run
+      end
+
+      private
+
+      def generate_slug
+        return if slug.present?
+
+        base_slug = name.to_s.parameterize
+        self.slug = base_slug
+
+        # Ensure uniqueness within scope
+        counter = 1
+        scope = self.class.where(slug: slug)
+        scope = scope.where(account_id: account_id) if respond_to?(:account_id) && account_id
+        scope = scope.where(user_id: user_id) if respond_to?(:user_id) && user_id
+
+        while scope.exists?
+          self.slug = "#{base_slug}-#{counter}"
+          scope = self.class.where(slug: slug)
+          scope = scope.where(account_id: account_id) if respond_to?(:account_id) && account_id
+          scope = scope.where(user_id: user_id) if respond_to?(:user_id) && user_id
+          counter += 1
+        end
+      end
+
+      def create_initial_version
+        agent_versions.create!(
+          version_number: 1,
+          change_summary: "Initial creation",
+          configuration_snapshot: configuration_snapshot
+        )
+      end
+
+      def configuration_changed?
+        saved_changes.keys.any? do |key|
+          %w[instructions preset_type appearance instruction_sets tools mcp_servers model_config response_format].include?(key)
+        end
+      end
+
+      def create_version_on_config_change
+        next_version = (latest_version&.version_number || 0) + 1
+        changed_fields = saved_changes.keys.select do |key|
+          %w[instructions preset_type appearance instruction_sets tools mcp_servers model_config response_format].include?(key)
+        end
+
+        agent_versions.create!(
+          version_number: next_version,
+          change_summary: "Updated: #{changed_fields.join(', ')}",
+          configuration_snapshot: configuration_snapshot
+        )
+      end
+
+      def model_config_code
+        return "" if model_config.blank?
+
+        configs = model_config.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+        ", #{configs}"
+      end
+
+      def instructions_code
+        return "" if instructions.blank?
+
+        "\n    prompt instructions: <<~INSTRUCTIONS\n      #{instructions.gsub("\n", "\n      ")}\n    INSTRUCTIONS"
+      end
+
+      def build_and_execute_agent(input_prompt, **params)
+        # TODO: Implement actual ActiveAgent execution
+        # This will create a dynamic agent class and execute it
+        {
+          output: "Mock response for: #{input_prompt}",
+          metadata: { provider: provider, model: model },
+          usage: { input_tokens: 10, output_tokens: 20, total_tokens: 30 }
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Dashboard
+    # Tracks individual agent execution runs.
+    #
+    # Each run captures input, output, timing, token usage, and any errors
+    # that occurred during execution.
+    #
+    # @example Creating a run
+    #   run = agent.execute("Analyze this code", code: code)
+    #   run.status # => "pending"
+    #
+    # @example Monitoring a run
+    #   run.in_progress? # => true
+    #   run.finished?    # => false
+    #
+    class AgentRun < ApplicationRecord
+      belongs_to :agent, class_name: "ActiveAgent::Dashboard::Agent"
+      has_one :session_recording, class_name: "ActiveAgent::Dashboard::SessionRecording", dependent: :nullify
+
+      # Status enum
+      enum :status, { pending: 0, running: 1, complete: 2, failed: 3, cancelled: 4 }
+
+      # Validations
+      validates :trace_id, presence: true
+
+      # Scopes
+      scope :recent, -> { order(created_at: :desc) }
+      scope :successful, -> { where(status: :complete) }
+      scope :failed_runs, -> { where(status: :failed) }
+      scope :today, -> { where("created_at >= ?", Time.current.beginning_of_day) }
+
+      # Callbacks
+      before_validation :set_trace_id, on: :create
+      after_update_commit :broadcast_update, if: :saved_change_to_status?
+
+      # Add a log entry
+      def add_log(message, level: :info)
+        new_logs = logs || []
+        new_logs << {
+          timestamp: Time.current.iso8601,
+          level: level.to_s,
+          message: message
+        }
+        update!(logs: new_logs)
+      end
+
+      # Calculate duration if not set
+      def calculated_duration_ms
+        return duration_ms if duration_ms.present?
+        return nil unless started_at && completed_at
+
+        ((completed_at - started_at) * 1000).to_i
+      end
+
+      # Check if run is still in progress
+      def in_progress?
+        pending? || running?
+      end
+
+      # Check if run is finished
+      def finished?
+        complete? || failed? || cancelled?
+      end
+
+      # Get a summary for display
+      def summary
+        {
+          id: id,
+          status: status,
+          input_preview: input_prompt&.truncate(100),
+          output_preview: output&.truncate(200),
+          duration_ms: calculated_duration_ms,
+          tokens: total_tokens,
+          created_at: created_at,
+          error: error_message
+        }
+      end
+
+      # Stream output updates via ActionCable
+      def broadcast_update
+        return unless defined?(ActionCable)
+
+        ActionCable.server.broadcast(
+          "agent_run_#{id}",
+          {
+            type: "update",
+            run: summary
+          }
+        )
+      end
+
+      # Cancel a running execution
+      def cancel!
+        return unless in_progress?
+
+        update!(
+          status: :cancelled,
+          completed_at: Time.current,
+          error_message: "Cancelled by user"
+        )
+        broadcast_update
+      end
+
+      private
+
+      def set_trace_id
+        self.trace_id ||= SecureRandom.uuid
+      end
+    end
+  end
+end