ruby_llm-agents 0.4.0 → 1.0.0.beta.1

data/app/models/ruby_llm/agents/api_configuration.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Agents
+    # Database-backed API configuration for LLM providers
+    #
+    # Stores API keys (encrypted at rest) and configuration options that can be
+    # managed via the dashboard UI. Supports both global settings and per-tenant
+    # overrides.
+    #
+    # Resolution priority: per-tenant DB > global DB > config file (RubyLLM.configure)
+    #
+    # @!attribute [rw] scope_type
+    #   @return [String] Either 'global' or 'tenant'
+    # @!attribute [rw] scope_id
+    #   @return [String, nil] Tenant ID when scope_type='tenant'
+    #
+    # @example Setting global API keys
+    #   config = ApiConfiguration.global
+    #   config.update!(
+    #     openai_api_key: "sk-...",
+    #     anthropic_api_key: "sk-ant-..."
+    #   )
+    #
+    # @example Setting tenant-specific configuration
+    #   tenant_config = ApiConfiguration.for_tenant!("acme_corp")
+    #   tenant_config.update!(
+    #     anthropic_api_key: "sk-ant-tenant-specific...",
+    #     default_model: "claude-sonnet-4-20250514"
+    #   )
+    #
+    # @example Resolving configuration for a tenant
+    #   resolved = ApiConfiguration.resolve(tenant_id: "acme_corp")
+    #   resolved.apply_to_ruby_llm!  # Apply to RubyLLM.configuration
+    #
+    # @see ResolvedConfig
+    # @api public
+    class ApiConfiguration < ::ActiveRecord::Base
+      self.table_name = "ruby_llm_agents_api_configurations"
+
+      # Valid scope types
+      SCOPE_TYPES = %w[global tenant].freeze
+
+      # All API key attributes that should be encrypted
+      API_KEY_ATTRIBUTES = %i[
+        openai_api_key
+        anthropic_api_key
+        gemini_api_key
+        deepseek_api_key
+        mistral_api_key
+        perplexity_api_key
+        openrouter_api_key
+        gpustack_api_key
+        xai_api_key
+        ollama_api_key
+        bedrock_api_key
+        bedrock_secret_key
+        bedrock_session_token
+        vertexai_credentials
+      ].freeze
+
+      # All endpoint attributes
+      ENDPOINT_ATTRIBUTES = %i[
+        openai_api_base
+        gemini_api_base
+        ollama_api_base
+        gpustack_api_base
+        xai_api_base
+      ].freeze
+
+      # All default model attributes
+      MODEL_ATTRIBUTES = %i[
+        default_model
+        default_embedding_model
+        default_image_model
+        default_moderation_model
+      ].freeze
+
+      # Connection settings attributes
+      CONNECTION_ATTRIBUTES = %i[
+        request_timeout
+        max_retries
+        retry_interval
+        retry_backoff_factor
+        retry_interval_randomness
+        http_proxy
+      ].freeze
+
+      # All configurable attributes (excluding API keys)
+      NON_KEY_ATTRIBUTES = (
+        ENDPOINT_ATTRIBUTES +
+        MODEL_ATTRIBUTES +
+        CONNECTION_ATTRIBUTES +
+        %i[
+          openai_organization_id
+          openai_project_id
+          bedrock_region
+          vertexai_project_id
+          vertexai_location
+        ]
+      ).freeze
+
+      # Encrypt all API keys using Rails encrypted attributes
+      # Requires Rails encryption to be configured (rails credentials:edit)
+      API_KEY_ATTRIBUTES.each do |key_attr|
+        encrypts key_attr, deterministic: false
+      end
+
+      # Validations
+      validates :scope_type, presence: true, inclusion: { in: SCOPE_TYPES }
+      validates :scope_id, uniqueness: { scope: :scope_type }, allow_nil: true
+      validate :validate_scope_consistency
+
+      # Scopes
+      scope :global_config, -> { where(scope_type: "global", scope_id: nil) }
+      scope :for_scope, ->(type, id) { where(scope_type: type, scope_id: id) }
+      scope :tenant_configs, -> { where(scope_type: "tenant") }
+
+      # Provider configuration mappings for display
+      PROVIDERS = {
+        openai: {
+          name: "OpenAI",
+          key_attr: :openai_api_key,
+          base_attr: :openai_api_base,
+          extra_attrs: [:openai_organization_id, :openai_project_id],
+          capabilities: ["Chat", "Embeddings", "Images", "Moderation"]
+        },
+        anthropic: {
+          name: "Anthropic",
+          key_attr: :anthropic_api_key,
+          capabilities: ["Chat"]
+        },
+        gemini: {
+          name: "Google Gemini",
+          key_attr: :gemini_api_key,
+          base_attr: :gemini_api_base,
+          capabilities: ["Chat", "Embeddings", "Images"]
+        },
+        deepseek: {
+          name: "DeepSeek",
+          key_attr: :deepseek_api_key,
+          capabilities: ["Chat"]
+        },
+        mistral: {
+          name: "Mistral",
+          key_attr: :mistral_api_key,
+          capabilities: ["Chat", "Embeddings"]
+        },
+        perplexity: {
+          name: "Perplexity",
+          key_attr: :perplexity_api_key,
+          capabilities: ["Chat"]
+        },
+        openrouter: {
+          name: "OpenRouter",
+          key_attr: :openrouter_api_key,
+          capabilities: ["Chat"]
+        },
+        gpustack: {
+          name: "GPUStack",
+          key_attr: :gpustack_api_key,
+          base_attr: :gpustack_api_base,
+          capabilities: ["Chat"]
+        },
+        xai: {
+          name: "xAI",
+          key_attr: :xai_api_key,
+          base_attr: :xai_api_base,
+          capabilities: ["Chat"]
+        },
+        ollama: {
+          name: "Ollama",
+          key_attr: :ollama_api_key,
+          base_attr: :ollama_api_base,
+          capabilities: ["Chat", "Embeddings"]
+        },
+        bedrock: {
+          name: "AWS Bedrock",
+          key_attr: :bedrock_api_key,
+          extra_attrs: [:bedrock_secret_key, :bedrock_session_token, :bedrock_region],
+          capabilities: ["Chat", "Embeddings"]
+        },
+        vertexai: {
+          name: "Google Vertex AI",
+          key_attr: :vertexai_credentials,
+          extra_attrs: [:vertexai_project_id, :vertexai_location],
+          capabilities: ["Chat", "Embeddings"]
+        }
+      }.freeze
+
+      class << self
+        # Finds or creates the global configuration
+        #
+        # @return [ApiConfiguration] The global configuration record
+        def global
+          global_config.first_or_create!
+        end
+
+        # Finds a tenant-specific configuration
+        #
+        # @param tenant_id [String] The tenant identifier
+        # @return [ApiConfiguration, nil] The tenant configuration or nil
+        def for_tenant(tenant_id)
+          return nil if tenant_id.blank?
+
+          for_scope("tenant", tenant_id).first
+        end
+
+        # Finds or creates a tenant-specific configuration
+        #
+        # @param tenant_id [String] The tenant identifier
+        # @return [ApiConfiguration] The tenant configuration record
+        def for_tenant!(tenant_id)
+          raise ArgumentError, "tenant_id cannot be blank" if tenant_id.blank?
+
+          for_scope("tenant", tenant_id).first_or_create!(
+            scope_type: "tenant",
+            scope_id: tenant_id
+          )
+        end
+
+        # Resolves the effective configuration for a given tenant
+        #
+        # Creates a ResolvedConfig that combines tenant config > global DB > RubyLLM config
+        #
+        # @param tenant_id [String, nil] Optional tenant identifier
+        # @return [ResolvedConfig] The resolved configuration
+        def resolve(tenant_id: nil)
+          tenant_config = tenant_id.present? ? for_tenant(tenant_id) : nil
+          global = global_config.first
+
+          RubyLLM::Agents::ResolvedConfig.new(
+            tenant_config: tenant_config,
+            global_config: global,
+            ruby_llm_config: ruby_llm_current_config
+          )
+        end
+
+        # Attempts to get the current RubyLLM configuration object
+        # Gets the current RubyLLM configuration object
+        #
+        # @return [Object, nil] The RubyLLM config object or nil
+        def ruby_llm_current_config
+          return nil unless defined?(::RubyLLM)
+          return nil unless RubyLLM.respond_to?(:config)
+
+          RubyLLM.config
+        rescue StandardError
+          nil
+        end
+
+        # Checks if the table exists (for graceful degradation)
+        #
+        # @return [Boolean]
+        def table_exists?
+          connection.table_exists?(table_name)
+        rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+          false
+        end
+      end
+
+      # Checks if a specific attribute has a value set
+      #
+      # @param attr_name [Symbol, String] The attribute name
+      # @return [Boolean]
+      def has_value?(attr_name)
+        value = send(attr_name)
+        value.present?
+      rescue NoMethodError
+        false
+      end
+
+      # Returns a masked version of an API key for display
+      #
+      # @param attr_name [Symbol, String] The API key attribute name
+      # @return [String, nil] Masked key like "sk-ab****wxyz" or nil
+      def masked_key(attr_name)
+        value = send(attr_name)
+        return nil if value.blank?
+
+        mask_string(value)
+      end
+
+      # Returns the source of this configuration
+      #
+      # @return [String] "global" or "tenant:ID"
+      def source_label
+        scope_type == "global" ? "Global" : "Tenant: #{scope_id}"
+      end
+
+      # Converts this configuration to a hash suitable for RubyLLM
+      #
+      # @return [Hash] Configuration hash with non-nil values
+      def to_ruby_llm_config
+        {}.tap do |config|
+          # API keys
+          config[:openai_api_key] = openai_api_key if openai_api_key.present?
+          config[:anthropic_api_key] = anthropic_api_key if anthropic_api_key.present?
+          config[:gemini_api_key] = gemini_api_key if gemini_api_key.present?
+          config[:deepseek_api_key] = deepseek_api_key if deepseek_api_key.present?
+          config[:mistral_api_key] = mistral_api_key if mistral_api_key.present?
+          config[:perplexity_api_key] = perplexity_api_key if perplexity_api_key.present?
+          config[:openrouter_api_key] = openrouter_api_key if openrouter_api_key.present?
+          config[:gpustack_api_key] = gpustack_api_key if gpustack_api_key.present?
+          config[:xai_api_key] = xai_api_key if xai_api_key.present?
+          config[:ollama_api_key] = ollama_api_key if ollama_api_key.present?
+
+          # Bedrock
+          config[:bedrock_api_key] = bedrock_api_key if bedrock_api_key.present?
+          config[:bedrock_secret_key] = bedrock_secret_key if bedrock_secret_key.present?
+          config[:bedrock_session_token] = bedrock_session_token if bedrock_session_token.present?
+          config[:bedrock_region] = bedrock_region if bedrock_region.present?
+
+          # Vertex AI
+          config[:vertexai_credentials] = vertexai_credentials if vertexai_credentials.present?
+          config[:vertexai_project_id] = vertexai_project_id if vertexai_project_id.present?
+          config[:vertexai_location] = vertexai_location if vertexai_location.present?
+
+          # Endpoints
+          config[:openai_api_base] = openai_api_base if openai_api_base.present?
+          config[:gemini_api_base] = gemini_api_base if gemini_api_base.present?
+          config[:ollama_api_base] = ollama_api_base if ollama_api_base.present?
+          config[:gpustack_api_base] = gpustack_api_base if gpustack_api_base.present?
+          config[:xai_api_base] = xai_api_base if xai_api_base.present?
+
+          # OpenAI options
+          config[:openai_organization_id] = openai_organization_id if openai_organization_id.present?
+          config[:openai_project_id] = openai_project_id if openai_project_id.present?
+
+          # Default models
+          config[:default_model] = default_model if default_model.present?
+          config[:default_embedding_model] = default_embedding_model if default_embedding_model.present?
+          config[:default_image_model] = default_image_model if default_image_model.present?
+          config[:default_moderation_model] = default_moderation_model if default_moderation_model.present?
+
+          # Connection settings
+          config[:request_timeout] = request_timeout if request_timeout.present?
+          config[:max_retries] = max_retries if max_retries.present?
+          config[:retry_interval] = retry_interval if retry_interval.present?
+          config[:retry_backoff_factor] = retry_backoff_factor if retry_backoff_factor.present?
+          config[:retry_interval_randomness] = retry_interval_randomness if retry_interval_randomness.present?
+          config[:http_proxy] = http_proxy if http_proxy.present?
+        end
+      end
+
+      # Returns provider status information for display
+      #
+      # @return [Array<Hash>] Array of provider status hashes
+      def provider_statuses
+        PROVIDERS.map do |key, info|
+          key_value = send(info[:key_attr])
+          {
+            key: key,
+            name: info[:name],
+            configured: key_value.present?,
+            masked_key: key_value.present? ? mask_string(key_value) : nil,
+            capabilities: info[:capabilities],
+            has_base_url: info[:base_attr].present? && send(info[:base_attr]).present?
+          }
+        end
+      end
+
+      private
+
+      # Validates scope consistency
+      def validate_scope_consistency
+        if scope_type == "global" && scope_id.present?
+          errors.add(:scope_id, "must be nil for global scope")
+        elsif scope_type == "tenant" && scope_id.blank?
+          errors.add(:scope_id, "must be present for tenant scope")
+        end
+      end
+
+      # Masks a string for display (shows first 2 and last 4 chars)
+      #
+      # @param value [String] The string to mask
+      # @return [String] Masked string
+      def mask_string(value)
+        return nil if value.blank?
+        return "****" if value.length <= 8
+
+        "#{value[0..1]}****#{value[-4..]}"
+      end
+    end
+  end
+end

