ruby_llm-agents 1.3.4 → 2.1.0

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

@@ -1,386 +0,0 @@
-# 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/workflow.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Agents
-    class Execution
-      # Workflow concern for workflow-related methods and aggregate calculations
-      #
-      # Provides instance methods for determining workflow type, calculating
-      # aggregate statistics across child executions, and retrieving workflow
-      # step/branch information.
-      #
-      # @see RubyLLM::Agents::Execution
-      # @api public
-      module Workflow
-        extend ActiveSupport::Concern
-
-        # Returns whether this is a workflow execution (has workflow_type)
-        #
-        # @return [Boolean] true if this is a workflow execution
-        def workflow?
-          workflow_type.present?
-        end
-
-        # Returns whether this is a root workflow execution (top-level)
-        #
-        # @return [Boolean] true if this is a workflow with no parent
-        def root_workflow?
-          workflow? && root?
-        end
-
-        # Returns all workflow steps/branches ordered by creation time
-        #
-        # @return [ActiveRecord::Relation] Child executions for this workflow
-        def workflow_steps
-          child_executions.order(:created_at)
-        end
-
-        # Returns the count of child workflow steps
-        #
-        # @return [Integer] Number of child executions
-        def workflow_steps_count
-          child_executions.count
-        end
-
-        # @!group Aggregate Statistics
-
-        # Returns aggregate stats for all child executions
-        #
-        # @return [Hash] Aggregated metrics including cost, tokens, duration
-        def workflow_aggregate_stats
-          return @workflow_aggregate_stats if defined?(@workflow_aggregate_stats)
-
-          children = child_executions.to_a
-          return empty_aggregate_stats if children.empty?
-
-          @workflow_aggregate_stats = {
-            total_cost: children.sum { |c| c.total_cost || 0 },
-            total_tokens: children.sum { |c| c.total_tokens || 0 },
-            input_tokens: children.sum { |c| c.input_tokens || 0 },
-            output_tokens: children.sum { |c| c.output_tokens || 0 },
-            total_duration_ms: children.sum { |c| c.duration_ms || 0 },
-            wall_clock_ms: calculate_wall_clock_duration(children),
-            steps_count: children.size,
-            successful_count: children.count(&:status_success?),
-            failed_count: children.count(&:status_error?),
-            timeout_count: children.count(&:status_timeout?),
-            running_count: children.count(&:status_running?),
-            success_rate: calculate_success_rate(children),
-            models_used: children.map(&:model_id).uniq.compact
-          }
-        end
-
-        # Returns aggregate total cost across all child executions
-        #
-        # @return [Float] Total cost in USD
-        def workflow_total_cost
-          workflow_aggregate_stats[:total_cost]
-        end
-
-        # Returns aggregate total tokens across all child executions
-        #
-        # @return [Integer] Total tokens used
-        def workflow_total_tokens
-          workflow_aggregate_stats[:total_tokens]
-        end
-
-        # Returns the wall-clock duration (from first start to last completion)
-        #
-        # @return [Integer, nil] Duration in milliseconds
-        def workflow_wall_clock_ms
-          workflow_aggregate_stats[:wall_clock_ms]
-        end
-
-        # Returns the sum of all step durations (may exceed wall-clock for parallel)
-        #
-        # @return [Integer] Sum of all durations in milliseconds
-        def workflow_sum_duration_ms
-          workflow_aggregate_stats[:total_duration_ms]
-        end
-
-        # Returns the overall workflow status based on child executions
-        #
-        # @return [Symbol] :success, :error, :timeout, :running, or :pending
-        def workflow_overall_status
-          stats = workflow_aggregate_stats
-          return :pending if stats[:steps_count].zero?
-          return :running if stats[:running_count] > 0
-          return :error if stats[:failed_count] > 0
-          return :timeout if stats[:timeout_count] > 0
-
-          :success
-        end
-
-        # @!endgroup
-
-        private
-
-        # Returns empty aggregate stats hash
-        #
-        # @return [Hash] Empty stats with zero values
-        def empty_aggregate_stats
-          {
-            total_cost: 0,
-            total_tokens: 0,
-            input_tokens: 0,
-            output_tokens: 0,
-            total_duration_ms: 0,
-            wall_clock_ms: nil,
-            steps_count: 0,
-            successful_count: 0,
-            failed_count: 0,
-            timeout_count: 0,
-            running_count: 0,
-            success_rate: 0.0,
-            models_used: []
-          }
-        end
-
-        # Calculates wall-clock duration from child executions
-        #
-        # @param children [Array<Execution>] Child executions
-        # @return [Integer, nil] Duration in milliseconds
-        def calculate_wall_clock_duration(children)
-          started_times = children.map(&:started_at).compact
-          completed_times = children.map(&:completed_at).compact
-
-          return nil if started_times.empty? || completed_times.empty?
-
-          first_start = started_times.min
-          last_complete = completed_times.max
-
-          ((last_complete - first_start) * 1000).round
-        end
-
-        # Calculates success rate from children
-        #
-        # @param children [Array<Execution>] Child executions
-        # @return [Float] Success rate as percentage
-        def calculate_success_rate(children)
-          return 0.0 if children.empty?
-
-          completed = children.reject(&:status_running?)
-          return 0.0 if completed.empty?
-
-          (completed.count(&:status_success?).to_f / completed.size * 100).round(1)
-        end
-      end
-    end
-  end
-end

