activeagent 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ee3a092c5c836febf3c2e3045a1c1b2cd448edc18f3e76e4ee1ebc181f895b8
-  data.tar.gz: 9850ab912eedaac0a57f9a954648d096d6aa70ad470ff9aa7c84a18183ab76be
+  metadata.gz: 2a1deba19c874b6abb36731bcee93bddf79bc193a3443a234cc811d9a4cc8383
+  data.tar.gz: 6f8847ab0d5eebf0ce26a8425f7630c884f0b9af71384c67325e3c06a8b0a8ae
 SHA512:
-  metadata.gz: 199061594f115a823037504f84daf5ebc79b084c8a835b3e67f5427a19ffe33bbe208bb627dc26b1abf977c4d35a2977defcfb59e9128e60d94c6a3dc0ce5259
-  data.tar.gz: 661bf403014e2a0d1156614249b9fcdc352b8124e63457071ce75399ac69d089cf2d43d8b571e41614d811a5e6dc4ebc9072dfe38d912bc122672bf9823bb331
+  metadata.gz: 767f039bd0af4f600a34becaac7bb2d04d2f8b768aef11242191f8a355b4a442c9c10690fe25a1a7f8e0da8b27e7216025c6f882c6d6002e5da9d0a9e876f1cb
+  data.tar.gz: 30725fb2369bd3b8dc23aa9d41e7d8a9843c3c8dd0aa629ace4bbd4cc217077339684ae0925cc6ea330c1e018b444a66057bcf5854b5bebf2bcb6a14bf57a322

data/README.md

@@ -1,6 +1,6 @@
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://github.com/user-attachments/assets/2bad263a-c09f-40b6-94ba-fff8e346d65d">
-  <img alt="activeagents_banner" src="https://github.com/user-attachments/assets/0ebbaa2f-c6bf-4d40-bb77-931015a14be3">
+  <source media="(prefers-color-scheme: dark)" srcset="docs/public/banner-dark.svg">
+  <img alt="Active Agent - Build AI in Rails" src="docs/public/banner-light.svg">
 </picture>
 
 
@@ -39,6 +39,9 @@ bundle add openai
 
 # OpenRouter (uses OpenAI-compatible API)
 bundle add openai
+
+# RubyLLM (unified API for 15+ providers)
+bundle add ruby_llm
 ```
 
 ### Setup
@@ -119,12 +122,15 @@ development:
   ollama:
     service: "Ollama"
     model: "llama3.2"
+
+  ruby_llm:
+    service: "RubyLLM"
 ```
 
 ## Features
 
 - **Agent-Oriented Programming**: Build AI applications using familiar Rails patterns
-- **Multiple Provider Support**: Works with OpenAI, Anthropic, Ollama, and more
+- **Multiple Provider Support**: Works with OpenAI, Anthropic, Ollama, RubyLLM, and more
 - **Action-Based Design**: Define agent capabilities through actions
 - **View Templates**: Use ERB templates for prompts (text, JSON, HTML)
 - **Streaming Support**: Real-time response streaming with ActionCable