data/app/models/ruby_llm/agents/execution.rb

@@ -72,6 +72,9 @@ module RubyLLM
       has_many :child_executions, class_name: "RubyLLM::Agents::Execution",
                foreign_key: :parent_execution_id, dependent: :nullify, inverse_of: :parent_execution
 
+      # Polymorphic association to tenant model (for llm_tenant DSL)
+      belongs_to :tenant_record, polymorphic: true, optional: true
+
       # Validations
       validates :agent_type, :model_id, :started_at, presence: true
       validates :status, inclusion: { in: statuses.keys }

data/app/models/ruby_llm/agents/tenant_budget.rb

@@ -6,36 +6,56 @@ module RubyLLM
     #
     # Stores per-tenant budget limits that override the global configuration.
     # Supports runtime updates without application restarts.
+    # Supports cost-based (USD), token-based, and execution-based limits.
     #
     # @!attribute [rw] tenant_id
     #   @return [String] Unique identifier for the tenant
+    # @!attribute [rw] name
+    #   @return [String, nil] Human-readable name for the tenant
     # @!attribute [rw] daily_limit
     #   @return [BigDecimal, nil] Daily budget limit in USD
     # @!attribute [rw] monthly_limit
     #   @return [BigDecimal, nil] Monthly budget limit in USD
