activeagent 1.1.0 → 1.3.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeagent
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Justin Bowen
@@ -109,6 +109,26 @@ dependencies:
     - - "<="
       - !ruby/object:Gem::Version
         version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: activeagents-telemetry
   requirement: !ruby/object:Gem::Requirement
@@ -390,6 +410,7 @@ files:
 - lib/active_agent/base.rb
 - lib/active_agent/collector.rb
 - lib/active_agent/concerns/callbacks.rb
+- lib/active_agent/concerns/delegation.rb
 - lib/active_agent/concerns/observers.rb
 - lib/active_agent/concerns/parameterized.rb
 - lib/active_agent/concerns/preview.rb
@@ -400,34 +421,14 @@ files:
 - lib/active_agent/concerns/tooling.rb
 - lib/active_agent/concerns/view.rb
 - lib/active_agent/configuration.rb
-- lib/active_agent/dashboard.rb
-- lib/active_agent/dashboard/app/controllers/active_agent/dashboard/api/traces_controller.rb
-- lib/active_agent/dashboard/app/controllers/active_agent/dashboard/application_controller.rb
-- lib/active_agent/dashboard/app/controllers/active_agent/dashboard/dashboard_controller.rb
-- lib/active_agent/dashboard/app/controllers/active_agent/dashboard/traces_controller.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/dashboard/agent_execution_job.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/dashboard/application_job.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/dashboard/sandbox_cleanup_job.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/dashboard/sandbox_provision_job.rb
-- lib/active_agent/dashboard/app/jobs/active_agent/process_telemetry_traces_job.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/agent.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/agent_run.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/agent_template.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/agent_version.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/application_record.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/recording_action.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/recording_snapshot.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/sandbox_run.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/sandbox_session.rb
-- lib/active_agent/dashboard/app/models/active_agent/dashboard/session_recording.rb
-- lib/active_agent/dashboard/app/models/active_agent/telemetry_trace.rb
-- lib/active_agent/dashboard/app/views/active_agent/dashboard/traces/_trace_detail.html.erb
-- lib/active_agent/dashboard/app/views/active_agent/dashboard/traces/index.html.erb
-- lib/active_agent/dashboard/app/views/active_agent/dashboard/traces/metrics.html.erb
-- lib/active_agent/dashboard/app/views/active_agent/dashboard/traces/show.html.erb
-- lib/active_agent/dashboard/app/views/layouts/active_agent/dashboard/application.html.erb
-- lib/active_agent/dashboard/config/routes.rb
-- lib/active_agent/dashboard/engine.rb
+- lib/active_agent/delegation/backend.rb
+- lib/active_agent/delegation/budget.rb
+- lib/active_agent/delegation/contract.rb
+- lib/active_agent/delegation/definition.rb
+- lib/active_agent/delegation/ledger.rb
+- lib/active_agent/delegation/pricing.rb
+- lib/active_agent/delegation/runner.rb
+- lib/active_agent/delegation/schema.rb
 - lib/active_agent/deprecator.rb
 - lib/active_agent/generation.rb
 - lib/active_agent/generation_job.rb
@@ -551,14 +552,12 @@ files:
 - lib/active_agent/telemetry/instrumentation.rb
 - lib/active_agent/telemetry/reporter.rb
 - lib/active_agent/telemetry/span.rb
+- lib/active_agent/telemetry/tool_origin.rb
 - lib/active_agent/telemetry/tracer.rb
 - lib/active_agent/version.rb
 - lib/activeagent.rb
 - lib/generators/active_agent/agent/USAGE
 - lib/generators/active_agent/agent/agent_generator.rb
