activeagent 1.0.3 → 1.2.0

data/lib/active_agent/dashboard/app/controllers/active_agent/dashboard/traces_controller.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Controller for viewing telemetry traces.
-    #
-    # Provides:
-    # - List view with filtering and pagination
-    # - Detail view with span timeline
-    # - Metrics overview
-    # - Live updates via Turbo Streams
-    class TracesController < ApplicationController
-      def index
-        @traces = fetch_traces
-        @metrics = calculate_metrics
-
-        respond_to do |format|
-          format.html
-          format.turbo_stream
-        end
-      end
-
-      def show
-        @trace = ActiveAgent::TelemetryTrace.find(params[:id])
-      end
-
-      def metrics
-        @metrics = calculate_metrics
-        @agent_stats = agent_statistics
-        @time_series = time_series_data
-
-        respond_to do |format|
-          format.html
-          format.turbo_stream
-        end
-      end
-
-      private
-
-      def fetch_traces
-        traces = ActiveAgent::TelemetryTrace.recent
-
-        traces = traces.for_agent(params[:agent]) if params[:agent].present?
-        traces = traces.with_errors if params[:status] == "error"
-        traces = traces.for_service(params[:service]) if params[:service].present?
-
-        if params[:start_date].present? && params[:end_date].present?
-          traces = traces.for_date_range(
-            Time.parse(params[:start_date]),
-            Time.parse(params[:end_date])
-          )
-        end
-
-        traces.limit(params[:limit] || 50)
-      end
-
-      def calculate_metrics
-        traces = ActiveAgent::TelemetryTrace.where(
-          "created_at > ?", 24.hours.ago
-        )
-
-        {
-          total_traces: traces.count,
-          total_tokens: traces.sum(:total_input_tokens) + traces.sum(:total_output_tokens),
-          avg_duration_ms: traces.average(:total_duration_ms)&.round(2) || 0,
-          error_rate: calculate_error_rate(traces),
-          unique_agents: traces.distinct.count(:agent_class)
-        }
-      end
-
-      def calculate_error_rate(traces)
-        total = traces.count
-        return 0.0 if total.zero?
-
-        errors = traces.with_errors.count
-        ((errors.to_f / total) * 100).round(2)
-      end
-
-      def agent_statistics
-        ActiveAgent::TelemetryTrace
-          .where("created_at > ?", 24.hours.ago)
-          .group(:agent_class)
-          .select(
-            "agent_class",
-            "COUNT(*) as trace_count",
-            "SUM(total_input_tokens + total_output_tokens) as total_tokens",
-            "AVG(total_duration_ms) as avg_duration",
-            "SUM(CASE WHEN status = 'ERROR' THEN 1 ELSE 0 END) as error_count"
-          )
-      end
-
-      def time_series_data
-        ActiveAgent::TelemetryTrace
-          .where("created_at > ?", 1.hour.ago)
-          .group_by_minute(:created_at)
-          .count
-      rescue NoMethodError
-        # Fallback if groupdate gem not available
-        {}
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Background job for executing agent runs.
-    #
-    # Handles the actual execution of an agent with the given input,
-    # updating the AgentRun record with results.
-    #
-    class AgentExecutionJob < ApplicationJob
-      queue_as :default
-
-      def perform(agent_run_id)
-        run = AgentRun.find(agent_run_id)
-        return if run.finished?
-
-        run.update!(status: :running, started_at: Time.current)
-
-        begin
-          agent = run.agent
-          result = execute_agent(agent, run.input_prompt, **(run.input_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
-      end
-
-      private
-
-      def execute_agent(agent, input_prompt, **params)
-        # TODO: Build and execute actual ActiveAgent::Base subclass
-        # For now, return mock data
-        {
-          output: "Executed: #{input_prompt}",
-          metadata: { provider: agent.provider, model: agent.model },
-          usage: { input_tokens: 100, output_tokens: 200, total_tokens: 300 }
-        }
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Base class for all Dashboard engine jobs.
-    class ApplicationJob < ActiveJob::Base
-      # Retry failed jobs
-      retry_on StandardError, wait: :polynomially_longer, attempts: 3
-
-      # Discard jobs for records that no longer exist
-      discard_on ActiveRecord::RecordNotFound
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Background job for cleaning up sandbox environments.
-    #
-    # Removes containers, Cloud Run jobs, or other resources
-    # when a sandbox session expires.
-    #
-    class SandboxCleanupJob < ApplicationJob
-      queue_as :default
-
-      def perform(sandbox_session_id)
-        session = SandboxSession.find_by(id: sandbox_session_id)
-        return unless session
-
-        cleanup_sandbox(session)
-      end
-
-      private
-
-      def cleanup_sandbox(session)
-        case ActiveAgent::Dashboard.sandbox_service
-        when :cloud_run
-          cleanup_cloud_run(session)
-        when :kubernetes
-          cleanup_kubernetes(session)
-        else
-          cleanup_local(session)
-        end
-      end
-
-      def cleanup_local(session)
-        # Local mode: Nothing to clean up
-        Rails.logger.info "[ActiveAgent::Dashboard] Cleaned up local sandbox: #{session.session_id}"
-      end
-
-      def cleanup_cloud_run(session)
-        # TODO: Implement Cloud Run cleanup
-        Rails.logger.info "[ActiveAgent::Dashboard] Would clean up Cloud Run job: #{session.cloud_run_job_id}"
-      end
-
-      def cleanup_kubernetes(session)
-        # TODO: Implement Kubernetes cleanup
-        Rails.logger.info "[ActiveAgent::Dashboard] Would clean up Kubernetes pod: #{session.cloud_run_job_id}"
-      end
-    end
-  end
-end

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

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

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

@@ -1,256 +0,0 @@
-# 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 requesty].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