+    # @!attribute [rw] daily_token_limit
+    #   @return [Integer, nil] Daily token limit (across all models)
+    # @!attribute [rw] monthly_token_limit
+    #   @return [Integer, nil] Monthly token limit (across all models)
+    # @!attribute [rw] daily_execution_limit
+    #   @return [Integer, nil] Daily execution/call limit
+    # @!attribute [rw] monthly_execution_limit
+    #   @return [Integer, nil] Monthly execution/call limit
     # @!attribute [rw] per_agent_daily
-    #   @return [Hash] Per-agent daily limits: { "AgentName" => limit }
+    #   @return [Hash] Per-agent daily cost limits: { "AgentName" => limit }
     # @!attribute [rw] per_agent_monthly
-    #   @return [Hash] Per-agent monthly limits: { "AgentName" => limit }
+    #   @return [Hash] Per-agent monthly cost limits: { "AgentName" => limit }
     # @!attribute [rw] enforcement
     #   @return [String] Enforcement mode: "none", "soft", or "hard"
     # @!attribute [rw] inherit_global_defaults
     #   @return [Boolean] Whether to fall back to global config for unset limits
+    # @!attribute [rw] tenant_record
+    #   @return [ActiveRecord::Base, nil] Polymorphic association to tenant model
     #
-    # @example Creating a tenant budget
+    # @example Creating a tenant budget with cost, token, and execution limits
     #   TenantBudget.create!(
     #     tenant_id: "acme_corp",