-- lib/generators/active_agent/dashboard/install_generator.rb
-- lib/generators/active_agent/dashboard/templates/active_agent_dashboard.rb.erb
-- lib/generators/active_agent/dashboard/templates/create_active_agent_telemetry_traces.rb.erb
 - lib/generators/active_agent/install/USAGE
 - lib/generators/active_agent/install/install_generator.rb
 - lib/generators/active_agent/templates/active_agent.yml

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

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    module Api
-      # Telemetry ingestion endpoint.
-      #
-      # Receives traces from ActiveAgent::Telemetry::Reporter and stores them
-      # for analysis and visualization in the dashboard.
-      #
-      # Supports two modes:
-      # - Local mode: synchronous processing; unauthenticated unless
-      #   ActiveAgent::Dashboard.ingest_api_key is set (set it whenever the
-      #   mount is reachable beyond your own machine)
-      # - Multi-tenant mode: per-account Bearer token auth, async processing
-      #   via job
-      #
-      # @example Local mode request
-      #   POST <mount>/api/traces  (e.g. /activeagents/api/traces)
-      #   Content-Type: application/json
-      #
-      #   {
-      #     "traces": [...],
-      #     "sdk": { "name": "activeagent", "version": "0.5.0" }
-      #   }
-      #
-      # @example Multi-tenant mode request
-      #   POST <mount>/api/traces  (e.g. /activeagents/api/traces)
-      #   Authorization: Bearer <api_key>
-      #   Content-Type: application/json
-      #
-      #   {
-      #     "traces": [...],
-      #     "sdk": { "name": "activeagent", "version": "0.5.0" }
-      #   }
-      #
-      class TracesController < ActionController::API
-        before_action :authenticate_api_key!, if: -> { ActiveAgent::Dashboard.multi_tenant? }
-        before_action :authenticate_ingest_key!, unless: -> { ActiveAgent::Dashboard.multi_tenant? }
-
-        # Maximum traces accepted per request (mirrors
-        # ProcessTelemetryTracesJob::MAX_TRACES_PER_JOB).
-        MAX_TRACES_PER_REQUEST = 100
-
-        # POST <mount>/api/traces  (e.g. /activeagents/api/traces)
-        def create
-          traces = Array(params[:traces]).take(MAX_TRACES_PER_REQUEST)
-          sdk_info = params[:sdk] || {}
-
-          return head :accepted if traces.empty?
-
-          if ActiveAgent::Dashboard.multi_tenant?
-            # Multi-tenant mode: process in background
-            ActiveAgent::ProcessTelemetryTracesJob.perform_later(
-              account_id: @account&.id,
-              traces: traces.as_json,
-              sdk_info: sdk_info.as_json,
-              received_at: Time.current.iso8601(6)
-            )
-          else
-            # Local mode: process synchronously
-            process_traces_synchronously(traces, sdk_info)
-          end
-
-          head :accepted
-        rescue ActionController::ParameterMissing => e
-          render json: { error: e.message }, status: :bad_request
-        rescue StandardError => e
-          Rails.logger.error("[ActiveAgent::Dashboard] Trace ingestion error: #{e.message}")
-          render json: { error: "Internal server error" }, status: :internal_server_error
-        end
-
-        private
-
-        # Authenticates the request using Bearer token from Authorization header.
-        # Only used in multi-tenant mode.
-        def authenticate_api_key!
-          token = extract_bearer_token
-
-          if token.blank?
-            render json: { error: "Missing Authorization header" }, status: :unauthorized
-            return
-          end
-
-          account_class = ActiveAgent::Dashboard.account_class.constantize
-          @account = account_class.find_by(telemetry_api_key: token)
-
-          if @account.nil?
-            render json: { error: "Invalid API key" }, status: :unauthorized
-            return
-          end
-
-          # Track usage for rate limiting (if the account responds to it)
-          @account.increment_telemetry_usage! if @account.respond_to?(:increment_telemetry_usage!)
-        end
-
-        # Requires the configured single-tenant ingest key when one is set.
-        # The telemetry reporter and ruby_llm_telemetry both send their
-        # api_key as a Bearer header, so remote apps work unchanged.
-        def authenticate_ingest_key!
-          expected = ActiveAgent::Dashboard.ingest_api_key
-          return if expected.blank?
-
-          token = extract_bearer_token
-          return if token.present? && ActiveSupport::SecurityUtils.secure_compare(token, expected)
-
-          render json: { error: "Invalid API key" }, status: :unauthorized
-        end
-
-        # Extracts Bearer token from Authorization header.
-        def extract_bearer_token
-          auth_header = request.headers["Authorization"]
-          return nil if auth_header.blank?
-
-          match = auth_header.match(/^Bearer\s+(.+)$/i)
-          match[1] if match
-        end
-
-        # Process traces synchronously for local development.
-        def process_traces_synchronously(traces, sdk_info)
-          model = ActiveAgent::Dashboard.trace_model
-
-          traces.each do |trace|
-            # Skip if trace already exists (idempotency)
-            next if model.exists?(trace_id: trace["trace_id"])
-
-            model.create_from_payload(trace, sdk_info)
-          rescue StandardError => e
-            Rails.logger.error(
-              "[ActiveAgent::Dashboard] Failed to process trace #{trace['trace_id']}: " \
-              "#{e.class} - #{e.message}"
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Base controller for the ActiveAgent Dashboard.
-    #
-    # Handles authentication and provides helper methods for multi-tenant mode.
-    class ApplicationController < ActionController::Base
-      protect_from_forgery with: :exception
-
-      before_action :authenticate_dashboard!
-
-      # Add the engine's view path
-      prepend_view_path ActiveAgent::Dashboard::Engine.dashboard_root.join("app", "views").to_s
-
-      # Use custom layout if configured, otherwise use engine layout
-      layout -> { ActiveAgent::Dashboard.layout || "active_agent/dashboard/application" }
-
-      helper_method :current_user, :current_owner
-
-      private
-
-      def authenticate_dashboard!
-        if ActiveAgent::Dashboard.authentication_method.nil?
-          # Traces contain prompts, outputs, and error backtraces. Refuse to
-          # serve them unauthenticated in production rather than exposing
-          # them to the internet by default.
-          if Rails.env.production?
-            render plain: "ActiveAgent Dashboard: set ActiveAgent::Dashboard.authentication_method " \
-              "(see docs/framework/dashboard.md) to enable access in production.",
-              status: :forbidden
-          end
-          return
-        end
-
-        result = ActiveAgent::Dashboard.authentication_method.call(self)
-        head :unauthorized unless result
-      rescue StandardError => e
-        Rails.logger.error("[ActiveAgent::Dashboard] Authentication error: #{e.message}")
-        head :unauthorized
-      end
-
-      # Returns the current user from the host application.
-      def current_user
-        return nil unless ActiveAgent::Dashboard.current_user_method
-
-        send(ActiveAgent::Dashboard.current_user_method)
-      rescue NoMethodError
-        nil
-      end
-
-      # Returns the current owner (account in multi-tenant, user otherwise).
-      def current_owner
-        if ActiveAgent::Dashboard.multi_tenant? && ActiveAgent::Dashboard.current_account_method
-          send(ActiveAgent::Dashboard.current_account_method)
-        else
-          current_user
-        end
-      rescue NoMethodError
-        nil
-      end
-    end
-  end
-end

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

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Main dashboard controller showing overview metrics and recent activity.
-    #
-    class DashboardController < ApplicationController
-      def index
-        unless ActiveAgent::Dashboard.use_inertia && defined?(InertiaRails)
-          # No ERB overview ships yet — the traces list is the dashboard.
-          # Loading agent/run data here would also require the full
-          # dashboard tables, which telemetry-only installs don't have.
-          return redirect_to(traces_path)
-        end
-
-        @agents = fetch_agents.limit(10)
-        @recent_runs = fetch_recent_runs.limit(10)
-        @recent_traces = fetch_recent_traces.limit(10)
-        @metrics = calculate_metrics
-
-        render inertia: "Dashboard", props: {
-          agents: serialize_agents(@agents),
-          recentRuns: serialize_runs(@recent_runs),
-          recentTraces: serialize_traces(@recent_traces),
-          metrics: @metrics,
-          user: current_user_props,
-          account: current_account_props
-        }
-      end
-
-      private
-
-      def fetch_agents
-        agents = Agent.order(updated_at: :desc)
-        agents = agents.for_owner(current_owner) if current_owner
-        agents
-      end
-
-      def fetch_recent_runs
-        runs = AgentRun.includes(:agent).recent
-        if current_owner && ActiveAgent::Dashboard.multi_tenant?
-          runs = runs.joins(:agent).where(agents: { account_id: current_owner.id })
-        end
-        runs
-      end
-
-      def fetch_recent_traces
-        traces = ActiveAgent::Dashboard.trace_model.recent
-        traces = traces.for_account(current_owner) if current_owner && ActiveAgent::Dashboard.multi_tenant?
-        traces
-      end
-
-      def calculate_metrics
-        traces_24h = ActiveAgent::Dashboard.trace_model.where("created_at > ?", 24.hours.ago)
-        runs_24h = AgentRun.where("created_at > ?", 24.hours.ago)
-
-        if current_owner && ActiveAgent::Dashboard.multi_tenant?
-          traces_24h = traces_24h.for_account(current_owner)
-          runs_24h = runs_24h.joins(:agent).where(agents: { account_id: current_owner.id })
-        end
-
-        {
-          total_agents: fetch_agents.count,
-          active_agents: fetch_agents.active_agents.count,
-          total_runs_24h: runs_24h.count,
-          successful_runs_24h: runs_24h.successful.count,
-          failed_runs_24h: runs_24h.failed_runs.count,
-          total_traces_24h: traces_24h.count,
-          total_tokens_24h: traces_24h.sum(:total_input_tokens).to_i + traces_24h.sum(:total_output_tokens).to_i,
-          avg_duration_ms: runs_24h.where.not(duration_ms: nil).average(:duration_ms)&.round || 0
-        }
-      end
-
-      def serialize_agents(agents)
-        agents.map do |agent|
-          {
-            id: agent.id,
-            name: agent.name,
-            slug: agent.slug,
-            description: agent.description,
-            provider: agent.provider,
-            model: agent.model,
-            status: agent.status,
-            presetType: agent.preset_type,
-            versionCount: agent.version_count,
-            updatedAt: agent.updated_at.iso8601
-          }
-        end
-      end
-
-      def serialize_runs(runs)
-        runs.map(&:summary)
-      end
-
-      def serialize_traces(traces)
-        traces.map do |trace|
-          {
-            id: trace.id,
-            traceId: trace.trace_id,
-            displayName: trace.display_name,
-            status: trace.status,
-            duration: trace.formatted_duration,
-            tokens: trace.formatted_tokens,
-            timestamp: trace.timestamp&.iso8601
-          }
-        end
-      end
-
-      def current_user_props
-        return nil unless current_user
-
-        {
-          id: current_user.id,
-          name: current_user.try(:display_name) || current_user.try(:name) || current_user.try(:email),
-          email: current_user.try(:email)
-        }
-      end
-
-      def current_account_props
-        return nil unless current_owner && ActiveAgent::Dashboard.multi_tenant?
-
-        {
-          id: current_owner.id,
-          name: current_owner.try(:name)
-        }
-      end
-    end
-  end
-end

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

@@ -1,123 +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
-          # turbo-rails is optional; responding to an unregistered MIME
-          # type raises in host apps without it.
-          format.turbo_stream if turbo_stream_available?
-        end
-      end
-
-      def show
-        @trace = scoped_traces.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 if turbo_stream_available?
-        end
-      end
-
-      private
-
-      def turbo_stream_available?
-        Mime::Type.lookup_by_extension(:turbo_stream).present?
-      end
-
-      # All queries honor the configured trace model and, in multi-tenant
-      # mode, the current owner's account (for_account no-ops otherwise).
-      #
-      # In multi-tenant mode an unresolvable owner returns nothing rather
-      # than falling through: current_owner degrades to current_user when
-      # current_account_method is unset, which would scope by a user id
-      # against account_id — another tenant's traces.
-      def scoped_traces
-        model = ActiveAgent::Dashboard.trace_model
-        return model.none if ActiveAgent::Dashboard.multi_tenant? && current_owner.nil?
-
-        model.for_account(current_owner)
-      end
-
-      def fetch_traces
-        traces = scoped_traces.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 = scoped_traces.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
-        scoped_traces
-          .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
-        scoped_traces
-          .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