data/app/models/ruby_llm/agents/tenant/configurable.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/concern"
-
-module RubyLLM
-  module Agents
-    class Tenant
-      # Manages API configuration for a tenant.
-      #
-      # Links to the ApiConfiguration model to provide per-tenant API keys
-      # and settings. Supports inheritance from global configuration when
-      # tenant-specific settings are not defined.
-      #
-      # @example Accessing tenant API keys
-      #   tenant = Tenant.for("acme_corp")
-      #   tenant.api_key_for(:openai)  # => "sk-..."
-      #   tenant.has_custom_api_keys?  # => true
-      #
-      # @example Getting effective configuration
-      #   config = tenant.effective_api_configuration
-      #   config.apply_to_ruby_llm!
-      #
-      # @see ApiConfiguration
-      # @api public
-      module Configurable
-        extend ActiveSupport::Concern
-
-        included do
-          # Link to tenant-specific API configuration
-          has_one :api_configuration,
-                  -> { where(scope_type: "tenant") },
-                  class_name: "RubyLLM::Agents::ApiConfiguration",
-                  foreign_key: :scope_id,
-                  primary_key: :tenant_id,
-                  dependent: :destroy
-        end
-
-        # Get API key for a specific provider
-        #
-        # @param provider [Symbol] Provider name (:openai, :anthropic, :gemini, etc.)
-        # @return [String, nil] The API key or nil if not configured
-        #
-        # @example
-        #   tenant.api_key_for(:openai)     # => "sk-abc123..."
-        #   tenant.api_key_for(:anthropic)  # => "sk-ant-xyz..."
-        def api_key_for(provider)
-          attr_name = "#{provider}_api_key"
-          api_configuration&.send(attr_name) if api_configuration&.respond_to?(attr_name)
-        end
-
-        # Check if tenant has custom API keys configured
-        #
-        # @return [Boolean] true if tenant has an ApiConfiguration record
-        def has_custom_api_keys?
-          api_configuration.present?
-        end
-
-        # Get effective API configuration for this tenant
-        #
-        # Returns the resolved configuration that combines tenant-specific
-        # settings with global defaults.
-        #
-        # @return [ResolvedConfig] The resolved configuration
-        #
-        # @example
-        #   config = tenant.effective_api_configuration
-        #   config.openai_api_key  # Tenant's key or global fallback
-        def effective_api_configuration
-          ApiConfiguration.resolve(tenant_id: tenant_id)
-        end
-
-        # Get or create the API configuration for this tenant
-        #
-        # @return [ApiConfiguration] The tenant's API configuration record
-        def api_configuration!
-          api_configuration || create_api_configuration!(
-            scope_type: "tenant",
-            scope_id: tenant_id
-          )
-        end
-
-        # Configure API settings for this tenant
-        #
-        # @yield [config] Block to configure the API settings
-        # @yieldparam config [ApiConfiguration] The configuration to modify
-        # @return [ApiConfiguration] The saved configuration
-        #
-        # @example
-        #   tenant.configure_api do |config|
-        #     config.openai_api_key = "sk-..."
-        #     config.default_model = "gpt-4o"
-        #   end
-        def configure_api(&block)
-          config = api_configuration!
-          yield(config) if block_given?
-          config.save!
-          config
-        end
-
-        # Check if a specific provider is configured for this tenant
-        #
-        # @param provider [Symbol] Provider name
-        # @return [Boolean] true if the provider has an API key set
-        def provider_configured?(provider)
-          api_key_for(provider).present?
-        end
-
-        # Get all configured providers for this tenant
-        #
-        # @return [Array<Symbol>] List of configured provider symbols
-        def configured_providers
-          return [] unless api_configuration
-
-          ApiConfiguration::PROVIDERS.keys.select do |provider|
-            provider_configured?(provider)
-          end
-        end
-
-        # Get the default model for this tenant
-        #
-        # @return [String, nil] The default model or nil
-        def default_model
-          api_configuration&.default_model
-        end
-
-        # Get the default embedding model for this tenant
-        #
-        # @return [String, nil] The default embedding model or nil
-        def default_embedding_model
-          api_configuration&.default_embedding_model
-        end
-      end
-    end
-  end
-end