-    #     daily_limit: 50.0,
-    #     monthly_limit: 500.0,
-    #     per_agent_daily: { "ContentAgent" => 10.0 },
+    #     name: "Acme Corporation",
+    #     daily_limit: 50.0,              # USD
+    #     monthly_limit: 500.0,           # USD
+    #     daily_token_limit: 1_000_000,
+    #     monthly_token_limit: 10_000_000,
+    #     daily_execution_limit: 500,
+    #     monthly_execution_limit: 10_000,
     #     enforcement: "hard"
     #   )
     #
-    # @example Fetching budget for a tenant
-    #   budget = TenantBudget.for_tenant("acme_corp")
-    #   budget.effective_daily_limit  # => 50.0
+    # @example Fetching budget for a tenant object
+    #   budget = TenantBudget.for_tenant(organization)
+    #   budget.effective_daily_limit           # => 50.0 (cost)
+    #   budget.effective_daily_token_limit     # => 1_000_000 (tokens)
+    #   budget.effective_daily_execution_limit # => 500 (executions)
     #
     # @see RubyLLM::Agents::BudgetTracker
+    # @see RubyLLM::Agents::LLMTenant
     # @api public
     class TenantBudget < ::ActiveRecord::Base
       self.table_name = "ruby_llm_agents_tenant_budgets"