@@ -166,7 +172,7 @@ response = prompt.generate_now
 ## Learn More
 
 - [Documentation](https://docs.activeagents.ai)
-- [Getting Started Guide](https://docs.activeagents.ai/docs/getting-started)
+- [Getting Started Guide](https://docs.activeagents.ai/getting_started)
 - [API Reference](https://docs.activeagents.ai/docs/framework)
 - [Examples](https://docs.activeagents.ai/docs/agents)
 

data/lib/active_agent/base.rb

@@ -106,9 +106,10 @@ module ActiveAgent
       global_options    = provider_config_load(provider_reference)
       inherited_options = (self.prompt_options || {}).except(:instructions) # Don't inherit instructions from parent
 
-      # Different Service, different APIs
+      # Different Service, different APIs — discard all inherited options
+      # to prevent parent provider config (host, api_key, etc.) leaking through
       if global_options[:service] != inherited_options[:service]
-        inherited_options.extract!(:service, :api_version)
+        inherited_options = {}
       end
 
       self.prompt_options = global_options.merge(inherited_options).merge(agent_options)

data/lib/active_agent/concerns/provider.rb

@@ -9,8 +9,12 @@ module ActiveAgent
 
     # "Your tacky and I hate you" - Billy, https://youtu.be/dsheboxJNgQ?si=tzDlJ7sdSxM4RjSD
     PROVIDER_SERVICE_NAMES_REMAPS = {
-      "Openrouter" => "OpenRouter",
-      "Openai"     => "OpenAI"
+      "Openrouter"  => "OpenRouter",
+      "Openai"      => "OpenAI",
+      "AzureOpenai" => "AzureOpenAI",
+      "Azureopenai" => "AzureOpenAI",
+      "Rubyllm"     => "RubyLLM",
+      "RubyLlm"     => "RubyLLM"
     }
 
     included do

data/lib/active_agent/concerns/rescue.rb

@@ -13,6 +13,45 @@ module ActiveAgent
     include ActiveSupport::Rescuable
 
     class_methods do
+      # Handles exceptions raised during GenerationJob execution.
+      #
+      # Called by GenerationJob#handle_exception_with_agent_class as a
+      # class-level fallback when no instance is available to handle the error.
+      # Logs the exception and re-raises to preserve job failure semantics.
+      #
+      # @param exception [Exception] the exception to handle
+      # @raise [Exception] re-raises the exception after logging
+      # @return [void]
+      def handle_exception(exception)
+        rescue_logger.error "[#{name}] #{exception.class}: #{exception.message}"
+        rescue_logger.error exception.backtrace&.first(10)&.join("\n") if exception.backtrace
+        raise exception
+      end
+
+      private
+
+      # Returns the logger to use for class-level exception handling.
+      #
+      # Prefers the including class's logger, then ActiveAgent::Base.logger,
+      # then Rails.logger if available, and finally falls back to a standard
+      # Ruby Logger to $stderr.
+      #
+      # @return [#error] a logger-like object responding to `#error`
+      def rescue_logger
+        if respond_to?(:logger) && (current_logger = logger)
+          current_logger
+        elsif defined?(ActiveAgent::Base) &&
+              ActiveAgent::Base.respond_to?(:logger) &&
+              (base_logger = ActiveAgent::Base.logger)
+          base_logger
+        elsif defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger
+        else
+          require "logger"
+          @_rescue_logger ||= Logger.new($stderr)
+        end
+      end
+
       # Finds and instruments the rescue handler for an exception.
       #
       # @param exception [Exception] the exception to handle

data/lib/active_agent/concerns/streaming.rb

@@ -268,7 +268,8 @@ module ActiveAgent
     # @return [Proc] callback proc that accepts (message, delta, type)
     def stream_broadcaster
       proc do |message, delta, type|
-        self.stream_chunk = StreamChunk.new(message, delta)
+        cast_message = message.is_a?(Hash) ? Providers::Common::Messages::Types::MessageType.new.cast(message) : message
+        self.stream_chunk = StreamChunk.new(cast_message, delta)
 
         run_callbacks(:stream_open) if type == :open
         run_callbacks(:stream)

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

@@ -0,0 +1,117 @@
+# 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: No authentication, synchronous processing
+      # - Multi-tenant mode: Bearer token auth, async processing via job
+      #
+      # @example Local mode request
+      #   POST /active_agent/api/traces
+      #   Content-Type: application/json
+      #
+      #   {
+      #     "traces": [...],
+      #     "sdk": { "name": "activeagent", "version": "0.5.0" }
+      #   }
+      #
+      # @example Multi-tenant mode request
+      #   POST /active_agent/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? }
+
+        # POST /active_agent/api/traces
+        def create
+          traces = params[:traces] || []
+          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
+
+        # 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

@@ -0,0 +1,54 @@
+# 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!
+        return if ActiveAgent::Dashboard.authentication_method.nil?
+
+        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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Dashboard
+    # Main dashboard controller showing overview metrics and recent activity.
+    #
+    class DashboardController < ApplicationController
+      def index
+        @agents = fetch_agents.limit(10)
+        @recent_runs = fetch_recent_runs.limit(10)
+        @recent_traces = fetch_recent_traces.limit(10)
+        @metrics = calculate_metrics
+
+        if ActiveAgent::Dashboard.use_inertia && defined?(InertiaRails)
+          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
+          }
+        else
+          render :index
+        end
+      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

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

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

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

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