@@ -43,20 +63,51 @@ module RubyLLM
       # Valid enforcement modes
       ENFORCEMENT_MODES = %w[none soft hard].freeze
 
+      # Polymorphic association to the tenant model (e.g., Organization, Account)
+      belongs_to :tenant_record, polymorphic: true, optional: true
+
       # Validations
       validates :tenant_id, presence: true, uniqueness: true
       validates :enforcement, inclusion: { in: ENFORCEMENT_MODES }, allow_nil: true
       validates :daily_limit, :monthly_limit,
                 numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
+      validates :daily_token_limit, :monthly_token_limit,
+                numericality: { greater_than_or_equal_to: 0, only_integer: true }, allow_nil: true
+      validates :daily_execution_limit, :monthly_execution_limit,
+                numericality: { greater_than_or_equal_to: 0, only_integer: true }, allow_nil: true
 
       # Finds a budget for the given tenant
       #
-      # @param tenant_id [String] The tenant identifier
+      # @param tenant [String, Object] The tenant identifier string or object with llm_tenant_id
       # @return [TenantBudget, nil] The budget record or nil if not found
-      def self.for_tenant(tenant_id)
-        return nil if tenant_id.blank?
+      def self.for_tenant(tenant)
+        return nil if tenant.blank?
+
+        if tenant.respond_to?(:llm_tenant_id)
+          # Object with llm_tenant DSL - try polymorphic first, then tenant_id
+          find_by(tenant_record: tenant) || find_by(tenant_id: tenant.llm_tenant_id)
+        else
+          # String tenant_id
+          find_by(tenant_id: tenant.to_s)
+        end
+      end
 
-        find_by(tenant_id: tenant_id)
+      # Finds or creates a budget for the given tenant
+      #
+      # @param tenant_id [String] The tenant identifier
+      # @param name [String, nil] Optional human-readable name
+      # @return [TenantBudget] The budget record
+      def self.for_tenant!(tenant_id, name: nil)
+        find_or_create_by!(tenant_id: tenant_id) do |budget|
+          budget.name = name
+        end
+      end
+
+      # Returns the display name (name or tenant_id fallback)
+      #
+      # @return [String] The name to display
+      def display_name
+        name.presence || tenant_id
       end
 
       # Returns the effective daily limit, considering inheritance
@@ -103,6 +154,46 @@ module RubyLLM
         global_config&.dig(:per_agent_monthly, agent_type)
       end
 
+      # Returns the effective daily token limit, considering inheritance
+      #
+      # @return [Integer, nil] The daily token limit or nil if not set
+      def effective_daily_token_limit
+        return daily_token_limit if daily_token_limit.present?
+        return nil unless inherit_global_defaults
+
+        global_config&.dig(:global_daily_tokens)
+      end
+
+      # Returns the effective monthly token limit, considering inheritance
+      #
+      # @return [Integer, nil] The monthly token limit or nil if not set
+      def effective_monthly_token_limit
+        return monthly_token_limit if monthly_token_limit.present?
+        return nil unless inherit_global_defaults
+
+        global_config&.dig(:global_monthly_tokens)
+      end
+
+      # Returns the effective daily execution limit, considering inheritance
+      #
+      # @return [Integer, nil] The daily execution limit or nil if not set
+      def effective_daily_execution_limit
+        return daily_execution_limit if daily_execution_limit.present?
+        return nil unless inherit_global_defaults
+
+        global_config&.dig(:global_daily_executions)
+      end
+
+      # Returns the effective monthly execution limit, considering inheritance
+      #
+      # @return [Integer, nil] The monthly execution limit or nil if not set
+      def effective_monthly_execution_limit
+        return monthly_execution_limit if monthly_execution_limit.present?
+        return nil unless inherit_global_defaults
+
+        global_config&.dig(:global_monthly_executions)
+      end
+
       # Returns the effective enforcement mode
       #
       # @return [Symbol] :none, :soft, or :hard
@@ -127,10 +218,17 @@ module RubyLLM
         {
           enabled: budgets_enabled?,
           enforcement: effective_enforcement,
+          # Cost limits
           global_daily: effective_daily_limit,
           global_monthly: effective_monthly_limit,
           per_agent_daily: merged_per_agent_daily,
-          per_agent_monthly: merged_per_agent_monthly
+          per_agent_monthly: merged_per_agent_monthly,
+          # Token limits
+          global_daily_tokens: effective_daily_token_limit,
+          global_monthly_tokens: effective_monthly_token_limit,
+          # Execution limits
+          global_daily_executions: effective_daily_execution_limit,
+          global_monthly_executions: effective_monthly_execution_limit
         }
       end
 

data/app/services/ruby_llm/agents/agent_registry.rb

@@ -60,12 +60,19 @@ module RubyLLM
         #
         # @return [Array<String>] Agent class names
         def file_system_agents
-          # Ensure all agent classes are loaded
+          # Ensure all agent and workflow classes are loaded
           eager_load_agents!
 
-          # Find all descendants of the base class
-          base_class = RubyLLM::Agents::Base
-          base_class.descendants.map(&:name).compact
+          # Find all descendants of all base classes
+          agents = RubyLLM::Agents::Base.descendants.map(&:name).compact
+          workflows = RubyLLM::Agents::Workflow.descendants.map(&:name).compact
+          embedders = RubyLLM::Agents::Embedder.descendants.map(&:name).compact
+          moderators = RubyLLM::Agents::Moderator.descendants.map(&:name).compact
+          speakers = RubyLLM::Agents::Speaker.descendants.map(&:name).compact
+          transcribers = RubyLLM::Agents::Transcriber.descendants.map(&:name).compact
+          image_generators = RubyLLM::Agents::ImageGenerator.descendants.map(&:name).compact
+
+          (agents + workflows + embedders + moderators + speakers + transcribers + image_generators).uniq
         rescue StandardError => e
           Rails.logger.error("[RubyLLM::Agents] Error loading agents from file system: #{e.message}")
           []
@@ -81,17 +88,19 @@ module RubyLLM
           []
         end
 
-        # Eager loads all agent files to register descendants
+        # Eager loads all agent and workflow files to register descendants
         #
         # @return [void]
         def eager_load_agents!
-          agents_path = Rails.root.join("app", "agents")
-          return unless agents_path.exist?
+          %w[agents workflows embedders moderators speakers transcribers image_generators].each do |dir|
+            path = Rails.root.join("app", dir)
+            next unless path.exist?
 
-          Dir.glob(agents_path.join("**", "*.rb")).each do |file|
-            require_dependency file
-          rescue LoadError, StandardError => e
-            Rails.logger.error("[RubyLLM::Agents] Failed to load agent file #{file}: #{e.message}")
+            Dir.glob(path.join("**", "*.rb")).each do |file|
+              require_dependency file
+            rescue LoadError, StandardError => e
+              Rails.logger.error("[RubyLLM::Agents] Failed to load file #{file}: #{e.message}")
+            end
           end
         end
 
@@ -125,8 +134,11 @@ module RubyLLM
           agent_class = find(agent_type)
           stats = fetch_stats(agent_type)
 
+          # Detect the agent type (agent, workflow, embedder, moderator, speaker, transcriber)
+          detected_type = detect_agent_type(agent_class)
+
           # Check if this is a workflow class vs a regular agent
-          is_workflow = agent_class&.ancestors&.any? { |a| a.name&.include?("Workflow") }
+          is_workflow = detected_type == "workflow"
 
           # Determine specific workflow type and children
           workflow_type = is_workflow ? detect_workflow_type(agent_class) : nil
@@ -136,6 +148,7 @@ module RubyLLM
             name: agent_type,
             class: agent_class,
             active: agent_class.present?,
+            agent_type: detected_type,
             is_workflow: is_workflow,
             workflow_type: workflow_type,
             workflow_children: workflow_children,
@@ -209,6 +222,32 @@ module RubyLLM
           end
         end
 
+        # Detects the agent type from class hierarchy
+        #
+        # @param agent_class [Class, nil] The agent class
+        # @return [String] "agent", "workflow", "embedder", "moderator", "speaker", "transcriber", or "image_generator"
+        def detect_agent_type(agent_class)
+          return "agent" unless agent_class
+
+          ancestors = agent_class.ancestors.map { |a| a.name.to_s }
+
+          if ancestors.include?("RubyLLM::Agents::Embedder")
+            "embedder"
+          elsif ancestors.include?("RubyLLM::Agents::Moderator")
+            "moderator"
+          elsif ancestors.include?("RubyLLM::Agents::Speaker")
+            "speaker"
+          elsif ancestors.include?("RubyLLM::Agents::Transcriber")
+            "transcriber"
+          elsif ancestors.include?("RubyLLM::Agents::ImageGenerator")
+            "image_generator"
+          elsif ancestors.include?("RubyLLM::Agents::Workflow")
+            "workflow"
+          else
+            "agent"
+          end
+        end
+
         # Extracts child agents from workflow DSL configuration
         #
         # @param agent_class [Class, nil] The workflow class